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