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