Merge commit '28096e0a806e57376541e6222d315619906e3c55'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 1 Nov 2013 10:33:36 +0000 (11:33 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 1 Nov 2013 11:59:08 +0000 (12:59 +0100)
* commit '28096e0a806e57376541e6222d315619906e3c55':
  h264: wait for initial complete frame before outputing frames

Conflicts:
doc/APIchanges
libavcodec/h264.c
libavcodec/mpegvideo.h
libavutil/frame.h
libavutil/version.h

See: a64b028aeb6579636e578ceb73f69b468bddb2f0 (as well as various later commits)
Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
doc/APIchanges
libavcodec/avcodec.h
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_refs.c
libavcodec/mpegvideo.h
libavcodec/options_table.h
libavutil/frame.h
libavutil/version.h

diff --cc doc/APIchanges
@@@ -15,26 -13,9 +15,29 @@@ libavutil:     2012-10-2
  
  API changes, most recent first:
  
+ 2013-08-xx - xxxxxxx - lavu 52.17.0 - avframe.h
+   Add AVFrame.flags and AV_FRAME_FLAG_CORRUPT.
 +2013-10-27 - xxxxxxx - lavc 55.39.100 - avcodec.h
 +  Add CODEC_CAP_DELAY support to avcodec_decode_subtitle2.
 +
 +2013-10-27 - xxxxxxx - lavu 52.48.100 - parseutils.h
 +  Add av_get_known_color_name().
 +
 +2013-10-17 - xxxxxxx - lavu 52.47.100 - opt.h
 +  Add AV_OPT_TYPE_CHANNEL_LAYOUT and channel layout option handlers
 +  av_opt_get_channel_layout() and av_opt_set_channel_layout().
 +
 +2013-10-xx - xxxxxxx -libswscale 2.5.101 - options.c
 +  Change default scaler to bicubic
 +
 +2013-10-03 - xxxxxxx - lavc 55.34.100 - avcodec.h
 +  Add av_codec_get_max_lowres()
 +
 +2013-10-02 - xxxxxxx - lavf 55.19.100 - avformat.h
 +  Add audio/video/subtitle AVCodec fields to AVFormatContext to force specific
 +  decoders
 +
  2013-08-xx - xxxxxxx - lavfi 3.11.0 - avfilter.h
    Add AVFilterGraph.execute and AVFilterGraph.opaque for custom slice threading
    implementations.
Simple merge
@@@ -361,10 -336,7 +361,10 @@@ static int ref_picture(H264Context *h, 
      dst->field_picture = src->field_picture;
      dst->needs_realloc = src->needs_realloc;
      dst->reference     = src->reference;
-     dst->sync          = src->sync;
 +    dst->crop          = src->crop;
 +    dst->crop_left     = src->crop_left;
 +    dst->crop_top      = src->crop_top;
+     dst->recovered     = src->recovered;
  
      return 0;
  fail:
@@@ -1902,7 -1825,7 +1902,7 @@@ static int decode_update_thread_context
      copy_picture_range(h->delayed_pic, h1->delayed_pic,
                         MAX_DELAYED_PIC_COUNT + 2, h, h1);
  
-     h->sync            = h1->sync;
 -    h->last_slice_type = h1->last_slice_type;
++    h->frame_recovered       = h1->frame_recovered;
  
      if (context_reinitialized)
          h264_set_parameter_from_sps(h);
      h->prev_frame_num        = h->frame_num;
      h->outputed_poc          = h->next_outputed_poc;
  
 -    h->frame_recovered       = h1->frame_recovered;
+     h->recovery_frame        = h1->recovery_frame;
      return err;
  }
  
@@@ -1964,9 -1878,6 +1966,9 @@@ static int h264_frame_start(H264Contex
  
      if ((ret = alloc_picture(h, pic)) < 0)
          return ret;
-     if(!h->sync && !h->avctx->hwaccel &&
++    if(!h->frame_recovered && !h->avctx->hwaccel &&
 +       !(h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU))
 +        avpriv_color_frame(&pic->f, c);
  
      h->cur_pic_ptr = pic;
      unref_picture(h, &h->cur_pic);
@@@ -2179,18 -2122,37 +2181,25 @@@ static void decode_postinit(H264Contex
          for (i = out_idx; h->delayed_pic[i]; i++)
              h->delayed_pic[i] = h->delayed_pic[i + 1];
      }
 -    memmove(h->last_pocs, &h->last_pocs[1],
 -            sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
 -    h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
      if (!out_of_order && pics > h->avctx->has_b_frames) {
          h->next_output_pic = out;
 -        if (out->mmco_reset) {
 -            if (out_idx > 0) {
 -                h->next_outputed_poc                    = out->poc;
 -                h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
 -            } else {
 -                h->next_outputed_poc = INT_MIN;
 -            }
 -        } else {
 -            if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f.key_frame) {
 -                h->next_outputed_poc = INT_MIN;
 -            } else {
 -                h->next_outputed_poc = out->poc;
 -            }
 -        }
 -        h->mmco_reset = 0;
 +        if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f.key_frame || h->delayed_pic[0]->mmco_reset)) {
 +            h->next_outputed_poc = INT_MIN;
 +        } else
 +            h->next_outputed_poc = out->poc;
      } else {
 -        av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
 +        av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
      }
  
-     if (h->next_output_pic && h->next_output_pic->sync) {
-         h->sync |= 2;
+     if (h->next_output_pic) {
+         if (h->next_output_pic->recovered) {
+             // We have reached an recovery point and all frames after it in
+             // display order are "recovered".
+             h->frame_recovered |= FRAME_RECOVERED_SEI;
+         }
++#if 0
+         h->next_output_pic->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
++#endif
      }
  
      if (setup_finished && !h->avctx->hwaccel)
@@@ -2781,11 -2736,8 +2790,11 @@@ static void flush_change(H264Context *h
      memset(h->default_ref_list[0], 0, sizeof(h->default_ref_list[0]));
      memset(h->default_ref_list[1], 0, sizeof(h->default_ref_list[1]));
      ff_h264_reset_sei(h);
-     h->recovery_frame= -1;
-     h->sync= 0;
+     h->recovery_frame = -1;
+     h->frame_recovered = 0;
 +    h->list_count = 0;
 +    h->current_slice = 0;
 +    h->mmco_reset = 1;
  }
  
  /* forget old pics after a seek */
@@@ -4838,30 -4627,25 +4847,38 @@@ again
                  if ((err = decode_slice_header(hx, h)))
                      break;
  
 -                if (h->sei_recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
 +                if (h->sei_recovery_frame_cnt >= 0 && (h->frame_num != h->sei_recovery_frame_cnt || hx->slice_type_nos != AV_PICTURE_TYPE_I))
 +                    h->valid_recovery_point = 1;
 +
 +                if (   h->sei_recovery_frame_cnt >= 0
 +                    && (   h->recovery_frame<0
 +                        || ((h->recovery_frame - h->frame_num) & ((1 << h->sps.log2_max_frame_num)-1)) > h->sei_recovery_frame_cnt)) {
-                     h->recovery_frame = (h->frame_num + h->sei_recovery_frame_cnt) %
-                                         (1 << h->sps.log2_max_frame_num);
+                     h->recovery_frame = (h->frame_num + h->sei_recovery_frame_cnt) &
+                                         ((1 << h->sps.log2_max_frame_num) - 1);
 +
 +                    if (!h->valid_recovery_point)
 +                        h->recovery_frame = h->frame_num;
                  }
  
                  h->cur_pic_ptr->f.key_frame |=
 -                    (hx->nal_unit_type == NAL_IDR_SLICE) ||
 -                    (h->sei_recovery_frame_cnt >= 0);
 +                        (hx->nal_unit_type == NAL_IDR_SLICE);
  
-                 if (h->recovery_frame == h->frame_num) {
-                     h->cur_pic_ptr->sync |= 1;
-                     h->recovery_frame = -1;
+                 if (hx->nal_unit_type == NAL_IDR_SLICE ||
+                     h->recovery_frame == h->frame_num) {
+                     h->recovery_frame         = -1;
+                     h->cur_pic_ptr->recovered = 1;
                  }
-                 h->sync |= !!h->cur_pic_ptr->f.key_frame;
-                 h->sync |= 3*!!(avctx->flags2 & CODEC_FLAG2_SHOW_ALL);
-                 h->cur_pic_ptr->sync |= h->sync;
+                 // If we have an IDR, all frames after it in decoded order are
+                 // "recovered".
+                 if (hx->nal_unit_type == NAL_IDR_SLICE)
+                     h->frame_recovered |= FRAME_RECOVERED_IDR;
++                h->frame_recovered |= 3*!!(avctx->flags2 & CODEC_FLAG2_SHOW_ALL);
++                h->frame_recovered |= 3*!!(avctx->flags & CODEC_FLAG_OUTPUT_CORRUPT);
++#if 1
++                h->cur_pic_ptr->recovered |= h->frame_recovered;
++#else
+                 h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
++#endif
  
                  if (h->current_slice == 1) {
                      if (!(avctx->flags2 & CODEC_FLAG2_CHUNKS))
@@@ -5133,10 -4876,13 +5150,18 @@@ not_extra
  
          field_end(h, 0);
  
 +        /* Wait for second field. */
          *got_frame = 0;
-         if (h->next_output_pic && (h->next_output_pic->sync || h->sync>1)) {
 -        if (h->next_output_pic && ((avctx->flags & CODEC_FLAG_OUTPUT_CORRUPT) ||
++#if 1
++        if (h->next_output_pic && (h->next_output_pic->recovered || h->frame_recovered>1)) {
++#else
++        if (h->next_output_pic && (
+                                    h->next_output_pic->recovered)) {
++#endif
+             if (!h->next_output_pic->recovered)
+                 h->next_output_pic->f.flags |= AV_FRAME_FLAG_CORRUPT;
 -            ret = output_frame(h, pict, &h->next_output_pic->f);
 +            ret = output_frame(h, pict, h->next_output_pic);
              if (ret < 0)
                  return ret;
              *got_frame = 1;
@@@ -641,6 -610,7 +641,14 @@@ typedef struct H264Context 
       * frames.
       */
      int sei_recovery_frame_cnt;
++    /**
++     * Are the SEI recovery points looking valid.
++     */
++    int valid_recovery_point;
++
++    FPA sei_fpa;
++
      /**
       * recovery_frame is the frame_num at which the next frame should
       * be fully constructed.
  
      int cur_chroma_format_idc;
      uint8_t *bipred_scratchpad;
-     int sync;                      ///< did we had a keyframe or recovery point
 +
 +    int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
 +
 +    uint8_t parse_history[4];
 +    int parse_history_count;
 +    int parse_last_mb;
      uint8_t *edge_emu_buffer;
      int16_t *dc_val_base;
  
@@@ -731,13 -707,6 +731,13 @@@ int ff_h264_execute_ref_pic_marking(H26
  
      print_short_term(h);
      print_long_term(h);
-         h->cur_pic_ptr->sync |= 1;
 +
 +    if(err >= 0 && h->long_ref_count==0 && h->short_ref_count<=2 && h->pps.ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) && h->cur_pic_ptr->f.pict_type == AV_PICTURE_TYPE_I){
-             h->sync = 2;
++        h->cur_pic_ptr->recovered |= 1;
 +        if(!h->avctx->has_b_frames)
++            h->frame_recovered = 2;
 +    }
 +
      return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
  }
  
@@@ -177,10 -172,7 +176,11 @@@ typedef struct Picture
  
      int reference;
      int shared;
+     int recovered;              ///< Picture at IDR or recovery point + recovery count
 +
 +    int crop;
 +    int crop_left;
 +    int crop_top;
  } Picture;
  
  /**
@@@ -70,12 -68,11 +70,13 @@@ static const AVOption avcodec_options[
  {"aic", "H.263 advanced intra coding / MPEG-4 AC prediction", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V|E, "flags"},
  {"ilme", "interlaced motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V|E, "flags"},
  {"cgop", "closed GOP", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"output_corrupt", "Output even potentially corrupted frames", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_OUTPUT_CORRUPT }, INT_MIN, INT_MAX, V|D, "flags"},
  {"fast", "allow non-spec-compliant speedup tricks", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V|E, "flags2"},
  {"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},
 -{"ignorecrop", "ignore cropping information from sps", 1, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_IGNORE_CROP }, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"ignorecrop", "ignore cropping information from sps", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_IGNORE_CROP }, INT_MIN, INT_MAX, V|D, "flags2"},
  {"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},
 +{"chunks", "Frame data might be split into multiple chunks", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_CHUNKS }, INT_MIN, INT_MAX, V|D, "flags2"},
 +{"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},
  {"me_method", "set motion estimation method", OFFSET(me_method), AV_OPT_TYPE_INT, {.i64 = ME_EPZS }, INT_MIN, INT_MAX, V|E, "me_method"},
  {"zero", "zero motion estimation (fastest)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_ZERO }, INT_MIN, INT_MAX, V|E, "me_method" },
  {"full", "full motion estimation (slowest)", 0, AV_OPT_TYPE_CONST, {.i64 = ME_FULL }, INT_MIN, INT_MAX, V|E, "me_method" },
@@@ -386,137 -351,17 +386,147 @@@ typedef struct AVFrame 
      AVFrameSideData **side_data;
      int            nb_side_data;
  
+ /**
+  * The frame data may be corrupted, e.g. due to decoding errors.
+  */
+ #define AV_FRAME_FLAG_CORRUPT       (1 << 0)
+     /**
+      * Frame flags, a combination of AV_FRAME_FLAG_*
+      */
+     int flags;
++
 +    /**
 +     * frame timestamp estimated using various heuristics, in stream time base
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_best_effort_timestamp(frame)
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int64_t best_effort_timestamp;
 +
 +    /**
 +     * reordered pos from the last AVPacket that has been input into the decoder
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_pkt_pos(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_pos;
 +
 +    /**
 +     * duration of the corresponding packet, expressed in
 +     * AVStream->time_base units, 0 if unknown.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_pkt_duration(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int64_t pkt_duration;
 +
 +    /**
 +     * metadata.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_metadata(frame)
 +     * - encoding: Set by user.
 +     * - decoding: Set by libavcodec.
 +     */
 +    AVDictionary *metadata;
 +
 +    /**
 +     * decode error flags of the frame, set to a combination of
 +     * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there
 +     * were errors during the decoding.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_decode_error_flags(frame)
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int decode_error_flags;
 +#define FF_DECODE_ERROR_INVALID_BITSTREAM   1
 +#define FF_DECODE_ERROR_MISSING_REFERENCE   2
 +
 +    /**
 +     * number of audio channels, only used for audio.
 +     * Code outside libavcodec should access this field using:
 +     * av_frame_get_channels(frame)
 +     * - encoding: unused
 +     * - decoding: Read by user.
 +     */
 +    int channels;
 +
 +    /**
 +     * size of the corresponding packet containing the compressed
 +     * frame. It must be accessed using av_frame_get_pkt_size() and
 +     * av_frame_set_pkt_size().
 +     * It is set to a negative value if unknown.
 +     * - encoding: unused
 +     * - decoding: set by libavcodec, read by user.
 +     */
 +    int pkt_size;
 +
 +    /**
 +     * YUV colorspace type.
 +     * It must be accessed using av_frame_get_colorspace() and
 +     * av_frame_set_colorspace().
 +     * - encoding: Set by user
 +     * - decoding: Set by libavcodec
 +     */
 +    enum AVColorSpace colorspace;
 +
 +    /**
 +     * MPEG vs JPEG YUV range.
 +     * It must be accessed using av_frame_get_color_range() and
 +     * av_frame_set_color_range().
 +     * - encoding: Set by user
 +     * - decoding: Set by libavcodec
 +     */
 +    enum AVColorRange color_range;
 +
 +
 +    /**
 +     * Not to be accessed directly from outside libavutil
 +     */
 +    AVBufferRef *qp_table_buf;
  } AVFrame;
  
 +/**
 + * Accessors for some AVFrame fields.
 + * The position of these field in the structure is not part of the ABI,
 + * they should not be accessed directly outside libavcodec.
 + */
 +int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame);
 +void    av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val);
 +int64_t av_frame_get_pkt_duration         (const AVFrame *frame);
 +void    av_frame_set_pkt_duration         (AVFrame *frame, int64_t val);
 +int64_t av_frame_get_pkt_pos              (const AVFrame *frame);
 +void    av_frame_set_pkt_pos              (AVFrame *frame, int64_t val);
 +int64_t av_frame_get_channel_layout       (const AVFrame *frame);
 +void    av_frame_set_channel_layout       (AVFrame *frame, int64_t val);
 +int     av_frame_get_channels             (const AVFrame *frame);
 +void    av_frame_set_channels             (AVFrame *frame, int     val);
 +int     av_frame_get_sample_rate          (const AVFrame *frame);
 +void    av_frame_set_sample_rate          (AVFrame *frame, int     val);
 +AVDictionary *av_frame_get_metadata       (const AVFrame *frame);
 +void          av_frame_set_metadata       (AVFrame *frame, AVDictionary *val);
 +int     av_frame_get_decode_error_flags   (const AVFrame *frame);
 +void    av_frame_set_decode_error_flags   (AVFrame *frame, int     val);
 +int     av_frame_get_pkt_size(const AVFrame *frame);
 +void    av_frame_set_pkt_size(AVFrame *frame, int val);
 +AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame);
 +int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type);
 +int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type);
 +enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame);
 +void    av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val);
 +enum AVColorRange av_frame_get_color_range(const AVFrame *frame);
 +void    av_frame_set_color_range(AVFrame *frame, enum AVColorRange val);
 +
 +/**
 + * Get the name of a colorspace.
 + * @return a static string identifying the colorspace; can be NULL.
 + */
 +const char *av_get_colorspace_name(enum AVColorSpace val);
 +
  /**
   * Allocate an AVFrame and set its fields to default values.  The resulting
   * struct must be freed using av_frame_free().
@@@ -74,9 -36,9 +74,9 @@@
   * @{
   */
  
 -#define LIBAVUTIL_VERSION_MAJOR 52
 -#define LIBAVUTIL_VERSION_MINOR 17
 -#define LIBAVUTIL_VERSION_MICRO  0
 +#define LIBAVUTIL_VERSION_MAJOR  52
- #define LIBAVUTIL_VERSION_MINOR  48
++#define LIBAVUTIL_VERSION_MINOR  49
 +#define LIBAVUTIL_VERSION_MICRO 100
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                 LIBAVUTIL_VERSION_MINOR, \