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 MAX_VLC_ENTRIES 1023 // Note: Does not include the skip entries.
50 #define DC_VLC_BITS 9
51 
52 typedef struct RVDecContext {
54  int sub_id;
56 } RVDecContext;
57 
58 /* (run, length) encoded value for the symbols table. The actual symbols
59  * are run..run - length (mod 256).
60  * The last two entries in the following table apply to luma only.
61  * The skip values are not included in this list. */
62 static const uint8_t rv_sym_run_len[][2] = {
63  { 0, 0 }, { 1, 0 }, { 255, 0 }, { 3, 1 }, { 254, 1 },
64  { 7, 3 }, { 252, 3 }, { 15, 7 }, { 248, 7 }, { 31, 15 },
65  { 240, 15 }, { 63, 31 }, { 224, 31 }, { 127, 63 }, { 192, 63 },
66  { 255, 127 }, { 128, 127 }, { 127, 255 }, { 128, 255 },
67 };
68 
69 /* entry[i] of the following tables gives
70  * the number of VLC codes of length i + 2. */
71 static const uint16_t rv_lum_len_count[15] = {
72  1, 0, 2, 4, 8, 16, 32, 0, 64, 0, 128, 0, 256, 0, 512,
73 };
74 
75 static const uint16_t rv_chrom_len_count[15] = {
76  1, 2, 4, 0, 8, 0, 16, 0, 32, 0, 64, 0, 128, 0, 256,
77 };
78 
80 
82 {
83  int code;
84 
85  if (n < 4) {
87  } else {
89  if (code < 0) {
90  av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
91  return -1;
92  }
93  }
94  return code;
95 }
96 
97 /* read RV 1.0 compatible frame header */
99 {
100  int mb_count, pb_frame, marker, mb_xy;
101 
102  marker = get_bits1(&s->gb);
103 
104  if (get_bits1(&s->gb))
105  s->pict_type = AV_PICTURE_TYPE_P;
106  else
107  s->pict_type = AV_PICTURE_TYPE_I;
108 
109  if (!marker)
110  av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
111 
112  pb_frame = get_bits1(&s->gb);
113 
114  ff_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
115 
116  if (pb_frame) {
117  avpriv_request_sample(s->avctx, "PB-frame");
118  return AVERROR_PATCHWELCOME;
119  }
120 
121  s->qscale = get_bits(&s->gb, 5);
122  if (s->qscale == 0) {
123  av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
124  return AVERROR_INVALIDDATA;
125  }
126 
127  if (s->pict_type == AV_PICTURE_TYPE_I) {
128  if (s->rv10_version == 3) {
129  /* specific MPEG like DC coding not used */
130  s->last_dc[0] = get_bits(&s->gb, 8);
131  s->last_dc[1] = get_bits(&s->gb, 8);
132  s->last_dc[2] = get_bits(&s->gb, 8);
133  ff_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
134  s->last_dc[1], s->last_dc[2]);
135  }
136  }
137  /* if multiple packets per frame are sent, the position at which
138  * to display the macroblocks is coded here */
139 
140  mb_xy = s->mb_x + s->mb_y * s->mb_width;
141  if (show_bits(&s->gb, 12) == 0 || (mb_xy && mb_xy < s->mb_num)) {
142  s->mb_x = get_bits(&s->gb, 6); /* mb_x */
143  s->mb_y = get_bits(&s->gb, 6); /* mb_y */
144  mb_count = get_bits(&s->gb, 12);
145  } else {
146  s->mb_x = 0;
147  s->mb_y = 0;
148  mb_count = s->mb_width * s->mb_height;
149  }
150  skip_bits(&s->gb, 3); /* ignored */
151  s->f_code = 1;
152  s->unrestricted_mv = 1;
153 
154  return mb_count;
155 }
156 
157 static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
158 {
159  MpegEncContext *s = &rv->m;
160  int seq, mb_pos, i, ret;
161  int rpr_max;
162 
163  i = get_bits(&s->gb, 2);
164  switch (i) {
165  case 0:
166  s->pict_type = AV_PICTURE_TYPE_I;
167  break;
168  case 1:
169  s->pict_type = AV_PICTURE_TYPE_I;
170  break; // hmm ...
171  case 2:
172  s->pict_type = AV_PICTURE_TYPE_P;
173  break;
174  case 3:
175  s->pict_type = AV_PICTURE_TYPE_B;
176  break;
177  default:
178  av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
179  return AVERROR_INVALIDDATA;
180  }
181 
182  if (s->low_delay && s->pict_type == AV_PICTURE_TYPE_B) {
183  av_log(s->avctx, AV_LOG_ERROR, "low delay B\n");
184  return -1;
185  }
186  if (!s->last_picture_ptr && s->pict_type == AV_PICTURE_TYPE_B) {
187  av_log(s->avctx, AV_LOG_ERROR, "early B-frame\n");
188  return AVERROR_INVALIDDATA;
189  }
190 
191  if (get_bits1(&s->gb)) {
192  av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
193  return AVERROR_INVALIDDATA;
194  }
195 
196  s->qscale = get_bits(&s->gb, 5);
197  if (s->qscale == 0) {
198  av_log(s->avctx, AV_LOG_ERROR, "Invalid qscale value: 0\n");
199  return AVERROR_INVALIDDATA;
200  }
201 
202  if (RV_GET_MINOR_VER(rv->sub_id) >= 2)
203  s->loop_filter = get_bits1(&s->gb) && !s->avctx->lowres;
204 
205  if (RV_GET_MINOR_VER(rv->sub_id) <= 1)
206  seq = get_bits(&s->gb, 8) << 7;
207  else
208  seq = get_bits(&s->gb, 13) << 2;
209 
210  rpr_max = s->avctx->extradata[1] & 7;
211  if (rpr_max) {
212  int f, new_w, new_h;
213  int rpr_bits = av_log2(rpr_max) + 1;
214 
215  f = get_bits(&s->gb, rpr_bits);
216 
217  if (f) {
218  if (s->avctx->extradata_size < 8 + 2 * f) {
219  av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
220  return AVERROR_INVALIDDATA;
221  }
222 
223  new_w = 4 * ((uint8_t *) s->avctx->extradata)[6 + 2 * f];
224  new_h = 4 * ((uint8_t *) s->avctx->extradata)[7 + 2 * f];
225  } else {
226  new_w = rv->orig_width;
227  new_h = rv->orig_height;
228  }
229  if (new_w != s->width || new_h != s->height || !s->context_initialized) {
230  AVRational old_aspect = s->avctx->sample_aspect_ratio;
231  av_log(s->avctx, AV_LOG_DEBUG,
232  "attempting to change resolution to %dx%d\n", new_w, new_h);
233  if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
234  return AVERROR_INVALIDDATA;
235 
236  if (whole_size < (new_w + 15)/16 * ((new_h + 15)/16) / 8)
237  return AVERROR_INVALIDDATA;
238 
240 
241  // attempt to keep aspect during typical resolution switches
242  if (!old_aspect.num)
243  old_aspect = (AVRational){1, 1};
244  if (2 * (int64_t)new_w * s->height == (int64_t)new_h * s->width)
245  s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
246  if ((int64_t)new_w * s->height == 2 * (int64_t)new_h * s->width)
247  s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
248 
249  ret = ff_set_dimensions(s->avctx, new_w, new_h);
250  if (ret < 0)
251  return ret;
252 
253  s->width = new_w;
254  s->height = new_h;
255  if ((ret = ff_mpv_common_init(s)) < 0)
256  return ret;
257  }
258 
259  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
260  av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d/%d\n", f, rpr_bits, rpr_max);
261  }
262  }
263  if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
264  return AVERROR_INVALIDDATA;
265 
266  mb_pos = ff_h263_decode_mba(s);
267 
268  seq |= s->time & ~0x7FFF;
269  if (seq - s->time > 0x4000)
270  seq -= 0x8000;
271  if (seq - s->time < -0x4000)
272  seq += 0x8000;
273 
274  if (seq != s->time) {
275  if (s->pict_type != AV_PICTURE_TYPE_B) {
276  s->time = seq;
277  s->pp_time = s->time - s->last_non_b_time;
278  s->last_non_b_time = s->time;
279  } else {
280  s->time = seq;
281  s->pb_time = s->pp_time - (s->last_non_b_time - s->time);
282  }
283  }
284  if (s->pict_type == AV_PICTURE_TYPE_B) {
285  if (s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0) {
286  av_log(s->avctx, AV_LOG_DEBUG,
287  "messed up order, possible from seeking? skipping current B-frame\n");
288 #define ERROR_SKIP_FRAME -123
289  return ERROR_SKIP_FRAME;
290  }
292  }
293 
294  s->no_rounding = get_bits1(&s->gb);
295 
296  if (RV_GET_MINOR_VER(rv->sub_id) <= 1 && s->pict_type == AV_PICTURE_TYPE_B)
297  // binary decoder reads 3+2 bits here but they don't seem to be used
298  skip_bits(&s->gb, 5);
299 
300  s->f_code = 1;
301  s->unrestricted_mv = 1;
302  s->h263_aic = s->pict_type == AV_PICTURE_TYPE_I;
303  s->modified_quant = 1;
304  if (!s->avctx->lowres)
305  s->loop_filter = 1;
306 
307  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
308  av_log(s->avctx, AV_LOG_INFO,
309  "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
310  seq, s->mb_x, s->mb_y, s->pict_type, s->qscale,
311  s->no_rounding);
312  }
313 
314  av_assert0(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
315 
316  return s->mb_width * s->mb_height - mb_pos;
317 }
318 
319 static av_cold void rv10_build_vlc(VLC *vlc, const uint16_t len_count[15],
320  const uint8_t sym_rl[][2], int sym_rl_elems)
321 {
322  uint16_t syms[MAX_VLC_ENTRIES];
323  uint8_t lens[MAX_VLC_ENTRIES];
324  unsigned nb_syms = 0, nb_lens = 0;
325 
326  for (unsigned i = 0; i < sym_rl_elems; i++) {
327  unsigned cur_sym = sym_rl[i][0];
328  for (unsigned tmp = nb_syms + sym_rl[i][1]; nb_syms <= tmp; nb_syms++)
329  syms[nb_syms] = 0xFF & cur_sym--;
330  }
331 
332  for (unsigned i = 0; i < 15; i++)
333  for (unsigned tmp = nb_lens + len_count[i]; nb_lens < tmp; nb_lens++)
334  lens[nb_lens] = i + 2;
335  av_assert1(nb_lens == nb_syms);
336  ff_init_vlc_from_lengths(vlc, DC_VLC_BITS, nb_lens, lens, 1,
337  syms, 2, 2, 0, INIT_VLC_STATIC_OVERLONG, NULL);
338 }
339 
340 static av_cold void rv10_init_static(void)
341 {
342  static VLC_TYPE table[1472 + 992][2];
343 
345  rv_dc_lum.table_allocated = 1472;
348  for (int i = 0; i < 1 << (DC_VLC_BITS - 7 /* Length of skip prefix */); i++) {
349  /* All codes beginning with 0x7F have the same length and value.
350  * Modifying the table directly saves us the useless subtables. */
351  rv_dc_lum.table[(0x7F << (DC_VLC_BITS - 7)) + i][0] = 255;
352  rv_dc_lum.table[(0x7F << (DC_VLC_BITS - 7)) + i][1] = 18;
353  }
354  rv_dc_chrom.table = &table[1472];
358  for (int i = 0; i < 1 << (DC_VLC_BITS - 9 /* Length of skip prefix */); i++) {
359  /* Same as above. */
360  rv_dc_chrom.table[(0x1FE << (DC_VLC_BITS - 9)) + i][0] = 255;
361  rv_dc_chrom.table[(0x1FE << (DC_VLC_BITS - 9)) + i][1] = 18;
362  }
364 }
365 
367 {
368  static AVOnce init_static_once = AV_ONCE_INIT;
369  RVDecContext *rv = avctx->priv_data;
370  MpegEncContext *s = &rv->m;
371  int major_ver, minor_ver, micro_ver, ret;
372 
373  if (avctx->extradata_size < 8) {
374  av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
375  return AVERROR_INVALIDDATA;
376  }
377  if ((ret = av_image_check_size(avctx->coded_width,
378  avctx->coded_height, 0, avctx)) < 0)
379  return ret;
380 
381  ff_mpv_decode_init(s, avctx);
382 
383  s->out_format = FMT_H263;
384 
385  rv->orig_width =
386  s->width = avctx->coded_width;
387  rv->orig_height =
388  s->height = avctx->coded_height;
389 
390  s->h263_long_vectors = ((uint8_t *) avctx->extradata)[3] & 1;
391  rv->sub_id = AV_RB32((uint8_t *) avctx->extradata + 4);
392 
393  major_ver = RV_GET_MAJOR_VER(rv->sub_id);
394  minor_ver = RV_GET_MINOR_VER(rv->sub_id);
395  micro_ver = RV_GET_MICRO_VER(rv->sub_id);
396 
397  s->low_delay = 1;
398  switch (major_ver) {
399  case 1:
400  s->rv10_version = micro_ver ? 3 : 1;
401  s->obmc = micro_ver == 2;
402  break;
403  case 2:
404  if (minor_ver >= 2) {
405  s->low_delay = 0;
406  s->avctx->has_b_frames = 1;
407  }
408  break;
409  default:
410  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
411  avpriv_request_sample(avctx, "RV1/2 version");
412  return AVERROR_PATCHWELCOME;
413  }
414 
415  if (avctx->debug & FF_DEBUG_PICT_INFO) {
416  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%"PRIX32"\n", rv->sub_id,
417  ((uint32_t *) avctx->extradata)[0]);
418  }
419 
420  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
421 
423  if ((ret = ff_mpv_common_init(s)) < 0)
424  return ret;
425 
426  ff_h263dsp_init(&s->h263dsp);
427 
428  /* init static VLCs */
429  ff_thread_once(&init_static_once, rv10_init_static);
430 
431  return 0;
432 }
433 
435 {
436  MpegEncContext *s = avctx->priv_data;
437 
439  return 0;
440 }
441 
442 static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf,
443  int buf_size, int buf_size2, int whole_size)
444 {
445  RVDecContext *rv = avctx->priv_data;
446  MpegEncContext *s = &rv->m;
447  int mb_count, mb_pos, left, start_mb_x, active_bits_size, ret;
448 
449  active_bits_size = buf_size * 8;
450  init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
451  if (s->codec_id == AV_CODEC_ID_RV10)
452  mb_count = rv10_decode_picture_header(s);
453  else
454  mb_count = rv20_decode_picture_header(rv, whole_size);
455  if (mb_count < 0) {
456  if (mb_count != ERROR_SKIP_FRAME)
457  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
458  return AVERROR_INVALIDDATA;
459  }
460 
461  if (s->mb_x >= s->mb_width ||
462  s->mb_y >= s->mb_height) {
463  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
464  return AVERROR_INVALIDDATA;
465  }
466  mb_pos = s->mb_y * s->mb_width + s->mb_x;
467  left = s->mb_width * s->mb_height - mb_pos;
468  if (mb_count > left) {
469  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
470  return AVERROR_INVALIDDATA;
471  }
472 
473  if (whole_size < s->mb_width * s->mb_height / 8)
474  return AVERROR_INVALIDDATA;
475 
476  if ((s->mb_x == 0 && s->mb_y == 0) || !s->current_picture_ptr) {
477  // FIXME write parser so we always have complete frames?
478  if (s->current_picture_ptr) {
479  ff_er_frame_end(&s->er);
481  s->mb_x = s->mb_y = s->resync_mb_x = s->resync_mb_y = 0;
482  }
483  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
484  return ret;
486  } else {
487  if (s->current_picture_ptr->f->pict_type != s->pict_type) {
488  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
489  return AVERROR_INVALIDDATA;
490  }
491  }
492 
493 
494  ff_dlog(avctx, "qscale=%d\n", s->qscale);
495 
496  /* default quantization values */
497  if (s->codec_id == AV_CODEC_ID_RV10) {
498  if (s->mb_y == 0)
499  s->first_slice_line = 1;
500  } else {
501  s->first_slice_line = 1;
502  s->resync_mb_x = s->mb_x;
503  }
504  start_mb_x = s->mb_x;
505  s->resync_mb_y = s->mb_y;
506  if (s->h263_aic) {
507  s->y_dc_scale_table =
508  s->c_dc_scale_table = ff_aic_dc_scale_table;
509  } else {
510  s->y_dc_scale_table =
511  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
512  }
513 
514  if (s->modified_quant)
515  s->chroma_qscale_table = ff_h263_chroma_qscale_table;
516 
517  ff_set_qscale(s, s->qscale);
518 
519  s->rv10_first_dc_coded[0] = 0;
520  s->rv10_first_dc_coded[1] = 0;
521  s->rv10_first_dc_coded[2] = 0;
522  s->block_wrap[0] =
523  s->block_wrap[1] =
524  s->block_wrap[2] =
525  s->block_wrap[3] = s->b8_stride;
526  s->block_wrap[4] =
527  s->block_wrap[5] = s->mb_stride;
529 
530  /* decode each macroblock */
531  for (s->mb_num_left = mb_count; s->mb_num_left > 0; s->mb_num_left--) {
532  int ret;
534  ff_tlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
535 
536  s->mv_dir = MV_DIR_FORWARD;
537  s->mv_type = MV_TYPE_16X16;
538  ret = ff_h263_decode_mb(s, s->block);
539 
540  // Repeat the slice end check from ff_h263_decode_mb with our active
541  // bitstream size
542  if (ret != SLICE_ERROR && active_bits_size >= get_bits_count(&s->gb)) {
543  int v = show_bits(&s->gb, 16);
544 
545  if (get_bits_count(&s->gb) + 16 > active_bits_size)
546  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
547 
548  if (!v)
549  ret = SLICE_END;
550  }
551  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
552  8 * buf_size2 >= get_bits_count(&s->gb)) {
553  active_bits_size = buf_size2 * 8;
554  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
555  8 * buf_size, active_bits_size);
556  ret = SLICE_OK;
557  }
558 
559  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
560  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x,
561  s->mb_y);
562  return AVERROR_INVALIDDATA;
563  }
564  if (s->pict_type != AV_PICTURE_TYPE_B)
566  ff_mpv_reconstruct_mb(s, s->block);
567  if (s->loop_filter)
569 
570  if (++s->mb_x == s->mb_width) {
571  s->mb_x = 0;
572  s->mb_y++;
574  }
575  if (s->mb_x == s->resync_mb_x)
576  s->first_slice_line = 0;
577  if (ret == SLICE_END)
578  break;
579  }
580 
581  ff_er_add_slice(&s->er, start_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y,
582  ER_MB_END);
583 
584  return active_bits_size;
585 }
586 
587 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
588 {
589  if (avctx->slice_count)
590  return avctx->slice_offset[n];
591  else
592  return AV_RL32(buf + n * 8);
593 }
594 
595 static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
596  AVPacket *avpkt)
597 {
598  const uint8_t *buf = avpkt->data;
599  int buf_size = avpkt->size;
600  MpegEncContext *s = avctx->priv_data;
601  AVFrame *pict = data;
602  int i, ret;
603  int slice_count;
604  const uint8_t *slices_hdr = NULL;
605 
606  ff_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
607 
608  /* no supplementary picture */
609  if (buf_size == 0) {
610  return 0;
611  }
612 
613  if (!avctx->slice_count) {
614  slice_count = (*buf++) + 1;
615  buf_size--;
616 
617  if (!slice_count || buf_size <= 8 * slice_count) {
618  av_log(avctx, AV_LOG_ERROR, "Invalid slice count: %d.\n",
619  slice_count);
620  return AVERROR_INVALIDDATA;
621  }
622 
623  slices_hdr = buf + 4;
624  buf += 8 * slice_count;
625  buf_size -= 8 * slice_count;
626  } else
627  slice_count = avctx->slice_count;
628 
629  for (i = 0; i < slice_count; i++) {
630  unsigned offset = get_slice_offset(avctx, slices_hdr, i);
631  int size, size2;
632 
633  if (offset >= buf_size)
634  return AVERROR_INVALIDDATA;
635 
636  if (i + 1 == slice_count)
637  size = buf_size - offset;
638  else
639  size = get_slice_offset(avctx, slices_hdr, i + 1) - offset;
640 
641  if (i + 2 >= slice_count)
642  size2 = buf_size - offset;
643  else
644  size2 = get_slice_offset(avctx, slices_hdr, i + 2) - offset;
645 
646  if (size <= 0 || size2 <= 0 ||
647  offset + FFMAX(size, size2) > buf_size)
648  return AVERROR_INVALIDDATA;
649 
650  if ((ret = rv10_decode_packet(avctx, buf + offset, size, size2, buf_size)) < 0)
651  return ret;
652 
653  if (ret > 8 * size)
654  i++;
655  }
656 
657  if (s->current_picture_ptr && s->mb_y >= s->mb_height) {
658  ff_er_frame_end(&s->er);
660 
661  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
662  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
663  return ret;
664  ff_print_debug_info(s, s->current_picture_ptr, pict);
665  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
666  } else if (s->last_picture_ptr) {
667  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
668  return ret;
669  ff_print_debug_info(s, s->last_picture_ptr, pict);
670  ff_mpv_export_qp_table(s, pict,s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
671  }
672 
673  if (s->last_picture_ptr || s->low_delay) {
674  *got_frame = 1;
675  }
676 
677  // so we can detect if frame_end was not called (find some nicer solution...)
678  s->current_picture_ptr = NULL;
679  }
680 
681  return avpkt->size;
682 }
683 
685  .name = "rv10",
686  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
687  .type = AVMEDIA_TYPE_VIDEO,
688  .id = AV_CODEC_ID_RV10,
689  .priv_data_size = sizeof(RVDecContext),
691  .close = rv10_decode_end,
693  .capabilities = AV_CODEC_CAP_DR1,
694  .max_lowres = 3,
695  .pix_fmts = (const enum AVPixelFormat[]) {
698  },
699 };
700 
702  .name = "rv20",
703  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
704  .type = AVMEDIA_TYPE_VIDEO,
705  .id = AV_CODEC_ID_RV20,
706  .priv_data_size = sizeof(RVDecContext),
708  .close = rv10_decode_end,
710  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
711  .flush = ff_mpeg_flush,
712  .max_lowres = 3,
713  .pix_fmts = (const enum AVPixelFormat[]) {
716  },
717 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:913
AVCodec
AVCodec.
Definition: codec.h:197
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:31
RV_GET_MINOR_VER
#define RV_GET_MINOR_VER(x)
Definition: rv10.c:46
thread.h
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
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:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AVCodecContext::slice_offset
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:850
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:142
ff_h263_decode_mba
int ff_h263_decode_mba(MpegEncContext *s)
Definition: ituh263dec.c:138
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:2267
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:91
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:52
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1409
AVCodecContext::slice_count
int slice_count
slice count
Definition: avcodec.h:843
MAX_VLC_ENTRIES
#define MAX_VLC_ENTRIES
Definition: rv10.c:49
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
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
ff_h263dsp_init
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:689
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:520
ff_h263_update_motion_val
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:54
AVRational::num
int num
Numerator.
Definition: rational.h:59
rv10_decode_end
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Definition: rv10.c:434
ff_h263_decode_init_vlc
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:108
ff_init_vlc_from_lengths
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: bitstream.c:370
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1111
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
rv10_decode_picture_header
static int rv10_decode_picture_header(MpegEncContext *s)
Definition: rv10.c:98
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:603
ff_h263_chroma_qscale_table
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.c:260
s
#define s(width, name)
Definition: cbs_vp9.c:257
RV_GET_MAJOR_VER
#define RV_GET_MAJOR_VER(x)
Definition: rv10.c:45
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:289
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
rv_dc_chrom
static VLC rv_dc_chrom
Definition: rv10.c:79
rv10_build_vlc
static av_cold void rv10_build_vlc(VLC *vlc, const uint16_t len_count[15], const uint8_t sym_rl[][2], int sym_rl_elems)
Definition: rv10.c:319
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:55
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
NULL
#define NULL
Definition: coverity.c:32
rv
int32_t rv
Definition: input.c:405
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:55
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ERROR_SKIP_FRAME
#define ERROR_SKIP_FRAME
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:2331
AVOnce
#define AVOnce
Definition: thread.h:172
rv_chrom_len_count
static const uint16_t rv_chrom_len_count[15]
Definition: rv10.c:75
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
VLC::table_allocated
int table_allocated
Definition: vlc.h:29
rv_dc_lum
static VLC rv_dc_lum
Definition: rv10.c:79
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:366
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:117
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:326
FF_QSCALE_TYPE_MPEG1
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:97
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
size
int size
Definition: twinvq_data.h:10344
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:96
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2300
ff_rv20_decoder
const AVCodec ff_rv20_decoder
Definition: rv10.c:701
RVDecContext::m
MpegEncContext m
Definition: rv10.c:53
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:1420
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1413
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:442
ff_rv10_decoder
const AVCodec ff_rv10_decoder
Definition: rv10.c:684
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
rv_sym_run_len
static const uint8_t rv_sym_run_len[][2]
Definition: rv10.c:62
ff_rv_decode_dc
int ff_rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:81
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:750
rv10_init_static
static av_cold void rv10_init_static(void)
Definition: rv10.c:340
FMT_H263
@ FMT_H263
Definition: mpegutils.h:126
i
int i
Definition: input.c:407
AV_CODEC_ID_RV10
@ AV_CODEC_ID_RV10
Definition: codec_id.h:54
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:602
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AV_CODEC_ID_RV20
@ AV_CODEC_ID_RV20
Definition: codec_id.h:55
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1405
avcodec.h
get_slice_offset
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
Definition: rv10.c:587
ret
ret
Definition: filter_design.txt:187
SLICE_OK
#define SLICE_OK
Definition: mpegvideo.h:518
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:96
ff_aic_dc_scale_table
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.c:245
rv20_decode_picture_header
static int rv20_decode_picture_header(RVDecContext *rv, int whole_size)
Definition: rv10.c:157
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:1181
ff_h263_loop_filter
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:147
ff_mpeg4_init_direct_mv
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:83
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:92
rv_lum_len_count
static const uint16_t rv_lum_len_count[15]
Definition: rv10.c:71
AVCodecContext
main external API structure.
Definition: avcodec.h:501
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:2248
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:77
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:1408
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:689
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:84
rv10_decode_init
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Definition: rv10.c:366
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1129
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:519
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
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:50
imgutils.h
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:595
ff_h263_decode_mb
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:696
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:315
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:699
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:54
h263.h