Merge commit '728d90a0c1973661a9e73da697bf4f90c9d19577'
authorClément Bœsch <u@pkh.me>
Sat, 18 Jun 2016 12:04:17 +0000 (14:04 +0200)
committerClément Bœsch <u@pkh.me>
Sat, 18 Jun 2016 12:04:55 +0000 (14:04 +0200)
* commit '728d90a0c1973661a9e73da697bf4f90c9d19577':
  h264: decouple h264_sei from the h264 decoder

Main changes:

- SEI decoding doesn't have access to the debug flag in the codec context so a
  few logging are dropped.

- naming of quincunx_sampling_flag and frame_packing_arrangement_type are kept
  as they are in FFmpeg instead of respectively quincunx_subsampling and
  arrangement_type used in Libav because the former match the specifications.

- don't reset the x264 build info once read in order to fix
  fate-h264-lossless (change by Hendrik)

- H264Context.has_recovery_point and deprecated
  AVCodecContext.dtg_active_format are set after ff_h264_sei_decode()
  based on the SEI state since ff_h264_sei_decode() doesn't have access
  to H264Context anymore.

- frame_packing_arrangement_type is not checked against <= 0 in
  decode_postinit() since it is always read as a positive value with
  get_bits(). This fixes a -Wtype-limits warning by GCC spotted by
  Michael.

Side Notes:

- tested that ffprobe on the file from ticket #3652 still returns 4
  keyframes
- tested that playback from ticket #3063 still works

Merged-by: Clément Bœsch <clement@stupeflix.com>
Signed-off-by: Hendrik Leppkes <h.leppkes@gmail.com>
1  2 
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_direct.c
libavcodec/h264_mb.c
libavcodec/h264_parser.c
libavcodec/h264_sei.c
libavcodec/h264_sei.h
libavcodec/h264_slice.c

@@@ -430,11 -400,8 +430,11 @@@ static int h264_init_context(AVCodecCon
      h->workaround_bugs       = avctx->workaround_bugs;
      h->flags                 = avctx->flags;
      h->poc.prev_poc_msb      = 1 << 16;
-     h->x264_build            = -1;
      h->recovery_frame        = -1;
      h->frame_recovered       = 0;
-     h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
 +    h->poc.prev_frame_num    = -1;
++    h->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1;
++    h->sei.unregistered.x264_build = -1;
  
      h->next_outputed_poc = INT_MIN;
      for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
@@@ -637,11 -588,11 +638,11 @@@ static void decode_postinit(H264Contex
          /* Derive top_field_first from field pocs. */
          cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
      } else {
 -        if (cur->f->interlaced_frame || sps->pic_struct_present_flag) {
 +        if (sps->pic_struct_present_flag) {
              /* Use picture timing SEI information. Even if it is a
               * information of a past frame, better than nothing. */
-             if (h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
-                 h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
+             if (h->sei.picture_timing.pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
+                 h->sei.picture_timing.pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
                  cur->f->top_field_first = 1;
              else
                  cur->f->top_field_first = 0;
          }
      }
  
-     if (h->sei_frame_packing_present &&
-         h->frame_packing_arrangement_type >= 0 &&
-         h->frame_packing_arrangement_type <= 6 &&
-         h->content_interpretation_type > 0 &&
-         h->content_interpretation_type < 3) {
+     if (h->sei.frame_packing.present &&
 -        h->sei.frame_packing.arrangement_type >= 0 &&
 -        h->sei.frame_packing.arrangement_type <= 6 &&
++        h->sei.frame_packing.frame_packing_arrangement_type <= 6 &&
+         h->sei.frame_packing.content_interpretation_type > 0 &&
+         h->sei.frame_packing.content_interpretation_type < 3) {
+         H264SEIFramePacking *fp = &h->sei.frame_packing;
          AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
 -        if (!stereo)
 -            return;
 -
 -        switch (fp->arrangement_type) {
 +        if (stereo) {
-         switch (h->frame_packing_arrangement_type) {
++        switch (fp->frame_packing_arrangement_type) {
          case 0:
              stereo->type = AV_STEREO3D_CHECKERBOARD;
              break;
              stereo->type = AV_STEREO3D_LINES;
              break;
          case 3:
-             if (h->quincunx_subsampling)
 -            if (fp->quincunx_subsampling)
++            if (fp->quincunx_sampling_flag)
                  stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
              else
                  stereo->type = AV_STEREO3D_SIDEBYSIDE;
              break;
          }
  
-         if (h->content_interpretation_type == 2)
+         if (fp->content_interpretation_type == 2)
              stereo->flags = AV_STEREO3D_FLAG_INVERT;
 +        }
      }
  
-     if (h->sei_display_orientation_present &&
-         (h->sei_anticlockwise_rotation || h->sei_hflip || h->sei_vflip)) {
-         double angle = h->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
+     if (h->sei.display_orientation.present &&
+         (h->sei.display_orientation.anticlockwise_rotation ||
+          h->sei.display_orientation.hflip ||
+          h->sei.display_orientation.vflip)) {
+         H264SEIDisplayOrientation *o = &h->sei.display_orientation;
+         double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
          AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
                                                             AV_FRAME_DATA_DISPLAYMATRIX,
                                                             sizeof(int32_t) * 9);
 -        if (!rotation)
 -            return;
 -
 -        av_display_rotation_set((int32_t *)rotation->data, angle);
 -        av_display_matrix_flip((int32_t *)rotation->data,
 -                               o->hflip, o->vflip);
 +        if (rotation) {
 +            av_display_rotation_set((int32_t *)rotation->data, angle);
 +            av_display_matrix_flip((int32_t *)rotation->data,
-                                    h->sei_hflip, h->sei_vflip);
++                                   o->hflip, o->vflip);
 +        }
      }
  
-     if (h->sei_reguserdata_afd_present) {
+     if (h->sei.afd.present) {
          AVFrameSideData *sd = av_frame_new_side_data(cur->f, AV_FRAME_DATA_AFD,
                                                       sizeof(uint8_t));
 -        if (!sd)
 -            return;
  
 -        *sd->data = h->sei.afd.active_format_description;
 -        h->sei.afd.present = 0;
 +        if (sd) {
-             *sd->data = h->active_format_description;
-             h->sei_reguserdata_afd_present = 0;
++            *sd->data = h->sei.afd.active_format_description;
++            h->sei.afd.present = 0;
 +        }
      }
  
-     if (h->a53_caption) {
+     if (h->sei.a53_caption.a53_caption) {
+         H264SEIA53Caption *a53 = &h->sei.a53_caption;
          AVFrameSideData *sd = av_frame_new_side_data(cur->f,
                                                       AV_FRAME_DATA_A53_CC,
-                                                      h->a53_caption_size);
+                                                      a53->a53_caption_size);
 -        if (!sd)
 -            return;
 -
 -        memcpy(sd->data, a53->a53_caption, a53->a53_caption_size);
 +        if (sd)
-             memcpy(sd->data, h->a53_caption, h->a53_caption_size);
-         av_freep(&h->a53_caption);
-         h->a53_caption_size = 0;
++            memcpy(sd->data, a53->a53_caption, a53->a53_caption_size);
+         av_freep(&a53->a53_caption);
+         a53->a53_caption_size = 0;
 +        h->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
      }
  
 +    cur->mmco_reset = h->mmco_reset;
 +    h->mmco_reset = 0;
 +
      // FIXME do something with unavailable reference frames
  
      /* Sort B-frames into display order */
@@@ -847,25 -833,12 +852,25 @@@ void ff_h264_flush_change(H264Context *
      h->next_outputed_poc = INT_MIN;
      h->prev_interlaced_frame = 1;
      idr(h);
 -    if (h->cur_pic_ptr)
 +
 +    h->poc.prev_frame_num = -1;
 +    if (h->cur_pic_ptr) {
          h->cur_pic_ptr->reference = 0;
 +        for (j=i=0; h->delayed_pic[i]; i++)
 +            if (h->delayed_pic[i] != h->cur_pic_ptr)
 +                h->delayed_pic[j++] = h->delayed_pic[i];
 +        h->delayed_pic[j] = NULL;
 +    }
 +    ff_h264_unref_picture(h, &h->last_pic_for_ec);
 +
      h->first_field = 0;
-     ff_h264_reset_sei(h);
+     ff_h264_sei_uninit(&h->sei);
      h->recovery_frame = -1;
      h->frame_recovered = 0;
 +    h->current_slice = 0;
 +    h->mmco_reset = 1;
 +    for (i = 0; i < h->nb_slice_ctx; i++)
 +        h->slice_ctx[i].list_count = 0;
  }
  
  /* forget old pics after a seek */
@@@ -1005,16 -932,9 +1010,16 @@@ static int decode_nal_units(H264Contex
          h->current_slice = 0;
          if (!h->first_field)
              h->cur_pic_ptr = NULL;
-         ff_h264_reset_sei(h);
+         ff_h264_sei_uninit(&h->sei);
      }
  
 +    if (h->nal_length_size == 4) {
 +        if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
 +            h->is_avc = 0;
 +        }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
 +            h->is_avc = 1;
 +    }
 +
      ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
                                  h->nal_length_size, avctx->codec_id);
      if (ret < 0) {
@@@ -1096,23 -989,15 +1101,25 @@@ again
              if ((err = ff_h264_decode_slice_header(h, sl)))
                  break;
  
-             if (h->sei_recovery_frame_cnt >= 0) {
-                 if (h->poc.frame_num != h->sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
 -            if (h->sei.recovery_point.recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
 -                h->recovery_frame = (h->poc.frame_num + h->sei.recovery_point.recovery_frame_cnt) &
 -                                    ((1 << h->ps.sps->log2_max_frame_num) - 1);
++            if (h->sei.recovery_point.recovery_frame_cnt >= 0) {
++                const int sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
++
++                if (h->poc.frame_num != sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
 +                    h->valid_recovery_point = 1;
 +
 +                if (   h->recovery_frame < 0
-                     || av_mod_uintp2(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > h->sei_recovery_frame_cnt) {
-                     h->recovery_frame = av_mod_uintp2(h->poc.frame_num + h->sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
++                    || av_mod_uintp2(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > sei_recovery_frame_cnt) {
++                    h->recovery_frame = av_mod_uintp2(h->poc.frame_num + sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
 +
 +                    if (!h->valid_recovery_point)
 +                        h->recovery_frame = h->poc.frame_num;
 +                }
              }
  
 -            h->cur_pic_ptr->f->key_frame |=
 -                (nal->type == NAL_IDR_SLICE) || (h->sei.recovery_point.recovery_frame_cnt >= 0);
 +            h->cur_pic_ptr->f->key_frame |= (nal->type == NAL_IDR_SLICE);
  
 -            if (nal->type == NAL_IDR_SLICE || h->recovery_frame == h->poc.frame_num) {
 +            if (nal->type == NAL_IDR_SLICE ||
 +                (h->recovery_frame == h->poc.frame_num && nal->ref_idc)) {
                  h->recovery_frame         = -1;
                  h->cur_pic_ptr->recovered = 1;
              }
          case NAL_DPB:
          case NAL_DPC:
              avpriv_request_sample(avctx, "data partitioning");
 -            ret = AVERROR(ENOSYS);
 -            goto end;
              break;
          case NAL_SEI:
-             h->gb = nal->gb;
-             ret = ff_h264_decode_sei(h);
+             ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
++            h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1;
 +            if (avctx->debug & FF_DEBUG_GREEN_MD)
-                 debug_green_metadata(&h->sei_green_metadata, h->avctx);
++                debug_green_metadata(&h->sei.green_metadata, h->avctx);
++#if FF_API_AFD
++FF_DISABLE_DEPRECATION_WARNINGS
++            h->avctx->dtg_active_format = h->sei.afd.active_format_description;
++FF_ENABLE_DEPRECATION_WARNINGS
++#endif /* FF_API_AFD */
              if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
                  goto end;
              break;
@@@ -1314,26 -1123,14 +1326,26 @@@ static int output_frame(H264Context *h
      if (ret < 0)
          return ret;
  
-     av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(h), 0);
 -    if (!h->ps.sps || !h->ps.sps->crop)
++    av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
 +
 +    h->backup_width   = h->avctx->width;
 +    h->backup_height  = h->avctx->height;
 +    h->backup_pix_fmt = h->avctx->pix_fmt;
 +
 +    h->avctx->width   = dst->width;
 +    h->avctx->height  = dst->height;
 +    h->avctx->pix_fmt = dst->format;
 +
 +    if (srcp->sei_recovery_frame_cnt == 0)
 +        dst->key_frame = 1;
 +    if (!srcp->crop)
          return 0;
  
 -    for (i = 0; i < 3; i++) {
 -        int hshift = (i > 0) ? h->chroma_x_shift : 0;
 -        int vshift = (i > 0) ? h->chroma_y_shift : 0;
 -        int off    = ((h->ps.sps->crop_left >> hshift) << h->pixel_shift) +
 -                     (h->ps.sps->crop_top >> vshift) * dst->linesize[i];
 +    for (i = 0; i < desc->nb_components; i++) {
 +        int hshift = (i > 0) ? desc->log2_chroma_w : 0;
 +        int vshift = (i > 0) ? desc->log2_chroma_h : 0;
 +        int off    = ((srcp->crop_left >> hshift) << h->pixel_shift) +
 +                      (srcp->crop_top  >> vshift) * dst->linesize[i];
          dst->data[i] += off;
      }
      return 0;
@@@ -1532,9 -1242,6 +1544,8 @@@ av_cold void ff_h264_free_context(H264C
      av_freep(&h->slice_ctx);
      h->nb_slice_ctx = 0;
  
-     h->a53_caption_size = 0;
-     av_freep(&h->a53_caption);
++    ff_h264_sei_uninit(&h->sei);
 +
      for (i = 0; i < MAX_SPS_COUNT; i++)
          av_buffer_unref(&h->ps.sps_list[i]);
  
@@@ -615,15 -517,13 +546,13 @@@ typedef struct H264Context 
      uint8_t field_scan[16];
      uint8_t field_scan8x8[64];
      uint8_t field_scan8x8_cavlc[64];
 -    const uint8_t *zigzag_scan_q0;
 -    const uint8_t *zigzag_scan8x8_q0;
 -    const uint8_t *zigzag_scan8x8_cavlc_q0;
 -    const uint8_t *field_scan_q0;
 -    const uint8_t *field_scan8x8_q0;
 -    const uint8_t *field_scan8x8_cavlc_q0;
 +    uint8_t zigzag_scan_q0[16];
 +    uint8_t zigzag_scan8x8_q0[64];
 +    uint8_t zigzag_scan8x8_cavlc_q0[64];
 +    uint8_t field_scan_q0[16];
 +    uint8_t field_scan8x8_q0[64];
 +    uint8_t field_scan8x8_cavlc_q0[64];
  
-     int x264_build;
      int mb_y;
      int mb_height, mb_width;
      int mb_stride;
       */
      int prev_interlaced_frame;
  
-     /**
-      * frame_packing_arrangment SEI message
-      */
-     int sei_frame_packing_present;
-     int frame_packing_arrangement_type;
-     int content_interpretation_type;
-     int quincunx_subsampling;
-     /**
-      * display orientation SEI message
-      */
-     int sei_display_orientation_present;
-     int sei_anticlockwise_rotation;
-     int sei_hflip, sei_vflip;
-     /**
-      * User data registered by Rec. ITU-T T.35 SEI
-      */
-     int sei_reguserdata_afd_present;
-     uint8_t active_format_description;
-     int a53_caption_size;
-     uint8_t *a53_caption;
-     /**
-      * Bit set of clock types for fields/frames in picture timing SEI message.
-      * For each found ct_type, appropriate bit is set (e.g., bit 1 for
-      * interlaced).
-      */
-     int sei_ct_type;
-     /**
-      * dpb_output_delay in picture timing SEI message, see H.264 C.2.2
-      */
-     int sei_dpb_output_delay;
-     /**
-      * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
-      */
-     int sei_cpb_removal_delay;
-     /**
-      * recovery_frame_cnt from SEI message
-      *
-      * Set to -1 if no recovery point SEI message found or to number of frames
-      * before playback synchronizes. Frames having recovery point are key
-      * 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.
       * slices) anymore */
      int setup_finished;
  
-     // Timestamp stuff
-     int sei_buffering_period_present;   ///< Buffering period SEI flag
-     int initial_cpb_removal_delay[32];  ///< Initial timestamps for CPBs
 +    int cur_chroma_format_idc;
 +    int cur_bit_depth_luma;
 +    int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
 +
 +    uint8_t parse_history[6];
 +    int parse_history_count;
 +    int parse_last_mb;
 +
      int enable_er;
  
+     H264SEIContext sei;
      AVBufferPool *qscale_table_pool;
      AVBufferPool *mb_type_pool;
      AVBufferPool *motion_val_pool;
      /* Motion Estimation */
      qpel_mc_func (*qpel_put)[16];
      qpel_mc_func (*qpel_avg)[16];
-     /*Green Metadata */
-     H264SEIGreenMetaData sei_green_metadata;
 +
  } H264Context;
  
  extern const uint16_t ff_h264_mb_sizes[4];
Simple merge
@@@ -636,12 -635,7 +636,12 @@@ static av_always_inline void hl_decode_
                  uint8_t *const ptr = dest_y + block_offset[i];
                  const int dir      = sl->intra4x4_pred_mode_cache[scan8[i]];
                  if (transform_bypass && h->ps.sps->profile_idc == 244 && dir <= 1) {
-                     if (h->x264_build != -1) {
 -                    h->hpc.pred8x8l_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
++                    if (h->sei.unregistered.x264_build != -1) {
 +                        h->hpc.pred8x8l_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
 +                    } else
 +                        h->hpc.pred8x8l_filter_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift),
 +                                                        (sl-> topleft_samples_available << i) & 0x8000,
 +                                                        (sl->topright_samples_available << i) & 0x4000, linesize);
                  } else {
                      const int nnz = sl->non_zero_count_cache[scan8[i + p * 16]];
                      h->hpc.pred8x8l[dir](ptr, (sl->topleft_samples_available << i) & 0x8000,
@@@ -249,8 -218,7 +251,8 @@@ static inline int parse_nal_units(AVCod
      s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
  
      h->avctx = avctx;
-     ff_h264_reset_sei(h);
-     h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
+     ff_h264_sei_uninit(&p->sei);
++    h->sei.frame_packing.frame_packing_arrangement_cancel_flag = -1;
  
      if (!buf_size)
          return 0;
              p->poc.prev_poc_lsb          = 0;
          /* fall through */
          case NAL_SLICE:
 -            get_ue_golomb(&nal.gb);  // skip first_mb_in_slice
 +            get_ue_golomb_long(&nal.gb);  // skip first_mb_in_slice
              slice_type   = get_ue_golomb_31(&nal.gb);
              s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
-             if (h->sei_recovery_frame_cnt >= 0) {
+             if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
                  /* key frame, since recovery_frame_cnt is set */
                  s->key_frame = 1;
              }
@@@ -601,12 -523,10 +598,12 @@@ static int h264_parse(AVCodecParserCont
  
      parse_nal_units(s, avctx, buf, buf_size);
  
-     if (h->sei_cpb_removal_delay >= 0) {
-         s->dts_sync_point    = h->sei_buffering_period_present;
-         s->dts_ref_dts_delta = h->sei_cpb_removal_delay;
-         s->pts_dts_delta     = h->sei_dpb_output_delay;
 +    if (avctx->framerate.num)
 +        avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
+     if (p->sei.picture_timing.cpb_removal_delay >= 0) {
+         s->dts_sync_point    = p->sei.buffering_period.present;
+         s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;
+         s->pts_dts_delta     = p->sei.picture_timing.dpb_output_delay;
      } else {
          s->dts_sync_point    = INT_MIN;
          s->dts_ref_dts_delta = INT_MIN;
@@@ -666,9 -580,11 +663,11 @@@ static void h264_close(AVCodecParserCon
      ParseContext *pc = &p->pc;
      int i;
  
 -    av_free(pc->buffer);
 +    av_freep(&pc->buffer);
      ff_h264_free_context(h);
  
+     ff_h264_sei_uninit(&p->sei);
      for (i = 0; i < FF_ARRAY_ELEMS(p->ps.sps_list); i++)
          av_buffer_unref(&p->ps.sps_list[i]);
  
@@@ -34,39 -36,33 +36,41 @@@ static const uint8_t sei_num_clock_ts_t
      1, 1, 1, 2, 2, 3, 3, 2, 3
  };
  
- void ff_h264_reset_sei(H264Context *h)
+ void ff_h264_sei_uninit(H264SEIContext *h)
  {
-     h->sei_recovery_frame_cnt       = -1;
-     h->sei_dpb_output_delay         =  0;
-     h->sei_cpb_removal_delay        = -1;
-     h->sei_buffering_period_present =  0;
-     h->sei_frame_packing_present    =  0;
-     h->sei_display_orientation_present = 0;
-     h->sei_reguserdata_afd_present  =  0;
-     h->a53_caption_size = 0;
-     av_freep(&h->a53_caption);
 -    h->unregistered.x264_build           = -1;
+     h->recovery_point.recovery_frame_cnt = -1;
+     h->picture_timing.dpb_output_delay  = 0;
+     h->picture_timing.cpb_removal_delay = -1;
+     h->buffering_period.present    = 0;
+     h->frame_packing.present       = 0;
+     h->display_orientation.present = 0;
+     h->afd.present                 =  0;
+     h->a53_caption.a53_caption_size = 0;
+     av_freep(&h->a53_caption.a53_caption);
  }
  
- static int decode_picture_timing(H264Context *h)
+ static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb,
 -                                 const SPS *sps, void *logctx)
++                                 const H264ParamSets *ps, void *logctx)
  {
-     const SPS *sps = h->ps.sps;
 -    if (!sps)
 -        return AVERROR_INVALIDDATA;
 +    int i;
++    const SPS *sps = ps->sps;
 +
 +    for (i = 0; i<MAX_SPS_COUNT; i++)
-         if ((!sps || !sps->log2_max_frame_num) && h->ps.sps_list[i])
-             sps = (const SPS *)h->ps.sps_list[i]->data;
++        if ((!sps || !sps->log2_max_frame_num) && ps->sps_list[i])
++            sps = (const SPS *)ps->sps_list[i]->data;
 +
 +    if (!sps) {
-         av_log(h->avctx, AV_LOG_ERROR, "SPS unavailable in decode_picture_timing\n");
++        av_log(logctx, AV_LOG_ERROR, "SPS unavailable in decode_picture_timing\n");
 +        return 0;
 +    }
  
-     if (sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag) {
-         h->sei_cpb_removal_delay = get_bits_long(&h->gb,
-                                                  sps->cpb_removal_delay_length);
-         h->sei_dpb_output_delay  = get_bits_long(&h->gb,
-                                                  sps->dpb_output_delay_length);
+     if (sps->nal_hrd_parameters_present_flag ||
+         sps->vcl_hrd_parameters_present_flag) {
 -        h->cpb_removal_delay = get_bits(gb, sps->cpb_removal_delay_length);
 -        h->dpb_output_delay  = get_bits(gb, sps->dpb_output_delay_length);
++        h->cpb_removal_delay = get_bits_long(gb, sps->cpb_removal_delay_length);
++        h->dpb_output_delay  = get_bits_long(gb, sps->dpb_output_delay_length);
      }
      if (sps->pic_struct_present_flag) {
          unsigned int i, num_clock_ts;
@@@ -187,8 -179,10 +187,8 @@@ static int decode_registered_user_data_
          }
      } else {
          int i;
 -        avpriv_request_sample(logctx, "Subtitles with data type 0x%02x",
 -                              user_data_type_code);
          for (i = 0; i < size - 1; i++)
-             skip_bits(&h->gb, 8);
+             skip_bits(gb, 8);
      }
  
      return 0;
@@@ -246,19 -243,17 +249,19 @@@ static int decode_unregistered_user_dat
      e = sscanf(user_data + 16, "x264 - core %d", &build);
      if (e == 1 && build > 0)
          h->x264_build = build;
 +    if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
 +        h->x264_build = 67;
  
      if (strlen(user_data + 16) > 0)
-         av_log(h->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data + 16);
+         av_log(logctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data + 16);
  
      av_free(user_data);
      return 0;
  }
  
- static int decode_recovery_point(H264Context *h)
+ static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb)
  {
-     h->sei_recovery_frame_cnt = get_ue_golomb_long(&h->gb);
 -    h->recovery_frame_cnt = get_ue_golomb(gb);
++    h->recovery_frame_cnt = get_ue_golomb_long(gb);
  
      /* 1b exact_match_flag,
       * 1b broken_link_flag,
@@@ -291,17 -282,17 +290,17 @@@ static int decode_buffering_period(H264
      if (sps->nal_hrd_parameters_present_flag) {
          for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
              h->initial_cpb_removal_delay[sched_sel_idx] =
-                 get_bits_long(&h->gb, sps->initial_cpb_removal_delay_length);
 -                get_bits(gb, sps->initial_cpb_removal_delay_length);
++                get_bits_long(gb, sps->initial_cpb_removal_delay_length);
              // initial_cpb_removal_delay_offset
-             skip_bits(&h->gb, sps->initial_cpb_removal_delay_length);
+             skip_bits(gb, sps->initial_cpb_removal_delay_length);
          }
      }
      if (sps->vcl_hrd_parameters_present_flag) {
          for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
              h->initial_cpb_removal_delay[sched_sel_idx] =
-                 get_bits_long(&h->gb, sps->initial_cpb_removal_delay_length);
 -                get_bits(gb, sps->initial_cpb_removal_delay_length);
++                get_bits_long(gb, sps->initial_cpb_removal_delay_length);
              // initial_cpb_removal_delay_offset
-             skip_bits(&h->gb, sps->initial_cpb_removal_delay_length);
+             skip_bits(gb, sps->initial_cpb_removal_delay_length);
          }
      }
  
      return 0;
  }
  
- static int decode_frame_packing_arrangement(H264Context *h)
+ static int decode_frame_packing_arrangement(H264SEIFramePacking *h,
+                                             GetBitContext *gb)
  {
-     h->sei_fpa.frame_packing_arrangement_id          = get_ue_golomb_long(&h->gb);
-     h->sei_fpa.frame_packing_arrangement_cancel_flag = get_bits1(&h->gb);
-     h->sei_frame_packing_present = !h->sei_fpa.frame_packing_arrangement_cancel_flag;
-     if (h->sei_frame_packing_present) {
-         h->sei_fpa.frame_packing_arrangement_type =
-         h->frame_packing_arrangement_type = get_bits(&h->gb, 7);
-         h->sei_fpa.quincunx_sampling_flag         =
-         h->quincunx_subsampling           = get_bits1(&h->gb);
-         h->sei_fpa.content_interpretation_type    =
-         h->content_interpretation_type    = get_bits(&h->gb, 6);
 -    get_ue_golomb(gb);              // frame_packing_arrangement_id
 -    h->present = !get_bits1(gb);
++    h->frame_packing_arrangement_id          = get_ue_golomb_long(gb);
++    h->frame_packing_arrangement_cancel_flag = get_bits1(gb);
++    h->present = !h->frame_packing_arrangement_cancel_flag;
+     if (h->present) {
 -        h->arrangement_type = get_bits(gb, 7);
 -        h->quincunx_subsampling           = get_bits1(gb);
++        h->frame_packing_arrangement_type = get_bits(gb, 7);
++        h->quincunx_sampling_flag         = get_bits1(gb);
+         h->content_interpretation_type    = get_bits(gb, 6);
  
          // the following skips: spatial_flipping_flag, frame0_flipped_flag,
          // field_views_flag, current_frame_is_frame0_flag,
          // frame0_self_contained_flag, frame1_self_contained_flag
-         skip_bits(&h->gb, 6);
+         skip_bits(gb, 6);
  
-         if (!h->quincunx_subsampling && h->frame_packing_arrangement_type != 5)
-             skip_bits(&h->gb, 16);      // frame[01]_grid_position_[xy]
-         skip_bits(&h->gb, 8);           // frame_packing_arrangement_reserved_byte
-         h->sei_fpa.frame_packing_arrangement_repetition_period = get_ue_golomb_long(&h->gb);
 -        if (!h->quincunx_subsampling && h->arrangement_type != 5)
++        if (!h->quincunx_sampling_flag && h->frame_packing_arrangement_type != 5)
+             skip_bits(gb, 16);      // frame[01]_grid_position_[xy]
+         skip_bits(gb, 8);           // frame_packing_arrangement_reserved_byte
 -        get_ue_golomb(gb);          // frame_packing_arrangement_repetition_period
++        h->frame_packing_arrangement_repetition_period = get_ue_golomb_long(gb);
      }
-     skip_bits1(&h->gb);                 // frame_packing_arrangement_extension_flag
-     if (h->avctx->debug & FF_DEBUG_PICT_INFO)
-         av_log(h->avctx, AV_LOG_DEBUG, "SEI FPA %d %d %d %d %d %d\n",
-                                        h->sei_fpa.frame_packing_arrangement_id,
-                                        h->sei_fpa.frame_packing_arrangement_cancel_flag,
-                                        h->sei_fpa.frame_packing_arrangement_type,
-                                        h->sei_fpa.quincunx_sampling_flag,
-                                        h->sei_fpa.content_interpretation_type,
-                                        h->sei_fpa.frame_packing_arrangement_repetition_period);
+     skip_bits1(gb);                 // frame_packing_arrangement_extension_flag
  
      return 0;
  }
  
- static int decode_display_orientation(H264Context *h)
+ static int decode_display_orientation(H264SEIDisplayOrientation *h,
+                                       GetBitContext *gb)
  {
-     h->sei_display_orientation_present = !get_bits1(&h->gb);
+     h->present = !get_bits1(gb);
  
-     if (h->sei_display_orientation_present) {
-         h->sei_hflip = get_bits1(&h->gb);     // hor_flip
-         h->sei_vflip = get_bits1(&h->gb);     // ver_flip
+     if (h->present) {
+         h->hflip = get_bits1(gb);     // hor_flip
+         h->vflip = get_bits1(gb);     // ver_flip
  
-         h->sei_anticlockwise_rotation = get_bits(&h->gb, 16);
-         get_ue_golomb_long(&h->gb);  // display_orientation_repetition_period
-         skip_bits1(&h->gb);          // display_orientation_extension_flag
+         h->anticlockwise_rotation = get_bits(gb, 16);
 -        get_ue_golomb(gb);  // display_orientation_repetition_period
 -        skip_bits1(gb);     // display_orientation_extension_flag
++        get_ue_golomb_long(gb);       // display_orientation_repetition_period
++        skip_bits1(gb);               // display_orientation_extension_flag
 +    }
 +
 +    return 0;
 +}
 +
 +static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
 +{
 +    h->green_metadata_type = get_bits(gb, 8);
 +
 +    if (h->green_metadata_type == 0) {
 +        h->period_type = get_bits(gb, 8);
 +
 +        if (h->period_type == 2)
 +            h->num_seconds = get_bits(gb, 16);
 +        else if (h->period_type == 3)
 +            h->num_pictures = get_bits(gb, 16);
 +
 +        h->percent_non_zero_macroblocks            = get_bits(gb, 8);
 +        h->percent_intra_coded_macroblocks         = get_bits(gb, 8);
 +        h->percent_six_tap_filtering               = get_bits(gb, 8);
 +        h->percent_alpha_point_deblocking_instance = get_bits(gb, 8);
 +
 +    } else if (h->green_metadata_type == 1) {
 +        h->xsd_metric_type  = get_bits(gb, 8);
 +        h->xsd_metric_value = get_bits(gb, 16);
      }
  
      return 0;
  }
  
- int ff_h264_decode_sei(H264Context *h)
+ int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
+                        const H264ParamSets *ps, void *logctx)
  {
-     while (get_bits_left(&h->gb) > 16 && show_bits(&h->gb, 16)) {
 -    while (get_bits_left(gb) > 16) {
 -        int size = 0;
++    while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
          int type = 0;
 +        unsigned size = 0;
 +        unsigned next;
          int ret  = 0;
 -        int last = 0;
  
 -        while (get_bits_left(gb) >= 8 &&
 -               (last = get_bits(gb, 8)) == 255) {
 -            type += 255;
 -        }
 -        type += last;
 +        do {
-             if (get_bits_left(&h->gb) < 8)
++            if (get_bits_left(gb) < 8)
 +                return AVERROR_INVALIDDATA;
-             type += show_bits(&h->gb, 8);
-         } while (get_bits(&h->gb, 8) == 255);
++            type += show_bits(gb, 8);
++        } while (get_bits(gb, 8) == 255);
  
 -        last = 0;
 -        while (get_bits_left(gb) >= 8 &&
 -               (last = get_bits(gb, 8)) == 255) {
 -            size += 255;
 -        }
 -        size += last;
 +        do {
-             if (get_bits_left(&h->gb) < 8)
++            if (get_bits_left(gb) < 8)
 +                return AVERROR_INVALIDDATA;
-             size += show_bits(&h->gb, 8);
-         } while (get_bits(&h->gb, 8) == 255);
-         if (h->avctx->debug&FF_DEBUG_STARTCODE)
-             av_log(h->avctx, AV_LOG_DEBUG, "SEI %d len:%d\n", type, size);
++            size += show_bits(gb, 8);
++        } while (get_bits(gb, 8) == 255);
  
-         if (size > get_bits_left(&h->gb) / 8) {
-             av_log(h->avctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
-                    type, 8*size, get_bits_left(&h->gb));
+         if (size > get_bits_left(gb) / 8) {
 -            av_log(logctx, AV_LOG_ERROR, "SEI type %d truncated at %d\n",
 -                   type, get_bits_left(gb));
++            av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
++                   type, 8*size, get_bits_left(gb));
              return AVERROR_INVALIDDATA;
          }
-         next = get_bits_count(&h->gb) + 8 * size;
++        next = get_bits_count(gb) + 8 * size;
  
          switch (type) {
          case SEI_TYPE_PIC_TIMING: // Picture timing SEI
-             ret = decode_picture_timing(h);
 -            ret = decode_picture_timing(&h->picture_timing, gb, ps->sps, logctx);
++            ret = decode_picture_timing(&h->picture_timing, gb, ps, logctx);
              break;
          case SEI_TYPE_USER_DATA_REGISTERED:
-             ret = decode_registered_user_data(h, size);
+             ret = decode_registered_user_data(h, gb, logctx, size);
              break;
          case SEI_TYPE_USER_DATA_UNREGISTERED:
-             ret = decode_unregistered_user_data(h, size);
+             ret = decode_unregistered_user_data(&h->unregistered, gb, logctx, size);
              break;
          case SEI_TYPE_RECOVERY_POINT:
-             ret = decode_recovery_point(h);
+             ret = decode_recovery_point(&h->recovery_point, gb);
              break;
          case SEI_TYPE_BUFFERING_PERIOD:
-             ret = decode_buffering_period(h);
+             ret = decode_buffering_period(&h->buffering_period, gb, ps, logctx);
              break;
          case SEI_TYPE_FRAME_PACKING:
-             ret = decode_frame_packing_arrangement(h);
+             ret = decode_frame_packing_arrangement(&h->frame_packing, gb);
              break;
          case SEI_TYPE_DISPLAY_ORIENTATION:
-             ret = decode_display_orientation(h);
+             ret = decode_display_orientation(&h->display_orientation, gb);
              break;
-             ret = decode_green_metadata(&h->sei_green_metadata, &h->gb);
 +        case SEI_TYPE_GREEN_METADATA:
++            ret = decode_green_metadata(&h->green_metadata, gb);
 +            break;
          default:
-             av_log(h->avctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
+             av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
 -            skip_bits(gb, 8 * size);
          }
          if (ret < 0)
              return ret;
  
-         skip_bits_long(&h->gb, next - get_bits_count(&h->gb));
++        skip_bits_long(gb, next - get_bits_count(gb));
 +
          // FIXME check bits here
-         align_get_bits(&h->gb);
+         align_get_bits(gb);
      }
  
      return 0;
  }
- const char* ff_h264_sei_stereo_mode(H264Context *h)
 +
-     if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 0) {
-         switch (h->sei_fpa.frame_packing_arrangement_type) {
++const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
 +{
-                 if (h->sei_fpa.content_interpretation_type == 2)
++    if (h->frame_packing_arrangement_cancel_flag == 0) {
++        switch (h->frame_packing_arrangement_type) {
 +            case SEI_FPA_TYPE_CHECKERBOARD:
-                 if (h->sei_fpa.content_interpretation_type == 2)
++                if (h->content_interpretation_type == 2)
 +                    return "checkerboard_rl";
 +                else
 +                    return "checkerboard_lr";
 +            case SEI_FPA_TYPE_INTERLEAVE_COLUMN:
-                 if (h->sei_fpa.content_interpretation_type == 2)
++                if (h->content_interpretation_type == 2)
 +                    return "col_interleaved_rl";
 +                else
 +                    return "col_interleaved_lr";
 +            case SEI_FPA_TYPE_INTERLEAVE_ROW:
-                 if (h->sei_fpa.content_interpretation_type == 2)
++                if (h->content_interpretation_type == 2)
 +                    return "row_interleaved_rl";
 +                else
 +                    return "row_interleaved_lr";
 +            case SEI_FPA_TYPE_SIDE_BY_SIDE:
-                 if (h->sei_fpa.content_interpretation_type == 2)
++                if (h->content_interpretation_type == 2)
 +                    return "right_left";
 +                else
 +                    return "left_right";
 +            case SEI_FPA_TYPE_TOP_BOTTOM:
-                 if (h->sei_fpa.content_interpretation_type == 2)
++                if (h->content_interpretation_type == 2)
 +                    return "bottom_top";
 +                else
 +                    return "top_bottom";
 +            case SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
-     } else if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 1) {
++                if (h->content_interpretation_type == 2)
 +                    return "block_rl";
 +                else
 +                    return "block_lr";
 +            case SEI_FPA_TYPE_2D:
 +            default:
 +                return "mono";
 +        }
++    } else if (h->frame_packing_arrangement_cancel_flag == 1) {
 +        return "mono";
 +    } else {
 +        return NULL;
 +    }
 +}
index 0000000,58f5ecc..9197795
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,137 +1,173 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
 -    int arrangement_type;
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVCODEC_H264_SEI_H
+ #define AVCODEC_H264_SEI_H
+ #include "get_bits.h"
+ /**
+  * SEI message types
+  */
+ typedef enum {
+     SEI_TYPE_BUFFERING_PERIOD       = 0,   ///< buffering period (H.264, D.1.1)
+     SEI_TYPE_PIC_TIMING             = 1,   ///< picture timing
+     SEI_TYPE_USER_DATA_REGISTERED   = 4,   ///< registered user data as specified by Rec. ITU-T T.35
+     SEI_TYPE_USER_DATA_UNREGISTERED = 5,   ///< unregistered user data
+     SEI_TYPE_RECOVERY_POINT         = 6,   ///< recovery point (frame # to decoder sync)
+     SEI_TYPE_FRAME_PACKING          = 45,  ///< frame packing arrangement
+     SEI_TYPE_DISPLAY_ORIENTATION    = 47,  ///< display orientation
++    SEI_TYPE_GREEN_METADATA         = 56   ///< GreenMPEG information
+ } SEI_Type;
+ /**
+  * pic_struct in picture timing SEI message
+  */
+ typedef enum {
+     SEI_PIC_STRUCT_FRAME             = 0, ///<  0: %frame
+     SEI_PIC_STRUCT_TOP_FIELD         = 1, ///<  1: top field
+     SEI_PIC_STRUCT_BOTTOM_FIELD      = 2, ///<  2: bottom field
+     SEI_PIC_STRUCT_TOP_BOTTOM        = 3, ///<  3: top field, bottom field, in that order
+     SEI_PIC_STRUCT_BOTTOM_TOP        = 4, ///<  4: bottom field, top field, in that order
+     SEI_PIC_STRUCT_TOP_BOTTOM_TOP    = 5, ///<  5: top field, bottom field, top field repeated, in that order
+     SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///<  6: bottom field, top field, bottom field repeated, in that order
+     SEI_PIC_STRUCT_FRAME_DOUBLING    = 7, ///<  7: %frame doubling
+     SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
+ } SEI_PicStructType;
++/**
++ * frame_packing_arrangement types
++ */
++typedef enum {
++    SEI_FPA_TYPE_CHECKERBOARD        = 0,
++    SEI_FPA_TYPE_INTERLEAVE_COLUMN   = 1,
++    SEI_FPA_TYPE_INTERLEAVE_ROW      = 2,
++    SEI_FPA_TYPE_SIDE_BY_SIDE        = 3,
++    SEI_FPA_TYPE_TOP_BOTTOM          = 4,
++    SEI_FPA_TYPE_INTERLEAVE_TEMPORAL = 5,
++    SEI_FPA_TYPE_2D                  = 6,
++} SEI_FpaType;
++
+ typedef struct H264SEIPictureTiming {
+     SEI_PicStructType pic_struct;
+     /**
+      * Bit set of clock types for fields/frames in picture timing SEI message.
+      * For each found ct_type, appropriate bit is set (e.g., bit 1 for
+      * interlaced).
+      */
+     int ct_type;
+     /**
+      * dpb_output_delay in picture timing SEI message, see H.264 C.2.2
+      */
+     int dpb_output_delay;
+     /**
+      * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
+      */
+     int cpb_removal_delay;
+ } H264SEIPictureTiming;
+ typedef struct H264SEIAFD {
+     int present;
+     uint8_t active_format_description;
+ } H264SEIAFD;
+ typedef struct H264SEIA53Caption {
+     int a53_caption_size;
+     uint8_t *a53_caption;
+ } H264SEIA53Caption;
+ typedef struct H264SEIUnregistered {
+     int x264_build;
+ } H264SEIUnregistered;
+ typedef struct H264SEIRecoveryPoint {
+     /**
+      * recovery_frame_cnt
+      *
+      * Set to -1 if no recovery point SEI message found or to number of frames
+      * before playback synchronizes. Frames having recovery point are key
+      * frames.
+      */
+     int recovery_frame_cnt;
+ } H264SEIRecoveryPoint;
+ typedef struct H264SEIBufferingPeriod {
+     int present;   ///< Buffering period SEI flag
+     int initial_cpb_removal_delay[32];  ///< Initial timestamps for CPBs
+ } H264SEIBufferingPeriod;
+ typedef struct H264SEIFramePacking {
+     int present;
 -    int quincunx_subsampling;
++    int frame_packing_arrangement_id;
++    int frame_packing_arrangement_cancel_flag;  ///< is previous arrangement canceled, -1 if never received
++    SEI_FpaType frame_packing_arrangement_type;
++    int frame_packing_arrangement_repetition_period;
+     int content_interpretation_type;
++    int quincunx_sampling_flag;
+ } H264SEIFramePacking;
+ typedef struct H264SEIDisplayOrientation {
+     int present;
+     int anticlockwise_rotation;
+     int hflip, vflip;
+ } H264SEIDisplayOrientation;
++typedef struct H264SEIGreenMetaData {
++    uint8_t green_metadata_type;
++    uint8_t period_type;
++    uint16_t num_seconds;
++    uint16_t num_pictures;
++    uint8_t percent_non_zero_macroblocks;
++    uint8_t percent_intra_coded_macroblocks;
++    uint8_t percent_six_tap_filtering;
++    uint8_t percent_alpha_point_deblocking_instance;
++    uint8_t xsd_metric_type;
++    uint16_t xsd_metric_value;
++} H264SEIGreenMetaData;
++
+ typedef struct H264SEIContext {
+     H264SEIPictureTiming picture_timing;
+     H264SEIAFD afd;
+     H264SEIA53Caption a53_caption;
+     H264SEIUnregistered unregistered;
+     H264SEIRecoveryPoint recovery_point;
+     H264SEIBufferingPeriod buffering_period;
+     H264SEIFramePacking frame_packing;
+     H264SEIDisplayOrientation display_orientation;
++    H264SEIGreenMetaData green_metadata;
+ } H264SEIContext;
+ struct H264ParamSets;
+ int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
+                        const struct H264ParamSets *ps, void *logctx);
+ /**
+  * Reset SEI values at the beginning of the frame.
+  */
+ void ff_h264_sei_uninit(H264SEIContext *h);
++/**
++ * Get stereo_mode string from the h264 frame_packing_arrangement
++ */
++const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h);
++
+ #endif /* AVCODEC_H264_SEI_H */
@@@ -418,7 -407,6 +418,7 @@@ int ff_h264_update_thread_context(AVCod
      // extradata/NAL handling
      h->is_avc = h1->is_avc;
      h->nal_length_size = h1->nal_length_size;
-     h->x264_build      = h1->x264_build;
++    h->sei.unregistered.x264_build = h1->sei.unregistered.x264_build;
  
      // POC timing
      copy_fields(h, h1, poc, current_slice);
@@@ -485,37 -456,9 +485,37 @@@ static int h264_frame_start(H264Contex
      pic->f->key_frame = 0;
      pic->mmco_reset  = 0;
      pic->recovered   = 0;
-     pic->sei_recovery_frame_cnt = h->sei_recovery_frame_cnt;
 +    pic->invalid_gap = 0;
++    pic->sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
  
 -    if (CONFIG_ERROR_RESILIENCE && h->enable_er)
 +    if ((ret = alloc_picture(h, pic)) < 0)
 +        return ret;
 +    if(!h->frame_recovered && !h->avctx->hwaccel
 +#if FF_API_CAP_VDPAU
 +       && !(h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU)
 +#endif
 +       )
 +        ff_color_frame(pic->f, c);
 +
 +    h->cur_pic_ptr = pic;
 +    ff_h264_unref_picture(h, &h->cur_pic);
 +    if (CONFIG_ERROR_RESILIENCE) {
 +        ff_h264_set_erpic(&h->slice_ctx[0].er.cur_pic, NULL);
 +    }
 +
 +    if ((ret = ff_h264_ref_picture(h, &h->cur_pic, h->cur_pic_ptr)) < 0)
 +        return ret;
 +
 +    for (i = 0; i < h->nb_slice_ctx; i++) {
 +        h->slice_ctx[i].linesize   = h->cur_pic_ptr->f->linesize[0];
 +        h->slice_ctx[i].uvlinesize = h->cur_pic_ptr->f->linesize[1];
 +    }
 +
 +    if (CONFIG_ERROR_RESILIENCE && h->enable_er) {
          ff_er_frame_start(&h->slice_ctx[0].er);
 +        ff_h264_set_erpic(&h->slice_ctx[0].er.last_pic, NULL);
 +        ff_h264_set_erpic(&h->slice_ctx[0].er.next_pic, NULL);
 +    }
  
      for (i = 0; i < 16; i++) {
          h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
@@@ -913,10 -826,10 +913,10 @@@ static int h264_slice_header_init(H264C
  
      if (sps->timing_info_present_flag) {
          int64_t den = sps->time_scale;
-         if (h->x264_build < 44U)
+         if (h->sei.unregistered.x264_build < 44U)
              den *= 2;
          av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
 -                  sps->num_units_in_tick, den, 1 << 30);
 +                  sps->num_units_in_tick * h->avctx->ticks_per_frame, den, 1 << 30);
      }
  
      ff_h264_free_tables(h);
@@@ -1121,17 -967,6 +1121,17 @@@ int ff_h264_decode_slice_header(H264Con
          return AVERROR_INVALIDDATA;
      }
  
-             (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != NAL_IDR_SLICE && h->sei_recovery_frame_cnt < 0) ||
 +    if (h->current_slice == 0 && !h->first_field) {
 +        if (
 +            (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
 +            (h->avctx->skip_frame >= AVDISCARD_BIDIR  && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
 +            (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
++            (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
 +            h->avctx->skip_frame >= AVDISCARD_ALL) {
 +            return SLICE_SKIPED;
 +        }
 +    }
 +
      // to make a few old functions happy, it's wrong though
      if (!h->setup_finished)
          h->pict_type = sl->slice_type;