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 {
53  int sub_id;
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 
198 
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 */
251 {
252  int mb_count, pb_frame, marker, mb_xy;
253 
254  marker = get_bits1(&s->gb);
255 
256  if (get_bits1(&s->gb))
258  else
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 
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:
319  break;
320  case 1:
322  break; // hmm ...
323  case 2:
325  break;
326  case 3:
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;
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;
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) {
435  "messed up order, possible from seeking? skipping current B-frame\n");
436 #define ERROR_SKIP_FRAME -123
437  return ERROR_SKIP_FRAME;
438  }
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;
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) {
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 
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);
476 }
477 
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 
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 
540 
541  /* init static VLCs */
542  ff_thread_once(&init_static_once, rv10_init_static);
543 
544  return 0;
545 }
546 
548 {
549  MpegEncContext *s = avctx->priv_data;
550 
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;
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 =
622  } else {
623  s->y_dc_scale_table =
625  }
626 
627  if (s->modified_quant)
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;
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;
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)
680  if (s->loop_filter)
682 
683  if (++s->mb_x == s->mb_width) {
684  s->mb_x = 0;
685  s->mb_y++;
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;
779  } else if (s->last_picture_ptr) {
780  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
781  return ret;
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...)
792  }
793 
794  return avpkt->size;
795 }
796 
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),
804  .close = rv10_decode_end,
806  .capabilities = AV_CODEC_CAP_DR1,
807  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
808  .max_lowres = 3,
809  .pix_fmts = (const enum AVPixelFormat[]) {
812  },
813 };
814 
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),
822  .close = rv10_decode_end,
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[]) {
831  },
832 };
#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
int rv10_first_dc_coded[3]
Definition: mpegvideo.h:421
#define ff_tlog(ctx,...)
Definition: internal.h:86
#define NULL
Definition: coverity.c:32
#define SLICE_ERROR
Definition: mpegvideo.h:520
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2254
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
Definition: rv10.c:700
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:188
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:719
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define ER_MB_END
static const uint16_t rv_chrom_code[256]
Definition: rv10.c:127
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
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:84
#define avpriv_request_sample(...)
void ff_er_frame_end(ERContext *s)
int orig_height
Definition: rv10.c:54
int num
Numerator.
Definition: rational.h:59
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
int size
Definition: packet.h:364
enum AVCodecID codec_id
Definition: mpegvideo.h:112
AVCodec ff_rv20_decoder
Definition: rv10.c:815
int sub_id
Definition: rv10.c:53
int av_log2(unsigned v)
Definition: intmath.c:26
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:366
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:910
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
mpegvideo header.
#define SLICE_OK
Definition: mpegvideo.h:519
static int rv10_decode_picture_header(MpegEncContext *s)
Definition: rv10.c:250
AVCodec.
Definition: codec.h:190
int qscale
QP.
Definition: mpegvideo.h:204
int h263_aic
Advanced INTRA Coding (AIC)
Definition: mpegvideo.h:87
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int block_wrap[6]
Definition: mpegvideo.h:294
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:697
int modified_quant
Definition: mpegvideo.h:379
#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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
Definition: mpegvideo.h:359
int64_t time
time of current frame
Definition: mpegvideo.h:390
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:108
uint8_t
#define av_cold
Definition: attributes.h:88
enum OutputFormat out_format
output format
Definition: mpegvideo.h:104
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1617
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
#define f(width, name)
Definition: cbs_vp9.c:255
#define RV_GET_MICRO_VER(x)
Definition: rv10.c:47
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
int ff_rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:199
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:632
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
Definition: mpegvideo.h:284
H.263 tables.
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
uint8_t * data
Definition: packet.h:363
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
MpegEncContext m
Definition: rv10.c:52
int ff_h263_decode_mba(MpegEncContext *s)
Definition: ituh263dec.c:139
#define ff_dlog(a,...)
#define ERROR_SKIP_FRAME
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:392
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:329
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1770
ptrdiff_t size
Definition: opengl_enc.c:100
#define AVOnce
Definition: thread.h:172
#define av_log(a,...)
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:743
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2318
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2, int whole_size)
Definition: rv10.c:555
int slice_count
slice count
Definition: avcodec.h:885
H263DSPContext h263dsp
Definition: mpegvideo.h:237
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:821
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
AVCodec ff_rv10_decoder
Definition: rv10.c:797
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:223
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
ERContext er
Definition: mpegvideo.h:569
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define RV_GET_MINOR_VER(x)
Definition: rv10.c:46
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:71
const char * name
Name of the codec implementation.
Definition: codec.h:197
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
GetBitContext gb
Definition: mpegvideo.h:451
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1110
#define FFMAX(a, b)
Definition: common.h:94
Definition: vlc.h:26
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2287
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:356
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:135
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1426
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:397
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.c:262
static av_cold void rv10_init_static(void)
Definition: rv10.c:467
#define RV_GET_MAJOR_VER(x)
Definition: rv10.c:45
#define DC_VLC_BITS
Definition: rv10.c:49
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rv10.c:708
#define s(width, name)
Definition: cbs_vp9.c:257
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
static const uint8_t rv_chrom_bits[256]
Definition: rv10.c:162
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Definition: rv10.c:547
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:667
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
int first_slice_line
used in MPEG-4 too to handle resync markers
Definition: mpegvideo.h:436
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.c:247
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Definition: rv10.c:478
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_ONCE_INIT
Definition: thread.h:173
int64_t last_non_b_time
Definition: mpegvideo.h:391
static const uint16_t rv_lum_code[256]
Definition: rv10.c:57
Libavcodec external API header.
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:42
int debug
debug
Definition: avcodec.h:1616
main external API structure.
Definition: avcodec.h:531
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
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
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1419
#define SLICE_END
end marker found
Definition: mpegvideo.h:521
int extradata_size
Definition: avcodec.h:633
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int coded_height
Definition: avcodec.h:719
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
Rational number (pair of numerator and denominator).
Definition: rational.h:58
struct AVFrame * f
Definition: mpegpicture.h:46
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
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
int f_code
forward MV resolution
Definition: mpegvideo.h:238
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
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
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:189
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:131
MpegEncContext.
Definition: mpegvideo.h:81
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:130
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Definition: mpegvideo.c:672
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:182
Bi-dir predicted.
Definition: avutil.h:276
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (H.263)
Definition: mpegvideo.h:190
void * priv_data
Definition: avcodec.h:558
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:884
static int rv20_decode_picture_header(RVDecContext *rv)
Definition: rv10.c:309
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1411
static const uint8_t rv_lum_bits[256]
Definition: rv10.c:92
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2235
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:357
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:511
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:901
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1222
int rv10_version
RV10 version: 0 or 3.
Definition: mpegvideo.h:420
int h263_long_vectors
use horrible H.263v1 long vector mode
Definition: mpegvideo.h:224
static VLC rv_dc_lum
Definition: rv10.c:197
int orig_width
Definition: rv10.c:54
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:92
int32_t rv
Definition: input.c:405
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:393
static VLC rv_dc_chrom
Definition: rv10.c:197