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