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