1/* 2 * RV10 codec 3 * Copyright (c) 2000,2001 Fabrice Bellard 4 * Copyright (c) 2002-2004 Michael Niedermayer 5 * 6 * This file is part of FFmpeg. 7 * 8 * FFmpeg is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * FFmpeg is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with FFmpeg; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23/** 24 * @file libavcodec/rv10.c 25 * RV10 codec. 26 */ 27 28#include "avcodec.h" 29#include "dsputil.h" 30#include "mpegvideo.h" 31 32//#define DEBUG 33 34#define DC_VLC_BITS 14 //FIXME find a better solution 35 36static const uint16_t rv_lum_code[256] = 37{ 38 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06, 39 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e, 40 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16, 41 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e, 42 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26, 43 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e, 44 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36, 45 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e, 46 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386, 47 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e, 48 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 49 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 50 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 51 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 52 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 53 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004, 54 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027, 55 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 56 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 57 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 58 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 59 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af, 60 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 61 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 62 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47, 63 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f, 64 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57, 65 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f, 66 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67, 67 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f, 68 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77, 69 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f, 70}; 71 72static const uint8_t rv_lum_bits[256] = 73{ 74 14, 12, 12, 12, 12, 12, 12, 12, 75 12, 12, 12, 12, 12, 12, 12, 12, 76 12, 12, 12, 12, 12, 12, 12, 12, 77 12, 12, 12, 12, 12, 12, 12, 12, 78 12, 12, 12, 12, 12, 12, 12, 12, 79 12, 12, 12, 12, 12, 12, 12, 12, 80 12, 12, 12, 12, 12, 12, 12, 12, 81 12, 12, 12, 12, 12, 12, 12, 12, 82 12, 10, 10, 10, 10, 10, 10, 10, 83 10, 10, 10, 10, 10, 10, 10, 10, 84 10, 10, 10, 10, 10, 10, 10, 10, 85 10, 10, 10, 10, 10, 10, 10, 10, 86 10, 8, 8, 8, 8, 8, 8, 8, 87 8, 8, 8, 8, 8, 8, 8, 8, 88 8, 7, 7, 7, 7, 7, 7, 7, 89 7, 6, 6, 6, 6, 5, 5, 4, 90 2, 4, 5, 5, 6, 6, 6, 6, 91 7, 7, 7, 7, 7, 7, 7, 7, 92 8, 8, 8, 8, 8, 8, 8, 8, 93 8, 8, 8, 8, 8, 8, 8, 8, 94 10, 10, 10, 10, 10, 10, 10, 10, 95 10, 10, 10, 10, 10, 10, 10, 10, 96 10, 10, 10, 10, 10, 10, 10, 10, 97 10, 10, 10, 10, 10, 10, 10, 10, 98 12, 12, 12, 12, 12, 12, 12, 12, 99 12, 12, 12, 12, 12, 12, 12, 12, 100 12, 12, 12, 12, 12, 12, 12, 12, 101 12, 12, 12, 12, 12, 12, 12, 12, 102 12, 12, 12, 12, 12, 12, 12, 12, 103 12, 12, 12, 12, 12, 12, 12, 12, 104 12, 12, 12, 12, 12, 12, 12, 12, 105 12, 12, 12, 12, 12, 12, 12, 12, 106}; 107 108static const uint16_t rv_chrom_code[256] = 109{ 110 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06, 111 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e, 112 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16, 113 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e, 114 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26, 115 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e, 116 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36, 117 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e, 118 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86, 119 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e, 120 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96, 121 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e, 122 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 123 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 124 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 125 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002, 126 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037, 127 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 128 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7, 129 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df, 130 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7, 131 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf, 132 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7, 133 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf, 134 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47, 135 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f, 136 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57, 137 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f, 138 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67, 139 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f, 140 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77, 141 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f, 142}; 143 144static const uint8_t rv_chrom_bits[256] = 145{ 146 16, 14, 14, 14, 14, 14, 14, 14, 147 14, 14, 14, 14, 14, 14, 14, 14, 148 14, 14, 14, 14, 14, 14, 14, 14, 149 14, 14, 14, 14, 14, 14, 14, 14, 150 14, 14, 14, 14, 14, 14, 14, 14, 151 14, 14, 14, 14, 14, 14, 14, 14, 152 14, 14, 14, 14, 14, 14, 14, 14, 153 14, 14, 14, 14, 14, 14, 14, 14, 154 14, 12, 12, 12, 12, 12, 12, 12, 155 12, 12, 12, 12, 12, 12, 12, 12, 156 12, 12, 12, 12, 12, 12, 12, 12, 157 12, 12, 12, 12, 12, 12, 12, 12, 158 12, 10, 10, 10, 10, 10, 10, 10, 159 10, 10, 10, 10, 10, 10, 10, 10, 160 10, 8, 8, 8, 8, 8, 8, 8, 161 8, 6, 6, 6, 6, 4, 4, 3, 162 2, 3, 4, 4, 6, 6, 6, 6, 163 8, 8, 8, 8, 8, 8, 8, 8, 164 10, 10, 10, 10, 10, 10, 10, 10, 165 10, 10, 10, 10, 10, 10, 10, 10, 166 12, 12, 12, 12, 12, 12, 12, 12, 167 12, 12, 12, 12, 12, 12, 12, 12, 168 12, 12, 12, 12, 12, 12, 12, 12, 169 12, 12, 12, 12, 12, 12, 12, 12, 170 14, 14, 14, 14, 14, 14, 14, 14, 171 14, 14, 14, 14, 14, 14, 14, 14, 172 14, 14, 14, 14, 14, 14, 14, 14, 173 14, 14, 14, 14, 14, 14, 14, 14, 174 14, 14, 14, 14, 14, 14, 14, 14, 175 14, 14, 14, 14, 14, 14, 14, 14, 176 14, 14, 14, 14, 14, 14, 14, 14, 177 14, 14, 14, 14, 14, 14, 14, 14, 178}; 179 180static VLC rv_dc_lum, rv_dc_chrom; 181 182int rv_decode_dc(MpegEncContext *s, int n) 183{ 184 int code; 185 186 if (n < 4) { 187 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2); 188 if (code < 0) { 189 /* XXX: I don't understand why they use LONGER codes than 190 necessary. The following code would be completely useless 191 if they had thought about it !!! */ 192 code = get_bits(&s->gb, 7); 193 if (code == 0x7c) { 194 code = (int8_t)(get_bits(&s->gb, 7) + 1); 195 } else if (code == 0x7d) { 196 code = -128 + get_bits(&s->gb, 7); 197 } else if (code == 0x7e) { 198 if (get_bits1(&s->gb) == 0) 199 code = (int8_t)(get_bits(&s->gb, 8) + 1); 200 else 201 code = (int8_t)(get_bits(&s->gb, 8)); 202 } else if (code == 0x7f) { 203 skip_bits(&s->gb, 11); 204 code = 1; 205 } 206 } else { 207 code -= 128; 208 } 209 } else { 210 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2); 211 /* same remark */ 212 if (code < 0) { 213 code = get_bits(&s->gb, 9); 214 if (code == 0x1fc) { 215 code = (int8_t)(get_bits(&s->gb, 7) + 1); 216 } else if (code == 0x1fd) { 217 code = -128 + get_bits(&s->gb, 7); 218 } else if (code == 0x1fe) { 219 skip_bits(&s->gb, 9); 220 code = 1; 221 } else { 222 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n"); 223 return 0xffff; 224 } 225 } else { 226 code -= 128; 227 } 228 } 229 return -code; 230} 231 232 233#if CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER 234/* write RV 1.0 compatible frame header */ 235void rv10_encode_picture_header(MpegEncContext *s, int picture_number) 236{ 237 int full_frame= 0; 238 239 align_put_bits(&s->pb); 240 241 put_bits(&s->pb, 1, 1); /* marker */ 242 243 put_bits(&s->pb, 1, (s->pict_type == FF_P_TYPE)); 244 245 put_bits(&s->pb, 1, 0); /* not PB frame */ 246 247 put_bits(&s->pb, 5, s->qscale); 248 249 if (s->pict_type == FF_I_TYPE) { 250 /* specific MPEG like DC coding not used */ 251 } 252 /* if multiple packets per frame are sent, the position at which 253 to display the macroblocks is coded here */ 254 if(!full_frame){ 255 put_bits(&s->pb, 6, 0); /* mb_x */ 256 put_bits(&s->pb, 6, 0); /* mb_y */ 257 put_bits(&s->pb, 12, s->mb_width * s->mb_height); 258 } 259 260 put_bits(&s->pb, 3, 0); /* ignored */ 261} 262 263void rv20_encode_picture_header(MpegEncContext *s, int picture_number){ 264 put_bits(&s->pb, 2, s->pict_type); //I 0 vs. 1 ? 265 put_bits(&s->pb, 1, 0); /* unknown bit */ 266 put_bits(&s->pb, 5, s->qscale); 267 268 put_sbits(&s->pb, 8, picture_number); //FIXME wrong, but correct is not known 269 s->mb_x= s->mb_y= 0; 270 ff_h263_encode_mba(s); 271 272 put_bits(&s->pb, 1, s->no_rounding); 273 274 assert(s->f_code == 1); 275 assert(s->unrestricted_mv == 1); 276// assert(s->h263_aic== (s->pict_type == FF_I_TYPE)); 277 assert(s->alt_inter_vlc == 0); 278 assert(s->umvplus == 0); 279 assert(s->modified_quant==1); 280 assert(s->loop_filter==1); 281 282 s->h263_aic= s->pict_type == FF_I_TYPE; 283 if(s->h263_aic){ 284 s->y_dc_scale_table= 285 s->c_dc_scale_table= ff_aic_dc_scale_table; 286 }else{ 287 s->y_dc_scale_table= 288 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 289 } 290} 291 292#if 0 /* unused, remove? */ 293static int get_num(GetBitContext *gb) 294{ 295 int n, n1; 296 297 n = get_bits(gb, 16); 298 if (n >= 0x4000) { 299 return n - 0x4000; 300 } else { 301 n1 = get_bits(gb, 16); 302 return (n << 16) | n1; 303 } 304} 305#endif 306 307#endif /* CONFIG_RV10_ENCODER || CONFIG_RV20_ENCODER */ 308 309/* read RV 1.0 compatible frame header */ 310static int rv10_decode_picture_header(MpegEncContext *s) 311{ 312 int mb_count, pb_frame, marker, unk, mb_xy; 313 314//printf("ff:%d\n", full_frame); 315 marker = get_bits1(&s->gb); 316 317 if (get_bits1(&s->gb)) 318 s->pict_type = FF_P_TYPE; 319 else 320 s->pict_type = FF_I_TYPE; 321//printf("h:%X ver:%d\n",h,s->rv10_version); 322 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n"); 323 pb_frame = get_bits1(&s->gb); 324 325#ifdef DEBUG 326 av_log(s->avctx, AV_LOG_DEBUG, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame); 327#endif 328 329 if (pb_frame){ 330 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n"); 331 return -1; 332 } 333 334 s->qscale = get_bits(&s->gb, 5); 335 if(s->qscale==0){ 336 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n"); 337 return -1; 338 } 339 340 if (s->pict_type == FF_I_TYPE) { 341 if (s->rv10_version == 3) { 342 /* specific MPEG like DC coding not used */ 343 s->last_dc[0] = get_bits(&s->gb, 8); 344 s->last_dc[1] = get_bits(&s->gb, 8); 345 s->last_dc[2] = get_bits(&s->gb, 8); 346#ifdef DEBUG 347 av_log(s->avctx, AV_LOG_DEBUG, "DC:%d %d %d\n", 348 s->last_dc[0], 349 s->last_dc[1], 350 s->last_dc[2]); 351#endif 352 } 353 } 354 /* if multiple packets per frame are sent, the position at which 355 to display the macroblocks is coded here */ 356 357 mb_xy= s->mb_x + s->mb_y*s->mb_width; 358 if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){ 359 s->mb_x = get_bits(&s->gb, 6); /* mb_x */ 360 s->mb_y = get_bits(&s->gb, 6); /* mb_y */ 361 mb_count = get_bits(&s->gb, 12); 362 } else { 363 s->mb_x = 0; 364 s->mb_y = 0; 365 mb_count = s->mb_width * s->mb_height; 366 } 367 unk= get_bits(&s->gb, 3); /* ignored */ 368//printf("%d\n", unk); 369 s->f_code = 1; 370 s->unrestricted_mv = 1; 371 372 return mb_count; 373} 374 375static int rv20_decode_picture_header(MpegEncContext *s) 376{ 377 int seq, mb_pos, i; 378 379#if 0 380 GetBitContext gb= s->gb; 381 for(i=0; i<64; i++){ 382 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&gb)); 383 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " "); 384 } 385 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 386#endif 387#if 0 388 av_log(s->avctx, AV_LOG_DEBUG, "%3dx%03d/%02Xx%02X ", s->width, s->height, s->width/4, s->height/4); 389 for(i=0; i<s->avctx->extradata_size; i++){ 390 av_log(s->avctx, AV_LOG_DEBUG, "%02X ", ((uint8_t*)s->avctx->extradata)[i]); 391 if(i%4==3) av_log(s->avctx, AV_LOG_DEBUG, " "); 392 } 393 av_log(s->avctx, AV_LOG_DEBUG, "\n"); 394#endif 395 396 if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){ 397 if (get_bits(&s->gb, 3)){ 398 av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n"); 399 return -1; 400 } 401 } 402 403 i= get_bits(&s->gb, 2); 404 switch(i){ 405 case 0: s->pict_type= FF_I_TYPE; break; 406 case 1: s->pict_type= FF_I_TYPE; break; //hmm ... 407 case 2: s->pict_type= FF_P_TYPE; break; 408 case 3: s->pict_type= FF_B_TYPE; break; 409 default: 410 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n"); 411 return -1; 412 } 413 414 if(s->last_picture_ptr==NULL && s->pict_type==FF_B_TYPE){ 415 av_log(s->avctx, AV_LOG_ERROR, "early B pix\n"); 416 return -1; 417 } 418 419 if (get_bits1(&s->gb)){ 420 av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n"); 421 return -1; 422 } 423 424 s->qscale = get_bits(&s->gb, 5); 425 if(s->qscale==0){ 426 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n"); 427 return -1; 428 } 429 if(s->avctx->sub_id == 0x30203002){ 430 if (get_bits1(&s->gb)){ 431 av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n"); 432 return -1; 433 } 434 } 435 436 if(s->avctx->has_b_frames){ 437 int f, new_w, new_h; 438 int v= s->avctx->extradata_size >= 4 ? 7&((uint8_t*)s->avctx->extradata)[1] : 0; 439 440 if (get_bits1(&s->gb)){ 441 av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n"); 442// return -1; 443 } 444 seq= get_bits(&s->gb, 13)<<2; 445 446 f= get_bits(&s->gb, av_log2(v)+1); 447 448 if(f){ 449 new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f]; 450 new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f]; 451 }else{ 452 new_w= s->width; //FIXME wrong we of course must save the original in the context 453 new_h= s->height; 454 } 455 if(new_w != s->width || new_h != s->height){ 456 av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h); 457 if (avcodec_check_dimensions(s->avctx, new_h, new_w) < 0) 458 return -1; 459 MPV_common_end(s); 460 s->width = s->avctx->width = new_w; 461 s->height = s->avctx->height= new_h; 462 if (MPV_common_init(s) < 0) 463 return -1; 464 } 465 466 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ 467 av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, v); 468 } 469 }else{ 470 seq= get_bits(&s->gb, 8)*128; 471 } 472 473// if(s->avctx->sub_id <= 0x20201002){ //0x20201002 definitely needs this 474 mb_pos= ff_h263_decode_mba(s); 475/* }else{ 476 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1); 477 s->mb_x= mb_pos % s->mb_width; 478 s->mb_y= mb_pos / s->mb_width; 479 }*/ 480//av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq); 481 seq |= s->time &~0x7FFF; 482 if(seq - s->time > 0x4000) seq -= 0x8000; 483 if(seq - s->time < -0x4000) seq += 0x8000; 484 if(seq != s->time){ 485 if(s->pict_type!=FF_B_TYPE){ 486 s->time= seq; 487 s->pp_time= s->time - s->last_non_b_time; 488 s->last_non_b_time= s->time; 489 }else{ 490 s->time= seq; 491 s->pb_time= s->pp_time - (s->last_non_b_time - s->time); 492 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){ 493 av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n"); 494 return FRAME_SKIPPED; 495 } 496 ff_mpeg4_init_direct_mv(s); 497 } 498 } 499// printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time); 500/*for(i=0; i<32; i++){ 501 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); 502} 503av_log(s->avctx, AV_LOG_DEBUG, "\n");*/ 504 s->no_rounding= get_bits1(&s->gb); 505 506 s->f_code = 1; 507 s->unrestricted_mv = 1; 508 s->h263_aic= s->pict_type == FF_I_TYPE; 509// s->alt_inter_vlc=1; 510// s->obmc=1; 511// s->umvplus=1; 512 s->modified_quant=1; 513 s->loop_filter=1; 514 515 if(s->avctx->debug & FF_DEBUG_PICT_INFO){ 516 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n", 517 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding); 518 } 519 520 assert(s->pict_type != FF_B_TYPE || !s->low_delay); 521 522 return s->mb_width*s->mb_height - mb_pos; 523} 524 525static av_cold int rv10_decode_init(AVCodecContext *avctx) 526{ 527 MpegEncContext *s = avctx->priv_data; 528 static int done=0; 529 530 if (avctx->extradata_size < 8) { 531 av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n"); 532 return -1; 533 } 534 535 MPV_decode_defaults(s); 536 537 s->avctx= avctx; 538 s->out_format = FMT_H263; 539 s->codec_id= avctx->codec_id; 540 541 s->width = avctx->width; 542 s->height = avctx->height; 543 544 s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1; 545 avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4); 546 547 if (avctx->sub_id == 0x10000000) { 548 s->rv10_version= 0; 549 s->low_delay=1; 550 } else if (avctx->sub_id == 0x10001000) { 551 s->rv10_version= 3; 552 s->low_delay=1; 553 } else if (avctx->sub_id == 0x10002000) { 554 s->rv10_version= 3; 555 s->low_delay=1; 556 s->obmc=1; 557 } else if (avctx->sub_id == 0x10003000) { 558 s->rv10_version= 3; 559 s->low_delay=1; 560 } else if (avctx->sub_id == 0x10003001) { 561 s->rv10_version= 3; 562 s->low_delay=1; 563 } else if ( avctx->sub_id == 0x20001000 564 || (avctx->sub_id >= 0x20100000 && avctx->sub_id < 0x201a0000)) { 565 s->low_delay=1; 566 } else if ( avctx->sub_id == 0x30202002 567 || avctx->sub_id == 0x30203002 568 || (avctx->sub_id >= 0x20200002 && avctx->sub_id < 0x20300000)) { 569 s->low_delay=0; 570 s->avctx->has_b_frames=1; 571 } else 572 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id); 573 574 if(avctx->debug & FF_DEBUG_PICT_INFO){ 575 av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1); 576 } 577 578 avctx->pix_fmt = PIX_FMT_YUV420P; 579 580 if (MPV_common_init(s) < 0) 581 return -1; 582 583 h263_decode_init_vlc(s); 584 585 /* init rv vlc */ 586 if (!done) { 587 init_vlc(&rv_dc_lum, DC_VLC_BITS, 256, 588 rv_lum_bits, 1, 1, 589 rv_lum_code, 2, 2, 1); 590 init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256, 591 rv_chrom_bits, 1, 1, 592 rv_chrom_code, 2, 2, 1); 593 done = 1; 594 } 595 596 return 0; 597} 598 599static av_cold int rv10_decode_end(AVCodecContext *avctx) 600{ 601 MpegEncContext *s = avctx->priv_data; 602 603 MPV_common_end(s); 604 return 0; 605} 606 607static int rv10_decode_packet(AVCodecContext *avctx, 608 const uint8_t *buf, int buf_size) 609{ 610 MpegEncContext *s = avctx->priv_data; 611 int mb_count, mb_pos, left, start_mb_x; 612 613 init_get_bits(&s->gb, buf, buf_size*8); 614 if(s->codec_id ==CODEC_ID_RV10) 615 mb_count = rv10_decode_picture_header(s); 616 else 617 mb_count = rv20_decode_picture_header(s); 618 if (mb_count < 0) { 619 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n"); 620 return -1; 621 } 622 623 if (s->mb_x >= s->mb_width || 624 s->mb_y >= s->mb_height) { 625 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y); 626 return -1; 627 } 628 mb_pos = s->mb_y * s->mb_width + s->mb_x; 629 left = s->mb_width * s->mb_height - mb_pos; 630 if (mb_count > left) { 631 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n"); 632 return -1; 633 } 634//if(s->pict_type == FF_P_TYPE) return 0; 635 636 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) { 637 if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames? 638 ff_er_frame_end(s); 639 MPV_frame_end(s); 640 s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0; 641 } 642 if(MPV_frame_start(s, avctx) < 0) 643 return -1; 644 ff_er_frame_start(s); 645 } 646 647#ifdef DEBUG 648 av_log(avctx, AV_LOG_DEBUG, "qscale=%d\n", s->qscale); 649#endif 650 651 /* default quantization values */ 652 if(s->codec_id== CODEC_ID_RV10){ 653 if(s->mb_y==0) s->first_slice_line=1; 654 }else{ 655 s->first_slice_line=1; 656 s->resync_mb_x= s->mb_x; 657 } 658 start_mb_x= s->mb_x; 659 s->resync_mb_y= s->mb_y; 660 if(s->h263_aic){ 661 s->y_dc_scale_table= 662 s->c_dc_scale_table= ff_aic_dc_scale_table; 663 }else{ 664 s->y_dc_scale_table= 665 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; 666 } 667 668 if(s->modified_quant) 669 s->chroma_qscale_table= ff_h263_chroma_qscale_table; 670 671 ff_set_qscale(s, s->qscale); 672 673 s->rv10_first_dc_coded[0] = 0; 674 s->rv10_first_dc_coded[1] = 0; 675 s->rv10_first_dc_coded[2] = 0; 676//printf("%d %X %X\n", s->pict_type, s->current_picture.motion_val[0], s->current_picture.motion_val[1]); 677 s->block_wrap[0]= 678 s->block_wrap[1]= 679 s->block_wrap[2]= 680 s->block_wrap[3]= s->b8_stride; 681 s->block_wrap[4]= 682 s->block_wrap[5]= s->mb_stride; 683 ff_init_block_index(s); 684 /* decode each macroblock */ 685 686 for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) { 687 int ret; 688 ff_update_block_index(s); 689#ifdef DEBUG 690 av_log(avctx, AV_LOG_DEBUG, "**mb x=%d y=%d\n", s->mb_x, s->mb_y); 691#endif 692 693 s->mv_dir = MV_DIR_FORWARD; 694 s->mv_type = MV_TYPE_16X16; 695 ret=ff_h263_decode_mb(s, s->block); 696 697 if (ret == SLICE_ERROR || s->gb.size_in_bits < get_bits_count(&s->gb)) { 698 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y); 699 return -1; 700 } 701 if(s->pict_type != FF_B_TYPE) 702 ff_h263_update_motion_val(s); 703 MPV_decode_mb(s, s->block); 704 if(s->loop_filter) 705 ff_h263_loop_filter(s); 706 707 if (++s->mb_x == s->mb_width) { 708 s->mb_x = 0; 709 s->mb_y++; 710 ff_init_block_index(s); 711 } 712 if(s->mb_x == s->resync_mb_x) 713 s->first_slice_line=0; 714 if(ret == SLICE_END) break; 715 } 716 717 ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END); 718 719 return buf_size; 720} 721 722static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n) 723{ 724 if(avctx->slice_count) return avctx->slice_offset[n]; 725 else return AV_RL32(buf + n*8); 726} 727 728static int rv10_decode_frame(AVCodecContext *avctx, 729 void *data, int *data_size, 730 const uint8_t *buf, int buf_size) 731{ 732 MpegEncContext *s = avctx->priv_data; 733 int i; 734 AVFrame *pict = data; 735 int slice_count; 736 const uint8_t *slices_hdr = NULL; 737 738#ifdef DEBUG 739 av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, buf_size); 740#endif 741 742 /* no supplementary picture */ 743 if (buf_size == 0) { 744 return 0; 745 } 746 747 if(!avctx->slice_count){ 748 slice_count = (*buf++) + 1; 749 slices_hdr = buf + 4; 750 buf += 8 * slice_count; 751 }else 752 slice_count = avctx->slice_count; 753 754 for(i=0; i<slice_count; i++){ 755 int offset= get_slice_offset(avctx, slices_hdr, i); 756 int size; 757 758 if(i+1 == slice_count) 759 size= buf_size - offset; 760 else 761 size= get_slice_offset(avctx, slices_hdr, i+1) - offset; 762 763 rv10_decode_packet(avctx, buf+offset, size); 764 } 765 766 if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){ 767 ff_er_frame_end(s); 768 MPV_frame_end(s); 769 770 if (s->pict_type == FF_B_TYPE || s->low_delay) { 771 *pict= *(AVFrame*)s->current_picture_ptr; 772 } else if (s->last_picture_ptr != NULL) { 773 *pict= *(AVFrame*)s->last_picture_ptr; 774 } 775 776 if(s->last_picture_ptr || s->low_delay){ 777 *data_size = sizeof(AVFrame); 778 ff_print_debug_info(s, pict); 779 } 780 s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...) 781 } 782 783 return buf_size; 784} 785 786AVCodec rv10_decoder = { 787 "rv10", 788 CODEC_TYPE_VIDEO, 789 CODEC_ID_RV10, 790 sizeof(MpegEncContext), 791 rv10_decode_init, 792 NULL, 793 rv10_decode_end, 794 rv10_decode_frame, 795 CODEC_CAP_DR1, 796 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"), 797 .pix_fmts= ff_pixfmt_list_420, 798}; 799 800AVCodec rv20_decoder = { 801 "rv20", 802 CODEC_TYPE_VIDEO, 803 CODEC_ID_RV20, 804 sizeof(MpegEncContext), 805 rv10_decode_init, 806 NULL, 807 rv10_decode_end, 808 rv10_decode_frame, 809 CODEC_CAP_DR1 | CODEC_CAP_DELAY, 810 .flush= ff_mpeg_flush, 811 .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"), 812 .pix_fmts= ff_pixfmt_list_420, 813}; 814 815