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