libavcodec/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"
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "error_resilience.h"
34 #include "mpegvideo.h"
35 #include "h263.h"
36 #include "h263_parser.h"
37 #include "mpeg4video_parser.h"
38 #include "msmpeg4.h"
39 #include "vdpau_internal.h"
40 #include "thread.h"
41 #include "flv.h"
42 #include "mpeg4video.h"
43 
44 //#define DEBUG
45 //#define PRINT_FRAME_TIME
46 
48 {
49  MpegEncContext *s = avctx->priv_data;
50  int ret;
51 
52  s->avctx = avctx;
53  s->out_format = FMT_H263;
54 
55  s->width = avctx->coded_width;
56  s->height = avctx->coded_height;
58 
59  // set defaults
61  s->quant_precision=5;
63  s->low_delay= 1;
64  if (avctx->codec->id == AV_CODEC_ID_MSS2)
65  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
66  else
67  avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
68  s->unrestricted_mv= 1;
69 
70  /* select sub codec */
71  switch(avctx->codec->id) {
72  case AV_CODEC_ID_H263:
73  case AV_CODEC_ID_H263P:
74  s->unrestricted_mv= 0;
76  break;
77  case AV_CODEC_ID_MPEG4:
78  break;
80  s->h263_pred = 1;
81  s->msmpeg4_version=1;
82  break;
84  s->h263_pred = 1;
85  s->msmpeg4_version=2;
86  break;
88  s->h263_pred = 1;
89  s->msmpeg4_version=3;
90  break;
91  case AV_CODEC_ID_WMV1:
92  s->h263_pred = 1;
93  s->msmpeg4_version=4;
94  break;
95  case AV_CODEC_ID_WMV2:
96  s->h263_pred = 1;
97  s->msmpeg4_version=5;
98  break;
99  case AV_CODEC_ID_VC1:
100  case AV_CODEC_ID_WMV3:
103  case AV_CODEC_ID_MSS2:
104  s->h263_pred = 1;
105  s->msmpeg4_version=6;
107  break;
108  case AV_CODEC_ID_H263I:
109  break;
110  case AV_CODEC_ID_FLV1:
111  s->h263_flv = 1;
112  break;
113  default:
114  return AVERROR(EINVAL);
115  }
116  s->codec_id= avctx->codec->id;
117  avctx->hwaccel= ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
118 
119  /* for h263, we allocate the images after having read the header */
120  if (avctx->codec->id != AV_CODEC_ID_H263 && avctx->codec->id != AV_CODEC_ID_H263P && avctx->codec->id != AV_CODEC_ID_MPEG4)
121  if ((ret = ff_MPV_common_init(s)) < 0)
122  return ret;
123 
125 
126  return 0;
127 }
128 
130 {
131  MpegEncContext *s = avctx->priv_data;
132 
134  return 0;
135 }
136 
137 /**
138  * Return the number of bytes consumed for building the current frame.
139  */
140 static int get_consumed_bytes(MpegEncContext *s, int buf_size){
141  int pos= (get_bits_count(&s->gb)+7)>>3;
142 
143  if(s->divx_packed || s->avctx->hwaccel){
144  //we would have to scan through the whole buf to handle the weird reordering ...
145  return buf_size;
146  }else if(s->flags&CODEC_FLAG_TRUNCATED){
147  pos -= s->parse_context.last_index;
148  if(pos<0) pos=0; // padding is not really read so this might be -1
149  return pos;
150  }else{
151  if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
152  if(pos+10>buf_size) pos=buf_size; // oops ;)
153 
154  return pos;
155  }
156 }
157 
159  const int part_mask= s->partitioned_frame ? (ER_AC_END|ER_AC_ERROR) : 0x7F;
160  const int mb_size= 16>>s->avctx->lowres;
161  int ret;
162 
163  s->last_resync_gb= s->gb;
164  s->first_slice_line= 1;
165 
166  s->resync_mb_x= s->mb_x;
167  s->resync_mb_y= s->mb_y;
168 
169  ff_set_qscale(s, s->qscale);
170 
171  if (s->avctx->hwaccel) {
172  const uint8_t *start= s->gb.buffer + get_bits_count(&s->gb)/8;
173  const uint8_t *end = ff_h263_find_resync_marker(s, start + 1, s->gb.buffer_end);
174  skip_bits_long(&s->gb, 8*(end - start));
175  return s->avctx->hwaccel->decode_slice(s->avctx, start, end - start);
176  }
177 
178  if(s->partitioned_frame){
179  const int qscale= s->qscale;
180 
182  if ((ret = ff_mpeg4_decode_partitions(s)) < 0)
183  return ret;
184  }
185 
186  /* restore variables which were modified */
187  s->first_slice_line=1;
188  s->mb_x= s->resync_mb_x;
189  s->mb_y= s->resync_mb_y;
190  ff_set_qscale(s, qscale);
191  }
192 
193  for(; s->mb_y < s->mb_height; s->mb_y++) {
194  /* per-row end of slice checks */
195  if(s->msmpeg4_version){
196  if(s->resync_mb_y + s->slice_height == s->mb_y){
197  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
198 
199  return 0;
200  }
201  }
202 
203  if(s->msmpeg4_version==1){
204  s->last_dc[0]=
205  s->last_dc[1]=
206  s->last_dc[2]= 128;
207  }
208 
210  for(; s->mb_x < s->mb_width; s->mb_x++) {
211  int ret;
212 
214 
215  if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
216  s->first_slice_line=0;
217  }
218 
219  /* DCT & quantize */
220 
221  s->mv_dir = MV_DIR_FORWARD;
222  s->mv_type = MV_TYPE_16X16;
223 // s->mb_skipped = 0;
224  av_dlog(s, "%d %d %06X\n",
225  ret, get_bits_count(&s->gb), show_bits(&s->gb, 24));
226  ret= s->decode_mb(s, s->block);
227 
230 
231  if(ret<0){
232  const int xy= s->mb_x + s->mb_y*s->mb_stride;
233  if(ret==SLICE_END){
234  ff_MPV_decode_mb(s, s->block);
235  if(s->loop_filter)
237 
238  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask);
239 
240  s->padding_bug_score--;
241 
242  if(++s->mb_x >= s->mb_width){
243  s->mb_x=0;
244  ff_mpeg_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
246  s->mb_y++;
247  }
248  return 0;
249  }else if(ret==SLICE_NOEND){
250  av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy);
251  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x+1, s->mb_y, ER_MB_END&part_mask);
252  return AVERROR_INVALIDDATA;
253  }
254  av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy);
255  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR&part_mask);
256 
257  return AVERROR_INVALIDDATA;
258  }
259 
260  ff_MPV_decode_mb(s, s->block);
261  if(s->loop_filter)
263  }
264 
265  ff_mpeg_draw_horiz_band(s, s->mb_y*mb_size, mb_size);
267 
268  s->mb_x= 0;
269  }
270 
271  av_assert1(s->mb_x==0 && s->mb_y==s->mb_height);
272 
275  && get_bits_left(&s->gb) >= 48
276  && show_bits(&s->gb, 24)==0x4010
277  && !s->data_partitioning)
278  s->padding_bug_score+=32;
279 
280  /* try to detect the padding bug */
283  && get_bits_left(&s->gb) >=0
284  && get_bits_left(&s->gb) < 137
285 // && !s->resync_marker
286  && !s->data_partitioning){
287 
288  const int bits_count= get_bits_count(&s->gb);
289  const int bits_left = s->gb.size_in_bits - bits_count;
290 
291  if(bits_left==0){
292  s->padding_bug_score+=16;
293  } else if(bits_left != 1){
294  int v= show_bits(&s->gb, 8);
295  v|= 0x7F >> (7-(bits_count&7));
296 
297  if(v==0x7F && bits_left<=8)
298  s->padding_bug_score--;
299  else if(v==0x7F && ((get_bits_count(&s->gb)+8)&8) && bits_left<=16)
300  s->padding_bug_score+= 4;
301  else
302  s->padding_bug_score++;
303  }
304  }
305 
307  if(s->padding_bug_score > -2 && !s->data_partitioning /*&& (s->divx_version>=0 || !s->resync_marker)*/)
309  else
311  }
312 
313  // handle formats which don't have unique end markers
314  if(s->msmpeg4_version || (s->workaround_bugs&FF_BUG_NO_PADDING)){ //FIXME perhaps solve this more cleanly
315  int left= get_bits_left(&s->gb);
316  int max_extra=7;
317 
318  /* no markers in M$ crap */
320  max_extra+= 17;
321 
322  /* buggy padding but the frame should still end approximately at the bitstream end */
324  max_extra+= 48;
325  else if((s->workaround_bugs&FF_BUG_NO_PADDING))
326  max_extra+= 256*256*256*64;
327 
328  if(left>max_extra){
329  av_log(s->avctx, AV_LOG_ERROR, "discarding %d junk bits at end, next would be %X\n", left, show_bits(&s->gb, 24));
330  }
331  else if(left<0){
332  av_log(s->avctx, AV_LOG_ERROR, "overreading %d bits\n", -left);
333  }else
334  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
335 
336  return 0;
337  }
338 
339  av_log(s->avctx, AV_LOG_ERROR, "slice end not reached but screenspace end (%d left %06X, score= %d)\n",
340  get_bits_left(&s->gb),
341  show_bits(&s->gb, 24), s->padding_bug_score);
342 
343  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END&part_mask);
344 
345  return AVERROR_INVALIDDATA;
346 }
347 
349  void *data, int *got_frame,
350  AVPacket *avpkt)
351 {
352  const uint8_t *buf = avpkt->data;
353  int buf_size = avpkt->size;
354  MpegEncContext *s = avctx->priv_data;
355  int ret;
356  AVFrame *pict = data;
357 
358 #ifdef PRINT_FRAME_TIME
359 uint64_t time= rdtsc();
360 #endif
361  s->flags= avctx->flags;
362  s->flags2= avctx->flags2;
363 
364  /* no supplementary picture */
365  if (buf_size == 0) {
366  /* special case for last picture */
367  if (s->low_delay==0 && s->next_picture_ptr) {
368  if ((ret = av_frame_ref(pict, &s->next_picture_ptr->f)) < 0)
369  return ret;
371 
372  *got_frame = 1;
373  }
374 
375  return 0;
376  }
377 
379  int next;
380 
382  next= ff_mpeg4_find_frame_end(&s->parse_context, buf, buf_size);
384  next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
386  next= ff_h263_find_frame_end(&s->parse_context, buf, buf_size);
387  }else{
388  av_log(s->avctx, AV_LOG_ERROR, "this codec does not support truncated bitstreams\n");
389  return AVERROR(EINVAL);
390  }
391 
392  if( ff_combine_frame(&s->parse_context, next, (const uint8_t **)&buf, &buf_size) < 0 )
393  return buf_size;
394  }
395 
396 
397 retry:
398  if(s->divx_packed && s->bitstream_buffer_size){
399  int i;
400  for(i=0; i<buf_size-3; i++){
401  if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1){
402  if(buf[i+3]==0xB0){
403  av_log(s->avctx, AV_LOG_WARNING, "Discarding excessive bitstream in packed xvid\n");
405  }
406  break;
407  }
408  }
409  }
410 
411  if(s->bitstream_buffer_size && (s->divx_packed || buf_size<20)){ //divx 5.01+/xvid frame reorder
413  }else
414  init_get_bits(&s->gb, buf, buf_size*8);
416 
417  if (!s->context_initialized) {
418  if ((ret = ff_MPV_common_init(s)) < 0) //we need the idct permutaton for reading a custom matrix
419  return ret;
420  }
421 
422  /* We need to set current_picture_ptr before reading the header,
423  * otherwise we cannot store anyting in there */
424  if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
425  int i= ff_find_unused_picture(s, 0);
426  if (i < 0)
427  return i;
428  s->current_picture_ptr= &s->picture[i];
429  }
430 
431  /* let's go :-) */
432  if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5) {
434  } else if (CONFIG_MSMPEG4_DECODER && s->msmpeg4_version) {
436  } else if (CONFIG_MPEG4_DECODER && s->h263_pred) {
437  if(s->avctx->extradata_size && s->picture_number==0){
438  GetBitContext gb;
439 
441  ret = ff_mpeg4_decode_picture_header(s, &gb);
442  }
443  ret = ff_mpeg4_decode_picture_header(s, &s->gb);
444  } else if (CONFIG_H263I_DECODER && s->codec_id == AV_CODEC_ID_H263I) {
446  } else if (CONFIG_FLV_DECODER && s->h263_flv) {
448  } else {
450  }
451 
452  if (ret < 0 || ret==FRAME_SKIPPED) {
453  if ( s->width != avctx->coded_width
454  || s->height != avctx->coded_height) {
455  av_log(s->avctx, AV_LOG_WARNING, "Reverting picture dimensions change due to header decoding failure\n");
456  s->width = avctx->coded_width;
457  s->height= avctx->coded_height;
458  }
459  }
460  if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_size);
461 
462  /* skip if the header was thrashed */
463  if (ret < 0){
464  av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
465  return ret;
466  }
467 
468  avctx->has_b_frames= !s->low_delay;
469 
470  if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){
471  if(s->stream_codec_tag == AV_RL32("XVID") ||
472  s->codec_tag == AV_RL32("XVID") || s->codec_tag == AV_RL32("XVIX") ||
473  s->codec_tag == AV_RL32("RMP4") || s->codec_tag == AV_RL32("ZMP4") ||
474  s->codec_tag == AV_RL32("SIPP")
475  )
476  s->xvid_build= 0;
477 #if 0
478  if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==1
479  && s->padding_bug_score > 0 && s->low_delay) // XVID with modified fourcc
480  s->xvid_build= 0;
481 #endif
482  }
483 
484  if(s->xvid_build==-1 && s->divx_version==-1 && s->lavc_build==-1){
485  if(s->codec_tag == AV_RL32("DIVX") && s->vo_type==0 && s->vol_control_parameters==0)
486  s->divx_version= 400; //divx 4
487  }
488 
489  if(s->xvid_build>=0 && s->divx_version>=0){
490  s->divx_version=
491  s->divx_build= -1;
492  }
493 
495  if(s->codec_tag == AV_RL32("XVIX"))
497 
498  if(s->codec_tag == AV_RL32("UMP4")){
500  }
501 
502  if(s->divx_version>=500 && s->divx_build<1814){
504  }
505 
506  if(s->divx_version>502 && s->divx_build<1814){
508  }
509 
510  if(s->xvid_build<=3U)
511  s->padding_bug_score= 256*256*256*64;
512 
513  if(s->xvid_build<=1U)
515 
516  if(s->xvid_build<=12U)
518 
519  if(s->xvid_build<=32U)
521 
522 #define SET_QPEL_FUNC(postfix1, postfix2) \
523  s->dsp.put_ ## postfix1 = ff_put_ ## postfix2;\
524  s->dsp.put_no_rnd_ ## postfix1 = ff_put_no_rnd_ ## postfix2;\
525  s->dsp.avg_ ## postfix1 = ff_avg_ ## postfix2;
526 
527  if(s->lavc_build<4653U)
529 
530  if(s->lavc_build<4655U)
532 
533  if(s->lavc_build<4670U){
535  }
536 
537  if(s->lavc_build<=4712U)
539 
540  if(s->divx_version>=0)
542  if(s->divx_version==501 && s->divx_build==20020416)
543  s->padding_bug_score= 256*256*256*64;
544 
545  if(s->divx_version<500U){
547  }
548 
549  if(s->divx_version>=0)
551 #if 0
552  if(s->divx_version==500)
553  s->padding_bug_score= 256*256*256*64;
554 
555  /* very ugly XVID padding bug detection FIXME/XXX solve this differently
556  * Let us hope this at least works.
557  */
558  if( s->resync_marker==0 && s->data_partitioning==0 && s->divx_version==-1
559  && s->codec_id==AV_CODEC_ID_MPEG4 && s->vo_type==0)
561 
562  if(s->lavc_build<4609U) //FIXME not sure about the version num but a 4609 file seems ok
564 #endif
565  }
566 
568  SET_QPEL_FUNC(qpel_pixels_tab[0][ 5], qpel16_mc11_old_c)
569  SET_QPEL_FUNC(qpel_pixels_tab[0][ 7], qpel16_mc31_old_c)
570  SET_QPEL_FUNC(qpel_pixels_tab[0][ 9], qpel16_mc12_old_c)
571  SET_QPEL_FUNC(qpel_pixels_tab[0][11], qpel16_mc32_old_c)
572  SET_QPEL_FUNC(qpel_pixels_tab[0][13], qpel16_mc13_old_c)
573  SET_QPEL_FUNC(qpel_pixels_tab[0][15], qpel16_mc33_old_c)
574 
575  SET_QPEL_FUNC(qpel_pixels_tab[1][ 5], qpel8_mc11_old_c)
576  SET_QPEL_FUNC(qpel_pixels_tab[1][ 7], qpel8_mc31_old_c)
577  SET_QPEL_FUNC(qpel_pixels_tab[1][ 9], qpel8_mc12_old_c)
578  SET_QPEL_FUNC(qpel_pixels_tab[1][11], qpel8_mc32_old_c)
579  SET_QPEL_FUNC(qpel_pixels_tab[1][13], qpel8_mc13_old_c)
580  SET_QPEL_FUNC(qpel_pixels_tab[1][15], qpel8_mc33_old_c)
581  }
582 
583  if(avctx->debug & FF_DEBUG_BUGS)
584  av_log(s->avctx, AV_LOG_DEBUG, "bugs: %X lavc_build:%d xvid_build:%d divx_version:%d divx_build:%d %s\n",
586  s->divx_packed ? "p" : "");
587 
588 #if HAVE_MMX
590  avctx->idct_algo= FF_IDCT_XVIDMMX;
592  goto retry;
593  }
594 #endif
595 
596  /* After H263 & mpeg4 header decode we have the height, width,*/
597  /* and other parameters. So then we could init the picture */
598  /* FIXME: By the way H263 decoder is evolving it should have */
599  /* an H263EncContext */
600 
601  if ((!avctx->coded_width || !avctx->coded_height) && 0) {
602  ParseContext pc= s->parse_context; //FIXME move these demuxng hack to avformat
603 
604  s->parse_context.buffer=0;
606  s->parse_context= pc;
607  avcodec_set_dimensions(avctx, s->width, s->height);
608 
609  goto retry;
610  }
611 
612  if (s->width != avctx->coded_width ||
613  s->height != avctx->coded_height ||
614  s->context_reinit) {
615  /* H.263 could change picture size any time */
616  s->context_reinit = 0;
617 
618  avcodec_set_dimensions(avctx, s->width, s->height);
619 
620  if ((ret = ff_MPV_common_frame_size_change(s)))
621  return ret;
622  }
623 
626 
627  // for skipping the frame
630 
631  /* skip B-frames if we don't have reference frames */
632  if (s->last_picture_ptr == NULL &&
633  (s->pict_type == AV_PICTURE_TYPE_B || s->droppable))
634  return get_consumed_bytes(s, buf_size);
637  || avctx->skip_frame >= AVDISCARD_ALL)
638  return get_consumed_bytes(s, buf_size);
639 
640  if(s->next_p_frame_damaged){
642  return get_consumed_bytes(s, buf_size);
643  else
645  }
646 
647  if((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
650  }else{
653  }
654 
655  if ((ret = ff_MPV_frame_start(s, avctx)) < 0)
656  return ret;
657 
658  if (!s->divx_packed && !avctx->hwaccel)
659  ff_thread_finish_setup(avctx);
660 
663  goto frame_end;
664  }
665 
666  if (avctx->hwaccel) {
667  if ((ret = avctx->hwaccel->start_frame(avctx, s->gb.buffer, s->gb.buffer_end - s->gb.buffer)) < 0)
668  return ret;
669  }
670 
672 
673  //the second part of the wmv2 header contains the MB skip bits which are stored in current_picture->mb_type
674  //which is not available before ff_MPV_frame_start()
675  if (CONFIG_WMV2_DECODER && s->msmpeg4_version==5){
677  if(ret<0) return ret;
678  if(ret==1) goto intrax8_decoded;
679  }
680 
681  /* decode each macroblock */
682  s->mb_x=0;
683  s->mb_y=0;
684 
685  ret = decode_slice(s);
686  while(s->mb_y<s->mb_height){
687  if(s->msmpeg4_version){
688  if(s->slice_height==0 || s->mb_x!=0 || (s->mb_y%s->slice_height)!=0 || get_bits_left(&s->gb)<0)
689  break;
690  }else{
691  int prev_x=s->mb_x, prev_y=s->mb_y;
692  if(ff_h263_resync(s)<0)
693  break;
694  if (prev_y * s->mb_width + prev_x < s->mb_y * s->mb_width + s->mb_x)
695  s->er.error_occurred = 1;
696  }
697 
698  if(s->msmpeg4_version<4 && s->h263_pred)
700 
701  if (decode_slice(s) < 0) ret = AVERROR_INVALIDDATA;
702  }
703 
705  if(!CONFIG_MSMPEG4_DECODER || ff_msmpeg4_decode_ext_header(s, buf_size) < 0){
707  }
708 
710 frame_end:
711  /* divx 5.01+ bitstream reorder stuff */
712  if(s->codec_id==AV_CODEC_ID_MPEG4 && s->divx_packed){
713  int current_pos= s->gb.buffer == s->bitstream_buffer ? 0 : (get_bits_count(&s->gb)>>3);
714  int startcode_found=0;
715 
716  if(buf_size - current_pos > 7){
717  int i;
718  for(i=current_pos; i<buf_size-4; i++){
719  if(buf[i]==0 && buf[i+1]==0 && buf[i+2]==1 && buf[i+3]==0xB6){
720  startcode_found=!(buf[i+4]&0x40);
721  break;
722  }
723  }
724  }
725 
726  if(startcode_found){
728  &s->bitstream_buffer,
730  buf_size - current_pos + FF_INPUT_BUFFER_PADDING_SIZE);
731  if (!s->bitstream_buffer)
732  return AVERROR(ENOMEM);
733  memcpy(s->bitstream_buffer, buf + current_pos, buf_size - current_pos);
734  s->bitstream_buffer_size= buf_size - current_pos;
735  }
736  }
737 
738 intrax8_decoded:
739  ff_er_frame_end(&s->er);
740 
741  if (avctx->hwaccel) {
742  if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
743  return ret;
744  }
745 
746  ff_MPV_frame_end(s);
747 
748  if (!s->divx_packed && avctx->hwaccel)
749  ff_thread_finish_setup(avctx);
750 
753  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
754  if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
755  return ret;
758  } else if (s->last_picture_ptr != NULL) {
759  if ((ret = av_frame_ref(pict, &s->last_picture_ptr->f)) < 0)
760  return ret;
763  }
764 
765  if(s->last_picture_ptr || s->low_delay){
766  *got_frame = 1;
767  }
768 
769 #ifdef PRINT_FRAME_TIME
770 av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
771 #endif
772 
773  return (ret && (avctx->err_recognition & AV_EF_EXPLODE))?ret:get_consumed_bytes(s, buf_size);
774 }
775 
777 #if CONFIG_VAAPI
779 #endif
780 #if CONFIG_VDPAU
782 #endif
785 };
786 
788  .name = "h263",
789  .type = AVMEDIA_TYPE_VIDEO,
790  .id = AV_CODEC_ID_H263,
791  .priv_data_size = sizeof(MpegEncContext),
795  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
797  .flush = ff_mpeg_flush,
798  .max_lowres = 3,
799  .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
801 };
802 
804  .name = "h263p",
805  .type = AVMEDIA_TYPE_VIDEO,
806  .id = AV_CODEC_ID_H263P,
807  .priv_data_size = sizeof(MpegEncContext),
811  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
813  .flush = ff_mpeg_flush,
814  .max_lowres = 3,
815  .long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
817 };
int bitstream_buffer_size
Definition: mpegvideo.h:611
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: start.py:1
const struct AVCodec * codec
discard all frames except keyframes
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:3005
float v
int picture_number
Definition: mpegvideo.h:275
const char * s
Definition: avisynth_c.h:668
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:76
struct MpegEncContext MpegEncContext
MpegEncContext.
int vol_control_parameters
does the stream contain the low_delay flag, used to workaround buggy encoders
Definition: mpegvideo.h:594
mpeg2/4, h264 default
int coded_width
Bitstream width / height, may be different from width/height e.g.
av_cold int ff_dct_common_init(MpegEncContext *s)
Definition: mpegvideo.c:160
av_cold int ff_MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:993
#define SLICE_NOEND
no end marker or error found but mb count exceeded
Definition: mpegvideo.h:706
#define ER_MB_END
void ff_MPV_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:3314
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:198
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int decode_slice(MpegEncContext *s)
#define CODEC_CAP_TRUNCATED
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:154
void ff_er_frame_end(ERContext *s)
int msmpeg4_version
0=not msmpeg4, 1=mp41, 2=mp42, 3=mp43/divx3 4=wmv1/7 5=wmv2/8
Definition: mpegvideo.h:639
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
uint8_t * bitstream_buffer
Definition: mpegvideo.h:610
enum AVCodecID codec_id
Definition: mpegvideo.h:257
HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the b...
Definition: pixfmt.h:126
#define AV_EF_AGGRESSIVE
const uint8_t * buffer
Definition: get_bits.h:55
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
mpegvideo header.
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
int padding_bug_score
used to detect the VERY common padding bug in MPEG4
Definition: mpegvideo.h:601
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:282
#define FF_BUG_STD_QPEL
int qscale
QP.
Definition: mpegvideo.h:369
int quant_precision
Definition: mpegvideo.h:578
int ff_h263_decode_mb(MpegEncContext *s, int16_t block[6][64])
Definition: ituh263dec.c:605
#define FF_QSCALE_TYPE_MPEG1
int ff_mpeg4_decode_partitions(MpegEncContext *s)
Decode the first and second partition.
enum AVDiscard skip_frame
Skip decoding for selected frames.
void ff_mpeg4_clean_buffers(MpegEncContext *s)
Definition: mpeg4video.c:43
struct AVHWAccel * hwaccel
Hardware accelerator in use.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
#define FF_BUG_QPEL_CHROMA2
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2996
int context_reinit
Definition: mpegvideo.h:740
#define FF_BUG_UMP4
int ff_MPV_common_frame_size_change(MpegEncContext *s)
Definition: mpegvideo.c:1171
void ff_h263_decode_init_vlc(void)
Definition: ituh263dec.c:103
uint8_t
#define av_cold
Definition: attributes.h:78
enum OutputFormat out_format
output format
Definition: mpegvideo.h:249
end end
#define CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
#define ER_MB_ERROR
qpel_mc_func(* qpel_put)[16]
Definition: mpegvideo.h:228
const uint8_t * ff_h263_find_resync_marker(MpegEncContext *s, const uint8_t *p, const uint8_t *end)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:439
int resync_marker
could this stream contain resync markers
Definition: mpegvideo.h:591
int ff_intel_h263_decode_picture_header(MpegEncContext *s)
Definition: intelh263dec.c:25
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:343
GetBitContext last_resync_gb
used to search for the next resync marker
Definition: mpegvideo.h:529
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
mpeg1, jpeg, h263
uint8_t * data
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:193
#define FF_BUG_NO_PADDING
int flags2
AVCodecContext.flags2.
Definition: mpegvideo.h:261
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:277
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
#define CONFIG_H263I_DECODER
Definition: config.h:499
void ff_MPV_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1717
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
Definition: mpegvideo.h:267
int ff_wmv2_decode_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:113
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:861
qpel_mc_func put_qpel_pixels_tab[2][16]
Definition: dsputil.h:189
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:3300
#define CONFIG_H263P_DECODER
Definition: config.h:500
#define FF_BUG_QPEL_CHROMA
#define U(x)
#define FF_BUG_DIRECT_BLOCKSIZE
#define FF_IDCT_XVIDMMX
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:557
enum AVCodecID id
#define CODEC_FLAG_TRUNCATED
int has_b_frames
Size of the frame reordering buffer in the decoder.
int stream_codec_tag
internal stream_codec_tag upper case converted from avctx stream_codec_tag
Definition: mpegvideo.h:268
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:348
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Multithreading support functions.
#define AV_EF_EXPLODE
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
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:214
int partitioned_frame
is current frame partitioned
Definition: mpegvideo.h:589
qpel_mc_func avg_qpel_pixels_tab[2][16]
Definition: dsputil.h:190
AVCodec ff_h263_decoder
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:388
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
ERContext er
Definition: mpegvideo.h:742
Spectrum Plot time data
int capabilities
Codec capabilities.
int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
Definition: wmv2dec.c:133
int flags
CODEC_FLAG_*.
#define FF_BUG_AUTODETECT
autodetection
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:246
const char * name
Name of the codec implementation.
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:592
GetBitContext gb
Definition: mpegvideo.h:649
external API header
int ff_flv_decode_picture_header(MpegEncContext *s)
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:3066
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:527
uint8_t * error_status_table
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
#define ER_AC_ERROR
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:141
int err_recognition
Definition: mpegvideo.h:532
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:2170
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
void ff_mpeg_er_frame_start(MpegEncContext *s)
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:144
#define CONFIG_MPEG4_DECODER
Definition: config.h:530
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
int ff_h263_get_gob_height(MpegEncContext *s)
Get the GOB height based on picture height.
Definition: h263.c:377
static int get_consumed_bytes(MpegEncContext *s, int buf_size)
Return the number of bytes consumed for building the current frame.
int last_index
Definition: parser.h:31
int next_p_frame_damaged
set if the next p frame is damaged, to avoid showing trashed b frames
Definition: mpegvideo.h:531
ret
Definition: avfilter.c:821
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
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:347
unsigned int allocated_bitstream_buffer_size
Definition: mpegvideo.h:612
int size_in_bits
Definition: get_bits.h:57
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:255
int ff_msmpeg4_decode_ext_header(MpegEncContext *s, int buf_size)
Definition: msmpeg4dec.c:551
AVCodec ff_h263p_decoder
#define AV_RL32
MotionEstContext me
Definition: mpegvideo.h:437
int(* decode_mb)(struct MpegEncContext *s, int16_t block[6][64])
Definition: mpegvideo.h:702
#define SET_QPEL_FUNC(postfix1, postfix2)
int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function for encode/decode called after coding/decoding the header and before a frame is code...
Definition: mpegvideo.c:1493
av_cold int ff_h263_decode_end(AVCodecContext *avctx)
static void flush(AVCodecContext *avctx)
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:421
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:637
#define FF_IDCT_AUTO
NULL
Definition: eval.c:55
uint8_t * buffer
Definition: parser.h:29
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:48
int h263_flv
use flv h263 header
Definition: mpegvideo.h:255
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
main external API structure.
#define AV_CPU_FLAG_MMX
standard MMX
Definition: cpu.h:29
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:375
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:245
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:148
void * buf
Definition: avisynth_c.h:594
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:2164
#define SLICE_END
end marker found
Definition: mpegvideo.h:705
Picture * picture
main picture buffer
Definition: mpegvideo.h:285
int data_partitioning
data partitioning flag from header
Definition: mpegvideo.h:588
#define CONFIG_H263_DECODER
Definition: config.h:498
void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2907
#define FF_BUG_XVID_ILACE
synthesis window for stochastic i
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:203
#define CONFIG_MPEG4_VDPAU_DECODER
Definition: config.h:532
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:379
int context_initialized
Definition: mpegvideo.h:272
int slice_height
in macroblocks
Definition: mpegvideo.h:636
AVHWAccel * ff_find_hwaccel(enum AVCodecID codec_id, enum AVPixelFormat pix_fmt)
Return the hardware accelerated codec for codec codec_id and pixel format pix_fmt.
#define FF_BUG_DC_CLIP
#define CONFIG_FLV_DECODER
Definition: config.h:492
DSPContext dsp
pointers for accelerated dsp functions
Definition: mpegvideo.h:391
int ff_h263_decode_picture_header(MpegEncContext *s)
Definition: ituh263dec.c:871
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:30
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFilterBuffer 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.Buffer references ownership and permissions
#define MV_DIR_FORWARD
Definition: mpegvideo.h:417
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:377
int h263_pred
use mpeg4/h263 ac/dc predictions
Definition: mpegvideo.h:250
av_cold int ff_h263_decode_init(AVCodecContext *avctx)
int ff_h263_resync(MpegEncContext *s)
Decode the group of blocks / video packet header.
Definition: ituh263dec.c:231
#define FF_BUG_HPEL_CHROMA
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by an given frame.
Definition: frame.c:228
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:87
qpel_mc_func(* qpel_avg)[16]
Definition: mpegvideo.h:229
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
MpegEncContext.
Definition: mpegvideo.h:241
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:346
struct AVCodecContext * avctx
Definition: mpegvideo.h:243
discard all non reference
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:68
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:278
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:162
const uint8_t * buffer_end
Definition: get_bits.h:55
enum AVPixelFormat ff_h263_hwaccel_pixfmt_list_420[]
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:345
Bi-dir predicted.
Definition: avutil.h:218
int workaround_bugs
Work around bugs in encoders which sometimes cannot be detected automatically.
void ff_MPV_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1244
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:528
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:700
ParseContext parse_context
Definition: mpegvideo.h:534
void ff_vdpau_mpeg4_decode_picture(MpegEncContext *s, const uint8_t *buf, int buf_size)
#define FF_DEBUG_BUGS
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:139
#define CONFIG_WMV2_DECODER
Definition: config.h:625
int flags2
CODEC_FLAG2_*.
struct AVFrame f
Definition: mpegvideo.h:98
int flags
AVCodecContext.flags (HQ, MV4, ...)
Definition: mpegvideo.h:260
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:266
#define FRAME_SKIPPED
return value for header parsers if frame is not coded
Definition: mpegvideo.h:48
qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]
Definition: dsputil.h:191
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
int ff_mpeg4_decode_picture_header(MpegEncContext *s, GetBitContext *gb)
Decode mpeg4 headers.
int ff_msmpeg4_decode_picture_header(MpegEncContext *s)
Definition: msmpeg4dec.c:396
#define ER_AC_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.
#define CONFIG_MSMPEG4_DECODER
Definition: msmpeg4.h:59
int ff_find_unused_picture(MpegEncContext *s, int shared)
Definition: mpegvideo.c:1453
int ff_h263_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size)
Definition: h263_parser.c:30
#define AV_EF_BUFFER
#define FF_BUG_EDGE
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
This structure stores compressed data.
void ff_MPV_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:826