FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "mpegvideo.h"
45 #include "mpegvideodata.h"
46 #include "mpegvideodec.h"
47 #include "mpegvideo_unquantize.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  MPVUnquantDSPContext unquant_dsp_ctx;
95  int ret;
96 
97  s->out_format = FMT_H263;
98 
99  // set defaults
100  ret = ff_mpv_decode_init(s, avctx);
101  if (ret < 0)
102  return ret;
103 
104  s->decode_mb = ff_h263_decode_mb;
105  s->low_delay = 1;
106 
107  s->y_dc_scale_table =
108  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
109 
110  ff_mpv_unquantize_init(&unquant_dsp_ctx,
111  avctx->flags & AV_CODEC_FLAG_BITEXACT, 0);
112  // dct_unquantize defaults for H.263;
113  // they might change on a per-frame basis for MPEG-4;
114  // dct_unquantize_inter will be unset for MSMPEG4 codecs later.
115  s->dct_unquantize_intra = unquant_dsp_ctx.dct_unquantize_h263_intra;
116  s->dct_unquantize_inter = unquant_dsp_ctx.dct_unquantize_h263_inter;
117 
118  /* select sub codec */
119  switch (avctx->codec->id) {
120  case AV_CODEC_ID_H263:
121  case AV_CODEC_ID_H263P:
123  break;
124  case AV_CODEC_ID_MPEG4:
125  break;
127  s->h263_pred = 1;
128  s->msmpeg4_version = MSMP4_V1;
129  break;
131  s->h263_pred = 1;
132  s->msmpeg4_version = MSMP4_V2;
133  break;
135  s->h263_pred = 1;
136  s->msmpeg4_version = MSMP4_V3;
137  break;
138  case AV_CODEC_ID_WMV1:
139  s->h263_pred = 1;
140  s->msmpeg4_version = MSMP4_WMV1;
141  break;
142  case AV_CODEC_ID_WMV2:
143  s->h263_pred = 1;
144  s->msmpeg4_version = MSMP4_WMV2;
145  break;
146  case AV_CODEC_ID_H263I:
147  case AV_CODEC_ID_RV10:
148  case AV_CODEC_ID_RV20:
149  break;
150  case AV_CODEC_ID_FLV1:
151  s->h263_flv = 1;
152  break;
153  default:
154  av_unreachable("Switch contains a case for every codec using ff_h263_decode_init()");
155  }
156 
157  if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263"))
158  if (avctx->extradata_size == 56 && avctx->extradata[0] == 1)
159  s->ehc_mode = 1;
160 
161  /* for H.263, we allocate the images after having read the header */
162  if (avctx->codec->id != AV_CODEC_ID_H263 &&
163  avctx->codec->id != AV_CODEC_ID_H263P &&
164  avctx->codec->id != AV_CODEC_ID_MPEG4) {
165  avctx->pix_fmt = h263_get_format(avctx);
166  if ((ret = ff_mpv_common_init(s)) < 0)
167  return ret;
168  }
169 
170  ff_h263dsp_init(&s->h263dsp);
172 
173  return 0;
174 }
175 
177 {
178  if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
179  ff_thread_progress_report(&s->cur_pic.ptr->progress, s->mb_y);
180 }
181 
183 {
184  const int part_mask = s->partitioned_frame
185  ? (ER_AC_END | ER_AC_ERROR) : 0x7F;
186  const int mb_size = 16 >> s->avctx->lowres;
187  int ret;
188 
189  s->last_resync_gb = s->gb;
190  s->first_slice_line = 1;
191  s->resync_mb_x = s->mb_x;
192  s->resync_mb_y = s->mb_y;
193 
194  ff_set_qscale(s, s->qscale);
195 
196  if (s->studio_profile) {
197  if ((ret = ff_mpeg4_decode_studio_slice_header(s->avctx->priv_data)) < 0)
198  return ret;
199  }
200 
201  if (s->avctx->hwaccel) {
202  const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8;
203  ret = FF_HW_CALL(s->avctx, decode_slice, start, s->gb.buffer_end - start);
204  // ensure we exit decode loop
205  s->mb_y = s->mb_height;
206  return ret;
207  }
208 
209  if (s->partitioned_frame) {
210  const int qscale = s->qscale;
211 
212  if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4)
213  if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0)
214  return ret;
215 
216  /* restore variables which were modified */
217  s->first_slice_line = 1;
218  s->mb_x = s->resync_mb_x;
219  s->mb_y = s->resync_mb_y;
220  ff_set_qscale(s, qscale);
221  }
222 
223  for (; s->mb_y < s->mb_height; s->mb_y++) {
224  /* per-row end of slice checks */
225  if (s->msmpeg4_version != MSMP4_UNUSED) {
226  if (s->resync_mb_y + s->slice_height == s->mb_y) {
227  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
228  s->mb_x - 1, s->mb_y, ER_MB_END);
229 
230  return 0;
231  }
232  }
233 
234  if (s->msmpeg4_version == MSMP4_V1) {
235  s->last_dc[0] =
236  s->last_dc[1] =
237  s->last_dc[2] = 128;
238  }
239 
241  for (; s->mb_x < s->mb_width; s->mb_x++) {
242  int ret;
243 
244  ff_update_block_index(s, s->avctx->bits_per_raw_sample,
245  s->avctx->lowres, s->chroma_x_shift);
246 
247  if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y)
248  s->first_slice_line = 0;
249 
250  /* DCT & quantize */
251 
252  s->mv_dir = MV_DIR_FORWARD;
253  s->mv_type = MV_TYPE_16X16;
254  ff_dlog(s->avctx, "%d %06X\n",
255  get_bits_count(&s->gb), show_bits(&s->gb, 24));
256 
257  ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);
258  ret = s->decode_mb(s, s->block);
259 
260  if (s->h263_pred || s->h263_aic) {
261  int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
262  if (!s->mb_intra) {
263  if (s->mbintra_table[mb_xy])
265  } else
266  s->mbintra_table[mb_xy] = 1;
267  }
268 
269  if (s->pict_type != AV_PICTURE_TYPE_B)
271 
272  if (ret < 0) {
273  const int xy = s->mb_x + s->mb_y * s->mb_stride;
274  if (ret == SLICE_END) {
275  ff_mpv_reconstruct_mb(s, s->block);
276  if (s->loop_filter)
278 
279  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
280  s->mb_x, s->mb_y, ER_MB_END & part_mask);
281 
282  s->padding_bug_score--;
283 
284  if (++s->mb_x >= s->mb_width) {
285  s->mb_x = 0;
287  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
288  s->mb_y++;
289  }
290  return 0;
291  } else if (ret == SLICE_NOEND) {
292  av_log(s->avctx, AV_LOG_ERROR,
293  "Slice mismatch at MB: %d\n", xy);
294  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
295  s->mb_x + 1, s->mb_y,
296  ER_MB_END & part_mask);
297  return AVERROR_INVALIDDATA;
298  }
299  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
300  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
301  s->mb_x, s->mb_y, ER_MB_ERROR & part_mask);
302 
303  if ((s->avctx->err_recognition & AV_EF_IGNORE_ERR) && get_bits_left(&s->gb) > 0)
304  continue;
305  return AVERROR_INVALIDDATA;
306  }
307 
308  ff_mpv_reconstruct_mb(s, s->block);
309  if (s->loop_filter)
311  }
312 
314  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
315 
316  s->mb_x = 0;
317  }
318 
319  av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height);
320 
321  // Detect incorrect padding with wrong stuffing codes used by NEC N-02B
322  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
323  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
324  get_bits_left(&s->gb) >= 48 &&
325  show_bits(&s->gb, 24) == 0x4010 &&
326  !s->data_partitioning)
327  s->padding_bug_score += 32;
328 
329  /* try to detect the padding bug */
330  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
331  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
332  get_bits_left(&s->gb) >= 0 &&
333  get_bits_left(&s->gb) < 137 &&
334  !s->data_partitioning) {
335  const int bits_count = get_bits_count(&s->gb);
336  const int bits_left = s->gb.size_in_bits - bits_count;
337 
338  if (bits_left == 0) {
339  s->padding_bug_score += 16;
340  } else if (bits_left != 1) {
341  int v = show_bits(&s->gb, 8);
342  v |= 0x7F >> (7 - (bits_count & 7));
343 
344  if (v == 0x7F && bits_left <= 8)
345  s->padding_bug_score--;
346  else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) &&
347  bits_left <= 16)
348  s->padding_bug_score += 4;
349  else
350  s->padding_bug_score++;
351  }
352  }
353 
354  if (s->codec_id == AV_CODEC_ID_H263 &&
355  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
356  get_bits_left(&s->gb) >= 8 &&
357  get_bits_left(&s->gb) < 300 &&
358  s->pict_type == AV_PICTURE_TYPE_I &&
359  show_bits(&s->gb, 8) == 0 &&
360  !s->data_partitioning) {
361 
362  s->padding_bug_score += 32;
363  }
364 
365  if (s->codec_id == AV_CODEC_ID_H263 &&
366  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
367  get_bits_left(&s->gb) >= 64 &&
368  AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {
369 
370  s->padding_bug_score += 32;
371  }
372 
373  if (s->workaround_bugs & FF_BUG_AUTODETECT) {
374  if (
375  (s->padding_bug_score > -2 && !s->data_partitioning))
376  s->workaround_bugs |= FF_BUG_NO_PADDING;
377  else
378  s->workaround_bugs &= ~FF_BUG_NO_PADDING;
379  }
380 
381  // handle formats which don't have unique end markers
382  if (s->msmpeg4_version != MSMP4_UNUSED || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly
383  int left = get_bits_left(&s->gb);
384  int max_extra = 7;
385 
386  /* no markers in M$ crap */
387  if (s->msmpeg4_version != MSMP4_UNUSED && s->pict_type == AV_PICTURE_TYPE_I)
388  max_extra += 17;
389 
390  /* buggy padding but the frame should still end approximately at
391  * the bitstream end */
392  if ((s->workaround_bugs & FF_BUG_NO_PADDING) &&
393  (s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE)))
394  max_extra += 48;
395  else if ((s->workaround_bugs & FF_BUG_NO_PADDING))
396  max_extra += 256 * 256 * 256 * 64;
397 
398  if (left > max_extra)
399  av_log(s->avctx, AV_LOG_ERROR,
400  "discarding %d junk bits at end, next would be %X\n",
401  left, show_bits(&s->gb, 24));
402  else if (left < 0)
403  av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
404  else
405  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
406  s->mb_x - 1, s->mb_y, ER_MB_END);
407 
408  return 0;
409  }
410 
411  av_log(s->avctx, AV_LOG_ERROR,
412  "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
413  get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score);
414 
415  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
416  ER_MB_END & part_mask);
417 
418  return AVERROR_INVALIDDATA;
419 }
420 
422  int *got_frame, AVPacket *avpkt)
423 {
424  const uint8_t *buf = avpkt->data;
425  int buf_size = avpkt->size;
426  MpegEncContext *s = avctx->priv_data;
427  int ret;
428  int slice_ret = 0;
429  int bak_width, bak_height;
430 
431  /* no supplementary picture */
432  if (buf_size == 0) {
433  /* special case for last picture */
434  if ((!s->low_delay || s->skipped_last_frame) && s->next_pic.ptr) {
435  if ((ret = av_frame_ref(pict, s->next_pic.ptr->f)) < 0)
436  return ret;
437  if (s->skipped_last_frame) {
438  /* If the stream ended with an NVOP, we output the last frame
439  * in display order, but with the props from the last input
440  * packet so that the stream's end time is correct. */
441  ret = ff_decode_frame_props(avctx, pict);
442  if (ret < 0)
443  return ret;
444  }
445 
446  ff_mpv_unref_picture(&s->next_pic);
447 
448  *got_frame = 1;
449  }
450 
451  return 0;
452  }
453 
454  // s->gb might be overridden in ff_mpeg4_decode_picture_header() below.
455  ret = init_get_bits8(&s->gb, buf, buf_size);
456  if (ret < 0)
457  return ret;
458 
459  bak_width = s->width;
460  bak_height = s->height;
461 
462  /* let's go :-) */
463  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == MSMP4_WMV2) {
465 #if CONFIG_MSMPEG4DEC
466  } else if (s->msmpeg4_version != MSMP4_UNUSED) {
468 #endif
469  } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
471  } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {
473  } else if (CONFIG_FLV_DECODER && s->h263_flv) {
475  } else {
477  }
478 
479  if (ret < 0 || ret == FRAME_SKIPPED) {
480  if ( s->width != bak_width
481  || s->height != bak_height) {
482  av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");
483  s->width = bak_width;
484  s->height= bak_height;
485 
486  }
487  }
488  if (ret == FRAME_SKIPPED)
489  return buf_size;
490 
491  /* skip if the header was thrashed */
492  if (ret < 0) {
493  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
494  return ret;
495  }
496 
497  if (!s->context_initialized) {
498  avctx->pix_fmt = h263_get_format(avctx);
499  if ((ret = ff_mpv_common_init(s)) < 0)
500  return ret;
501  }
502 
503  avctx->has_b_frames = !s->low_delay;
504 
505  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
506  if (s->pict_type != AV_PICTURE_TYPE_B && s->mb_num/2 > get_bits_left(&s->gb))
507  return AVERROR_INVALIDDATA;
509  if (s->studio_profile != (s->idsp.idct == NULL))
511  }
512 
513  /* After H.263 & MPEG-4 header decode we have the height, width,
514  * and other parameters. So then we could init the picture.
515  * FIXME: By the way H.263 decoder is evolving it should have
516  * an H263EncContext */
517  if (s->width != avctx->coded_width ||
518  s->height != avctx->coded_height ||
519  s->context_reinit) {
520  /* H.263 could change picture size any time */
521  s->context_reinit = 0;
522 
523  ret = ff_set_dimensions(avctx, s->width, s->height);
524  if (ret < 0)
525  return ret;
526 
527  ff_set_sar(avctx, avctx->sample_aspect_ratio);
528 
530  return ret;
531 
532  if (avctx->pix_fmt != h263_get_format(avctx)) {
533  av_log(avctx, AV_LOG_ERROR, "format change not supported\n");
534  avctx->pix_fmt = AV_PIX_FMT_NONE;
535  return AVERROR_UNKNOWN;
536  }
537  }
538 
539  /* skip B-frames if we don't have reference frames */
540  if (!s->last_pic.ptr &&
541  (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))
542  return buf_size;
543  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
544  s->pict_type == AV_PICTURE_TYPE_B) ||
545  (avctx->skip_frame >= AVDISCARD_NONKEY &&
546  s->pict_type != AV_PICTURE_TYPE_I) ||
547  avctx->skip_frame >= AVDISCARD_ALL)
548  return buf_size;
549 
550  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
551  return ret;
552 
553  if (!s->divx_packed)
554  ff_thread_finish_setup(avctx);
555 
556  if (avctx->hwaccel) {
557  ret = FF_HW_CALL(avctx, start_frame, NULL,
558  s->gb.buffer, s->gb.buffer_end - s->gb.buffer);
559  if (ret < 0 )
560  return ret;
561  }
562 
564 
565  /* the second part of the wmv2 header contains the MB skip bits which
566  * are stored in current_picture->mb_type which is not available before
567  * ff_mpv_frame_start() */
568 #if CONFIG_WMV2_DECODER
569  if (s->msmpeg4_version == MSMP4_WMV2) {
571  if (ret < 0)
572  return ret;
573  if (ret == 1)
574  goto frame_end;
575  }
576 #endif
577 
578  /* decode each macroblock */
579  s->mb_x = 0;
580  s->mb_y = 0;
581 
582  slice_ret = decode_slice(s);
583  while (s->mb_y < s->mb_height) {
584  if (s->msmpeg4_version != MSMP4_UNUSED) {
585  if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 ||
586  (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)
587  break;
588  } else {
589  int prev_x = s->mb_x, prev_y = s->mb_y;
590  if (ff_h263_resync(s) < 0)
591  break;
592  if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
593  s->er.error_occurred = 1;
594  }
595 
596  if (s->msmpeg4_version < MSMP4_WMV1 && s->h263_pred)
598 
599  if (decode_slice(s) < 0)
600  slice_ret = AVERROR_INVALIDDATA;
601  }
602 
603  if (s->msmpeg4_version != MSMP4_UNUSED && s->msmpeg4_version < MSMP4_WMV1 &&
604  s->pict_type == AV_PICTURE_TYPE_I)
605  if (!CONFIG_MSMPEG4DEC ||
606  ff_msmpeg4_decode_ext_header(s, buf_size) < 0)
607  s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;
608 
609 frame_end:
610  if (!s->studio_profile)
611  ff_er_frame_end(&s->er, NULL);
612 
613  if (avctx->hwaccel) {
614  ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
615  if (ret < 0)
616  return ret;
617  }
618 
620 
621  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)
622  ff_mpeg4_frame_end(avctx, avpkt);
623 
624  av_assert1(s->pict_type == s->cur_pic.ptr->f->pict_type);
625  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
626  if ((ret = av_frame_ref(pict, s->cur_pic.ptr->f)) < 0)
627  return ret;
628  ff_print_debug_info(s, s->cur_pic.ptr, pict);
629  ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1);
630  } else if (s->last_pic.ptr) {
631  if ((ret = av_frame_ref(pict, s->last_pic.ptr->f)) < 0)
632  return ret;
633  ff_print_debug_info(s, s->last_pic.ptr, pict);
634  ff_mpv_export_qp_table(s, pict, s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG1);
635  }
636 
637  if (s->last_pic.ptr || s->low_delay) {
638  if ( pict->format == AV_PIX_FMT_YUV420P
639  && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {
640  for (int p = 0; p < 3; p++) {
641  int h = AV_CEIL_RSHIFT(pict->height, !!p);
642 
643  pict->data[p] += (h - 1) * pict->linesize[p];
644  pict->linesize[p] *= -1;
645  }
646  }
647  *got_frame = 1;
648  }
649 
650  if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
651  return slice_ret;
652  else
653  return buf_size;
654 }
655 
657 #if CONFIG_H263_VAAPI_HWACCEL
658  HWACCEL_VAAPI(h263),
659 #endif
660 #if CONFIG_MPEG4_NVDEC_HWACCEL
661  HWACCEL_NVDEC(mpeg4),
662 #endif
663 #if CONFIG_MPEG4_VDPAU_HWACCEL
664  HWACCEL_VDPAU(mpeg4),
665 #endif
666 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL
667  HWACCEL_VIDEOTOOLBOX(h263),
668 #endif
669  NULL
670 };
671 
673  .p.name = "h263",
674  CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
675  .p.type = AVMEDIA_TYPE_VIDEO,
676  .p.id = AV_CODEC_ID_H263,
677  .priv_data_size = sizeof(MpegEncContext),
680  .close = ff_mpv_decode_close,
681  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
683  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
685  .flush = ff_mpeg_flush,
686  .p.max_lowres = 3,
687  .hw_configs = h263_hw_config_list,
688 };
689 
691  .p.name = "h263p",
692  CODEC_LONG_NAME("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
693  .p.type = AVMEDIA_TYPE_VIDEO,
694  .p.id = AV_CODEC_ID_H263P,
695  .priv_data_size = sizeof(MpegEncContext),
698  .close = ff_mpv_decode_close,
699  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
701  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
703  .flush = ff_mpeg_flush,
704  .p.max_lowres = 3,
705  .hw_configs = h263_hw_config_list,
706 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:386
hwconfig.h
mpegvideo_unquantize.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1405
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:185
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
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
ff_thread_progress_report
void ff_thread_progress_report(ThreadProgress *pro, int n)
This function is a no-op in no-op mode; otherwise it notifies other threads that a certain level of p...
Definition: threadprogress.c:53
h263_hw_config_list
static const AVCodecHWConfigInternal *const h263_hw_config_list[]
Definition: h263dec.c:656
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
ff_mpv_decode_init
av_cold int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:47
ff_h263_decode_mb
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:788
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1203
mpeg4videodec.h
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1398
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:249
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:410
AVPacket::data
uint8_t * data
Definition: packet.h:535
ff_mpeg4_decode_studio_slice_header
int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:802
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:562
FFCodec
Definition: codec_internal.h:127
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
Definition: mpegvideo.c:490
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:176
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:826
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:514
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:91
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:431
ff_wmv2_decode_secondary_picture_header
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:236
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo_dec.c:1067
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:440
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1662
decode_slice
static int decode_slice(MpegEncContext *s)
Definition: h263dec.c:182
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
MPVUnquantDSPContext::dct_unquantize_h263_intra
void(* dct_unquantize_h263_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo_unquantize.h:43
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:607
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:318
ff_h263_decode_picture_header
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:1089
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:118
mpegvideodec.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
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:1269
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:528
ff_wmv2_decode_picture_header
int ff_wmv2_decode_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:205
ff_msmpeg4_decode_picture_header
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:396
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:697
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:896
ff_mpeg_flush
av_cold void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:414
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
s
#define s(width, name)
Definition: cbs_vp9.c:198
report_decode_progress
static void report_decode_progress(MpegEncContext *s)
Definition: h263dec.c:176
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
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:1331
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:70
ff_mpeg1_dc_scale_table
static const uint8_t *const ff_mpeg1_dc_scale_table
Definition: mpegvideodata.h:32
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:1553
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:326
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:441
FMT_H263
@ FMT_H263
Definition: mpegvideo.h:56
ff_mpv_unref_picture
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition: mpegpicture.c:98
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:229
ff_h263_decode_init_vlc
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:138
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const MPVPicture *p, int qp_type)
Definition: mpegvideo_dec.c:375
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:669
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:29
hwaccel_internal.h
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:95
ff_mpv_decode_close
av_cold int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:128
av_unreachable
#define av_unreachable(msg)
Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.
Definition: avassert.h:109
SLICE_NOEND
#define SLICE_NOEND
no end marker or error found but mb count exceeded
Definition: mpegvideo.h:319
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:36
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
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:547
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:106
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:421
ff_mpv_unquantize_init
#define ff_mpv_unquantize_init(s, bitexact, q_scale_type)
Definition: mpegvideo_unquantize.h:50
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:716
FF_MPV_QSCALE_TYPE_MPEG1
#define FF_MPV_QSCALE_TYPE_MPEG1
Definition: mpegvideodec.h:40
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
ff_mpeg4_decode_picture_header
int ff_mpeg4_decode_picture_header(MpegEncContext *s)
Definition: mpeg4videodec.c:3693
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:228
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:302
AVPacket::size
int size
Definition: packet.h:536
ff_mpeg4_clean_buffers
void ff_mpeg4_clean_buffers(MpegEncContext *s)
Definition: mpeg4video.c:44
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:276
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:382
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
ff_h263dsp_init
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
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:406
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:497
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:309
ff_h263_decoder
const FFCodec ff_h263_decoder
Definition: h263dec.c:672
mpegvideodata.h
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:186
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:368
AV_CODEC_ID_RV10
@ AV_CODEC_ID_RV10
Definition: codec_id.h:57
MPVUnquantDSPContext::dct_unquantize_h263_inter
void(* dct_unquantize_h263_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo_unquantize.h:45
ff_h263p_decoder
const FFCodec ff_h263p_decoder
Definition: h263dec.c:690
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:354
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
FF_BUG_AUTODETECT
#define FF_BUG_AUTODETECT
autodetection
Definition: avcodec.h:1328
ff_intel_h263_decode_picture_header
int ff_intel_h263_decode_picture_header(MpegEncContext *s)
Definition: intelh263dec.c:29
AV_CODEC_ID_RV20
@ AV_CODEC_ID_RV20
Definition: codec_id.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
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:676
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
avcodec.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
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:94
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:1484
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVFrame::height
int height
Definition: frame.h:482
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:280
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:772
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:173
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:360
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
ff_mpeg4_workaround_bugs
void ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
Definition: mpeg4videodec.c:3050
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:607
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AV_EF_BUFFER
#define AV_EF_BUFFER
detect improper bitstream length
Definition: defs.h:50
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:322
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:37
ff_mpeg4_frame_end
int ff_mpeg4_frame_end(AVCodecContext *avctx, const AVPacket *pkt)
Definition: mpeg4videodec.c:3728
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:181
ff_tlog
#define ff_tlog(a,...)
Definition: tableprint_vlc.h:29
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
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:218
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:455
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
MPVUnquantDSPContext
Definition: mpegvideo_unquantize.h:34
h
h
Definition: vp9dsp_template.c:2070
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:32
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:73
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:225
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:64
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:616
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
ff_mpv_common_frame_size_change
av_cold int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo_dec.c:137
h263.h