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 if (s->avctx->extradata_size < 8 + 2 * f) {
00345 av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
00346 return AVERROR_INVALIDDATA;
00347 }
00348
00349 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
00350 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
00351 }else{
00352 new_w= s->orig_width ;
00353 new_h= s->orig_height;
00354 }
00355 if(new_w != s->width || new_h != s->height){
00356 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
00357 if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
00358 return -1;
00359 MPV_common_end(s);
00360 avcodec_set_dimensions(s->avctx, new_w, new_h);
00361 s->width = new_w;
00362 s->height = new_h;
00363 if (MPV_common_init(s) < 0)
00364 return -1;
00365 }
00366
00367 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00368 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
00369 }
00370 } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
00371 return AVERROR_INVALIDDATA;
00372
00373 mb_pos = ff_h263_decode_mba(s);
00374
00375
00376 seq |= s->time &~0x7FFF;
00377 if(seq - s->time > 0x4000) seq -= 0x8000;
00378 if(seq - s->time < -0x4000) seq += 0x8000;
00379 if(seq != s->time){
00380 if(s->pict_type!=AV_PICTURE_TYPE_B){
00381 s->time= seq;
00382 s->pp_time= s->time - s->last_non_b_time;
00383 s->last_non_b_time= s->time;
00384 }else{
00385 s->time= seq;
00386 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
00387 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
00388 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
00389 return FRAME_SKIPPED;
00390 }
00391 ff_mpeg4_init_direct_mv(s);
00392 }
00393 }
00394
00395
00396
00397
00398
00399 s->no_rounding= get_bits1(&s->gb);
00400
00401 if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
00402 skip_bits(&s->gb, 5);
00403
00404 s->f_code = 1;
00405 s->unrestricted_mv = 1;
00406 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
00407
00408
00409
00410 s->modified_quant=1;
00411 if(!s->avctx->lowres)
00412 s->loop_filter=1;
00413
00414 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
00415 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
00416 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
00417 }
00418
00419 assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
00420
00421 return s->mb_width*s->mb_height - mb_pos;
00422 }
00423
00424 static av_cold int rv10_decode_init(AVCodecContext *avctx)
00425 {
00426 MpegEncContext *s = avctx->priv_data;
00427 static int done=0;
00428 int major_ver, minor_ver, micro_ver, ret;
00429
00430 if (avctx->extradata_size < 8) {
00431 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
00432 return -1;
00433 }
00434 if ((ret = av_image_check_size(avctx->coded_width,
00435 avctx->coded_height, 0, avctx)) < 0)
00436 return ret;
00437
00438 MPV_decode_defaults(s);
00439
00440 s->avctx= avctx;
00441 s->out_format = FMT_H263;
00442 s->codec_id= avctx->codec_id;
00443 avctx->flags |= CODEC_FLAG_EMU_EDGE;
00444
00445 s->orig_width = s->width = avctx->coded_width;
00446 s->orig_height= s->height = avctx->coded_height;
00447
00448 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
00449 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
00450
00451 major_ver = RV_GET_MAJOR_VER(avctx->sub_id);
00452 minor_ver = RV_GET_MINOR_VER(avctx->sub_id);
00453 micro_ver = RV_GET_MICRO_VER(avctx->sub_id);
00454
00455 s->low_delay = 1;
00456 switch (major_ver) {
00457 case 1:
00458 s->rv10_version = micro_ver ? 3 : 1;
00459 s->obmc = micro_ver == 2;
00460 break;
00461 case 2:
00462 if (minor_ver >= 2) {
00463 s->low_delay = 0;
00464 s->avctx->has_b_frames = 1;
00465 }
00466 break;
00467 default:
00468 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
00469 av_log_missing_feature(avctx, "RV1/2 version", 1);
00470 return AVERROR_PATCHWELCOME;
00471 }
00472
00473 if(avctx->debug & FF_DEBUG_PICT_INFO){
00474 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
00475 }
00476
00477 avctx->pix_fmt = PIX_FMT_YUV420P;
00478
00479 if (MPV_common_init(s) < 0)
00480 return -1;
00481
00482 ff_h263_decode_init_vlc(s);
00483
00484
00485 if (!done) {
00486 INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
00487 rv_lum_bits, 1, 1,
00488 rv_lum_code, 2, 2, 16384);
00489 INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
00490 rv_chrom_bits, 1, 1,
00491 rv_chrom_code, 2, 2, 16388);
00492 done = 1;
00493 }
00494
00495 return 0;
00496 }
00497
00498 static av_cold int rv10_decode_end(AVCodecContext *avctx)
00499 {
00500 MpegEncContext *s = avctx->priv_data;
00501
00502 MPV_common_end(s);
00503 return 0;
00504 }
00505
00506 static int rv10_decode_packet(AVCodecContext *avctx,
00507 const uint8_t *buf, int buf_size, int buf_size2)
00508 {
00509 MpegEncContext *s = avctx->priv_data;
00510 int mb_count, mb_pos, left, start_mb_x, active_bits_size;
00511
00512 active_bits_size = buf_size * 8;
00513 init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
00514 if(s->codec_id ==CODEC_ID_RV10)
00515 mb_count = rv10_decode_picture_header(s);
00516 else
00517 mb_count = rv20_decode_picture_header(s);
00518 if (mb_count < 0) {
00519 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
00520 return -1;
00521 }
00522
00523 if (s->mb_x >= s->mb_width ||
00524 s->mb_y >= s->mb_height) {
00525 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
00526 return -1;
00527 }
00528 mb_pos = s->mb_y * s->mb_width + s->mb_x;
00529 left = s->mb_width * s->mb_height - mb_pos;
00530 if (mb_count > left) {
00531 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
00532 return -1;
00533 }
00534
00535 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
00536 if(s->current_picture_ptr){
00537 ff_er_frame_end(s);
00538 MPV_frame_end(s);
00539 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
00540 }
00541 if(MPV_frame_start(s, avctx) < 0)
00542 return -1;
00543 ff_er_frame_start(s);
00544 } else {
00545 if (s->current_picture_ptr->f.pict_type != s->pict_type) {
00546 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
00547 return -1;
00548 }
00549 }
00550
00551 av_dlog(avctx, "qscale=%d\n", s->qscale);
00552
00553
00554 if(s->codec_id== CODEC_ID_RV10){
00555 if(s->mb_y==0) s->first_slice_line=1;
00556 }else{
00557 s->first_slice_line=1;
00558 s->resync_mb_x= s->mb_x;
00559 }
00560 start_mb_x= s->mb_x;
00561 s->resync_mb_y= s->mb_y;
00562 if(s->h263_aic){
00563 s->y_dc_scale_table=
00564 s->c_dc_scale_table= ff_aic_dc_scale_table;
00565 }else{
00566 s->y_dc_scale_table=
00567 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
00568 }
00569
00570 if(s->modified_quant)
00571 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
00572
00573 ff_set_qscale(s, s->qscale);
00574
00575 s->rv10_first_dc_coded[0] = 0;
00576 s->rv10_first_dc_coded[1] = 0;
00577 s->rv10_first_dc_coded[2] = 0;
00578 s->block_wrap[0]=
00579 s->block_wrap[1]=
00580 s->block_wrap[2]=
00581 s->block_wrap[3]= s->b8_stride;
00582 s->block_wrap[4]=
00583 s->block_wrap[5]= s->mb_stride;
00584 ff_init_block_index(s);
00585
00586
00587 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
00588 int ret;
00589 ff_update_block_index(s);
00590 av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
00591
00592 s->mv_dir = MV_DIR_FORWARD;
00593 s->mv_type = MV_TYPE_16X16;
00594 ret=ff_h263_decode_mb(s, s->block);
00595
00596
00597
00598 if (ret != SLICE_ERROR) {
00599 int v = show_bits(&s->gb, 16);
00600
00601 if (get_bits_count(&s->gb) + 16 > active_bits_size)
00602 v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
00603
00604 if (!v)
00605 ret = SLICE_END;
00606 }
00607 if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
00608 8 * buf_size2 >= get_bits_count(&s->gb)) {
00609 active_bits_size = buf_size2 * 8;
00610 av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
00611 8 * buf_size, active_bits_size);
00612 ret= SLICE_OK;
00613 }
00614
00615 if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
00616 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
00617 return -1;
00618 }
00619 if(s->pict_type != AV_PICTURE_TYPE_B)
00620 ff_h263_update_motion_val(s);
00621 MPV_decode_mb(s, s->block);
00622 if(s->loop_filter)
00623 ff_h263_loop_filter(s);
00624
00625 if (++s->mb_x == s->mb_width) {
00626 s->mb_x = 0;
00627 s->mb_y++;
00628 ff_init_block_index(s);
00629 }
00630 if(s->mb_x == s->resync_mb_x)
00631 s->first_slice_line=0;
00632 if(ret == SLICE_END) break;
00633 }
00634
00635 ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
00636
00637 return active_bits_size;
00638 }
00639
00640 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
00641 {
00642 if(avctx->slice_count) return avctx->slice_offset[n];
00643 else return AV_RL32(buf + n*8);
00644 }
00645
00646 static int rv10_decode_frame(AVCodecContext *avctx,
00647 void *data, int *data_size,
00648 AVPacket *avpkt)
00649 {
00650 const uint8_t *buf = avpkt->data;
00651 int buf_size = avpkt->size;
00652 MpegEncContext *s = avctx->priv_data;
00653 int i;
00654 AVFrame *pict = data;
00655 int slice_count;
00656 const uint8_t *slices_hdr = NULL;
00657
00658 av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
00659
00660
00661 if (buf_size == 0) {
00662 return 0;
00663 }
00664
00665 if(!avctx->slice_count){
00666 slice_count = (*buf++) + 1;
00667 buf_size--;
00668 slices_hdr = buf + 4;
00669 buf += 8 * slice_count;
00670 buf_size -= 8 * slice_count;
00671 if (buf_size <= 0)
00672 return AVERROR_INVALIDDATA;
00673 }else
00674 slice_count = avctx->slice_count;
00675
00676 for(i=0; i<slice_count; i++){
00677 int offset= get_slice_offset(avctx, slices_hdr, i);
00678 int size, size2;
00679
00680 if(i+1 == slice_count)
00681 size= buf_size - offset;
00682 else
00683 size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
00684
00685 if(i+2 >= slice_count)
00686 size2= buf_size - offset;
00687 else
00688 size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
00689
00690 if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
00691 i++;
00692 }
00693
00694 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
00695 ff_er_frame_end(s);
00696 MPV_frame_end(s);
00697
00698 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
00699 *pict= *(AVFrame*)s->current_picture_ptr;
00700 } else if (s->last_picture_ptr != NULL) {
00701 *pict= *(AVFrame*)s->last_picture_ptr;
00702 }
00703
00704 if(s->last_picture_ptr || s->low_delay){
00705 *data_size = sizeof(AVFrame);
00706 ff_print_debug_info(s, pict);
00707 }
00708 s->current_picture_ptr= NULL;
00709 }
00710
00711 return avpkt->size;
00712 }
00713
00714 AVCodec ff_rv10_decoder = {
00715 .name = "rv10",
00716 .type = AVMEDIA_TYPE_VIDEO,
00717 .id = CODEC_ID_RV10,
00718 .priv_data_size = sizeof(MpegEncContext),
00719 .init = rv10_decode_init,
00720 .close = rv10_decode_end,
00721 .decode = rv10_decode_frame,
00722 .capabilities = CODEC_CAP_DR1,
00723 .max_lowres = 3,
00724 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
00725 .pix_fmts= ff_pixfmt_list_420,
00726 };
00727
00728 AVCodec ff_rv20_decoder = {
00729 .name = "rv20",
00730 .type = AVMEDIA_TYPE_VIDEO,
00731 .id = CODEC_ID_RV20,
00732 .priv_data_size = sizeof(MpegEncContext),
00733 .init = rv10_decode_init,
00734 .close = rv10_decode_end,
00735 .decode = rv10_decode_frame,
00736 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
00737 .flush= ff_mpeg_flush,
00738 .max_lowres = 3,
00739 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
00740 .pix_fmts= ff_pixfmt_list_420,
00741 };