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