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 "libavutil/imgutils.h"
29 #include "avcodec.h"
30 #include "error_resilience.h"
31 #include "mpegvideo.h"
32 #include "mpeg4video.h"
33 #include "h263.h"
34 
35 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
36 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
37 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
38 
39 #define DC_VLC_BITS 14 //FIXME find a better solution
40 
41 typedef struct RVDecContext {
42  MpegEncContext m;
43  int sub_id;
44 } RVDecContext;
45 
46 static const uint16_t rv_lum_code[256] = {
47  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
48  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
49  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
50  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
51  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
52  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
53  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
54  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
55  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
56  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
57  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
58  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
59  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
60  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
61  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
62  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
63  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
64  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
65  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
66  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
67  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
68  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
69  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
70  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
71  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
72  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
73  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
74  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
75  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
76  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
77  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
78  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
79 };
80 
81 static const uint8_t rv_lum_bits[256] = {
82  14, 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, 12, 12, 12, 12, 12, 12, 12,
90  12, 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, 10, 10, 10, 10, 10, 10, 10,
94  10, 8, 8, 8, 8, 8, 8, 8,
95  8, 8, 8, 8, 8, 8, 8, 8,
96  8, 7, 7, 7, 7, 7, 7, 7,
97  7, 6, 6, 6, 6, 5, 5, 4,
98  2, 4, 5, 5, 6, 6, 6, 6,
99  7, 7, 7, 7, 7, 7, 7, 7,
100  8, 8, 8, 8, 8, 8, 8, 8,
101  8, 8, 8, 8, 8, 8, 8, 8,
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  10, 10, 10, 10, 10, 10, 10, 10,
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  12, 12, 12, 12, 12, 12, 12, 12,
114 };
115 
116 static const uint16_t rv_chrom_code[256] = {
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 
151 static const uint8_t rv_chrom_bits[256] = {
152  16, 14, 14, 14, 14, 14, 14, 14,
153  14, 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, 12, 12, 12, 12, 12, 12, 12,
161  12, 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, 10, 10, 10, 10, 10, 10, 10,
165  10, 10, 10, 10, 10, 10, 10, 10,
166  10, 8, 8, 8, 8, 8, 8, 8,
167  8, 6, 6, 6, 6, 4, 4, 3,
168  2, 3, 4, 4, 6, 6, 6, 6,
169  8, 8, 8, 8, 8, 8, 8, 8,
170  10, 10, 10, 10, 10, 10, 10, 10,
171  10, 10, 10, 10, 10, 10, 10, 10,
172  12, 12, 12, 12, 12, 12, 12, 12,
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  14, 14, 14, 14, 14, 14, 14, 14,
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 };
185 
186 static VLC rv_dc_lum, rv_dc_chrom;
187 
188 int ff_rv_decode_dc(MpegEncContext *s, int n)
189 {
190  int code;
191 
192  if (n < 4) {
193  code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
194  if (code < 0) {
195  /* XXX: I don't understand why they use LONGER codes than
196  necessary. The following code would be completely useless
197  if they had thought about it !!! */
198  code = get_bits(&s->gb, 7);
199  if (code == 0x7c) {
200  code = (int8_t)(get_bits(&s->gb, 7) + 1);
201  } else if (code == 0x7d) {
202  code = -128 + get_bits(&s->gb, 7);
203  } else if (code == 0x7e) {
204  if (get_bits1(&s->gb) == 0)
205  code = (int8_t)(get_bits(&s->gb, 8) + 1);
206  else
207  code = (int8_t)(get_bits(&s->gb, 8));
208  } else if (code == 0x7f) {
209  skip_bits(&s->gb, 11);
210  code = 1;
211  }
212  } else {
213  code -= 128;
214  }
215  } else {
216  code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
217  /* same remark */
218  if (code < 0) {
219  code = get_bits(&s->gb, 9);
220  if (code == 0x1fc) {
221  code = (int8_t)(get_bits(&s->gb, 7) + 1);
222  } else if (code == 0x1fd) {
223  code = -128 + get_bits(&s->gb, 7);
224  } else if (code == 0x1fe) {
225  skip_bits(&s->gb, 9);
226  code = 1;
227  } else {
228  av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
229  return 0xffff;
230  }
231  } else {
232  code -= 128;
233  }
234  }
235  return -code;
236 }
237 
238 /* read RV 1.0 compatible frame header */
239 static int rv10_decode_picture_header(MpegEncContext *s)
240 {
241  int mb_count, pb_frame, marker, mb_xy;
242 
243  marker = get_bits1(&s->gb);
244 
245  if (get_bits1(&s->gb))
246  s->pict_type = AV_PICTURE_TYPE_P;
247  else
248  s->pict_type = AV_PICTURE_TYPE_I;
249 
250  if (!marker)
251  av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
252 
253  pb_frame = get_bits1(&s->gb);
254 
255  av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
256 
257  if (pb_frame) {
258  avpriv_request_sample(s->avctx, "pb frame");
259  return AVERROR_PATCHWELCOME;
260  }
261 
262  s->qscale = get_bits(&s->gb, 5);
263  if (s->qscale == 0) {
264  av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
265  return AVERROR_INVALIDDATA;
266  }
267 
268  if (s->pict_type == AV_PICTURE_TYPE_I) {
269  if (s->rv10_version == 3) {
270  /* specific MPEG like DC coding not used */
271  s->last_dc[0] = get_bits(&s->gb, 8);
272  s->last_dc[1] = get_bits(&s->gb, 8);
273  s->last_dc[2] = get_bits(&s->gb, 8);
274  av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
275  s->last_dc[1], s->last_dc[2]);
276  }
277  }
278  /* if multiple packets per frame are sent, the position at which
279  to display the macroblocks is coded here */
280 
281  mb_xy = s->mb_x + s->mb_y * s->mb_width;
282  if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
283  s->mb_x = get_bits(&s->gb, 6); /* mb_x */
284  s->mb_y = get_bits(&s->gb, 6); /* mb_y */
285  mb_count = get_bits(&s->gb, 12);
286  } else {
287  s->mb_x = 0;
288  s->mb_y = 0;
289  mb_count = s->mb_width * s->mb_height;
290  }
291  skip_bits(&s->gb, 3); /* ignored */
292  s->f_code = 1;
293  s->unrestricted_mv = 1;
294 
295  return mb_count;
296 }
297 
298 static int rv20_decode_picture_header(RVDecContext *rv)
299 {
300  MpegEncContext *s = &rv->m;
301  int seq, mb_pos, i, ret;
302  int rpr_bits;
303 
304  i = get_bits(&s->gb, 2);
305  switch(i) {
306  case 0: s->pict_type = AV_PICTURE_TYPE_I; break;
307  case 1: s->pict_type = AV_PICTURE_TYPE_I; break; //hmm ...
308  case 2: s->pict_type = AV_PICTURE_TYPE_P; break;
309  case 3: s->pict_type = AV_PICTURE_TYPE_B; break;
310  default:
311  av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
312  return AVERROR_INVALIDDATA;
313  }
314 
315  if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
316  av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
317  return -1;
318  }
319  if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) {
320  av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
321  return AVERROR_INVALIDDATA;
322  }
323 
324  if (get_bits1(&s->gb)) {
325  av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
326  return AVERROR_INVALIDDATA;
327  }
328 
329  s->qscale = get_bits(&s->gb, 5);
330  if (s->qscale == 0) {
331  av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
332  return AVERROR_INVALIDDATA;
333  }
334 
335  if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
336  s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
337 
338  if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
339  seq = get_bits(&s->gb, 8) << 7;
340  else
341  seq = get_bits(&s->gb, 13) << 2;
342 
343  rpr_bits = s->avctx->extradata[1] & 7;
344  if (rpr_bits) {
345  int f, new_w, new_h;
346  rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
347 
348  f = get_bits(&s->gb, rpr_bits);
349 
350  if (f) {
351  if (s->avctx->extradata_size < 8 + 2 * f) {
352  av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
353  return AVERROR_INVALIDDATA;
354  }
355 
356  new_w = 4 * ((uint8_t*)s->avctx->extradata)[6 + 2 * f];
357  new_h = 4 * ((uint8_t*)s->avctx->extradata)[7 + 2 * f];
358  } else {
359  new_w = s->orig_width ;
360  new_h = s->orig_height;
361  }
362  if (new_w != s->width || new_h != s->height) {
363  AVRational old_aspect = s->avctx->sample_aspect_ratio;
364  av_log(s->avctx, AV_LOG_DEBUG,
365  "attempting to change resolution to %dx%d\n", new_w, new_h);
366  if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
367  return AVERROR_INVALIDDATA;
368  ff_MPV_common_end(s);
369 
370  // attempt to keep aspect during typical resolution switches
371  if (!old_aspect.num)
372  old_aspect = (AVRational){1, 1};
373  if (2 * new_w * s->height == new_h * s->width)
374  s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
375  if (new_w * s->height == 2 * new_h * s->width)
376  s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
377  avcodec_set_dimensions(s->avctx, new_w, new_h);
378  s->width = new_w;
379  s->height = new_h;
380  if ((ret = ff_MPV_common_init(s)) < 0)
381  return ret;
382  }
383 
384  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
385  av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
386  }
387  }
388  if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
389  return AVERROR_INVALIDDATA;
390 
391  mb_pos = ff_h263_decode_mba(s);
392 
393  seq |= s->time & ~0x7FFF;
394  if (seq - s->time > 0x4000)
395  seq -= 0x8000;
396  if (seq - s->time < -0x4000)
397  seq += 0x8000;
398 
399  if (seq != s->time) {
400  if (s->pict_type != AV_PICTURE_TYPE_B) {
401  s->time = seq;
402  s->pp_time = s->time - s->last_non_b_time;
403  s->last_non_b_time = s->time;
404  } else {
405  s->time = seq;
406  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
407  }
408  }
409  if (s->pict_type == AV_PICTURE_TYPE_B) {
410  if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
411  av_log(s->avctx, AV_LOG_DEBUG,
412  "messed up order, possible from seeking? skipping current b frame\n");
413 #define ERROR_SKIP_FRAME -123
414  return ERROR_SKIP_FRAME;
415  }
416  ff_mpeg4_init_direct_mv(s);
417  }
418 
419  s->no_rounding = get_bits1(&s->gb);
420 
421  if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
422  skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
423 
424  s->f_code = 1;
425  s->unrestricted_mv = 1;
426  s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
427  s->modified_quant = 1;
428  if (!s->avctx->lowres)
429  s->loop_filter = 1;
430 
431  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
432  av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
433  seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
434  }
435 
436  av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
437 
438  return s->mb_width*s->mb_height - mb_pos;
439 }
440 
441 static av_cold int rv10_decode_init(AVCodecContext *avctx)
442 {
443  RVDecContext *rv = avctx->priv_data;
444  MpegEncContext *s = &rv->m;
445  static int done = 0;
446  int major_ver, minor_ver, micro_ver, ret;
447 
448  if (avctx->extradata_size < 8) {
449  av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
450  return AVERROR_INVALIDDATA;
451  }
452  if ((ret = av_image_check_size(avctx->coded_width,
453  avctx->coded_height, 0, avctx)) < 0)
454  return ret;
455 
456  ff_MPV_decode_defaults(s);
457 
458  s->avctx = avctx;
459  s->out_format = FMT_H263;
460  s->codec_id = avctx->codec_id;
461 
462  s->orig_width = s->width = avctx->coded_width;
463  s->orig_height = s->height = avctx->coded_height;
464 
465  s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
466  rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
467 
468  major_ver = RV_GET_MAJOR_VER(rv->sub_id);
469  minor_ver = RV_GET_MINOR_VER(rv->sub_id);
470  micro_ver = RV_GET_MICRO_VER(rv->sub_id);
471 
472  s->low_delay = 1;
473  switch (major_ver) {
474  case 1:
475  s->rv10_version = micro_ver ? 3 : 1;
476  s->obmc = micro_ver == 2;
477  break;
478  case 2:
479  if (minor_ver >= 2) {
480  s->low_delay = 0;
481  s->avctx->has_b_frames = 1;
482  }
483  break;
484  default:
485  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
486  avpriv_request_sample(avctx, "RV1/2 version");
487  return AVERROR_PATCHWELCOME;
488  }
489 
490  if (avctx->debug & FF_DEBUG_PICT_INFO) {
491  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
492  ((uint32_t*)avctx->extradata)[0]);
493  }
494 
495  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
496 
497  if ((ret = ff_MPV_common_init(s)) < 0)
498  return ret;
499 
500  ff_h263_decode_init_vlc();
501 
502  /* init rv vlc */
503  if (!done) {
504  INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
505  rv_lum_bits, 1, 1,
506  rv_lum_code, 2, 2, 16384);
507  INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
508  rv_chrom_bits, 1, 1,
509  rv_chrom_code, 2, 2, 16388);
510  done = 1;
511  }
512 
513  return 0;
514 }
515 
516 static av_cold int rv10_decode_end(AVCodecContext *avctx)
517 {
518  MpegEncContext *s = avctx->priv_data;
519 
520  ff_MPV_common_end(s);
521  return 0;
522 }
523 
524 static int rv10_decode_packet(AVCodecContext *avctx,
525  const uint8_t *buf, int buf_size, int buf_size2)
526 {
527  RVDecContext *rv = avctx->priv_data;
528  MpegEncContext *s = &rv->m;
529  int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
530 
531  active_bits_size = buf_size * 8;
532  init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
533  if (s->codec_id == AV_CODEC_ID_RV10)
534  mb_count = rv10_decode_picture_header(s);
535  else
536  mb_count = rv20_decode_picture_header(rv);
537  if (mb_count < 0) {
538  if (mb_count != ERROR_SKIP_FRAME)
539  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
540  return AVERROR_INVALIDDATA;
541  }
542 
543  if (s->mb_x >= s->mb_width ||
544  s->mb_y >= s->mb_height) {
545  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
546  return AVERROR_INVALIDDATA;
547  }
548  mb_pos = s->mb_y * s->mb_width + s->mb_x;
549  left = s->mb_width * s->mb_height - mb_pos;
550  if (mb_count > left) {
551  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
552  return AVERROR_INVALIDDATA;
553  }
554 
555  if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
556  if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
557  ff_er_frame_end(&s->er);
558  ff_MPV_frame_end(s);
559  s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
560  }
561  if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
562  return ret;
563  ff_mpeg_er_frame_start(s);
564  } else {
565  if (s->current_picture_ptr->f.pict_type != s->pict_type) {
566  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
567  return AVERROR_INVALIDDATA;
568  }
569  }
570 
571 
572  av_dlog(avctx, "qscale=%d\n", s->qscale);
573 
574  /* default quantization values */
575  if (s->codec_id == AV_CODEC_ID_RV10) {
576  if (s->mb_y == 0)
577  s->first_slice_line = 1;
578  } else {
579  s->first_slice_line = 1;
580  s->resync_mb_x = s->mb_x;
581  }
582  start_mb_x = s->mb_x;
583  s->resync_mb_y = s->mb_y;
584  if (s->h263_aic) {
585  s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
586  } else {
587  s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
588  }
589 
590  if (s->modified_quant)
591  s->chroma_qscale_table = ff_h263_chroma_qscale_table;
592 
593  ff_set_qscale(s, s->qscale);
594 
595  s->rv10_first_dc_coded[0] = 0;
596  s->rv10_first_dc_coded[1] = 0;
597  s->rv10_first_dc_coded[2] = 0;
598  s->block_wrap[0] =
599  s->block_wrap[1] =
600  s->block_wrap[2] =
601  s->block_wrap[3] = s->b8_stride;
602  s->block_wrap[4] =
603  s->block_wrap[5] = s->mb_stride;
604  ff_init_block_index(s);
605 
606  /* decode each macroblock */
607  for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
608  int ret;
609  ff_update_block_index(s);
610  av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
611 
612  s->mv_dir = MV_DIR_FORWARD;
613  s->mv_type = MV_TYPE_16X16;
614  ret = ff_h263_decode_mb(s, s->block);
615 
616  // Repeat the slice end check from ff_h263_decode_mb with our active
617  // bitstream size
618  if (ret != SLICE_ERROR) {
619  int v = show_bits(&s->gb, 16);
620 
621  if (get_bits_count(&s->gb) + 16 > active_bits_size)
622  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
623 
624  if (!v)
625  ret = SLICE_END;
626  }
627  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
628  8 * buf_size2 >= get_bits_count(&s->gb)) {
629  active_bits_size = buf_size2 * 8;
630  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
631  8 * buf_size, active_bits_size);
632  ret = SLICE_OK;
633  }
634 
635  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
636  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
637  return AVERROR_INVALIDDATA;
638  }
639  if (s->pict_type != AV_PICTURE_TYPE_B)
640  ff_h263_update_motion_val(s);
641  ff_MPV_decode_mb(s, s->block);
642  if (s->loop_filter)
643  ff_h263_loop_filter(s);
644 
645  if (++s->mb_x == s->mb_width) {
646  s->mb_x = 0;
647  s->mb_y++;
648  ff_init_block_index(s);
649  }
650  if (s->mb_x == s->resync_mb_x)
651  s->first_slice_line = 0;
652  if (ret == SLICE_END)
653  break;
654  }
655 
656  ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
657  ER_MB_END);
658 
659  return active_bits_size;
660 }
661 
662 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
663 {
664  if (avctx->slice_count)
665  return avctx->slice_offset[n];
666  else
667  return AV_RL32(buf + n * 8);
668 }
669 
670 static int rv10_decode_frame(AVCodecContext *avctx,
671  void *data, int *got_frame,
672  AVPacket *avpkt)
673 {
674  const uint8_t *buf = avpkt->data;
675  int buf_size = avpkt->size;
676  MpegEncContext *s = avctx->priv_data;
677  AVFrame *pict = data;
678  int i, ret;
679  int slice_count;
680  const uint8_t *slices_hdr = NULL;
681 
682  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
683  s->flags = avctx->flags;
684  s->flags2 = avctx->flags2;
685 
686  /* no supplementary picture */
687  if (buf_size == 0) {
688  return 0;
689  }
690 
691  if (!avctx->slice_count) {
692  slice_count = (*buf++) + 1;
693  buf_size--;
694 
695  if (!slice_count || buf_size <= 8 * slice_count) {
696  av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
697  return AVERROR_INVALIDDATA;
698  }
699 
700  slices_hdr = buf + 4;
701  buf += 8 * slice_count;
702  buf_size -= 8 * slice_count;
703  } else
704  slice_count = avctx->slice_count;
705 
706  for (i = 0; i < slice_count; i++) {
707  unsigned offset = get_slice_offset(avctx, slices_hdr, i);
708  int size, size2;
709 
710  if (offset >= buf_size)
711  return AVERROR_INVALIDDATA;
712 
713  if (i + 1 == slice_count)
714  size = buf_size - offset;
715  else
716  size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
717 
718  if (i + 2 >= slice_count)
719  size2 = buf_size - offset;
720  else
721  size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
722 
723  if (size <= 0 || size2 <= 0 ||
724  offset + FFMAX(size, size2) > buf_size)
725  return AVERROR_INVALIDDATA;
726 
727  if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
728  i++;
729  }
730 
731  if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
732  ff_er_frame_end(&s->er);
733  ff_MPV_frame_end(s);
734 
735  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
736  if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
737  return ret;
738  ff_print_debug_info(s, s->current_picture_ptr, pict);
739  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
740  } else if (s->last_picture_ptr != NULL) {
741  if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
742  return ret;
743  ff_print_debug_info(s, s->last_picture_ptr, pict);
744  ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
745  }
746 
747  if (s->last_picture_ptr || s->low_delay) {
748  *got_frame = 1;
749  }
750 
751  // so we can detect if frame_end was not called (find some nicer solution...)
752  s->current_picture_ptr = NULL;
753  }
754 
755  return avpkt->size;
756 }
757 
758 AVCodec ff_rv10_decoder = {
759  .name = "rv10",
760  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
761  .type = AVMEDIA_TYPE_VIDEO,
762  .id = AV_CODEC_ID_RV10,
763  .priv_data_size = sizeof(RVDecContext),
764  .init = rv10_decode_init,
765  .close = rv10_decode_end,
766  .decode = rv10_decode_frame,
767  .capabilities = CODEC_CAP_DR1,
768  .max_lowres = 3,
769  .pix_fmts = ff_pixfmt_list_420,
770 };
771 
772 AVCodec ff_rv20_decoder = {
773  .name = "rv20",
774  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
775  .type = AVMEDIA_TYPE_VIDEO,
776  .id = AV_CODEC_ID_RV20,
777  .priv_data_size = sizeof(RVDecContext),
778  .init = rv10_decode_init,
779  .close = rv10_decode_end,
780  .decode = rv10_decode_frame,
781  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
782  .flush = ff_mpeg_flush,
783  .max_lowres = 3,
784  .pix_fmts = ff_pixfmt_list_420,
785 };
Generated on Sat Jan 25 2014 19:51:54 for FFmpeg by   doxygen 1.8.2