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