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