Libav
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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
28 #include <inttypes.h>
29 
30 #include "libavutil/imgutils.h"
31 
32 #include "avcodec.h"
33 #include "error_resilience.h"
34 #include "h263.h"
35 #include "internal.h"
36 #include "mpeg_er.h"
37 #include "mpegvideo.h"
38 #include "mpeg4video.h"
39 
40 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
41 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
42 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
43 
44 #define DC_VLC_BITS 14 // FIXME find a better solution
45 
46 typedef struct RVDecContext {
48  int sub_id;
50 } RVDecContext;
51 
52 static const uint16_t rv_lum_code[256] = {
53  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
54  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
55  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
56  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
57  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
58  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
59  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
60  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
61  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
62  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
63  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
64  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
65  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
66  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
67  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
68  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
69  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
70  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
71  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
72  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
73  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
74  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
75  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
76  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
77  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
78  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
79  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
80  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
81  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
82  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
83  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
84  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
85 };
86 
87 static const uint8_t rv_lum_bits[256] = {
88  14, 12, 12, 12, 12, 12, 12, 12,
89  12, 12, 12, 12, 12, 12, 12, 12,
90  12, 12, 12, 12, 12, 12, 12, 12,
91  12, 12, 12, 12, 12, 12, 12, 12,
92  12, 12, 12, 12, 12, 12, 12, 12,
93  12, 12, 12, 12, 12, 12, 12, 12,
94  12, 12, 12, 12, 12, 12, 12, 12,
95  12, 12, 12, 12, 12, 12, 12, 12,
96  12, 10, 10, 10, 10, 10, 10, 10,
97  10, 10, 10, 10, 10, 10, 10, 10,
98  10, 10, 10, 10, 10, 10, 10, 10,
99  10, 10, 10, 10, 10, 10, 10, 10,
100  10, 8, 8, 8, 8, 8, 8, 8,
101  8, 8, 8, 8, 8, 8, 8, 8,
102  8, 7, 7, 7, 7, 7, 7, 7,
103  7, 6, 6, 6, 6, 5, 5, 4,
104  2, 4, 5, 5, 6, 6, 6, 6,
105  7, 7, 7, 7, 7, 7, 7, 7,
106  8, 8, 8, 8, 8, 8, 8, 8,
107  8, 8, 8, 8, 8, 8, 8, 8,
108  10, 10, 10, 10, 10, 10, 10, 10,
109  10, 10, 10, 10, 10, 10, 10, 10,
110  10, 10, 10, 10, 10, 10, 10, 10,
111  10, 10, 10, 10, 10, 10, 10, 10,
112  12, 12, 12, 12, 12, 12, 12, 12,
113  12, 12, 12, 12, 12, 12, 12, 12,
114  12, 12, 12, 12, 12, 12, 12, 12,
115  12, 12, 12, 12, 12, 12, 12, 12,
116  12, 12, 12, 12, 12, 12, 12, 12,
117  12, 12, 12, 12, 12, 12, 12, 12,
118  12, 12, 12, 12, 12, 12, 12, 12,
119  12, 12, 12, 12, 12, 12, 12, 12,
120 };
121 
122 static const uint16_t rv_chrom_code[256] = {
123  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
124  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
125  0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
126  0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
127  0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
128  0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
129  0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
130  0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
131  0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
132  0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
133  0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
134  0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
135  0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
136  0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
137  0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
138  0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
139  0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
140  0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
141  0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
142  0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
143  0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
144  0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
145  0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
146  0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
147  0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
148  0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
149  0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
150  0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
151  0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
152  0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
153  0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
154  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
155 };
156 
157 static const uint8_t rv_chrom_bits[256] = {
158  16, 14, 14, 14, 14, 14, 14, 14,
159  14, 14, 14, 14, 14, 14, 14, 14,
160  14, 14, 14, 14, 14, 14, 14, 14,
161  14, 14, 14, 14, 14, 14, 14, 14,
162  14, 14, 14, 14, 14, 14, 14, 14,
163  14, 14, 14, 14, 14, 14, 14, 14,
164  14, 14, 14, 14, 14, 14, 14, 14,
165  14, 14, 14, 14, 14, 14, 14, 14,
166  14, 12, 12, 12, 12, 12, 12, 12,
167  12, 12, 12, 12, 12, 12, 12, 12,
168  12, 12, 12, 12, 12, 12, 12, 12,
169  12, 12, 12, 12, 12, 12, 12, 12,
170  12, 10, 10, 10, 10, 10, 10, 10,
171  10, 10, 10, 10, 10, 10, 10, 10,
172  10, 8, 8, 8, 8, 8, 8, 8,
173  8, 6, 6, 6, 6, 4, 4, 3,
174  2, 3, 4, 4, 6, 6, 6, 6,
175  8, 8, 8, 8, 8, 8, 8, 8,
176  10, 10, 10, 10, 10, 10, 10, 10,
177  10, 10, 10, 10, 10, 10, 10, 10,
178  12, 12, 12, 12, 12, 12, 12, 12,
179  12, 12, 12, 12, 12, 12, 12, 12,
180  12, 12, 12, 12, 12, 12, 12, 12,
181  12, 12, 12, 12, 12, 12, 12, 12,
182  14, 14, 14, 14, 14, 14, 14, 14,
183  14, 14, 14, 14, 14, 14, 14, 14,
184  14, 14, 14, 14, 14, 14, 14, 14,
185  14, 14, 14, 14, 14, 14, 14, 14,
186  14, 14, 14, 14, 14, 14, 14, 14,
187  14, 14, 14, 14, 14, 14, 14, 14,
188  14, 14, 14, 14, 14, 14, 14, 14,
189  14, 14, 14, 14, 14, 14, 14, 14,
190 };
191 
193 
195 {
196  int code;
197 
198  if (n < 4) {
199  code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
200  if (code < 0) {
201  /* XXX: I don't understand why they use LONGER codes than
202  * necessary. The following code would be completely useless
203  * if they had thought about it !!! */
204  code = get_bits(&s->gb, 7);
205  if (code == 0x7c) {
206  code = (int8_t) (get_bits(&s->gb, 7) + 1);
207  } else if (code == 0x7d) {
208  code = -128 + get_bits(&s->gb, 7);
209  } else if (code == 0x7e) {
210  if (get_bits1(&s->gb) == 0)
211  code = (int8_t) (get_bits(&s->gb, 8) + 1);
212  else
213  code = (int8_t) (get_bits(&s->gb, 8));
214  } else if (code == 0x7f) {
215  skip_bits(&s->gb, 11);
216  code = 1;
217  }
218  } else {
219  code -= 128;
220  }
221  } else {
222  code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
223  /* same remark */
224  if (code < 0) {
225  code = get_bits(&s->gb, 9);
226  if (code == 0x1fc) {
227  code = (int8_t) (get_bits(&s->gb, 7) + 1);
228  } else if (code == 0x1fd) {
229  code = -128 + get_bits(&s->gb, 7);
230  } else if (code == 0x1fe) {
231  skip_bits(&s->gb, 9);
232  code = 1;
233  } else {
234  av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
235  return 0xffff;
236  }
237  } else {
238  code -= 128;
239  }
240  }
241  return -code;
242 }
243 
244 /* read RV 1.0 compatible frame header */
246 {
247  int mb_count, pb_frame, marker, mb_xy;
248 
249  marker = get_bits1(&s->gb);
250 
251  if (get_bits1(&s->gb))
253  else
255 
256  if (!marker)
257  av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
258 
259  pb_frame = get_bits1(&s->gb);
260 
261  av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
262 
263  if (pb_frame) {
264  avpriv_request_sample(s->avctx, "pb frame");
265  return AVERROR_PATCHWELCOME;
266  }
267 
268  s->qscale = get_bits(&s->gb, 5);
269  if (s->qscale == 0) {
270  av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
271  return AVERROR_INVALIDDATA;
272  }
273 
274  if (s->pict_type == AV_PICTURE_TYPE_I) {
275  if (s->rv10_version == 3) {
276  /* specific MPEG like DC coding not used */
277  s->last_dc[0] = get_bits(&s->gb, 8);
278  s->last_dc[1] = get_bits(&s->gb, 8);
279  s->last_dc[2] = get_bits(&s->gb, 8);
280  av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
281  s->last_dc[1], s->last_dc[2]);
282  }
283  }
284  /* if multiple packets per frame are sent, the position at which
285  * to display the macroblocks is coded here */
286 
287  mb_xy = s->mb_x + s->mb_y * s->mb_width;
288  if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
289  s->mb_x = get_bits(&s->gb, 6); /* mb_x */
290  s->mb_y = get_bits(&s->gb, 6); /* mb_y */
291  mb_count = get_bits(&s->gb, 12);
292  } else {
293  s->mb_x = 0;
294  s->mb_y = 0;
295  mb_count = s->mb_width * s->mb_height;
296  }
297  skip_bits(&s->gb, 3); /* ignored */
298  s->f_code = 1;
299  s->unrestricted_mv = 1;
300 
301  return mb_count;
302 }
303 
305 {
306  MpegEncContext *s = &rv->m;
307  int seq, mb_pos, i, ret;
308  int rpr_bits;
309 
310  i = get_bits(&s->gb, 2);
311  switch (i) {
312  case 0:
314  break;
315  case 1:
317  break; // hmm ...
318  case 2:
320  break;
321  case 3:
323  break;
324  default:
325  av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
326  return AVERROR_INVALIDDATA;
327  }
328 
329  if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
330  av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
331  return AVERROR_INVALIDDATA;
332  }
333 
334  if (get_bits1(&s->gb)) {
335  av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
336  return AVERROR_INVALIDDATA;
337  }
338 
339  s->qscale = get_bits(&s->gb, 5);
340  if (s->qscale == 0) {
341  av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
342  return AVERROR_INVALIDDATA;
343  }
344 
345  if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
346  s->loop_filter = get_bits1(&s->gb);
347 
348  if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
349  seq = get_bits(&s->gb, 8) << 7;
350  else
351  seq = get_bits(&s->gb, 13) << 2;
352 
353  rpr_bits = s->avctx->extradata[1] & 7;
354  if (rpr_bits) {
355  int f, new_w, new_h;
356  rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
357 
358  f = get_bits(&s->gb, rpr_bits);
359 
360  if (f) {
361  if (s->avctx->extradata_size < 8 + 2 * f) {
362  av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
363  return AVERROR_INVALIDDATA;
364  }
365 
366  new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
367  new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
368  } else {
369  new_w = rv->orig_width;
370  new_h = rv->orig_height;
371  }
372  if (new_w != s->width || new_h != s->height) {
374  "attempting to change resolution to %dx%d\n", new_w, new_h);
376 
377  ret = ff_set_dimensions(s->avctx, new_w, new_h);
378  if (ret < 0)
379  return ret;
380 
381  s->width = new_w;
382  s->height = new_h;
383  if ((ret = ff_mpv_common_init(s)) < 0)
384  return ret;
385  }
386 
387  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
388  av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
389  }
390  } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
391  return AVERROR_INVALIDDATA;
392 
393  mb_pos = ff_h263_decode_mba(s);
394 
395  seq |= s->time & ~0x7FFF;
396  if (seq - s->time > 0x4000)
397  seq -= 0x8000;
398  if (seq - s->time < -0x4000)
399  seq += 0x8000;
400 
401  if (seq != s->time) {
402  if (s->pict_type != AV_PICTURE_TYPE_B) {
403  s->time = seq;
404  s->pp_time = s->time - s->last_non_b_time;
405  s->last_non_b_time = s->time;
406  } else {
407  s->time = seq;
408  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
409  if (s->pp_time <= s->pb_time ||
410  s->pp_time <= s->pp_time - s->pb_time || s->pp_time <= 0) {
411  av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible "
412  "from seeking? skipping current b frame\n");
413  return FRAME_SKIPPED;
414  }
416  }
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  // binary decoder reads 3+2 bits here but they don't seem to be used
423  skip_bits(&s->gb, 5);
424 
425  s->f_code = 1;
426  s->unrestricted_mv = 1;
428  s->modified_quant = 1;
429  s->loop_filter = 1;
430 
431  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
433  "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
434  seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
435  s->no_rounding);
436  }
437 
438  assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
439 
440  return s->mb_width * s->mb_height - mb_pos;
441 }
442 
444 {
445  RVDecContext *rv = avctx->priv_data;
446  MpegEncContext *s = &rv->m;
447  static int done = 0;
448  int major_ver, minor_ver, micro_ver, ret;
449 
450  if (avctx->extradata_size < 8) {
451  av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
452  return AVERROR_INVALIDDATA;
453  }
454  if ((ret = av_image_check_size(avctx->coded_width,
455  avctx->coded_height, 0, avctx)) < 0)
456  return ret;
457 
459 
460  s->avctx = avctx;
461  s->out_format = FMT_H263;
462  s->codec_id = avctx->codec_id;
463 
464  rv->orig_width =
465  s->width = avctx->coded_width;
466  rv->orig_height =
467  s->height = avctx->coded_height;
468 
469  s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
470  rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
471 
472  major_ver = RV_GET_MAJOR_VER(rv->sub_id);
473  minor_ver = RV_GET_MINOR_VER(rv->sub_id);
474  micro_ver = RV_GET_MICRO_VER(rv->sub_id);
475 
476  s->low_delay = 1;
477  switch (major_ver) {
478  case 1:
479  s->rv10_version = micro_ver ? 3 : 1;
480  s->obmc = micro_ver == 2;
481  break;
482  case 2:
483  if (minor_ver >= 2) {
484  s->low_delay = 0;
485  s->avctx->has_b_frames = 1;
486  }
487  break;
488  default:
489  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
490  avpriv_request_sample(avctx, "RV1/2 version");
491  return AVERROR_PATCHWELCOME;
492  }
493 
494  if (avctx->debug & FF_DEBUG_PICT_INFO) {
495  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id,
496  avctx->extradata_size >= 4 ? ((int *) avctx->extradata)[0] : -1);
497  }
498 
499  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
500 
501  ff_mpv_idct_init(s);
502  if ((ret = ff_mpv_common_init(s)) < 0)
503  return ret;
504 
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 
523 {
524  MpegEncContext *s = avctx->priv_data;
525 
527  return 0;
528 }
529 
530 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
531  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  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
545  return AVERROR_INVALIDDATA;
546  }
547 
548  if (s->mb_x >= s->mb_width ||
549  s->mb_y >= s->mb_height) {
550  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
551  return AVERROR_INVALIDDATA;
552  }
553  mb_pos = s->mb_y * s->mb_width + s->mb_x;
554  left = s->mb_width * s->mb_height - mb_pos;
555  if (mb_count > left) {
556  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
557  return AVERROR_INVALIDDATA;
558  }
559 
560  if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
561  // FIXME write parser so we always have complete frames?
562  if (s->current_picture_ptr) {
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;
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  av_dlog(avctx, "qscale=%d\n", s->qscale);
578 
579  /* default quantization values */
580  if (s->codec_id == AV_CODEC_ID_RV10) {
581  if (s->mb_y == 0)
582  s->first_slice_line = 1;
583  } else {
584  s->first_slice_line = 1;
585  s->resync_mb_x = s->mb_x;
586  }
587  start_mb_x = s->mb_x;
588  s->resync_mb_y = s->mb_y;
589  if (s->h263_aic) {
590  s->y_dc_scale_table =
592  } else {
593  s->y_dc_scale_table =
595  }
596 
597  if (s->modified_quant)
599 
600  ff_set_qscale(s, s->qscale);
601 
602  s->rv10_first_dc_coded[0] = 0;
603  s->rv10_first_dc_coded[1] = 0;
604  s->rv10_first_dc_coded[2] = 0;
605  s->block_wrap[0] =
606  s->block_wrap[1] =
607  s->block_wrap[2] =
608  s->block_wrap[3] = s->b8_stride;
609  s->block_wrap[4] =
610  s->block_wrap[5] = s->mb_stride;
612 
613  /* decode each macroblock */
614  for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
615  int ret;
617  av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
618 
619  s->mv_dir = MV_DIR_FORWARD;
620  s->mv_type = MV_TYPE_16X16;
621  ret = ff_h263_decode_mb(s, s->block);
622 
623  // Repeat the slice end check from ff_h263_decode_mb with our active
624  // bitstream size
625  if (ret != SLICE_ERROR) {
626  int v = show_bits(&s->gb, 16);
627 
628  if (get_bits_count(&s->gb) + 16 > active_bits_size)
629  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
630 
631  if (!v)
632  ret = SLICE_END;
633  }
634  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
635  8 * buf_size2 >= get_bits_count(&s->gb)) {
636  active_bits_size = buf_size2 * 8;
637  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
638  8 * buf_size, active_bits_size);
639  ret = SLICE_OK;
640  }
641 
642  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
643  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
644  s->mb_y);
645  return AVERROR_INVALIDDATA;
646  }
647  if (s->pict_type != AV_PICTURE_TYPE_B)
649  ff_mpv_decode_mb(s, s->block);
650  if (s->loop_filter)
652 
653  if (++s->mb_x == s->mb_width) {
654  s->mb_x = 0;
655  s->mb_y++;
657  }
658  if (s->mb_x == s->resync_mb_x)
659  s->first_slice_line = 0;
660  if (ret == SLICE_END)
661  break;
662  }
663 
664  ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
665  ER_MB_END);
666 
667  return active_bits_size;
668 }
669 
670 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
671 {
672  if (avctx->slice_count)
673  return avctx->slice_offset[n];
674  else
675  return AV_RL32(buf + n * 8);
676 }
677 
678 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
679  AVPacket *avpkt)
680 {
681  const uint8_t *buf = avpkt->data;
682  int buf_size = avpkt->size;
683  MpegEncContext *s = avctx->priv_data;
684  AVFrame *pict = data;
685  int i, ret;
686  int slice_count;
687  const uint8_t *slices_hdr = NULL;
688 
689  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
690 
691  /* no supplementary picture */
692  if (buf_size == 0) {
693  return 0;
694  }
695 
696  if (!avctx->slice_count) {
697  slice_count = (*buf++) + 1;
698  buf_size--;
699 
700  if (!slice_count || buf_size <= 8 * slice_count) {
701  av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
702  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 && 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;
748  } else if (s->last_picture_ptr) {
749  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
750  return ret;
752  }
753 
754  if (s->last_picture_ptr || s->low_delay) {
755  *got_frame = 1;
756  }
757 
758  // so we can detect if frame_end was not called (find some nicer solution...)
760  }
761 
762  return avpkt->size;
763 }
764 
766  .name = "rv10",
767  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
768  .type = AVMEDIA_TYPE_VIDEO,
769  .id = AV_CODEC_ID_RV10,
770  .priv_data_size = sizeof(RVDecContext),
774  .capabilities = CODEC_CAP_DR1,
775  .pix_fmts = (const enum AVPixelFormat[]) {
778  },
779 };
780 
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),
790  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
791  .flush = ff_mpeg_flush,
792  .pix_fmts = (const enum AVPixelFormat[]) {
795  },
796 };
int rv10_first_dc_coded[3]
Definition: mpegvideo.h:534
#define SLICE_ERROR
Definition: mpegvideo.h:604
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2368
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
Definition: rv10.c:670
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:314
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1234
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
#define ER_MB_END
static const uint16_t rv_chrom_code[256]
Definition: rv10.c:122
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:133
void ff_er_frame_end(ERContext *s)
int orig_height
Definition: rv10.c:49
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
int size
Definition: avcodec.h:974
enum AVCodecID codec_id
Definition: mpegvideo.h:235
AVCodec ff_rv20_decoder
Definition: rv10.c:781
int sub_id
Definition: rv10.c:48
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:483
void ff_print_debug_info(MpegEncContext *s, Picture *p)
Print debugging info for the given picture.
Definition: mpegvideo.c:1910
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1254
mpegvideo header.
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
#define SLICE_OK
Definition: mpegvideo.h:603
static int rv10_decode_picture_header(MpegEncContext *s)
Definition: rv10.c:245
AVCodec.
Definition: avcodec.h:2796
int qscale
QP.
Definition: mpegvideo.h:332
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:210
int block_wrap[6]
Definition: mpegvideo.h:416
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:599
int modified_quant
Definition: mpegvideo.h:494
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
Definition: mpegvideo.h:475
int64_t time
time of current frame
Definition: mpegvideo.h:503
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:102
uint8_t
#define av_cold
Definition: attributes.h:66
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:443
enum OutputFormat out_format
output format
Definition: mpegvideo.h:227
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2363
#define AV_RB32
Definition: intreadwrite.h:130
#define RV_GET_MICRO_VER(x)
Definition: rv10.c:42
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:188
int ff_rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:194
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1164
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:406
void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2351
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:973
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
MpegEncContext m
Definition: rv10.c:47
int ff_h263_decode_mba(MpegEncContext *s)
Definition: ituh263dec.c:134
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:505
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:408
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:255
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:756
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2459
int slice_count
slice count
Definition: avcodec.h:1404
H263DSPContext h263dsp
Definition: mpegvideo.h:361
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1339
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:311
AVCodec ff_rv10_decoder
Definition: rv10.c:765
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:713
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:348
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:150
ERContext er
Definition: mpegvideo.h:638
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
#define RV_GET_MINOR_VER(x)
Definition: rv10.c:41
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:81
const char * name
Name of the codec implementation.
Definition: avcodec.h:2803
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:519
GetBitContext gb
Definition: mpegvideo.h:558
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1478
#define FFMAX(a, b)
Definition: common.h:55
Definition: get_bits.h:64
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2429
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:472
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:222
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:139
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:196
#define FFMIN(a, b)
Definition: common.h:57
#define RV_GET_MAJOR_VER(x)
Definition: rv10.c:40
#define DC_VLC_BITS
Definition: rv10.c:44
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:310
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:45
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:254
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rv10.c:678
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:522
#define AV_RL32
Definition: intreadwrite.h:146
static const uint8_t rv_chrom_bits[256]
Definition: rv10.c:157
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.h:248
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Definition: rv10.c:522
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:1050
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:388
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:546
NULL
Definition: eval.c:55
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Definition: rv10.c:443
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
int64_t last_non_b_time
Definition: mpegvideo.h:504
static const uint16_t rv_lum_code[256]
Definition: rv10.c:52
Libavcodec external API header.
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:46
enum AVCodecID codec_id
Definition: avcodec.h:1067
int debug
debug
Definition: avcodec.h:2362
main external API structure.
Definition: avcodec.h:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:223
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:55
#define SLICE_END
end marker found
Definition: mpegvideo.h:605
int extradata_size
Definition: avcodec.h:1165
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
int coded_height
Definition: avcodec.h:1234
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
struct AVFrame * f
Definition: mpegvideo.h:100
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1677
int f_code
forward MV resolution
Definition: mpegvideo.h:362
#define MV_DIR_FORWARD
Definition: mpegvideo.h:384
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:339
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:315
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:257
MpegEncContext.
Definition: mpegvideo.h:204
struct AVCodecContext * avctx
Definition: mpegvideo.h:221
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:256
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.h:262
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:1771
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:308
Bi-dir predicted.
Definition: avutil.h:255
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
Definition: mpegvideo.h:316
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
void * priv_data
Definition: avcodec.h:1092
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:1235
static int rv20_decode_picture_header(RVDecContext *rv)
Definition: rv10.c:304
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1889
static const uint8_t rv_lum_bits[256]
Definition: rv10.c:87
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:473
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:600
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:1420
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1822
int rv10_version
RV10 version: 0 or 3.
Definition: mpegvideo.h:533
#define FRAME_SKIPPED
return value for header parsers if frame is not coded
Definition: mpegvideo.h:54
int h263_long_vectors
use horrible h263v1 long vector mode
Definition: mpegvideo.h:349
static VLC rv_dc_lum
Definition: rv10.c:192
int orig_width
Definition: rv10.c:49
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:950
Predicted.
Definition: avutil.h:254
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:506
static VLC rv_dc_chrom
Definition: rv10.c:192
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2)
Definition: rv10.c:530