00001 /* 00002 * RV10/RV20 decoder 00003 * Copyright (c) 2000,2001 Fabrice Bellard 00004 * Copyright (c) 2002-2004 Michael Niedermayer 00005 * 00006 * This file is part of FFmpeg. 00007 * 00008 * FFmpeg is free software; you can redistribute it and/or 00009 * modify it under the terms of the GNU Lesser General Public 00010 * License as published by the Free Software Foundation; either 00011 * version 2.1 of the License, or (at your option) any later version. 00012 * 00013 * FFmpeg is distributed in the hope that it will be useful, 00014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00016 * Lesser General Public License for more details. 00017 * 00018 * You should have received a copy of the GNU Lesser General Public 00019 * License along with FFmpeg; if not, write to the Free Software 00020 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 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 //#define DEBUG 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 /* XXX: I don't understand why they use LONGER codes than 00197 necessary. The following code would be completely useless 00198 if they had thought about it !!! */ 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 /* same remark */ 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 /* read RV 1.0 compatible frame header */ 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 /* specific MPEG like DC coding not used */ 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 /* if multiple packets per frame are sent, the position at which 00277 to display the macroblocks is coded here */ 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); /* mb_x */ 00282 s->mb_y = get_bits(&s->gb, 6); /* mb_y */ 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); /* ignored */ 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; //hmm ... 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 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq); 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 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time); 00407 /*for(i=0; i<32; i++){ 00408 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 00409 } 00410 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/ 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); // binary decoder reads 3+2 bits here but they don't seem to be used 00415 00416 s->f_code = 1; 00417 s->unrestricted_mv = 1; 00418 s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I; 00419 // s->alt_inter_vlc=1; 00420 // s->obmc=1; 00421 // s->umvplus=1; 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 /* init rv vlc */ 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){ //FIXME write parser so we always have complete frames? 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 /* default quantization values */ 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 /* decode each macroblock */ 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 // Repeat the slice end check from ff_h263_decode_mb with our active 00606 // bitstream size 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 /* no supplementary picture */ 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; //so we can detect if frame_end wasnt called (find some nicer solution...) 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 };