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 "mpegvideo.h"
46 #include "mpegvideodec.h"
47 #include "msmpeg4dec.h"
48 #include "thread.h"
49 #include "wmv2dec.h"
50 
52 #if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL
54 #endif
55 #if CONFIG_MPEG4_NVDEC_HWACCEL
57 #endif
58 #if CONFIG_MPEG4_VDPAU_HWACCEL
60 #endif
61 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL || CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL
63 #endif
66 };
67 
69 {
70  /* MPEG-4 Studio Profile only, not supported by hardware */
71  if (avctx->bits_per_raw_sample > 8) {
72  av_assert1(((MpegEncContext *)avctx->priv_data)->studio_profile);
73  return avctx->pix_fmt;
74  }
75 
76  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {
79  return AV_PIX_FMT_GRAY8;
80  }
81 
82  if (avctx->codec_id == AV_CODEC_ID_H263 ||
83  avctx->codec_id == AV_CODEC_ID_H263P ||
84  avctx->codec_id == AV_CODEC_ID_MPEG4)
85  return avctx->pix_fmt = ff_get_format(avctx, h263_hwaccel_pixfmt_list_420);
86 
87  return AV_PIX_FMT_YUV420P;
88 }
89 
91 {
92  MpegEncContext *s = avctx->priv_data;
93  int ret;
94 
95  s->out_format = FMT_H263;
96 
97  // set defaults
98  ff_mpv_decode_init(s, avctx);
99 
100  s->quant_precision = 5;
101  s->decode_mb = ff_h263_decode_mb;
102  s->low_delay = 1;
103 
104  /* select sub codec */
105  switch (avctx->codec->id) {
106  case AV_CODEC_ID_H263:
107  case AV_CODEC_ID_H263P:
109  break;
110  case AV_CODEC_ID_MPEG4:
111  break;
113  s->h263_pred = 1;
114  s->msmpeg4_version = 1;
115  break;
117  s->h263_pred = 1;
118  s->msmpeg4_version = 2;
119  break;
121  s->h263_pred = 1;
122  s->msmpeg4_version = 3;
123  break;
124  case AV_CODEC_ID_WMV1:
125  s->h263_pred = 1;
126  s->msmpeg4_version = 4;
127  break;
128  case AV_CODEC_ID_WMV2:
129  s->h263_pred = 1;
130  s->msmpeg4_version = 5;
131  break;
132  case AV_CODEC_ID_H263I:
133  break;
134  case AV_CODEC_ID_FLV1:
135  s->h263_flv = 1;
136  break;
137  default:
138  av_log(avctx, AV_LOG_ERROR, "Unsupported codec %d\n",
139  avctx->codec->id);
140  return AVERROR(ENOSYS);
141  }
142 
143  if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263"))
144  if (avctx->extradata_size == 56 && avctx->extradata[0] == 1)
145  s->ehc_mode = 1;
146 
147  /* for H.263, we allocate the images after having read the header */
148  if (avctx->codec->id != AV_CODEC_ID_H263 &&
149  avctx->codec->id != AV_CODEC_ID_H263P &&
150  avctx->codec->id != AV_CODEC_ID_MPEG4) {
151  avctx->pix_fmt = h263_get_format(avctx);
152  if ((ret = ff_mpv_common_init(s)) < 0)
153  return ret;
154  }
155 
156  ff_h263dsp_init(&s->h263dsp);
158 
159  return 0;
160 }
161 
163 {
164  MpegEncContext *s = avctx->priv_data;
165 
167  return 0;
168 }
169 
170 /**
171  * Return the number of bytes consumed for building the current frame.
172  */
173 static int get_consumed_bytes(MpegEncContext *s, int buf_size)
174 {
175  int pos = (get_bits_count(&s->gb) + 7) >> 3;
176 
177  if (s->divx_packed || s->avctx->hwaccel) {
178  /* We would have to scan through the whole buf to handle the weird
179  * reordering ... */
180  return buf_size;
181  } else {
182  // avoid infinite loops (maybe not needed...)
183  if (pos == 0)
184  pos = 1;
185  // oops ;)
186  if (pos + 10 > buf_size)
187  pos = buf_size;
188 
189  return pos;
190  }
191 }
192 
194 {
195  const int part_mask = s->partitioned_frame
196  ? (ER_AC_END | ER_AC_ERROR) : 0x7F;
197  const int mb_size = 16 >> s->avctx->lowres;
198  int ret;
199 
200  s->last_resync_gb = s->gb;
201  s->first_slice_line = 1;
202  s->resync_mb_x = s->mb_x;
203  s->resync_mb_y = s->mb_y;
204 
205  ff_set_qscale(s, s->qscale);
206 
207  if (s->studio_profile) {
208  if ((ret = ff_mpeg4_decode_studio_slice_header(s->avctx->priv_data)) < 0)
209  return ret;
210  }
211 
212  if (s->avctx->hwaccel) {
213  const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8;
214  ret = FF_HW_CALL(s->avctx, decode_slice, start, s->gb.buffer_end - start);
215  // ensure we exit decode loop
216  s->mb_y = s->mb_height;
217  return ret;
218  }
219 
220  if (s->partitioned_frame) {
221  const int qscale = s->qscale;
222 
223  if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4)
224  if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0)
225  return ret;
226 
227  /* restore variables which were modified */
228  s->first_slice_line = 1;
229  s->mb_x = s->resync_mb_x;
230  s->mb_y = s->resync_mb_y;
231  ff_set_qscale(s, qscale);
232  }
233 
234  for (; s->mb_y < s->mb_height; s->mb_y++) {
235  /* per-row end of slice checks */
236  if (s->msmpeg4_version) {
237  if (s->resync_mb_y + s->slice_height == s->mb_y) {
238  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
239  s->mb_x - 1, s->mb_y, ER_MB_END);
240 
241  return 0;
242  }
243  }
244 
245  if (s->msmpeg4_version == 1) {
246  s->last_dc[0] =
247  s->last_dc[1] =
248  s->last_dc[2] = 128;
249  }
250 
252  for (; s->mb_x < s->mb_width; s->mb_x++) {
253  int ret;
254 
255  ff_update_block_index(s, s->avctx->bits_per_raw_sample,
256  s->avctx->lowres, s->chroma_x_shift);
257 
258  if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y)
259  s->first_slice_line = 0;
260 
261  /* DCT & quantize */
262 
263  s->mv_dir = MV_DIR_FORWARD;
264  s->mv_type = MV_TYPE_16X16;
265  ff_dlog(s, "%d %06X\n",
266  get_bits_count(&s->gb), show_bits(&s->gb, 24));
267 
268  ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);
269  ret = s->decode_mb(s, s->block);
270 
271  if (s->pict_type != AV_PICTURE_TYPE_B)
273 
274  if (ret < 0) {
275  const int xy = s->mb_x + s->mb_y * s->mb_stride;
276  if (ret == SLICE_END) {
277  ff_mpv_reconstruct_mb(s, s->block);
278  if (s->loop_filter)
280 
281  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
282  s->mb_x, s->mb_y, ER_MB_END & part_mask);
283 
284  s->padding_bug_score--;
285 
286  if (++s->mb_x >= s->mb_width) {
287  s->mb_x = 0;
288  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
290  s->mb_y++;
291  }
292  return 0;
293  } else if (ret == SLICE_NOEND) {
294  av_log(s->avctx, AV_LOG_ERROR,
295  "Slice mismatch at MB: %d\n", xy);
296  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
297  s->mb_x + 1, s->mb_y,
298  ER_MB_END & part_mask);
299  return AVERROR_INVALIDDATA;
300  }
301  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
302  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
303  s->mb_x, s->mb_y, ER_MB_ERROR & part_mask);
304 
305  if ((s->avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&s->gb) > 0)
306  continue;
307  return AVERROR_INVALIDDATA;
308  }
309 
310  ff_mpv_reconstruct_mb(s, s->block);
311  if (s->loop_filter)
313  }
314 
315  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
317 
318  s->mb_x = 0;
319  }
320 
321  av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height);
322 
323  // Detect incorrect padding with wrong stuffing codes used by NEC N-02B
324  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
325  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
326  get_bits_left(&s->gb) >= 48 &&
327  show_bits(&s->gb, 24) == 0x4010 &&
328  !s->data_partitioning)
329  s->padding_bug_score += 32;
330 
331  /* try to detect the padding bug */
332  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
333  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
334  get_bits_left(&s->gb) >= 0 &&
335  get_bits_left(&s->gb) < 137 &&
336  !s->data_partitioning) {
337  const int bits_count = get_bits_count(&s->gb);
338  const int bits_left = s->gb.size_in_bits - bits_count;
339 
340  if (bits_left == 0) {
341  s->padding_bug_score += 16;
342  } else if (bits_left != 1) {
343  int v = show_bits(&s->gb, 8);
344  v |= 0x7F >> (7 - (bits_count & 7));
345 
346  if (v == 0x7F && bits_left <= 8)
347  s->padding_bug_score--;
348  else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) &&
349  bits_left <= 16)
350  s->padding_bug_score += 4;
351  else
352  s->padding_bug_score++;
353  }
354  }
355 
356  if (s->codec_id == AV_CODEC_ID_H263 &&
357  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
358  get_bits_left(&s->gb) >= 8 &&
359  get_bits_left(&s->gb) < 300 &&
360  s->pict_type == AV_PICTURE_TYPE_I &&
361  show_bits(&s->gb, 8) == 0 &&
362  !s->data_partitioning) {
363 
364  s->padding_bug_score += 32;
365  }
366 
367  if (s->codec_id == AV_CODEC_ID_H263 &&
368  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
369  get_bits_left(&s->gb) >= 64 &&
370  AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {
371 
372  s->padding_bug_score += 32;
373  }
374 
375  if (s->workaround_bugs & FF_BUG_AUTODETECT) {
376  if (
377  (s->padding_bug_score > -2 && !s->data_partitioning))
378  s->workaround_bugs |= FF_BUG_NO_PADDING;
379  else
380  s->workaround_bugs &= ~FF_BUG_NO_PADDING;
381  }
382 
383  // handle formats which don't have unique end markers
384  if (s->msmpeg4_version || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly
385  int left = get_bits_left(&s->gb);
386  int max_extra = 7;
387 
388  /* no markers in M$ crap */
389  if (s->msmpeg4_version && s->pict_type == AV_PICTURE_TYPE_I)
390  max_extra += 17;
391 
392  /* buggy padding but the frame should still end approximately at
393  * the bitstream end */
394  if ((s->workaround_bugs & FF_BUG_NO_PADDING) &&
395  (s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE)))
396  max_extra += 48;
397  else if ((s->workaround_bugs & FF_BUG_NO_PADDING))
398  max_extra += 256 * 256 * 256 * 64;
399 
400  if (left > max_extra)
401  av_log(s->avctx, AV_LOG_ERROR,
402  "discarding %d junk bits at end, next would be %X\n",
403  left, show_bits(&s->gb, 24));
404  else if (left < 0)
405  av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
406  else
407  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
408  s->mb_x - 1, s->mb_y, ER_MB_END);
409 
410  return 0;
411  }
412 
413  av_log(s->avctx, AV_LOG_ERROR,
414  "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
415  get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score);
416 
417  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
418  ER_MB_END & part_mask);
419 
420  return AVERROR_INVALIDDATA;
421 }
422 
424  int *got_frame, AVPacket *avpkt)
425 {
426  const uint8_t *buf = avpkt->data;
427  int buf_size = avpkt->size;
428  MpegEncContext *s = avctx->priv_data;
429  int ret;
430  int slice_ret = 0;
431 
432  /* no supplementary picture */
433  if (buf_size == 0) {
434  /* special case for last picture */
435  if (s->low_delay == 0 && s->next_picture_ptr) {
436  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
437  return ret;
438  s->next_picture_ptr = NULL;
439 
440  *got_frame = 1;
441  } else if (s->skipped_last_frame && s->current_picture_ptr) {
442  /* Output the last picture we decoded again if the stream ended with
443  * an NVOP */
444  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
445  return ret;
446  /* Copy props from the last input packet. Otherwise, props from the last
447  * returned picture would be reused */
448  if ((ret = ff_decode_frame_props(avctx, pict)) < 0)
449  return ret;
450  s->current_picture_ptr = NULL;
451 
452  *got_frame = 1;
453  }
454 
455  return 0;
456  }
457 
458 retry:
459  if (s->divx_packed && s->bitstream_buffer_size) {
460  int i;
461  for(i=0; i < buf_size-3; i++) {
462  if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) {
463  if (buf[i+3]==0xB0) {
464  av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");
465  s->bitstream_buffer_size = 0;
466  }
467  break;
468  }
469  }
470  }
471 
472  if (s->bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) // divx 5.01+/xvid frame reorder
473  ret = init_get_bits8(&s->gb, s->bitstream_buffer,
474  s->bitstream_buffer_size);
475  else
476  ret = init_get_bits8(&s->gb, buf, buf_size);
477 
478  s->bitstream_buffer_size = 0;
479  if (ret < 0)
480  return ret;
481 
482  /* let's go :-) */
483  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {
485  } else if (CONFIG_MSMPEG4DEC && s->msmpeg4_version) {
487  } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
488  ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb, 0, 0);
489  s->skipped_last_frame = (ret == FRAME_SKIPPED);
490  } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {
492  } else if (CONFIG_FLV_DECODER && s->h263_flv) {
494  } else {
496  }
497 
498  if (ret < 0 || ret == FRAME_SKIPPED) {
499  if ( s->width != avctx->coded_width
500  || s->height != avctx->coded_height) {
501  av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");
502  s->width = avctx->coded_width;
503  s->height= avctx->coded_height;
504  }
505  }
506  if (ret == FRAME_SKIPPED)
507  return get_consumed_bytes(s, buf_size);
508 
509  /* skip if the header was thrashed */
510  if (ret < 0) {
511  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
512  return ret;
513  }
514 
515  if (!s->context_initialized) {
516  avctx->pix_fmt = h263_get_format(avctx);
517  if ((ret = ff_mpv_common_init(s)) < 0)
518  return ret;
519  }
520 
521  avctx->has_b_frames = !s->low_delay;
522 
523  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
524  if (s->pict_type != AV_PICTURE_TYPE_B && s->mb_num/2 > get_bits_left(&s->gb))
525  return AVERROR_INVALIDDATA;
526  if (ff_mpeg4_workaround_bugs(avctx) == 1)
527  goto retry;
528  if (s->studio_profile != (s->idsp.idct == NULL))
530  }
531 
532  /* After H.263 & MPEG-4 header decode we have the height, width,
533  * and other parameters. So then we could init the picture.
534  * FIXME: By the way H.263 decoder is evolving it should have
535  * an H263EncContext */
536  if (s->width != avctx->coded_width ||
537  s->height != avctx->coded_height ||
538  s->context_reinit) {
539  /* H.263 could change picture size any time */
540  s->context_reinit = 0;
541 
542  ret = ff_set_dimensions(avctx, s->width, s->height);
543  if (ret < 0)
544  return ret;
545 
546  ff_set_sar(avctx, avctx->sample_aspect_ratio);
547 
549  return ret;
550 
551  if (avctx->pix_fmt != h263_get_format(avctx)) {
552  av_log(avctx, AV_LOG_ERROR, "format change not supported\n");
553  avctx->pix_fmt = AV_PIX_FMT_NONE;
554  return AVERROR_UNKNOWN;
555  }
556  }
557 
558  if (s->codec_id == AV_CODEC_ID_H263 ||
559  s->codec_id == AV_CODEC_ID_H263P ||
560  s->codec_id == AV_CODEC_ID_H263I)
561  s->gob_index = H263_GOB_HEIGHT(s->height);
562 
563  /* skip B-frames if we don't have reference frames */
564  if (!s->last_picture_ptr &&
565  (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))
566  return get_consumed_bytes(s, buf_size);
567  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
568  s->pict_type == AV_PICTURE_TYPE_B) ||
569  (avctx->skip_frame >= AVDISCARD_NONKEY &&
570  s->pict_type != AV_PICTURE_TYPE_I) ||
571  avctx->skip_frame >= AVDISCARD_ALL)
572  return get_consumed_bytes(s, buf_size);
573 
574  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
575  return ret;
576 
577  if (!s->divx_packed && !avctx->hwaccel)
578  ff_thread_finish_setup(avctx);
579 
580  if (avctx->hwaccel) {
581  ret = FF_HW_CALL(avctx, start_frame,
582  s->gb.buffer, s->gb.buffer_end - s->gb.buffer);
583  if (ret < 0 )
584  return ret;
585  }
586 
588 
589  /* the second part of the wmv2 header contains the MB skip bits which
590  * are stored in current_picture->mb_type which is not available before
591  * ff_mpv_frame_start() */
592  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {
594  if (ret < 0)
595  return ret;
596  if (ret == 1)
597  goto frame_end;
598  }
599 
600  /* decode each macroblock */
601  s->mb_x = 0;
602  s->mb_y = 0;
603 
604  slice_ret = decode_slice(s);
605  while (s->mb_y < s->mb_height) {
606  if (s->msmpeg4_version) {
607  if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 ||
608  (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)
609  break;
610  } else {
611  int prev_x = s->mb_x, prev_y = s->mb_y;
612  if (ff_h263_resync(s) < 0)
613  break;
614  if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
615  s->er.error_occurred = 1;
616  }
617 
618  if (s->msmpeg4_version < 4 && s->h263_pred)
620 
621  if (decode_slice(s) < 0)
622  slice_ret = AVERROR_INVALIDDATA;
623  }
624 
625  if (s->msmpeg4_version && s->msmpeg4_version < 4 &&
626  s->pict_type == AV_PICTURE_TYPE_I)
627  if (!CONFIG_MSMPEG4DEC ||
628  ff_msmpeg4_decode_ext_header(s, buf_size) < 0)
629  s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;
630 
631  av_assert1(s->bitstream_buffer_size == 0);
632 frame_end:
633  if (!s->studio_profile)
634  ff_er_frame_end(&s->er, NULL);
635 
636  if (avctx->hwaccel) {
637  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
638  if (ret < 0)
639  return ret;
640  }
641 
643 
644  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)
645  ff_mpeg4_frame_end(avctx, buf, buf_size);
646 
647  if (!s->divx_packed && avctx->hwaccel)
648  ff_thread_finish_setup(avctx);
649 
650  av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
651  av_assert1(s->current_picture.f->pict_type == s->pict_type);
652  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
653  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
654  return ret;
655  ff_print_debug_info(s, s->current_picture_ptr, pict);
656  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
657  } else if (s->last_picture_ptr) {
658  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
659  return ret;
660  ff_print_debug_info(s, s->last_picture_ptr, pict);
661  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
662  }
663 
664  if (s->last_picture_ptr || s->low_delay) {
665  if ( pict->format == AV_PIX_FMT_YUV420P
666  && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {
667  for (int p = 0; p < 3; p++) {
668  int h = AV_CEIL_RSHIFT(pict->height, !!p);
669 
670  pict->data[p] += (h - 1) * pict->linesize[p];
671  pict->linesize[p] *= -1;
672  }
673  }
674  *got_frame = 1;
675  }
676 
677  if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
678  return slice_ret;
679  else
680  return get_consumed_bytes(s, buf_size);
681 }
682 
684 #if CONFIG_H263_VAAPI_HWACCEL
685  HWACCEL_VAAPI(h263),
686 #endif
687 #if CONFIG_MPEG4_NVDEC_HWACCEL
688  HWACCEL_NVDEC(mpeg4),
689 #endif
690 #if CONFIG_MPEG4_VDPAU_HWACCEL
691  HWACCEL_VDPAU(mpeg4),
692 #endif
693 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL
694  HWACCEL_VIDEOTOOLBOX(h263),
695 #endif
696  NULL
697 };
698 
700  .p.name = "h263",
701  CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
702  .p.type = AVMEDIA_TYPE_VIDEO,
703  .p.id = AV_CODEC_ID_H263,
704  .priv_data_size = sizeof(MpegEncContext),
706  .close = ff_h263_decode_end,
708  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
710  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
711  .flush = ff_mpeg_flush,
712  .p.max_lowres = 3,
713  .hw_configs = h263_hw_config_list,
714 };
715 
717  .p.name = "h263p",
718  CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
719  .p.type = AVMEDIA_TYPE_VIDEO,
720  .p.id = AV_CODEC_ID_H263P,
721  .priv_data_size = sizeof(MpegEncContext),
723  .close = ff_h263_decode_end,
725  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
727  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
728  .flush = ff_mpeg_flush,
729  .p.max_lowres = 3,
730  .hw_configs = h263_hw_config_list,
731 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:682
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1427
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:267
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:683
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:695
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:467
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:1241
mpeg4videodec.h
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
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:374
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo_dec.c:526
AVPacket::data
uint8_t * data
Definition: packet.h:524
ff_mpeg4_decode_studio_slice_header
int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:794
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:126
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:821
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:843
mpegvideo.h
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
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:395
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:3646
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo_dec.c:970
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
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:1820
decode_slice
static int decode_slice(MpegEncContext *s)
Definition: h263dec.c:193
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:502
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:633
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:460
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:479
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:783
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:1225
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:524
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
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:891
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:286
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
h263_get_format
static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)
Definition: h263dec.c:68
FF_BUG_NO_PADDING
#define FF_BUG_NO_PADDING
Definition: avcodec.h:1353
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:48
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:1575
ff_mpeg4_workaround_bugs
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
Definition: mpeg4videodec.c:2982
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:271
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
FMT_H263
@ FMT_H263
Definition: mpegvideo.h:65
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:695
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:343
SLICE_NOEND
#define SLICE_NOEND
no end marker or error found but mb count exceeded
Definition: mpegvideo.h:480
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:876
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:423
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:652
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:162
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:366
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:525
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:384
codec_internal.h
FRAME_SKIPPED
#define FRAME_SKIPPED
Return value for header parsers if frame is not coded.
Definition: h263dec.h:29
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:600
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:497
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:461
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:323
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:505
ff_h263_decoder
const FFCodec ff_h263_decoder
Definition: h263dec.c:699
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:173
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_h263p_decoder
const FFCodec ff_h263p_decoder
Definition: h263dec.c:716
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
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:3488
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:1350
ff_intel_h263_decode_picture_header
int ff_intel_h263_decode_picture_header(MpegEncContext *s)
Definition: intelh263dec.c:28
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:90
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:669
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:414
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:1467
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:446
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:708
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:452
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:633
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:141
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:263
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:419
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:51
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:73
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:642
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