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