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