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