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