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