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