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