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 
453  ff_MPV_decode_defaults(s);
454 
455  s->avctx = avctx;
456  s->out_format = FMT_H263;
457  s->codec_id = avctx->codec_id;
458 
459  s->orig_width = s->width = avctx->coded_width;
460  s->orig_height = s->height = avctx->coded_height;
461 
462  s->h263_long_vectors = ((uint8_t*)avctx->extradata)[3] & 1;
463  rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
464 
465  major_ver = RV_GET_MAJOR_VER(rv->sub_id);
466  minor_ver = RV_GET_MINOR_VER(rv->sub_id);
467  micro_ver = RV_GET_MICRO_VER(rv->sub_id);
468 
469  s->low_delay = 1;
470  switch (major_ver) {
471  case 1:
472  s->rv10_version = micro_ver ? 3 : 1;
473  s->obmc = micro_ver == 2;
474  break;
475  case 2:
476  if (minor_ver >= 2) {
477  s->low_delay = 0;
478  s->avctx->has_b_frames = 1;
479  }
480  break;
481  default:
482  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
483  avpriv_request_sample(avctx, "RV1/2 version");
484  return AVERROR_PATCHWELCOME;
485  }
486 
487  if (avctx->debug & FF_DEBUG_PICT_INFO) {
488  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
489  ((uint32_t*)avctx->extradata)[0]);
490  }
491 
492  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
493 
494  if ((ret = ff_MPV_common_init(s)) < 0)
495  return ret;
496 
497  ff_h263_decode_init_vlc();
498 
499  /* init rv vlc */
500  if (!done) {
501  INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
502  rv_lum_bits, 1, 1,
503  rv_lum_code, 2, 2, 16384);
504  INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
505  rv_chrom_bits, 1, 1,
506  rv_chrom_code, 2, 2, 16388);
507  done = 1;
508  }
509 
510  return 0;
511 }
512 
513 static av_cold int rv10_decode_end(AVCodecContext *avctx)
514 {
515  MpegEncContext *s = avctx->priv_data;
516 
517  ff_MPV_common_end(s);
518  return 0;
519 }
520 
521 static int rv10_decode_packet(AVCodecContext *avctx,
522  const uint8_t *buf, int buf_size, int buf_size2)
523 {
524  RVDecContext *rv = avctx->priv_data;
525  MpegEncContext *s = &rv->m;
526  int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
527 
528  active_bits_size = buf_size * 8;
529  init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
530  if (s->codec_id == AV_CODEC_ID_RV10)
531  mb_count = rv10_decode_picture_header(s);
532  else
533  mb_count = rv20_decode_picture_header(rv);
534  if (mb_count < 0) {
535  if (mb_count != ERROR_SKIP_FRAME)
536  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
537  return AVERROR_INVALIDDATA;
538  }
539 
540  if (s->mb_x >= s->mb_width ||
541  s->mb_y >= s->mb_height) {
542  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
543  return AVERROR_INVALIDDATA;
544  }
545  mb_pos = s->mb_y * s->mb_width + s->mb_x;
546  left = s->mb_width * s->mb_height - mb_pos;
547  if (mb_count > left) {
548  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
549  return AVERROR_INVALIDDATA;
550  }
551 
552  if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr == NULL) {
553  if (s->current_picture_ptr) { // FIXME write parser so we always have complete frames?
554  ff_er_frame_end(&s->er);
555  ff_MPV_frame_end(s);
556  s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
557  }
558  if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
559  return ret;
560  ff_mpeg_er_frame_start(s);
561  } else {
562  if (s->current_picture_ptr->f.pict_type != s->pict_type) {
563  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
564  return AVERROR_INVALIDDATA;
565  }
566  }
567 
568 
569  av_dlog(avctx, "qscale=%d\n", s->qscale);
570 
571  /* default quantization values */
572  if (s->codec_id == AV_CODEC_ID_RV10) {
573  if (s->mb_y == 0)
574  s->first_slice_line = 1;
575  } else {
576  s->first_slice_line = 1;
577  s->resync_mb_x = s->mb_x;
578  }
579  start_mb_x = s->mb_x;
580  s->resync_mb_y = s->mb_y;
581  if (s->h263_aic) {
582  s->y_dc_scale_table = s->c_dc_scale_table = ff_aic_dc_scale_table;
583  } else {
584  s->y_dc_scale_table = s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
585  }
586 
587  if (s->modified_quant)
588  s->chroma_qscale_table = ff_h263_chroma_qscale_table;
589 
590  ff_set_qscale(s, s->qscale);
591 
592  s->rv10_first_dc_coded[0] = 0;
593  s->rv10_first_dc_coded[1] = 0;
594  s->rv10_first_dc_coded[2] = 0;
595  s->block_wrap[0] =
596  s->block_wrap[1] =
597  s->block_wrap[2] =
598  s->block_wrap[3] = s->b8_stride;
599  s->block_wrap[4] =
600  s->block_wrap[5] = s->mb_stride;
601  ff_init_block_index(s);
602 
603  /* decode each macroblock */
604  for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
605  int ret;
606  ff_update_block_index(s);
607  av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
608 
609  s->mv_dir = MV_DIR_FORWARD;
610  s->mv_type = MV_TYPE_16X16;
611  ret = ff_h263_decode_mb(s, s->block);
612 
613  // Repeat the slice end check from ff_h263_decode_mb with our active
614  // bitstream size
615  if (ret != SLICE_ERROR) {
616  int v = show_bits(&s->gb, 16);
617 
618  if (get_bits_count(&s->gb) + 16 > active_bits_size)
619  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
620 
621  if (!v)
622  ret = SLICE_END;
623  }
624  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
625  8 * buf_size2 >= get_bits_count(&s->gb)) {
626  active_bits_size = buf_size2 * 8;
627  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
628  8 * buf_size, active_bits_size);
629  ret = SLICE_OK;
630  }
631 
632  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
633  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
634  return AVERROR_INVALIDDATA;
635  }
636  if (s->pict_type != AV_PICTURE_TYPE_B)
637  ff_h263_update_motion_val(s);
638  ff_MPV_decode_mb(s, s->block);
639  if (s->loop_filter)
640  ff_h263_loop_filter(s);
641 
642  if (++s->mb_x == s->mb_width) {
643  s->mb_x = 0;
644  s->mb_y++;
645  ff_init_block_index(s);
646  }
647  if (s->mb_x == s->resync_mb_x)
648  s->first_slice_line = 0;
649  if (ret == SLICE_END)
650  break;
651  }
652 
653  ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y,
654  ER_MB_END);
655 
656  return active_bits_size;
657 }
658 
659 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
660 {
661  if (avctx->slice_count)
662  return avctx->slice_offset[n];
663  else
664  return AV_RL32(buf + n * 8);
665 }
666 
667 static int rv10_decode_frame(AVCodecContext *avctx,
668  void *data, int *got_frame,
669  AVPacket *avpkt)
670 {
671  const uint8_t *buf = avpkt->data;
672  int buf_size = avpkt->size;
673  MpegEncContext *s = avctx->priv_data;
674  AVFrame *pict = data;
675  int i, ret;
676  int slice_count;
677  const uint8_t *slices_hdr = NULL;
678 
679  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
680  s->flags = avctx->flags;
681  s->flags2 = avctx->flags2;
682 
683  /* no supplementary picture */
684  if (buf_size == 0) {
685  return 0;
686  }
687 
688  if (!avctx->slice_count) {
689  slice_count = (*buf++) + 1;
690  buf_size--;
691 
692  if (!slice_count || buf_size <= 8 * slice_count) {
693  av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n", slice_count);
694  return AVERROR_INVALIDDATA;
695  }
696 
697  slices_hdr = buf + 4;
698  buf += 8 * slice_count;
699  buf_size -= 8 * slice_count;
700  } else
701  slice_count = avctx->slice_count;
702 
703  for (i = 0; i < slice_count; i++) {
704  unsigned offset = get_slice_offset(avctx, slices_hdr, i);
705  int size, size2;
706 
707  if (offset >= buf_size)
708  return AVERROR_INVALIDDATA;
709 
710  if (i + 1 == slice_count)
711  size = buf_size - offset;
712  else
713  size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
714 
715  if (i + 2 >= slice_count)
716  size2 = buf_size - offset;
717  else
718  size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
719 
720  if (size <= 0 || size2 <= 0 ||
721  offset + FFMAX(size, size2) > buf_size)
722  return AVERROR_INVALIDDATA;
723 
724  if (rv10_decode_packet(avctx, buf + offset, size, size2) > 8 * size)
725  i++;
726  }
727 
728  if (s->current_picture_ptr != NULL && s->mb_y >= s->mb_height) {
729  ff_er_frame_end(&s->er);
730  ff_MPV_frame_end(s);
731 
732  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
733  if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
734  return ret;
735  ff_print_debug_info(s, s->current_picture_ptr, pict);
736  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
737  } else if (s->last_picture_ptr != NULL) {
738  if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
739  return ret;
740  ff_print_debug_info(s, s->last_picture_ptr, pict);
741  ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
742  }
743 
744  if (s->last_picture_ptr || s->low_delay) {
745  *got_frame = 1;
746  }
747 
748  // so we can detect if frame_end was not called (find some nicer solution...)
749  s->current_picture_ptr = NULL;
750  }
751 
752  return avpkt->size;
753 }
754 
755 AVCodec ff_rv10_decoder = {
756  .name = "rv10",
757  .type = AVMEDIA_TYPE_VIDEO,
758  .id = AV_CODEC_ID_RV10,
759  .priv_data_size = sizeof(RVDecContext),
760  .init = rv10_decode_init,
761  .close = rv10_decode_end,
762  .decode = rv10_decode_frame,
763  .capabilities = CODEC_CAP_DR1,
764  .max_lowres = 3,
765  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
766  .pix_fmts = ff_pixfmt_list_420,
767 };
768 
769 AVCodec ff_rv20_decoder = {
770  .name = "rv20",
771  .type = AVMEDIA_TYPE_VIDEO,
772  .id = AV_CODEC_ID_RV20,
773  .priv_data_size = sizeof(RVDecContext),
774  .init = rv10_decode_init,
775  .close = rv10_decode_end,
776  .decode = rv10_decode_frame,
777  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
778  .flush = ff_mpeg_flush,
779  .max_lowres = 3,
780  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
781  .pix_fmts = ff_pixfmt_list_420,
782 };
Generated on Wed Jul 10 2013 23:48:04 for FFmpeg by   doxygen 1.8.2