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