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