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
00458 s->orig_width = s->width = avctx->coded_width;
00459 s->orig_height= s->height = avctx->coded_height;
00460
00461 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
00462 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
00463
00464 if (avctx->sub_id == 0x10000000) {
00465 s->rv10_version= 0;
00466 s->low_delay=1;
00467 } else if (avctx->sub_id == 0x10001000) {
00468 s->rv10_version= 3;
00469 s->low_delay=1;
00470 } else if (avctx->sub_id == 0x10002000) {
00471 s->rv10_version= 3;
00472 s->low_delay=1;
00473 s->obmc=1;
00474 } else if (avctx->sub_id == 0x10003000) {
00475 s->rv10_version= 3;
00476 s->low_delay=1;
00477 } else if (avctx->sub_id == 0x10003001) {
00478 s->rv10_version= 3;
00479 s->low_delay=1;
00480 } else if ( avctx->sub_id == 0x20001000
00481 || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) {
00482 s->low_delay=1;
00483 } else if ( avctx->sub_id == 0x30202002
00484 || avctx->sub_id == 0x30203002
00485 || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) {
00486 s->low_delay=0;
00487 s->avctx->has_b_frames=1;
00488 } else
00489 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
00490
00491 if(avctx->debug & FF_DEBUG_PICT_INFO){
00492 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
00493 }
00494
00495 avctx->pix_fmt = PIX_FMT_YUV420P;
00496
00497 if (MPV_common_init(s) < 0)
00498 return -1;
00499
00500 h263_decode_init_vlc(s);
00501
00502
00503 if (!done) {
00504 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
00505 rv_lum_bits, 1, 1,
00506 rv_lum_code, 2, 2, 16384);
00507 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
00508 rv_chrom_bits, 1, 1,
00509 rv_chrom_code, 2, 2, 16388);
00510 done = 1;
00511 }
00512
00513 return 0;
00514 }
00515
00516 static av_cold int rv10_decode_end(AVCodecContext *avctx)
00517 {
00518 MpegEncContext *s = avctx->priv_data;
00519
00520 MPV_common_end(s);
00521 return 0;
00522 }
00523
00524 static int rv10_decode_packet(AVCodecContext *avctx,
00525 const uint8_t *buf, int buf_size, int buf_size2)
00526 {
00527 MpegEncContext *s = avctx->priv_data;
00528 int mb_count, mb_pos, left, start_mb_x;
00529
00530 init_get_bits(&s->gb, buf, buf_size*8);
00531 if(s->codec_id ==CODEC_ID_RV10)
00532 mb_count = rv10_decode_picture_header(s);
00533 else
00534 mb_count = rv20_decode_picture_header(s);
00535 if (mb_count < 0) {
00536 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
00537 return -1;
00538 }
00539
00540 if (s->mb_x >= s->mb_width ||
00541 s->mb_y >= s->mb_height) {
00542 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
00543 return -1;
00544 }
00545 mb_pos = s->mb_y * s->mb_width + s->mb_x;
00546 left = s->mb_width * s->mb_height - mb_pos;
00547 if (mb_count > left) {
00548 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
00549 return -1;
00550 }
00551
00552 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
00553 if(s->current_picture_ptr){
00554 ff_er_frame_end(s);
00555 MPV_frame_end(s);
00556 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
00557 }
00558 if(MPV_frame_start(s, avctx) < 0)
00559 return -1;
00560 ff_er_frame_start(s);
00561 }
00562
00563 dprintf(avctx, "qscale=%d\n", s->qscale);
00564
00565
00566 if(s->codec_id== CODEC_ID_RV10){
00567 if(s->mb_y==0) s->first_slice_line=1;
00568 }else{
00569 s->first_slice_line=1;
00570 s->resync_mb_x= s->mb_x;
00571 }
00572 start_mb_x= s->mb_x;
00573 s->resync_mb_y= s->mb_y;
00574 if(s->h263_aic){
00575 s->y_dc_scale_table=
00576 s->c_dc_scale_table= ff_aic_dc_scale_table;
00577 }else{
00578 s->y_dc_scale_table=
00579 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00580 }
00581
00582 if(s->modified_quant)
00583 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00584
00585 ff_set_qscale(s, s->qscale);
00586
00587 s->rv10_first_dc_coded[0] = 0;
00588 s->rv10_first_dc_coded[1] = 0;
00589 s->rv10_first_dc_coded[2] = 0;
00590 s->block_wrap[0]=
00591 s->block_wrap[1]=
00592 s->block_wrap[2]=
00593 s->block_wrap[3]= s->b8_stride;
00594 s->block_wrap[4]=
00595 s->block_wrap[5]= s->mb_stride;
00596 ff_init_block_index(s);
00597
00598
00599 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
00600 int ret;
00601 ff_update_block_index(s);
00602 dprintf(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00603
00604 s->mv_dir = MV_DIR_FORWARD;
00605 s->mv_type = MV_TYPE_16X16;
00606 ret=ff_h263_decode_mb(s, s->block);
00607
00608 if (ret != SLICE_ERROR && s->gb.size_in_bits < get_bits_count(&s->gb) && 8*buf_size2 >= get_bits_count(&s->gb)){
00609 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n", s->gb.size_in_bits, 8*buf_size2);
00610 s->gb.size_in_bits= 8*buf_size2;
00611 ret= SLICE_OK;
00612 }
00613
00614 if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) {
00615 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
00616 return -1;
00617 }
00618 if(s->pict_type != FF_B_TYPE)
00619 ff_h263_update_motion_val(s);
00620 MPV_decode_mb(s, s->block);
00621 if(s->loop_filter)
00622 ff_h263_loop_filter(s);
00623
00624 if (++s->mb_x == s->mb_width) {
00625 s->mb_x = 0;
00626 s->mb_y++;
00627 ff_init_block_index(s);
00628 }
00629 if(s->mb_x == s->resync_mb_x)
00630 s->first_slice_line=0;
00631 if(ret == SLICE_END) break;
00632 }
00633
00634 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);
00635
00636 return s->gb.size_in_bits;
00637 }
00638
00639 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
00640 {
00641 if(avctx->slice_count) return avctx->slice_offset[n];
00642 else return AV_RL32(buf + n*8);
00643 }
00644
00645 static int rv10_decode_frame(AVCodecContext *avctx,
00646 void *data, int *data_size,
00647 AVPacket *avpkt)
00648 {
00649 const uint8_t *buf = avpkt->data;
00650 int buf_size = avpkt->size;
00651 MpegEncContext *s = avctx->priv_data;
00652 int i;
00653 AVFrame *pict = data;
00654 int slice_count;
00655 const uint8_t *slices_hdr = NULL;
00656
00657 dprintf(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00658
00659
00660 if (buf_size == 0) {
00661 return 0;
00662 }
00663
00664 if(!avctx->slice_count){
00665 slice_count = (*buf++) + 1;
00666 slices_hdr = buf + 4;
00667 buf += 8 * slice_count;
00668 }else
00669 slice_count = avctx->slice_count;
00670
00671 for(i=0; i<slice_count; i++){
00672 int offset= get_slice_offset(avctx, slices_hdr, i);
00673 int size, size2;
00674
00675 if(i+1 == slice_count)
00676 size= buf_size - offset;
00677 else
00678 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
00679
00680 if(i+2 >= slice_count)
00681 size2= buf_size - offset;
00682 else
00683 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
00684
00685 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
00686 i++;
00687 }
00688
00689 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
00690 ff_er_frame_end(s);
00691 MPV_frame_end(s);
00692
00693 if (s->pict_type == FF_B_TYPE || s->low_delay) {
00694 *pict= *(AVFrame*)s->current_picture_ptr;
00695 } else if (s->last_picture_ptr != NULL) {
00696 *pict= *(AVFrame*)s->last_picture_ptr;
00697 }
00698
00699 if(s->last_picture_ptr || s->low_delay){
00700 *data_size = sizeof(AVFrame);
00701 ff_print_debug_info(s, pict);
00702 }
00703 s->current_picture_ptr= NULL;
00704 }
00705
00706 return buf_size;
00707 }
00708
00709 AVCodec rv10_decoder = {
00710 "rv10",
00711 AVMEDIA_TYPE_VIDEO,
00712 CODEC_ID_RV10,
00713 sizeof(MpegEncContext),
00714 rv10_decode_init,
00715 NULL,
00716 rv10_decode_end,
00717 rv10_decode_frame,
00718 CODEC_CAP_DR1,
00719 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
00720 .pix_fmts= ff_pixfmt_list_420,
00721 };
00722
00723 AVCodec rv20_decoder = {
00724 "rv20",
00725 AVMEDIA_TYPE_VIDEO,
00726 CODEC_ID_RV20,
00727 sizeof(MpegEncContext),
00728 rv10_decode_init,
00729 NULL,
00730 rv10_decode_end,
00731 rv10_decode_frame,
00732 CODEC_CAP_DR1 | CODEC_CAP_DELAY,
00733 .flush= ff_mpeg_flush,
00734 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
00735 .pix_fmts= ff_pixfmt_list_420,
00736 };