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 "error_resilience.h"
35 #include "flvdec.h"
36 #include "h263.h"
37 #include "h263dec.h"
38 #if FF_API_FLAG_TRUNCATED
39 #include "h263_parser.h"
40 #endif
41 #include "hwconfig.h"
42 #include "internal.h"
43 #include "mpeg_er.h"
44 #include "mpeg4video.h"
45 #include "mpeg4videodec.h"
46 #if FF_API_FLAG_TRUNCATED
47 #include "mpeg4video_parser.h"
48 #endif
49 #include "mpegutils.h"
50 #include "mpegvideo.h"
51 #include "mpegvideodec.h"
52 #include "msmpeg4dec.h"
53 #include "qpeldsp.h"
54 #include "thread.h"
55 #include "wmv2dec.h"
56 
58 {
59  /* MPEG-4 Studio Profile only, not supported by hardware */
60  if (avctx->bits_per_raw_sample > 8) {
61  av_assert1(((MpegEncContext *)avctx->priv_data)->studio_profile);
62  return avctx->pix_fmt;
63  }
64 
65  if (avctx->codec->id == AV_CODEC_ID_MSS2)
66  return AV_PIX_FMT_YUV420P;
67 
68  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY)) {
71  return AV_PIX_FMT_GRAY8;
72  }
73 
74  return avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
75 }
76 
78 {
79  MpegEncContext *s = avctx->priv_data;
80  int ret;
81 
82  s->out_format = FMT_H263;
83 
84  // set defaults
85  ff_mpv_decode_init(s, avctx);
86 
87  s->quant_precision = 5;
88  s->decode_mb = ff_h263_decode_mb;
89  s->low_delay = 1;
90 
91  /* select sub codec */
92  switch (avctx->codec->id) {
93  case AV_CODEC_ID_H263:
94  case AV_CODEC_ID_H263P:
96  break;
97  case AV_CODEC_ID_MPEG4:
98  break;
100  s->h263_pred = 1;
101  s->msmpeg4_version = 1;
102  break;
104  s->h263_pred = 1;
105  s->msmpeg4_version = 2;
106  break;
108  s->h263_pred = 1;
109  s->msmpeg4_version = 3;
110  break;
111  case AV_CODEC_ID_WMV1:
112  s->h263_pred = 1;
113  s->msmpeg4_version = 4;
114  break;
115  case AV_CODEC_ID_WMV2:
116  s->h263_pred = 1;
117  s->msmpeg4_version = 5;
118  break;
119  case AV_CODEC_ID_VC1:
120  case AV_CODEC_ID_WMV3:
123  case AV_CODEC_ID_MSS2:
124  s->h263_pred = 1;
125  s->msmpeg4_version = 6;
127  break;
128  case AV_CODEC_ID_H263I:
129  break;
130  case AV_CODEC_ID_FLV1:
131  s->h263_flv = 1;
132  break;
133  default:
134  av_log(avctx, AV_LOG_ERROR, "Unsupported codec %d\n",
135  avctx->codec->id);
136  return AVERROR(ENOSYS);
137  }
138 
139  if (avctx->codec_tag == AV_RL32("L263") || avctx->codec_tag == AV_RL32("S263"))
140  if (avctx->extradata_size == 56 && avctx->extradata[0] == 1)
141  s->ehc_mode = 1;
142 
143  /* for H.263, we allocate the images after having read the header */
144  if (avctx->codec->id != AV_CODEC_ID_H263 &&
145  avctx->codec->id != AV_CODEC_ID_H263P &&
146  avctx->codec->id != AV_CODEC_ID_MPEG4) {
147  avctx->pix_fmt = h263_get_format(avctx);
149  if ((ret = ff_mpv_common_init(s)) < 0)
150  return ret;
151  }
152 
153  ff_h263dsp_init(&s->h263dsp);
154  ff_qpeldsp_init(&s->qdsp);
156 
157  return 0;
158 }
159 
161 {
162  MpegEncContext *s = avctx->priv_data;
163 
165  return 0;
166 }
167 
168 /**
169  * Return the number of bytes consumed for building the current frame.
170  */
171 static int get_consumed_bytes(MpegEncContext *s, int buf_size)
172 {
173  int pos = (get_bits_count(&s->gb) + 7) >> 3;
174 
175  if (s->divx_packed || s->avctx->hwaccel) {
176  /* We would have to scan through the whole buf to handle the weird
177  * reordering ... */
178  return buf_size;
179 #if FF_API_FLAG_TRUNCATED
180  } else if (s->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
181  pos -= s->parse_context.last_index;
182  // padding is not really read so this might be -1
183  if (pos < 0)
184  pos = 0;
185  return pos;
186 #endif
187  } else {
188  // avoid infinite loops (maybe not needed...)
189  if (pos == 0)
190  pos = 1;
191  // oops ;)
192  if (pos + 10 > buf_size)
193  pos = buf_size;
194 
195  return pos;
196  }
197 }
198 
200 {
201  const int part_mask = s->partitioned_frame
202  ? (ER_AC_END | ER_AC_ERROR) : 0x7F;
203  const int mb_size = 16 >> s->avctx->lowres;
204  int ret;
205 
206  s->last_resync_gb = s->gb;
207  s->first_slice_line = 1;
208  s->resync_mb_x = s->mb_x;
209  s->resync_mb_y = s->mb_y;
210 
211  ff_set_qscale(s, s->qscale);
212 
213  if (s->studio_profile) {
214  if ((ret = ff_mpeg4_decode_studio_slice_header(s->avctx->priv_data)) < 0)
215  return ret;
216  }
217 
218  if (s->avctx->hwaccel) {
219  const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8;
220  ret = s->avctx->hwaccel->decode_slice(s->avctx, start, s->gb.buffer_end - start);
221  // ensure we exit decode loop
222  s->mb_y = s->mb_height;
223  return ret;
224  }
225 
226  if (s->partitioned_frame) {
227  const int qscale = s->qscale;
228 
229  if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4)
230  if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0)
231  return ret;
232 
233  /* restore variables which were modified */
234  s->first_slice_line = 1;
235  s->mb_x = s->resync_mb_x;
236  s->mb_y = s->resync_mb_y;
237  ff_set_qscale(s, qscale);
238  }
239 
240  for (; s->mb_y < s->mb_height; s->mb_y++) {
241  /* per-row end of slice checks */
242  if (s->msmpeg4_version) {
243  if (s->resync_mb_y + s->slice_height == s->mb_y) {
244  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
245  s->mb_x - 1, s->mb_y, ER_MB_END);
246 
247  return 0;
248  }
249  }
250 
251  if (s->msmpeg4_version == 1) {
252  s->last_dc[0] =
253  s->last_dc[1] =
254  s->last_dc[2] = 128;
255  }
256 
258  for (; s->mb_x < s->mb_width; s->mb_x++) {
259  int ret;
260 
261  ff_update_block_index(s, s->avctx->bits_per_raw_sample,
262  s->avctx->lowres, s->chroma_x_shift);
263 
264  if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y)
265  s->first_slice_line = 0;
266 
267  /* DCT & quantize */
268 
269  s->mv_dir = MV_DIR_FORWARD;
270  s->mv_type = MV_TYPE_16X16;
271  ff_dlog(s, "%d %06X\n",
272  get_bits_count(&s->gb), show_bits(&s->gb, 24));
273 
274  ff_tlog(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y);
275  ret = s->decode_mb(s, s->block);
276 
277  if (s->pict_type != AV_PICTURE_TYPE_B)
279 
280  if (ret < 0) {
281  const int xy = s->mb_x + s->mb_y * s->mb_stride;
282  if (ret == SLICE_END) {
283  ff_mpv_reconstruct_mb(s, s->block);
284  if (s->loop_filter)
286 
287  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
288  s->mb_x, s->mb_y, ER_MB_END & part_mask);
289 
290  s->padding_bug_score--;
291 
292  if (++s->mb_x >= s->mb_width) {
293  s->mb_x = 0;
294  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
296  s->mb_y++;
297  }
298  return 0;
299  } else if (ret == SLICE_NOEND) {
300  av_log(s->avctx, AV_LOG_ERROR,
301  "Slice mismatch at MB: %d\n", xy);
302  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
303  s->mb_x + 1, s->mb_y,
304  ER_MB_END & part_mask);
305  return AVERROR_INVALIDDATA;
306  }
307  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
308  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
309  s->mb_x, s->mb_y, ER_MB_ERROR & part_mask);
310 
311  if (s->avctx->err_recognition & AV_EF_IGNORE_ERR)
312  continue;
313  return AVERROR_INVALIDDATA;
314  }
315 
316  ff_mpv_reconstruct_mb(s, s->block);
317  if (s->loop_filter)
319  }
320 
321  ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size);
323 
324  s->mb_x = 0;
325  }
326 
327  av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height);
328 
329  // Detect incorrect padding with wrong stuffing codes used by NEC N-02B
330  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
331  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
332  get_bits_left(&s->gb) >= 48 &&
333  show_bits(&s->gb, 24) == 0x4010 &&
334  !s->data_partitioning)
335  s->padding_bug_score += 32;
336 
337  /* try to detect the padding bug */
338  if (s->codec_id == AV_CODEC_ID_MPEG4 &&
339  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
340  get_bits_left(&s->gb) >= 0 &&
341  get_bits_left(&s->gb) < 137 &&
342  !s->data_partitioning) {
343  const int bits_count = get_bits_count(&s->gb);
344  const int bits_left = s->gb.size_in_bits - bits_count;
345 
346  if (bits_left == 0) {
347  s->padding_bug_score += 16;
348  } else if (bits_left != 1) {
349  int v = show_bits(&s->gb, 8);
350  v |= 0x7F >> (7 - (bits_count & 7));
351 
352  if (v == 0x7F && bits_left <= 8)
353  s->padding_bug_score--;
354  else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) &&
355  bits_left <= 16)
356  s->padding_bug_score += 4;
357  else
358  s->padding_bug_score++;
359  }
360  }
361 
362  if (s->codec_id == AV_CODEC_ID_H263 &&
363  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
364  get_bits_left(&s->gb) >= 8 &&
365  get_bits_left(&s->gb) < 300 &&
366  s->pict_type == AV_PICTURE_TYPE_I &&
367  show_bits(&s->gb, 8) == 0 &&
368  !s->data_partitioning) {
369 
370  s->padding_bug_score += 32;
371  }
372 
373  if (s->codec_id == AV_CODEC_ID_H263 &&
374  (s->workaround_bugs & FF_BUG_AUTODETECT) &&
375  get_bits_left(&s->gb) >= 64 &&
376  AV_RB64(s->gb.buffer_end - 8) == 0xCDCDCDCDFC7F0000) {
377 
378  s->padding_bug_score += 32;
379  }
380 
381  if (s->workaround_bugs & FF_BUG_AUTODETECT) {
382  if (
383  (s->padding_bug_score > -2 && !s->data_partitioning))
384  s->workaround_bugs |= FF_BUG_NO_PADDING;
385  else
386  s->workaround_bugs &= ~FF_BUG_NO_PADDING;
387  }
388 
389  // handle formats which don't have unique end markers
390  if (s->msmpeg4_version || (s->workaround_bugs & FF_BUG_NO_PADDING)) { // FIXME perhaps solve this more cleanly
391  int left = get_bits_left(&s->gb);
392  int max_extra = 7;
393 
394  /* no markers in M$ crap */
395  if (s->msmpeg4_version && s->pict_type == AV_PICTURE_TYPE_I)
396  max_extra += 17;
397 
398  /* buggy padding but the frame should still end approximately at
399  * the bitstream end */
400  if ((s->workaround_bugs & FF_BUG_NO_PADDING) &&
401  (s->avctx->err_recognition & (AV_EF_BUFFER|AV_EF_AGGRESSIVE)))
402  max_extra += 48;
403  else if ((s->workaround_bugs & FF_BUG_NO_PADDING))
404  max_extra += 256 * 256 * 256 * 64;
405 
406  if (left > max_extra)
407  av_log(s->avctx, AV_LOG_ERROR,
408  "discarding %d junk bits at end, next would be %X\n",
409  left, show_bits(&s->gb, 24));
410  else if (left < 0)
411  av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
412  else
413  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
414  s->mb_x - 1, s->mb_y, ER_MB_END);
415 
416  return 0;
417  }
418 
419  av_log(s->avctx, AV_LOG_ERROR,
420  "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
421  get_bits_left(&s->gb), show_bits(&s->gb, 24), s->padding_bug_score);
422 
423  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
424  ER_MB_END & part_mask);
425 
426  return AVERROR_INVALIDDATA;
427 }
428 
430  int *got_frame, AVPacket *avpkt)
431 {
432  const uint8_t *buf = avpkt->data;
433  int buf_size = avpkt->size;
434  MpegEncContext *s = avctx->priv_data;
435  int ret;
436  int slice_ret = 0;
437 
438  /* no supplementary picture */
439  if (buf_size == 0) {
440  /* special case for last picture */
441  if (s->low_delay == 0 && s->next_picture_ptr) {
442  if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
443  return ret;
444  s->next_picture_ptr = NULL;
445 
446  *got_frame = 1;
447  }
448 
449  return 0;
450  }
451 
452 #if FF_API_FLAG_TRUNCATED
453  if (s->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
454  int next;
455 
456  if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) {
457  next = ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
458  } else if (CONFIG_H263_DECODER && s->codec_id == AV_CODEC_ID_H263) {
459  next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
460  } else if (CONFIG_H263P_DECODER && s->codec_id == AV_CODEC_ID_H263P) {
461  next = ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
462  } else {
463  av_log(s->avctx, AV_LOG_ERROR,
464  "this codec does not support truncated bitstreams\n");
465  return AVERROR(ENOSYS);
466  }
467 
468  if (ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf,
469  &buf_size) < 0)
470  return buf_size;
471  }
472 #endif
473 
474 retry:
475  if (s->divx_packed && s->bitstream_buffer_size) {
476  int i;
477  for(i=0; i < buf_size-3; i++) {
478  if (buf[i]==0 && buf[i+1]==0 && buf[i+2]==1) {
479  if (buf[i+3]==0xB0) {
480  av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");
481  s->bitstream_buffer_size = 0;
482  }
483  break;
484  }
485  }
486  }
487 
488  if (s->bitstream_buffer_size && (s->divx_packed || buf_size <= MAX_NVOP_SIZE)) // divx 5.01+/xvid frame reorder
489  ret = init_get_bits8(&s->gb, s->bitstream_buffer,
490  s->bitstream_buffer_size);
491  else
492  ret = init_get_bits8(&s->gb, buf, buf_size);
493 
494  s->bitstream_buffer_size = 0;
495  if (ret < 0)
496  return ret;
497 
498  if (!s->context_initialized)
499  // we need the idct permutation for reading a custom matrix
501 
502  /* let's go :-) */
503  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {
505  } else if (CONFIG_MSMPEG4DEC && s->msmpeg4_version) {
507  } else if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
508  if (s->avctx->extradata_size && s->picture_number == 0) {
509  GetBitContext gb;
510 
511  if (init_get_bits8(&gb, s->avctx->extradata, s->avctx->extradata_size) >= 0 )
512  ff_mpeg4_decode_picture_header(avctx->priv_data, &gb, 1, 0);
513  }
514  ret = ff_mpeg4_decode_picture_header(avctx->priv_data, &s->gb, 0, 0);
515  } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {
517  } else if (CONFIG_FLV_DECODER && s->h263_flv) {
519  } else {
521  }
522 
523  if (ret < 0 || ret == FRAME_SKIPPED) {
524  if ( s->width != avctx->coded_width
525  || s->height != avctx->coded_height) {
526  av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");
527  s->width = avctx->coded_width;
528  s->height= avctx->coded_height;
529  }
530  }
531  if (ret == FRAME_SKIPPED)
532  return get_consumed_bytes(s, buf_size);
533 
534  /* skip if the header was thrashed */
535  if (ret < 0) {
536  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
537  return ret;
538  }
539 
540  if (!s->context_initialized) {
541  avctx->pix_fmt = h263_get_format(avctx);
542  if ((ret = ff_mpv_common_init(s)) < 0)
543  return ret;
544  }
545 
546  if (!s->current_picture_ptr || s->current_picture_ptr->f->data[0]) {
547  int i = ff_find_unused_picture(s->avctx, s->picture, 0);
548  if (i < 0)
549  return i;
550  s->current_picture_ptr = &s->picture[i];
551  }
552 
553  avctx->has_b_frames = !s->low_delay;
554 
555  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4) {
556  if (ff_mpeg4_workaround_bugs(avctx) == 1)
557  goto retry;
558  if (s->studio_profile != (s->idsp.idct == NULL))
560  }
561 
562  /* After H.263 & MPEG-4 header decode we have the height, width,
563  * and other parameters. So then we could init the picture.
564  * FIXME: By the way H.263 decoder is evolving it should have
565  * an H263EncContext */
566  if (s->width != avctx->coded_width ||
567  s->height != avctx->coded_height ||
568  s->context_reinit) {
569  /* H.263 could change picture size any time */
570  s->context_reinit = 0;
571 
572  ret = ff_set_dimensions(avctx, s->width, s->height);
573  if (ret < 0)
574  return ret;
575 
576  ff_set_sar(avctx, avctx->sample_aspect_ratio);
577 
579  return ret;
580 
581  if (avctx->pix_fmt != h263_get_format(avctx)) {
582  av_log(avctx, AV_LOG_ERROR, "format change not supported\n");
583  avctx->pix_fmt = AV_PIX_FMT_NONE;
584  return AVERROR_UNKNOWN;
585  }
586  }
587 
588  if (s->codec_id == AV_CODEC_ID_H263 ||
589  s->codec_id == AV_CODEC_ID_H263P ||
590  s->codec_id == AV_CODEC_ID_H263I)
591  s->gob_index = H263_GOB_HEIGHT(s->height);
592 
593  // for skipping the frame
594  s->current_picture.f->pict_type = s->pict_type;
595  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
596 
597  /* skip B-frames if we don't have reference frames */
598  if (!s->last_picture_ptr &&
599  (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))
600  return get_consumed_bytes(s, buf_size);
601  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
602  s->pict_type == AV_PICTURE_TYPE_B) ||
603  (avctx->skip_frame >= AVDISCARD_NONKEY &&
604  s->pict_type != AV_PICTURE_TYPE_I) ||
605  avctx->skip_frame >= AVDISCARD_ALL)
606  return get_consumed_bytes(s, buf_size);
607 
608  if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
609  s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
610  s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
611  } else {
612  s->me.qpel_put = s->qdsp.put_no_rnd_qpel_pixels_tab;
613  s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
614  }
615 
616  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
617  return ret;
618 
619  if (!s->divx_packed && !avctx->hwaccel)
620  ff_thread_finish_setup(avctx);
621 
622  if (avctx->hwaccel) {
623  ret = avctx->hwaccel->start_frame(avctx, s->gb.buffer,
624  s->gb.buffer_end - s->gb.buffer);
625  if (ret < 0 )
626  return ret;
627  }
628 
630 
631  /* the second part of the wmv2 header contains the MB skip bits which
632  * are stored in current_picture->mb_type which is not available before
633  * ff_mpv_frame_start() */
634  if (CONFIG_WMV2_DECODER && s->msmpeg4_version == 5) {
636  if (ret < 0)
637  return ret;
638  if (ret == 1)
639  goto frame_end;
640  }
641 
642  /* decode each macroblock */
643  s->mb_x = 0;
644  s->mb_y = 0;
645 
646  slice_ret = decode_slice(s);
647  while (s->mb_y < s->mb_height) {
648  if (s->msmpeg4_version) {
649  if (s->slice_height == 0 || s->mb_x != 0 || slice_ret < 0 ||
650  (s->mb_y % s->slice_height) != 0 || get_bits_left(&s->gb) < 0)
651  break;
652  } else {
653  int prev_x = s->mb_x, prev_y = s->mb_y;
654  if (ff_h263_resync(s) < 0)
655  break;
656  if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
657  s->er.error_occurred = 1;
658  }
659 
660  if (s->msmpeg4_version < 4 && s->h263_pred)
662 
663  if (decode_slice(s) < 0)
664  slice_ret = AVERROR_INVALIDDATA;
665  }
666 
667  if (s->msmpeg4_version && s->msmpeg4_version < 4 &&
668  s->pict_type == AV_PICTURE_TYPE_I)
669  if (!CONFIG_MSMPEG4DEC ||
670  ff_msmpeg4_decode_ext_header(s, buf_size) < 0)
671  s->er.error_status_table[s->mb_num - 1] = ER_MB_ERROR;
672 
673  av_assert1(s->bitstream_buffer_size == 0);
674 frame_end:
675  if (!s->studio_profile)
676  ff_er_frame_end(&s->er);
677 
678  if (avctx->hwaccel) {
679  ret = avctx->hwaccel->end_frame(avctx);
680  if (ret < 0)
681  return ret;
682  }
683 
685 
686  if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)
687  ff_mpeg4_frame_end(avctx, buf, buf_size);
688 
689  if (!s->divx_packed && avctx->hwaccel)
690  ff_thread_finish_setup(avctx);
691 
692  av_assert1(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
693  av_assert1(s->current_picture.f->pict_type == s->pict_type);
694  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
695  if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
696  return ret;
697  ff_print_debug_info(s, s->current_picture_ptr, pict);
698  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
699  } else if (s->last_picture_ptr) {
700  if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
701  return ret;
702  ff_print_debug_info(s, s->last_picture_ptr, pict);
703  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_MPV_QSCALE_TYPE_MPEG1);
704  }
705 
706  if (s->last_picture_ptr || s->low_delay) {
707  if ( pict->format == AV_PIX_FMT_YUV420P
708  && (s->codec_tag == AV_RL32("GEOV") || s->codec_tag == AV_RL32("GEOX"))) {
709  for (int p = 0; p < 3; p++) {
710  int h = AV_CEIL_RSHIFT(pict->height, !!p);
711 
712  pict->data[p] += (h - 1) * pict->linesize[p];
713  pict->linesize[p] *= -1;
714  }
715  }
716  *got_frame = 1;
717  }
718 
719  if (slice_ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
720  return slice_ret;
721  else
722  return get_consumed_bytes(s, buf_size);
723 }
724 
726 #if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL
728 #endif
729 #if CONFIG_MPEG4_NVDEC_HWACCEL
731 #endif
732 #if CONFIG_MPEG4_VDPAU_HWACCEL
734 #endif
735 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL || CONFIG_MPEG4_VIDEOTOOLBOX_HWACCEL
737 #endif
740 };
741 
743 #if CONFIG_H263_VAAPI_HWACCEL
744  HWACCEL_VAAPI(h263),
745 #endif
746 #if CONFIG_MPEG4_NVDEC_HWACCEL
747  HWACCEL_NVDEC(mpeg4),
748 #endif
749 #if CONFIG_MPEG4_VDPAU_HWACCEL
750  HWACCEL_VDPAU(mpeg4),
751 #endif
752 #if CONFIG_H263_VIDEOTOOLBOX_HWACCEL
753  HWACCEL_VIDEOTOOLBOX(h263),
754 #endif
755  NULL
756 };
757 
759  .p.name = "h263",
760  .p.long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
761  .p.type = AVMEDIA_TYPE_VIDEO,
762  .p.id = AV_CODEC_ID_H263,
763  .priv_data_size = sizeof(MpegEncContext),
765  .close = ff_h263_decode_end,
767  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
768 #if FF_API_FLAG_TRUNCATED
769  AV_CODEC_CAP_TRUNCATED |
770 #endif
772  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
773  .flush = ff_mpeg_flush,
774  .p.max_lowres = 3,
775  .p.pix_fmts = ff_h263_hwaccel_pixfmt_list_420,
776  .hw_configs = h263_hw_config_list,
777 };
778 
780  .p.name = "h263p",
781  .p.long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
782  .p.type = AVMEDIA_TYPE_VIDEO,
783  .p.id = AV_CODEC_ID_H263P,
784  .priv_data_size = sizeof(MpegEncContext),
786  .close = ff_h263_decode_end,
788  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
789 #if FF_API_FLAG_TRUNCATED
790  AV_CODEC_CAP_TRUNCATED |
791 #endif
793  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
794  .flush = ff_mpeg_flush,
795  .p.max_lowres = 3,
796  .p.pix_fmts = ff_h263_hwaccel_pixfmt_list_420,
797  .hw_configs = h263_hw_config_list,
798 };
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:743
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1388
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:255
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:225
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
h263_hw_config_list
static const AVCodecHWConfigInternal *const h263_hw_config_list[]
Definition: h263dec.c:742
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:839
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:507
ff_h263_decode_mb
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:786
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1159
mpeg4videodec.h
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1353
ff_qpeldsp_init
av_cold void ff_qpeldsp_init(QpelDSPContext *c)
Definition: qpeldsp.c:784
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:226
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo_dec.c:574
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_mpeg4_decode_studio_slice_header
int ff_mpeg4_decode_studio_slice_header(Mpeg4DecContext *ctx)
Decode the next video packet.
Definition: mpeg4videodec.c:617
ff_msmpeg4_decode_ext_header
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:564
FFCodec
Definition: codec_internal.h:118
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:1673
mpegvideo.h
AV_EF_BUFFER
#define AV_EF_BUFFER
detect improper bitstream length
Definition: avcodec.h:1363
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
mpegutils.h
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
init
static int init
Definition: av_tx.c:47
ff_wmv2_decode_secondary_picture_header
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:240
ff_mpeg4_frame_end
int ff_mpeg4_frame_end(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg4videodec.c:3469
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:407
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1704
GetBitContext
Definition: get_bits.h:61
decode_slice
static int decode_slice(MpegEncContext *s)
Definition: h263dec.c:199
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:478
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:586
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const Picture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:500
SLICE_END
#define SLICE_END
end marker found
Definition: mpegvideo.h:481
ff_h263_decode_picture_header
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:1088
AV_CODEC_ID_MSMPEG4V2
@ AV_CODEC_ID_MSMPEG4V2
Definition: codec_id.h:65
ff_h263_update_motion_val
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:53
ff_h263_find_frame_end
int ff_h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
Definition: h263_parser.c:32
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:879
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:70
ff_mpeg4_decode_partitions
int ff_mpeg4_decode_partitions(Mpeg4DecContext *ctx)
Decode the first and second partition.
Definition: mpeg4videodec.c:1048
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
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:408
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:694
ff_mpv_common_frame_size_change
int ff_mpv_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo_dec.c:194
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
s
#define s(width, name)
Definition: cbs_vp9.c:256
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
h263_get_format
static enum AVPixelFormat h263_get_format(AVCodecContext *avctx)
Definition: h263dec.c:57
FF_BUG_NO_PADDING
#define FF_BUG_NO_PADDING
Definition: avcodec.h:1284
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:68
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1457
ff_mpeg4_workaround_bugs
int ff_mpeg4_workaround_bugs(AVCodecContext *avctx)
Definition: mpeg4videodec.c:2808
AV_CODEC_ID_MSMPEG4V1
@ AV_CODEC_ID_MSMPEG4V1
Definition: codec_id.h:64
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_CODEC_ID_VC1IMAGE
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:202
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:408
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:54
AV_CODEC_ID_WMV3
@ AV_CODEC_ID_WMV3
Definition: codec_id.h:121
ff_find_unused_picture
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:446
ff_h263_decode_init_vlc
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:135
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:982
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:31
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:627
SLICE_NOEND
#define SLICE_NOEND
no end marker or error found but mb count exceeded
Definition: mpegvideo.h:482
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:38
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:2176
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
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:1709
AV_CODEC_FLAG_TRUNCATED
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:271
ff_h263_decode_frame
int ff_h263_decode_frame(AVCodecContext *avctx, AVFrame *pict, int *got_frame, AVPacket *avpkt)
Definition: h263dec.c:429
qpeldsp.h
AV_CODEC_ID_WMV1
@ AV_CODEC_ID_WMV1
Definition: codec_id.h:67
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1364
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:572
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:160
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:53
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_EF_IGNORE_ERR
#define AV_EF_IGNORE_ERR
ignore errors and continue
Definition: avcodec.h:1366
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:259
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
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:353
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:602
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:54
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:53
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo_dec.c:537
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:412
AVCodecHWConfigInternal
Definition: hwconfig.h:29
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:270
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:545
ff_h263_decoder
const FFCodec ff_h263_decoder
Definition: h263dec.c:758
msmpeg4dec.h
flvdec.h
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:119
ff_combine_frame
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
Combine the (truncated) bitstream to a complete frame.
Definition: parser.c:199
AV_CODEC_ID_MSS2
@ AV_CODEC_ID_MSS2
Definition: codec_id.h:217
AVCodec::id
enum AVCodecID id
Definition: codec.h:218
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:187
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:171
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:274
FMT_H263
@ FMT_H263
Definition: mpegutils.h:119
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
ff_h263p_decoder
const FFCodec ff_h263p_decoder
Definition: h263dec.c:779
ff_h263_hwaccel_pixfmt_list_420
enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[]
Definition: h263dec.c:725
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
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:3311
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:37
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
FF_BUG_AUTODETECT
#define FF_BUG_AUTODETECT
autodetection
Definition: avcodec.h:1281
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:211
ff_h263_decode_init
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
Definition: h263dec.c:77
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:120
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:989
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:589
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:77
h263_parser.h
avcodec.h
ret
ret
Definition: filter_design.txt:187
wmv2dec.h
pos
unsigned int pos
Definition: spdifenc.c:412
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_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:105
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVFrame::height
int height
Definition: frame.h:397
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:69
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
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:628
error_resilience.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
frame_end
static void frame_end(MpegEncContext *s)
Definition: mpegvideo_enc.c:1542
MAX_NVOP_SIZE
#define MAX_NVOP_SIZE
Definition: mpeg4video.h:70
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:492
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:1649
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:82
ff_mpeg4_find_frame_end
int ff_mpeg4_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
Find the end of the current frame in the bitstream.
Definition: mpeg4video_parser.c:42
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:1369
AVHWAccel::start_frame
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:2138
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:586
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mpeg4video_parser.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:90
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:39
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:423
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:207
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:251
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:892
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:215
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
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:370
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:66
h
h
Definition: vp9dsp_template.c:2038
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:34
AV_CODEC_ID_WMV3IMAGE
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:201
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:71
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:50
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:62
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:768
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