FFmpeg
h263dec.c
Go to the documentation of this file.
1 /*
2  * H.263 decoder
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
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  * H.263 decoder.
26  */
27 
28 #define UNCHECKED_BITSTREAM_READER 1
29 
30 #include "config_components.h"
31 
32 #include "avcodec.h"
33 #include "codec_internal.h"
34 #include "decode.h"
35 #include "error_resilience.h"
36 #include "flvdec.h"
37 #include "h263.h"
38 #include "h263dec.h"
39 #include "hwaccel_internal.h"
40 #include "hwconfig.h"
41 #include "mpeg_er.h"
42 #include "mpeg4video.h"
43 #include "mpeg4videodec.h"
44 #include "mpeg4videodefs.h"
45 #include "mpegutils.h"
46 #include "mpegvideo.h"
47 #include "mpegvideodec.h"
48 #include "msmpeg4dec.h"
49 #include "thread.h"
50 #include "wmv2dec.h"
51 
53 #if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL
55 #endif
56 #if CONFIG_MPEG4_NVDEC_HWACCEL
58 #endif
59 #if CONFIG_MPEG4_VDPAU_HWACCEL
61 #endif
62 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL || CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL
64 #endif
67 };
68 
70 {
71  /* MPEG-4 Studio Profile only, not supported by hardware */
72  if (avctx->bits_per_raw_sample > 8) {
73  av_assert1(((MpegEncContext *)avctx->priv_data)->studio_profile);
74  return avctx->pix_fmt;
75  }
76 
77  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {
80  return AV_PIX_FMT_GRAY8;
81  }
82 
83  if (avctx->codec_id == AV_CODEC_ID_H263 ||
84  avctx->codec_id == AV_CODEC_ID_H263P ||
85  avctx->codec_id == AV_CODEC_ID_MPEG4)
86  return avctx->pix_fmt = ff_get_format(avctx, h263_hwaccel_pixfmt_list_420);
87 
88  return AV_PIX_FMT_YUV420P;
89 }
90 
92 {
93  MpegEncContext *s = avctx->priv_data;
94  int ret;
95 
96  s->out_format = FMT_H263;
97 
98  // set defaults
99  ff_mpv_decode_init(s, avctx);
100 
101  s->quant_precision = 5;
102  s->decode_mb = ff_h263_decode_mb;
103  s->low_delay = 1;
104 
105  /* select sub codec */
106  switch (avctx->codec->id) {
107  case AV_CODEC_ID_H263:
108  case AV_CODEC_ID_H263P:
110  break;
111  case AV_CODEC_ID_MPEG4:
112  break;
114  s->h263_pred = 1;
115  s->msmpeg4_version = 1;
116  break;
118  s->h263_pred = 1;
119  s->msmpeg4_version = 2;
120  break;
122  s->h263_pred = 1;
123  s->msmpeg4_version = 3;
124  break;
125  case AV_CODEC_ID_WMV1:
126  s->h263_pred = 1;
127  s->msmpeg4_version = 4;
128  break;
129  case AV_CODEC_ID_WMV2:
130  s->h263_pred = 1;
131  s->msmpeg4_version = 5;
132  break;
133  case AV_CODEC_ID_H263I:
134  break;
135  case AV_CODEC_ID_FLV1:
136  s->h263_flv = 1;
137  break;
138  default:
139  av_log(avctx, AV_LOG_ERROR, "Unsupported codec %d\n",
140  avctx->codec->id);
141  return AVERROR(ENOSYS);
142  }
143 
144  if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263"))
145  if (avctx->extradata_size == 56 && avctx->extradata[0] == 1)
146  s->ehc_mode = 1;
147 
148  /* for H.263, we allocate the images after having read the header */
149  if (avctx->codec->id != AV_CODEC_ID_H263 &&
150  avctx->codec->id != AV_CODEC_ID_H263P &&
151  avctx->codec->id != AV_CODEC_ID_MPEG4) {
152  avctx->pix_fmt = h263_get_format(avctx);
153  if ((ret = ff_mpv_common_init(s)) < 0)
154  return ret;
155  }
156 
157  ff_h263dsp_init(&s->h263dsp);
159 
160  return 0;
161 }
162 
164 {
165  MpegEncContext *s = avctx->priv_data;
166 
168  return 0;
169 }
170 
171 /**
172  * Return the number of bytes consumed for building the current frame.
173  */
174 static int get_consumed_bytes(MpegEncContext *s, int buf_size)
175 {
176  int pos = (get_bits_count(&s->gb) + 7) >> 3;
177 
178  if (s->divx_packed || s->avctx->hwaccel) {
179  /* We would have to scan through the whole buf to handle the weird
180  * reordering ... */
181  return buf_size;
182  } else {
183  // avoid infinite loops (maybe not needed...)
184  if (pos == 0)
185  pos = 1;
186  // oops ;)
187  if (pos + 10 > buf_size)
188  pos = buf_size;
189 
190  return pos;
191  }
192 }
193 
195 {
196  const int part_mask = s->partitioned_frame
197  ? (ER_AC_END | ER_AC_ERROR) : 0x7F;
198  const int mb_size = 16 >> s->avctx->lowres;
199  int ret;
200 
201  s->last_resync_gb = s->gb;
202  s->first_slice_line = 1;
203  s->resync_mb_x = s->mb_x;
204  s->resync_mb_y = s->mb_y;
205 
206  ff_set_qscale(s, s->qscale);
207 
208  if (s->studio_profile) {
209  if ((ret = ff_mpeg4_decode_studio_slice_header(s->avctx->priv_data)) < 0)
210  return ret;
211  }
212 
213  if (s->avctx->hwaccel) {
214  const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8;
215  ret = FF_HW_CALL(s->avctx, decode_slice, start, s->gb.buffer_end - start);
216  // ensure we exit decode loop
217  s->mb_y = s->mb_height;
218  return ret;
219  }
220 
221  if (s->partitioned_frame) {
222  const int qscale = s->qscale;
223 
224  if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4)
225  if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0)
226  return ret;
227 
228  /* restore variables which were modified */
229  s->first_slice_line = 1;
230  s->mb_x = s->resync_mb_x;
231  s->mb_y = s->resync_mb_y;
232  ff_set_qscale(s, qscale);
233  }
234 
235  for (; s->mb_y < s->mb_height; s->mb_y++) {
236  /* per-row end of slice checks */
237  if (s->msmpeg4_version) {
238  if (s->resync_mb_y + s->slice_height == s->mb_y) {
239  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
240  s->mb_x - 1, s->mb_y, ER_MB_END);
241 
242  return 0;
243  }
244  }
245 
246  if (s->msmpeg4_version == 1) {
247  s->last_dc[0] =
248  s->last_dc[1] =
249  s->last_dc[2] = 128;
250  }
251 
253  for (; s->mb_x < s->mb_width; s->mb_x++) {
254  int ret;
255 
256  ff_update_block_index(s, s->avctx->bits_per_raw_sample,
257  s->avctx->lowres, s->chroma_x_shift);
258 
259  if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y)
260  s->first_slice_line = 0;
261 
262  /* DCT & quantize */
263 
264  s->mv_dir = MV_DIR_FORWARD;
265  s->mv_type = MV_TYPE_16X16;
266  ff_dlog(s, "%d %06X\n",
267  get_bits_count(&s->gb), show_bits(&s->gb, 24));
268 
269  ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);
270  ret = s->decode_mb(s, s->block);
271 
272  if (s->pict_type != AV_PICTURE_TYPE_B)
274 
275  if (ret < 0) {
276  const int xy = s->mb_x + s->mb_y * s->mb_stride;
277  if (ret == SLICE_END) {
278  ff_mpv_reconstruct_mb(s, s->block);
279  if (s->loop_filter)
281 
282  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
283  s->mb_x, s->mb_y, ER_MB_END & part_mask);
284 
285  s->padding_bug_score--;
286 
287  if (++s->mb_x >= s->mb_width) {
288  s->mb_x = 0;
289  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
291  s->mb_y++;
292  }
293  return 0;
294  } else if (ret == SLICE_NOEND) {
295  av_log(s->avctx, AV_LOG_ERROR,
296  "Slice mismatch at MB: %d\n", xy);
297  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
298  s->mb_x + 1, s->mb_y,
299  ER_MB_END & part_mask);
300  return AVERROR_INVALIDDATA;
301  }
302  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
303  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
304  s->mb_x, s->mb_y, ER_MB_ERROR & part_mask);
305 
306  if ((s->avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&s->gb) > 0)
307  continue;
308  return AVERROR_INVALIDDATA;
309  }
310 
311  ff_mpv_reconstruct_mb(s, s->block);
312  if (s->loop_filter)
314  }
315 
316  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
318 
319  s->mb_x = 0;
320  }
321 
322  av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height);
323 
324  // Detect incorrect padding with wrong stuffing codes used by NEC N-02B
325  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
326  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
327  get_bits_left(&s->gb) >= 48 &&
328  show_bits(&s->gb, 24) == 0x4010 &&
329  !s->data_partitioning)
330  s->padding_bug_score += 32;
331 
332  /* try to detect the padding bug */
333  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
334  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
335  get_bits_left(&s->gb) >= 0 &&
336  get_bits_left(&s->gb) < 137 &&
337  !s->data_partitioning) {
338  const int bits_count = get_bits_count(&s->gb);
339  const int bits_left = s->gb.size_in_bits - bits_count;
340 
341  if (bits_left == 0) {
342  s->padding_bug_score += 16;
343  } else if (bits_left != 1) {
344  int v = show_bits(&s->gb, 8);
345  v |= 0x7F >> (7 - (bits_count & 7));
346 
347  if (v == 0x7F && bits_left <= 8)
348  s->padding_bug_score--;
349  else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) &&
350  bits_left <= 16)
351  s->padding_bug_score += 4;
352  else
353  s->padding_bug_score++;
354  }
355  }
356 
357  if (s->codec_id == AV_CODEC_ID_H263 &&
358  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
359  get_bits_left(&s->gb) >= 8 &&
360  get_bits_left(&s->gb) < 300 &&
361  s->pict_type == AV_PICTURE_TYPE_I &&
362  show_bits(&s->gb, 8) == 0 &&
363  !s->data_partitioning) {
364 
365  s->padding_bug_score += 32;
366  }
367 
368  if (s->codec_id == AV_CODEC_ID_H263 &&
369  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
370  get_bits_left(&s->gb) >= 64 &&
371  AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {
372 
373  s->padding_bug_score += 32;
374  }
375 
376  if (s->workaround_bugs & FF_BUG_AUTODETECT) {
377  if (
378  (s->padding_bug_score > -2 && !s->data_partitioning))
379  s->workaround_bugs |= FF_BUG_NO_PADDING;
380  else
381  s->workaround_bugs &= ~FF_BUG_NO_PADDING;
382  }
383 
384  // handle formats which don't have unique end markers
385  if (s->msmpeg4_version || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly
386  int left = get_bits_left(&s->gb);
387  int max_extra = 7;
388 
389  /* no markers in M$ crap */
390  if (s->msmpeg4_version && s->pict_type == AV_PICTURE_TYPE_I)
391  max_extra += 17;
392 
393  /* buggy padding but the frame should still end approximately at
394  * the bitstream end */
395  if ((s->workaround_bugs & FF_BUG_NO_PADDING) &&
396  (s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE)))
397  max_extra += 48;
398  else if ((s->workaround_bugs & FF_BUG_NO_PADDING))
399  max_extra += 256 * 256 * 256 * 64;
400 
401  if (left > max_extra)
402  av_log(s->avctx, AV_LOG_ERROR,
403  "discarding %d junk bits at end, next would be %X\n",
404  left, show_bits(&s->gb, 24));
405  else if (left < 0)
406  av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
407  else
408  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
409  s->mb_x - 1, s->mb_y, ER_MB_END);
410 
411  return 0;
412  }
413 
414  av_log(s->avctx, AV_LOG_ERROR,
415  "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
416  get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score);
417 
418  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
419  ER_MB_END & part_mask);
420 
421  return AVERROR_INVALIDDATA;
422 }
423 
425  int *got_frame, AVPacket *avpkt)
426 {
427  const uint8_t *buf = avpkt->data;
428  int buf_size = avpkt->size;
429  MpegEncContext *s = avctx->priv_data;
430  int ret;
431  int slice_ret = 0;
432 
433  /* no supplementary picture */
434  if (buf_size == 0) {
435  /* special case for last picture */
436  if (s->low_delay == 0 && s->next_picture_ptr) {
437  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
438  return ret;
439  s->next_picture_ptr = NULL;
440 
441  *got_frame = 1;
442  } else if (s->skipped_last_frame && s->current_picture_ptr) {
443  /* Output the last picture we decoded again if the stream ended with
444  * an NVOP */
445  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
446  return ret;
447  /* Copy props from the last input packet. Otherwise, props from the last
448  * returned picture would be reused */
449  if ((ret = ff_decode_frame_props(avctx, pict)) < 0)
450  return ret;
451  s->current_picture_ptr = NULL;
452 
453  *got_frame = 1;
454  }
455 
456  return 0;
457  }
458 
459 retry:
460  if (s->divx_packed && s->bitstream_buffer_size) {
461  int i;
462  for(i=0; i < buf_size-3; i++) {
463  if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) {
464  if (buf[i+3]==0xB0) {
465  av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");
466  s->bitstream_buffer_size = 0;
467  }
468  break;
469  }
470  }
471  }
472 
473  if (s->bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) // divx 5.01+/xvid frame reorder
474  ret = init_get_bits8(&s->gb, s->bitstream_buffer,
475  s->bitstream_buffer_size);
476  else
477  ret = init_get_bits8(&s->gb, buf, buf_size);
478 
479  s->bitstream_buffer_size = 0;
480  if (ret < 0)
481  return ret;
482 
483  /* let's go :-) */
484  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {
486  } else if (CONFIG_MSMPEG4DEC && s->msmpeg4_version) {
488  } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
489  ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb, 0, 0);
490  s->skipped_last_frame = (ret == FRAME_SKIPPED);
491  } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {
493  } else if (CONFIG_FLV_DECODER && s->h263_flv) {
495  } else {
497  }
498 
499  if (ret < 0 || ret == FRAME_SKIPPED) {
500  if ( s->width != avctx->coded_width
501  || s->height != avctx->coded_height) {
502  av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");
503  s->width = avctx->coded_width;
504  s->height= avctx->coded_height;
505  }
506  }
507  if (ret == FRAME_SKIPPED)
508  return get_consumed_bytes(s, buf_size);
509 
510  /* skip if the header was thrashed */
511  if (ret < 0) {
512  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
513  return ret;
514  }
515 
516  if (!s->context_initialized) {
517  avctx->pix_fmt = h263_get_format(avctx);
518  if ((ret = ff_mpv_common_init(s)) < 0)
519  return ret;
520  }
521 
522  avctx->has_b_frames = !s->low_delay;
523 
524  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
525  if (s->pict_type != AV_PICTURE_TYPE_B && s->mb_num/2 > get_bits_left(&s->gb))
526  return AVERROR_INVALIDDATA;
527  if (ff_mpeg4_workaround_bugs(avctx) == 1)
528  goto retry;
529  if (s->studio_profile != (s->idsp.idct == NULL))
531  }
532 
533  /* After H.263 & MPEG-4 header decode we have the height, width,
534  * and other parameters. So then we could init the picture.
535  * FIXME: By the way H.263 decoder is evolving it should have
536  * an H263EncContext */
537  if (s->width != avctx->coded_width ||
538  s->height != avctx->coded_height ||
539  s->context_reinit) {
540  /* H.263 could change picture size any time */
541  s->context_reinit = 0;
542 
543  ret = ff_set_dimensions(avctx, s->width, s->height);
544  if (ret < 0)
545  return ret;
546 
547  ff_set_sar(avctx, avctx->sample_aspect_ratio);
548 
550  return ret;
551 
552  if (avctx->pix_fmt != h263_get_format(avctx)) {
553  av_log(avctx, AV_LOG_ERROR, "format change not supported\n");
554  avctx->pix_fmt = AV_PIX_FMT_NONE;
555  return AVERROR_UNKNOWN;
556  }
557  }
558 
559  if (s->codec_id == AV_CODEC_ID_H263 ||
560  s->codec_id == AV_CODEC_ID_H263P ||
561  s->codec_id == AV_CODEC_ID_H263I)
562  s->gob_index = H263_GOB_HEIGHT(s->height);
563 
564  /* skip B-frames if we don't have reference frames */
565  if (!s->last_picture_ptr &&
566  (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))
567  return get_consumed_bytes(s, buf_size);
568  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
569  s->pict_type == AV_PICTURE_TYPE_B) ||
570  (avctx->skip_frame >= AVDISCARD_NONKEY &&
571  s->pict_type != AV_PICTURE_TYPE_I) ||
572  avctx->skip_frame >= AVDISCARD_ALL)
573  return get_consumed_bytes(s, buf_size);
574 
575  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
576  return ret;
577 
578  if (!s->divx_packed && !avctx->hwaccel)
579  ff_thread_finish_setup(avctx);
580 
581  if (avctx->hwaccel) {
582  ret = FF_HW_CALL(avctx, start_frame,
583  s->gb.buffer, s->gb.buffer_end - s->gb.buffer);
584  if (ret < 0 )
585  return ret;
586  }
587 
589 
590  /* the second part of the wmv2 header contains the MB skip bits which
591  * are stored in current_picture->mb_type which is not available before
592  * ff_mpv_frame_start() */
593  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {
595  if (ret < 0)
596  return ret;
597  if (ret == 1)
598  goto frame_end;
599  }
600 
601  /* decode each macroblock */
602  s->mb_x = 0;
603  s->mb_y = 0;
604 
605  slice_ret = decode_slice(s);
606  while (s->mb_y < s->mb_height) {
607  if (s->msmpeg4_version) {
608  if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 ||
609  (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)
610  break;
611  } else {
612  int prev_x = s->mb_x, prev_y = s->mb_y;
613  if (ff_h263_resync(s) < 0)
614  break;
615  if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
616  s->er.error_occurred = 1;
617  }
618 
619  if (s->msmpeg4_version < 4 && s->h263_pred)
621 
622  if (decode_slice(s) < 0)
623  slice_ret = AVERROR_INVALIDDATA;
624  }
625 
626  if (s->msmpeg4_version && s->msmpeg4_version < 4 &&
627  s->pict_type == AV_PICTURE_TYPE_I)
628  if (!CONFIG_MSMPEG4DEC ||
629  ff_msmpeg4_decode_ext_header(s, buf_size) < 0)
630  s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;
631 
632  av_assert1(s->bitstream_buffer_size == 0);
633 frame_end:
634  if (!s->studio_profile)
635  ff_er_frame_end(&s->er, NULL);
636 
637  if (avctx->hwaccel) {
638  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
639  if (ret < 0)
640  return ret;
641  }
642 
644 
645  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)
646  ff_mpeg4_frame_end(avctx, buf, buf_size);
647 
648  if (!s->divx_packed && avctx->hwaccel)
649  ff_thread_finish_setup(avctx);
650 
651  av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
652  av_assert1(s->current_picture.f->pict_type == s->pict_type);
653  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
654  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
655  return ret;
656  ff_print_debug_info(s, s->current_picture_ptr, pict);
657  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
658  } else if (s->last_picture_ptr) {
659  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
660  return ret;
661  ff_print_debug_info(s, s->last_picture_ptr, pict);
662  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
663  }
664 
665  if (s->last_picture_ptr || s->low_delay) {
666  if ( pict->format == AV_PIX_FMT_YUV420P
667  && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {
668  for (int p = 0; p < 3; p++) {
669  int h = AV_CEIL_RSHIFT(pict->height, !!p);
670 
671  pict->data[p] += (h - 1) * pict->linesize[p];
672  pict->linesize[p] *= -1;
673  }
674  }
675  *got_frame = 1;
676  }
677 
678  if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
679  return slice_ret;
680  else
681  return get_consumed_bytes(s, buf_size);
682 }
683 
685 #if CONFIG_H263_VAAPI_HWACCEL
686  HWACCEL_VAAPI(h263),
687 #endif
688 #if CONFIG_MPEG4_NVDEC_HWACCEL
689  HWACCEL_NVDEC(mpeg4),
690 #endif
691 #if CONFIG_MPEG4_VDPAU_HWACCEL
692  HWACCEL_VDPAU(mpeg4),
693 #endif
694 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL
695  HWACCEL_VIDEOTOOLBOX(h263),
696 #endif
697  NULL
698 };
699 
701  .p.name = "h263",
702  CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
703  .p.type = AVMEDIA_TYPE_VIDEO,
704  .p.id = AV_CODEC_ID_H263,
705  .priv_data_size = sizeof(MpegEncContext),
707  .close = ff_h263_decode_end,
709  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
711  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
712  .flush = ff_mpeg_flush,
713  .p.max_lowres = 3,
714  .hw_configs = h263_hw_config_list,
715 };
716 
718  .p.name = "h263p",
719  CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
720  .p.type = AVMEDIA_TYPE_VIDEO,
721  .p.id = AV_CODEC_ID_H263P,
722  .priv_data_size = sizeof(MpegEncContext),
724  .close = ff_h263_decode_end,
726  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
728  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
729  .flush = ff_mpeg_flush,
730  .p.max_lowres = 3,
731  .hw_configs = h263_hw_config_list,
732 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:681
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1439
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:261
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
h263_hw_config_list
static const AVCodecHWConfigInternal *const h263_hw_config_list[]
Definition: h263dec.c:684
H263_GOB_HEIGHT
#define H263_GOB_HEIGHT(h)
Definition: h263.h:28
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const Picture *p, int qp_type)
Definition: mpegvideo_dec.c:511
ff_h263_decode_mb
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:787
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1264
mpeg4videodec.h
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1416
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo_dec.c:570
AVPacket::data
uint8_t * data
Definition: packet.h:522
ff_mpeg4_decode_studio_slice_header
int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:792
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:544
FFCodec
Definition: codec_internal.h:127
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:174
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:822
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:845
mpegvideo.h
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
mpegutils.h
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:94
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
ff_wmv2_decode_secondary_picture_header
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:235
ff_mpeg4_frame_end
int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg4videodec.c:3644
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo_dec.c:1014
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1770
decode_slice
static int decode_slice(MpegEncContext *s)
Definition: h263dec.c:194
ff_h263dsp_init
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:525
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:640
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:504
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:473
ff_h263_decode_picture_header
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:1090
AV_CODEC_ID_MSMPEG4V2
@ AV_CODEC_ID_MSMPEG4V2
Definition: codec_id.h:67
ff_h263_update_motion_val
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:53
frame_end
static int64_t frame_end(const SyncQueue *sq, SyncQueueFrame frame, int nb_samples)
Compute the end timestamp of a frame.
Definition: sync_queue.c:128
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:782
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
h263dec.h
av_cold
#define av_cold
Definition: attributes.h:90
AV_CODEC_ID_H263I
@ AV_CODEC_ID_H263I
Definition: codec_id.h:72
ff_mpeg4_decode_partitions
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
Decode the first and second partition.
Definition: mpeg4videodec.c:1223
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
ff_wmv2_decode_picture_header
int ff_wmv2_decode_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:204
ff_msmpeg4_decode_picture_header
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:388
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:748
ff_er_frame_end
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
Definition: error_resilience.c:892
ff_mpv_common_frame_size_change
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo_dec.c:190
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
h263_get_format
static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)
Definition: h263dec.c:69
FF_BUG_NO_PADDING
#define FF_BUG_NO_PADDING
Definition: avcodec.h:1349
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:47
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:70
AV_EF_IGNORE_ERR
#define AV_EF_IGNORE_ERR
ignore errors and continue
Definition: defs.h:53
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1521
ff_mpeg4_workaround_bugs
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
Definition: mpeg4videodec.c:2980
decode.h
AV_CODEC_ID_MSMPEG4V1
@ AV_CODEC_ID_MSMPEG4V1
Definition: codec_id.h:66
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:73
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
FRAME_SKIPPED
#define FRAME_SKIPPED
Return value for header parsers if frame is not coded.
Definition: mpegutils.h:33
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
ff_h263_decode_init_vlc
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:136
NULL
#define NULL
Definition: coverity.c:32
bits_left
#define bits_left
Definition: bitstream.h:114
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1043
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:30
hwaccel_internal.h
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:342
SLICE_NOEND
#define SLICE_NOEND
no end marker or error found but mb count exceeded
Definition: mpegvideo.h:474
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:37
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_flv_decode_picture_header
int ff_flv_decode_picture_header(MpegEncContext *s)
Definition: flvdec.c:29
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:878
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:109
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:424
AV_CODEC_ID_WMV1
@ AV_CODEC_ID_WMV1
Definition: codec_id.h:69
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:653
FF_MPV_QSCALE_TYPE_MPEG1
#define FF_MPV_QSCALE_TYPE_MPEG1
Definition: mpegvideodec.h:40
ff_h263_decode_end
av_cold int ff_h263_decode_end(AVCodecContext *avctx)
Definition: h263dec.c:163
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:218
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:523
ff_mpeg4_clean_buffers
void ff_mpeg4_clean_buffers(MpegEncContext *s)
Definition: mpeg4video.c:57
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:361
codec_internal.h
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
Definition: mpegvideo.h:594
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo_dec.c:541
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
AVCodecHWConfigInternal
Definition: hwconfig.h:25
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_dec.c:295
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:549
ff_h263_decoder
const FFCodec ff_h263_decoder
Definition: h263dec.c:700
msmpeg4dec.h
flvdec.h
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
get_consumed_bytes
static int get_consumed_bytes(MpegEncContext *s, int buf_size)
Return the number of bytes consumed for building the current frame.
Definition: h263dec.c:174
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:309
FMT_H263
@ FMT_H263
Definition: mpegutils.h:119
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
ff_h263p_decoder
const FFCodec ff_h263p_decoder
Definition: h263dec.c:717
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:546
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
ff_mpeg4_decode_picture_header
int ff_mpeg4_decode_picture_header(Mpeg4DecContext *ctx, GetBitContext *gb, int header, int parse_only)
Decode MPEG-4 headers.
Definition: mpeg4videodec.c:3486
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:45
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
FF_BUG_AUTODETECT
#define FF_BUG_AUTODETECT
autodetection
Definition: avcodec.h:1346
ff_intel_h263_decode_picture_header
int ff_intel_h263_decode_picture_header(MpegEncContext *s)
Definition: intelh263dec.c:30
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ff_h263_decode_init
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:91
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1050
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:670
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
avcodec.h
mpeg4videodefs.h
ret
ret
Definition: filter_design.txt:187
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
Definition: defs.h:56
wmv2dec.h
pos
unsigned int pos
Definition: spdifenc.c:413
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
ff_h263_loop_filter
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:105
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
ff_decode_frame_props
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1505
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:412
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:71
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
mpeg4video.h
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:709
error_resilience.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition: hwaccel_internal.h:171
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:496
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:76
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:640
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_EF_BUFFER
#define AV_EF_BUFFER
detect improper bitstream length
Definition: defs.h:50
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:38
MAX_NVOP_SIZE
#define MAX_NVOP_SIZE
Definition: mpeg4videodefs.h:66
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:470
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:153
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:257
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
ff_h263_resync
int ff_h263_resync(MpegEncContext *s)
Decode the group of blocks / video packet header / slice header (MPEG-4 Studio).
Definition: ituh263dec.c:216
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
mpeg_er.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CODEC_ID_MSMPEG4V3
@ AV_CODEC_ID_MSMPEG4V3
Definition: codec_id.h:68
h263_hwaccel_pixfmt_list_420
static enum AVPixelFormat h263_hwaccel_pixfmt_list_420[]
Definition: h263dec.c:52
h
h
Definition: vp9dsp_template.c:2038
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:33
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:73
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:215
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:67
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:826
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
h263.h