00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "libavutil/imgutils.h"
00029 #include "avcodec.h"
00030 #include "dsputil.h"
00031 #include "mpegvideo.h"
00032 #include "mpeg4video.h"
00033 #include "h263.h"
00034
00035
00036
00037 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
00038 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
00039 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
00040
00041 #define DC_VLC_BITS 14 //FIXME find a better solution
00042
00043 static const uint16_t rv_lum_code[256] =
00044 {
00045 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
00046 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
00047 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
00048 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
00049 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
00050 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
00051 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
00052 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
00053 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
00054 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
00055 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
00056 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
00057 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
00058 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
00059 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
00060 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
00061 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
00062 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
00063 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
00064 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
00065 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
00066 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
00067 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
00068 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
00069 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
00070 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
00071 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
00072 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
00073 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
00074 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
00075 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
00076 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
00077 };
00078
00079 static const uint8_t rv_lum_bits[256] =
00080 {
00081 14, 12, 12, 12, 12, 12, 12, 12,
00082 12, 12, 12, 12, 12, 12, 12, 12,
00083 12, 12, 12, 12, 12, 12, 12, 12,
00084 12, 12, 12, 12, 12, 12, 12, 12,
00085 12, 12, 12, 12, 12, 12, 12, 12,
00086 12, 12, 12, 12, 12, 12, 12, 12,
00087 12, 12, 12, 12, 12, 12, 12, 12,
00088 12, 12, 12, 12, 12, 12, 12, 12,
00089 12, 10, 10, 10, 10, 10, 10, 10,
00090 10, 10, 10, 10, 10, 10, 10, 10,
00091 10, 10, 10, 10, 10, 10, 10, 10,
00092 10, 10, 10, 10, 10, 10, 10, 10,
00093 10, 8, 8, 8, 8, 8, 8, 8,
00094 8, 8, 8, 8, 8, 8, 8, 8,
00095 8, 7, 7, 7, 7, 7, 7, 7,
00096 7, 6, 6, 6, 6, 5, 5, 4,
00097 2, 4, 5, 5, 6, 6, 6, 6,
00098 7, 7, 7, 7, 7, 7, 7, 7,
00099 8, 8, 8, 8, 8, 8, 8, 8,
00100 8, 8, 8, 8, 8, 8, 8, 8,
00101 10, 10, 10, 10, 10, 10, 10, 10,
00102 10, 10, 10, 10, 10, 10, 10, 10,
00103 10, 10, 10, 10, 10, 10, 10, 10,
00104 10, 10, 10, 10, 10, 10, 10, 10,
00105 12, 12, 12, 12, 12, 12, 12, 12,
00106 12, 12, 12, 12, 12, 12, 12, 12,
00107 12, 12, 12, 12, 12, 12, 12, 12,
00108 12, 12, 12, 12, 12, 12, 12, 12,
00109 12, 12, 12, 12, 12, 12, 12, 12,
00110 12, 12, 12, 12, 12, 12, 12, 12,
00111 12, 12, 12, 12, 12, 12, 12, 12,
00112 12, 12, 12, 12, 12, 12, 12, 12,
00113 };
00114
00115 static const uint16_t rv_chrom_code[256] =
00116 {
00117 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
00118 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
00119 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
00120 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
00121 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
00122 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
00123 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
00124 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
00125 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
00126 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
00127 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
00128 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
00129 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
00130 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
00131 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
00132 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
00133 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
00134 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
00135 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
00136 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
00137 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
00138 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
00139 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
00140 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
00141 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
00142 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
00143 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
00144 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
00145 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
00146 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
00147 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
00148 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
00149 };
00150
00151 static const uint8_t rv_chrom_bits[256] =
00152 {
00153 16, 14, 14, 14, 14, 14, 14, 14,
00154 14, 14, 14, 14, 14, 14, 14, 14,
00155 14, 14, 14, 14, 14, 14, 14, 14,
00156 14, 14, 14, 14, 14, 14, 14, 14,
00157 14, 14, 14, 14, 14, 14, 14, 14,
00158 14, 14, 14, 14, 14, 14, 14, 14,
00159 14, 14, 14, 14, 14, 14, 14, 14,
00160 14, 14, 14, 14, 14, 14, 14, 14,
00161 14, 12, 12, 12, 12, 12, 12, 12,
00162 12, 12, 12, 12, 12, 12, 12, 12,
00163 12, 12, 12, 12, 12, 12, 12, 12,
00164 12, 12, 12, 12, 12, 12, 12, 12,
00165 12, 10, 10, 10, 10, 10, 10, 10,
00166 10, 10, 10, 10, 10, 10, 10, 10,
00167 10, 8, 8, 8, 8, 8, 8, 8,
00168 8, 6, 6, 6, 6, 4, 4, 3,
00169 2, 3, 4, 4, 6, 6, 6, 6,
00170 8, 8, 8, 8, 8, 8, 8, 8,
00171 10, 10, 10, 10, 10, 10, 10, 10,
00172 10, 10, 10, 10, 10, 10, 10, 10,
00173 12, 12, 12, 12, 12, 12, 12, 12,
00174 12, 12, 12, 12, 12, 12, 12, 12,
00175 12, 12, 12, 12, 12, 12, 12, 12,
00176 12, 12, 12, 12, 12, 12, 12, 12,
00177 14, 14, 14, 14, 14, 14, 14, 14,
00178 14, 14, 14, 14, 14, 14, 14, 14,
00179 14, 14, 14, 14, 14, 14, 14, 14,
00180 14, 14, 14, 14, 14, 14, 14, 14,
00181 14, 14, 14, 14, 14, 14, 14, 14,
00182 14, 14, 14, 14, 14, 14, 14, 14,
00183 14, 14, 14, 14, 14, 14, 14, 14,
00184 14, 14, 14, 14, 14, 14, 14, 14,
00185 };
00186
00187 static VLC rv_dc_lum, rv_dc_chrom;
00188
00189 int rv_decode_dc(MpegEncContext *s, int n)
00190 {
00191 int code;
00192
00193 if (n < 4) {
00194 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
00195 if (code < 0) {
00196
00197
00198
00199 code = get_bits(&s->gb, 7);
00200 if (code == 0x7c) {
00201 code = (int8_t)(get_bits(&s->gb, 7) + 1);
00202 } else if (code == 0x7d) {
00203 code = -128 + get_bits(&s->gb, 7);
00204 } else if (code == 0x7e) {
00205 if (get_bits1(&s->gb) == 0)
00206 code = (int8_t)(get_bits(&s->gb, 8) + 1);
00207 else
00208 code = (int8_t)(get_bits(&s->gb, 8));
00209 } else if (code == 0x7f) {
00210 skip_bits(&s->gb, 11);
00211 code = 1;
00212 }
00213 } else {
00214 code -= 128;
00215 }
00216 } else {
00217 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
00218
00219 if (code < 0) {
00220 code = get_bits(&s->gb, 9);
00221 if (code == 0x1fc) {
00222 code = (int8_t)(get_bits(&s->gb, 7) + 1);
00223 } else if (code == 0x1fd) {
00224 code = -128 + get_bits(&s->gb, 7);
00225 } else if (code == 0x1fe) {
00226 skip_bits(&s->gb, 9);
00227 code = 1;
00228 } else {
00229 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
00230 return 0xffff;
00231 }
00232 } else {
00233 code -= 128;
00234 }
00235 }
00236 return -code;
00237 }
00238
00239
00240 static int rv10_decode_picture_header(MpegEncContext *s)
00241 {
00242 int mb_count, pb_frame, marker, mb_xy;
00243
00244 marker = get_bits1(&s->gb);
00245
00246 if (get_bits1(&s->gb))
00247 s->pict_type = AV_PICTURE_TYPE_P;
00248 else
00249 s->pict_type = AV_PICTURE_TYPE_I;
00250 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
00251 pb_frame = get_bits1(&s->gb);
00252
00253 av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
00254
00255 if (pb_frame){
00256 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
00257 return -1;
00258 }
00259
00260 s->qscale = get_bits(&s->gb, 5);
00261 if(s->qscale==0){
00262 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
00263 return -1;
00264 }
00265
00266 if (s->pict_type == AV_PICTURE_TYPE_I) {
00267 if (s->rv10_version == 3) {
00268
00269 s->last_dc[0] = get_bits(&s->gb, 8);
00270 s->last_dc[1] = get_bits(&s->gb, 8);
00271 s->last_dc[2] = get_bits(&s->gb, 8);
00272 av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
00273 s->last_dc[1], s->last_dc[2]);
00274 }
00275 }
00276
00277
00278
00279 mb_xy= s->mb_x + s->mb_y*s->mb_width;
00280 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
00281 s->mb_x = get_bits(&s->gb, 6);
00282 s->mb_y = get_bits(&s->gb, 6);
00283 mb_count = get_bits(&s->gb, 12);
00284 } else {
00285 s->mb_x = 0;
00286 s->mb_y = 0;
00287 mb_count = s->mb_width * s->mb_height;
00288 }
00289 skip_bits(&s->gb, 3);
00290 s->f_code = 1;
00291 s->unrestricted_mv = 1;
00292
00293 return mb_count;
00294 }
00295
00296 static int rv20_decode_picture_header(MpegEncContext *s)
00297 {
00298 int seq, mb_pos, i;
00299 int rpr_bits;
00300
00301 i= get_bits(&s->gb, 2);
00302 switch(i){
00303 case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
00304 case 1: s->pict_type= AV_PICTURE_TYPE_I; break;
00305 case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
00306 case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
00307 default:
00308 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
00309 return -1;
00310 }
00311
00312 if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
00313 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
00314 return -1;
00315 }
00316
00317 if (get_bits1(&s->gb)){
00318 av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
00319 return -1;
00320 }
00321
00322 s->qscale = get_bits(&s->gb, 5);
00323 if(s->qscale==0){
00324 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
00325 return -1;
00326 }
00327
00328 if(RV_GET_MINOR_VER(s->avctx->sub_id) >= 2)
00329 s->loop_filter = get_bits1(&s->gb);
00330
00331 if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1)
00332 seq = get_bits(&s->gb, 8) << 7;
00333 else
00334 seq = get_bits(&s->gb, 13) << 2;
00335
00336 rpr_bits = s->avctx->extradata[1] & 7;
00337 if(rpr_bits){
00338 int f, new_w, new_h;
00339 rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
00340
00341 f = get_bits(&s->gb, rpr_bits);
00342
00343 if(f){
00344 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
00345 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
00346 }else{
00347 new_w= s->orig_width ;
00348 new_h= s->orig_height;
00349 }
00350 if(new_w != s->width || new_h != s->height){
00351 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
00352 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
00353 return -1;
00354 MPV_common_end(s);
00355 avcodec_set_dimensions(s->avctx, new_w, new_h);
00356 s->width = new_w;
00357 s->height = new_h;
00358 if (MPV_common_init(s) < 0)
00359 return -1;
00360 }
00361
00362 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00363 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
00364 }
00365 } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
00366 return AVERROR_INVALIDDATA;
00367
00368 mb_pos = ff_h263_decode_mba(s);
00369
00370
00371 seq |= s->time &~0x7FFF;
00372 if(seq - s->time > 0x4000) seq -= 0x8000;
00373 if(seq - s->time < -0x4000) seq += 0x8000;
00374 if(seq != s->time){
00375 if(s->pict_type!=AV_PICTURE_TYPE_B){
00376 s->time= seq;
00377 s->pp_time= s->time - s->last_non_b_time;
00378 s->last_non_b_time= s->time;
00379 }else{
00380 s->time= seq;
00381 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00382 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
00383 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
00384 return FRAME_SKIPPED;
00385 }
00386 ff_mpeg4_init_direct_mv(s);
00387 }
00388 }
00389
00390
00391
00392
00393
00394 s->no_rounding= get_bits1(&s->gb);
00395
00396 if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
00397 skip_bits(&s->gb, 5);
00398
00399 s->f_code = 1;
00400 s->unrestricted_mv = 1;
00401 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
00402
00403
00404
00405 s->modified_quant=1;
00406 if(!s->avctx->lowres)
00407 s->loop_filter=1;
00408
00409 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00410 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
00411 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
00412 }
00413
00414 assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
00415
00416 return s->mb_width*s->mb_height - mb_pos;
00417 }
00418
00419 static av_cold int rv10_decode_init(AVCodecContext *avctx)
00420 {
00421 MpegEncContext *s = avctx->priv_data;
00422 static int done=0;
00423 int major_ver, minor_ver, micro_ver;
00424
00425 if (avctx->extradata_size < 8) {
00426 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
00427 return -1;
00428 }
00429
00430 MPV_decode_defaults(s);
00431
00432 s->avctx= avctx;
00433 s->out_format = FMT_H263;
00434 s->codec_id= avctx->codec_id;
00435 avctx->flags |= CODEC_FLAG_EMU_EDGE;
00436
00437 s->orig_width = s->width = avctx->coded_width;
00438 s->orig_height= s->height = avctx->coded_height;
00439
00440 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
00441 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
00442
00443 major_ver = RV_GET_MAJOR_VER(avctx->sub_id);
00444 minor_ver = RV_GET_MINOR_VER(avctx->sub_id);
00445 micro_ver = RV_GET_MICRO_VER(avctx->sub_id);
00446
00447 s->low_delay = 1;
00448 switch (major_ver) {
00449 case 1:
00450 s->rv10_version = micro_ver ? 3 : 1;
00451 s->obmc = micro_ver == 2;
00452 break;
00453 case 2:
00454 if (minor_ver >= 2) {
00455 s->low_delay = 0;
00456 s->avctx->has_b_frames = 1;
00457 }
00458 break;
00459 default:
00460 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
00461 av_log_missing_feature(avctx, "RV1/2 version", 1);
00462 return AVERROR_PATCHWELCOME;
00463 }
00464
00465 if(avctx->debug & FF_DEBUG_PICT_INFO){
00466 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
00467 }
00468
00469 avctx->pix_fmt = PIX_FMT_YUV420P;
00470
00471 if (MPV_common_init(s) < 0)
00472 return -1;
00473
00474 h263_decode_init_vlc(s);
00475
00476
00477 if (!done) {
00478 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
00479 rv_lum_bits, 1, 1,
00480 rv_lum_code, 2, 2, 16384);
00481 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
00482 rv_chrom_bits, 1, 1,
00483 rv_chrom_code, 2, 2, 16388);
00484 done = 1;
00485 }
00486
00487 return 0;
00488 }
00489
00490 static av_cold int rv10_decode_end(AVCodecContext *avctx)
00491 {
00492 MpegEncContext *s = avctx->priv_data;
00493
00494 MPV_common_end(s);
00495 return 0;
00496 }
00497
00498 static int rv10_decode_packet(AVCodecContext *avctx,
00499 const uint8_t *buf, int buf_size, int buf_size2)
00500 {
00501 MpegEncContext *s = avctx->priv_data;
00502 int mb_count, mb_pos, left, start_mb_x, active_bits_size;
00503
00504 active_bits_size = buf_size * 8;
00505 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
00506 if(s->codec_id ==CODEC_ID_RV10)
00507 mb_count = rv10_decode_picture_header(s);
00508 else
00509 mb_count = rv20_decode_picture_header(s);
00510 if (mb_count < 0) {
00511 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
00512 return -1;
00513 }
00514
00515 if (s->mb_x >= s->mb_width ||
00516 s->mb_y >= s->mb_height) {
00517 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
00518 return -1;
00519 }
00520 mb_pos = s->mb_y * s->mb_width + s->mb_x;
00521 left = s->mb_width * s->mb_height - mb_pos;
00522 if (mb_count > left) {
00523 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
00524 return -1;
00525 }
00526
00527 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
00528 if(s->current_picture_ptr){
00529 ff_er_frame_end(s);
00530 MPV_frame_end(s);
00531 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
00532 }
00533 if(MPV_frame_start(s, avctx) < 0)
00534 return -1;
00535 ff_er_frame_start(s);
00536 } else {
00537 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
00538 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
00539 return -1;
00540 }
00541 }
00542
00543 av_dlog(avctx, "qscale=%d\n", s->qscale);
00544
00545
00546 if(s->codec_id== CODEC_ID_RV10){
00547 if(s->mb_y==0) s->first_slice_line=1;
00548 }else{
00549 s->first_slice_line=1;
00550 s->resync_mb_x= s->mb_x;
00551 }
00552 start_mb_x= s->mb_x;
00553 s->resync_mb_y= s->mb_y;
00554 if(s->h263_aic){
00555 s->y_dc_scale_table=
00556 s->c_dc_scale_table= ff_aic_dc_scale_table;
00557 }else{
00558 s->y_dc_scale_table=
00559 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00560 }
00561
00562 if(s->modified_quant)
00563 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00564
00565 ff_set_qscale(s, s->qscale);
00566
00567 s->rv10_first_dc_coded[0] = 0;
00568 s->rv10_first_dc_coded[1] = 0;
00569 s->rv10_first_dc_coded[2] = 0;
00570 s->block_wrap[0]=
00571 s->block_wrap[1]=
00572 s->block_wrap[2]=
00573 s->block_wrap[3]= s->b8_stride;
00574 s->block_wrap[4]=
00575 s->block_wrap[5]= s->mb_stride;
00576 ff_init_block_index(s);
00577
00578
00579 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
00580 int ret;
00581 ff_update_block_index(s);
00582 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00583
00584 s->mv_dir = MV_DIR_FORWARD;
00585 s->mv_type = MV_TYPE_16X16;
00586 ret=ff_h263_decode_mb(s, s->block);
00587
00588
00589
00590 if (ret != SLICE_ERROR) {
00591 int v = show_bits(&s->gb, 16);
00592
00593 if (get_bits_count(&s->gb) + 16 > active_bits_size)
00594 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
00595
00596 if (!v)
00597 ret = SLICE_END;
00598 }
00599 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
00600 8 * buf_size2 >= get_bits_count(&s->gb)) {
00601 active_bits_size = buf_size2 * 8;
00602 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
00603 8 * buf_size, active_bits_size);
00604 ret= SLICE_OK;
00605 }
00606
00607 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
00608 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
00609 return -1;
00610 }
00611 if(s->pict_type != AV_PICTURE_TYPE_B)
00612 ff_h263_update_motion_val(s);
00613 MPV_decode_mb(s, s->block);
00614 if(s->loop_filter)
00615 ff_h263_loop_filter(s);
00616
00617 if (++s->mb_x == s->mb_width) {
00618 s->mb_x = 0;
00619 s->mb_y++;
00620 ff_init_block_index(s);
00621 }
00622 if(s->mb_x == s->resync_mb_x)
00623 s->first_slice_line=0;
00624 if(ret == SLICE_END) break;
00625 }
00626
00627 ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
00628
00629 return active_bits_size;
00630 }
00631
00632 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
00633 {
00634 if(avctx->slice_count) return avctx->slice_offset[n];
00635 else return AV_RL32(buf + n*8);
00636 }
00637
00638 static int rv10_decode_frame(AVCodecContext *avctx,
00639 void *data, int *data_size,
00640 AVPacket *avpkt)
00641 {
00642 const uint8_t *buf = avpkt->data;
00643 int buf_size = avpkt->size;
00644 MpegEncContext *s = avctx->priv_data;
00645 int i;
00646 AVFrame *pict = data;
00647 int slice_count;
00648 const uint8_t *slices_hdr = NULL;
00649
00650 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00651
00652
00653 if (buf_size == 0) {
00654 return 0;
00655 }
00656
00657 if(!avctx->slice_count){
00658 slice_count = (*buf++) + 1;
00659 buf_size--;
00660 slices_hdr = buf + 4;
00661 buf += 8 * slice_count;
00662 buf_size -= 8 * slice_count;
00663 if (buf_size <= 0)
00664 return AVERROR_INVALIDDATA;
00665 }else
00666 slice_count = avctx->slice_count;
00667
00668 for(i=0; i<slice_count; i++){
00669 int offset= get_slice_offset(avctx, slices_hdr, i);
00670 int size, size2;
00671
00672 if(i+1 == slice_count)
00673 size= buf_size - offset;
00674 else
00675 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
00676
00677 if(i+2 >= slice_count)
00678 size2= buf_size - offset;
00679 else
00680 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
00681
00682 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
00683 i++;
00684 }
00685
00686 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
00687 ff_er_frame_end(s);
00688 MPV_frame_end(s);
00689
00690 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
00691 *pict= *(AVFrame*)s->current_picture_ptr;
00692 } else if (s->last_picture_ptr != NULL) {
00693 *pict= *(AVFrame*)s->last_picture_ptr;
00694 }
00695
00696 if(s->last_picture_ptr || s->low_delay){
00697 *data_size = sizeof(AVFrame);
00698 ff_print_debug_info(s, pict);
00699 }
00700 s->current_picture_ptr= NULL;
00701 }
00702
00703 return avpkt->size;
00704 }
00705
00706 AVCodec ff_rv10_decoder = {
00707 .name = "rv10",
00708 .type = AVMEDIA_TYPE_VIDEO,
00709 .id = CODEC_ID_RV10,
00710 .priv_data_size = sizeof(MpegEncContext),
00711 .init = rv10_decode_init,
00712 .close = rv10_decode_end,
00713 .decode = rv10_decode_frame,
00714 .capabilities = CODEC_CAP_DR1,
00715 .max_lowres = 3,
00716 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
00717 .pix_fmts= ff_pixfmt_list_420,
00718 };
00719
00720 AVCodec ff_rv20_decoder = {
00721 .name = "rv20",
00722 .type = AVMEDIA_TYPE_VIDEO,
00723 .id = CODEC_ID_RV20,
00724 .priv_data_size = sizeof(MpegEncContext),
00725 .init = rv10_decode_init,
00726 .close = rv10_decode_end,
00727 .decode = rv10_decode_frame,
00728 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
00729 .flush= ff_mpeg_flush,
00730 .max_lowres = 3,
00731 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
00732 .pix_fmts= ff_pixfmt_list_420,
00733 };