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