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