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