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