@@ -430,17 +430,17 @@ static int h264_init_context(AVCodecContext *avctx, H264Context *h)

     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->poc.prev_frame_num    = -1;

-    h->sei_fpa.frame_packing_arrangement_cancel_flag = -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++)

         h->last_pocs[i] = INT_MIN;

-    ff_h264_reset_sei(h);

+    ff_h264_sei_uninit(&h->sei);

     avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

@@ -594,7 +594,8 @@ static void decode_postinit(H264Context *h, int setup_finished)

      * decoding process if it exists. */

     if (sps->pic_struct_present_flag) {

-        switch (h->sei_pic_struct) {

+        H264SEIPictureTiming *pt = &h->sei.picture_timing;

+        switch (pt->pic_struct) {

         case SEI_PIC_STRUCT_FRAME:

             break;

         case SEI_PIC_STRUCT_TOP_FIELD:

@@ -624,9 +625,9 @@ static void decode_postinit(H264Context *h, int setup_finished)

             break;

         }

-        if ((h->sei_ct_type & 3) &&

-            h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)

-            cur->f->interlaced_frame = (h->sei_ct_type & (1 << 1)) != 0;

+        if ((pt->ct_type & 3) &&

+            pt->pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)

+            cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;

     } else {

         /* Derive interlacing flag from used decoding process. */

         cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);

@@ -640,8 +641,8 @@ static void decode_postinit(H264Context *h, int setup_finished)

         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;

@@ -655,14 +656,14 @@ static void decode_postinit(H264Context *h, int setup_finished)

         }

     }

-    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.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) {

-        switch (h->frame_packing_arrangement_type) {

+        switch (fp->frame_packing_arrangement_type) {

         case 0:

             stereo->type = AV_STEREO3D_CHECKERBOARD;

             break;

@@ -673,7 +674,7 @@ static void decode_postinit(H264Context *h, int setup_finished)

             stereo->type = AV_STEREO3D_LINES;

             break;

         case 3:

-            if (h->quincunx_subsampling)

+            if (fp->quincunx_sampling_flag)

                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;

             else

                 stereo->type = AV_STEREO3D_SIDEBYSIDE;

@@ -689,42 +690,46 @@ static void decode_postinit(H264Context *h, int setup_finished)

             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) {

             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) {

-            *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)

-            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;

     }

@@ -859,7 +864,7 @@ void ff_h264_flush_change(H264Context *h)

     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;

@@ -1005,7 +1010,7 @@ static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,

         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) {

@@ -1096,13 +1101,15 @@ 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) {

+                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;

@@ -1167,10 +1174,15 @@ again:

             avpriv_request_sample(avctx, "data partitioning");

             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,7 +1326,7 @@ static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)

     if (ret < 0)

         return ret;

-    av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(h), 0);

+    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;

@@ -1532,8 +1544,7 @@ av_cold void ff_h264_free_context(H264Context *h)

     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]);

@@ -35,6 +35,7 @@

 #include "error_resilience.h"

 #include "get_bits.h"

 #include "h264_parse.h"

+#include "h264_sei.h"

 #include "h2645_parse.h"

 #include "h264chroma.h"

 #include "h264dsp.h"

@@ -131,48 +132,6 @@ enum {

 };

 /**

- * 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;

-

-/**

  * Sequence parameter set

  */

 typedef struct SPS {

@@ -281,34 +240,6 @@ typedef struct H264ParamSets {

 } H264ParamSets;

 /**

- * Frame Packing Arrangement Type

- */

-typedef struct FPA {

-    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;

-} FPA;

-

-/**

- * Green MetaData Information Type

- */

-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;

-

-/**

  * Memory management control operation opcode.

  */

 typedef enum MMCOOpcode {

@@ -622,8 +553,6 @@ typedef struct H264Context {

     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;

@@ -708,11 +637,6 @@ typedef struct H264Context {

     /** @} */

     /**

-     * pic_struct in picture timing SEI message

-     */

-    SEI_PicStructType sei_pic_struct;

-

-    /**

      * Complement sei_pic_struct

      * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.

      * However, soft telecined frames may have these values.

@@ -721,61 +645,10 @@ typedef struct H264Context {

     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.

@@ -807,10 +680,6 @@ typedef struct H264Context {

      * 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

@@ -821,6 +690,8 @@ typedef struct H264Context {

     int enable_er;

+    H264SEIContext sei;

+

     AVBufferPool *qscale_table_pool;

     AVBufferPool *mb_type_pool;

     AVBufferPool *motion_val_pool;

@@ -830,19 +701,11 @@ typedef struct H264Context {

     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];

 /**

- * Decode SEI

- */

-int ff_h264_decode_sei(H264Context *h);

-

-/**

  * Decode SPS

  */

 int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,

@@ -921,19 +784,6 @@ void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int

                        uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,

                        unsigned int linesize, unsigned int uvlinesize);

-/**

- * Reset SEI values at the beginning of the frame.

- *

- * @param h H.264 context.

- */

-void ff_h264_reset_sei(H264Context *h);

-

-/**

- * Get stereo_mode string from the h264 frame_packing_arrangement

- * @param h H.264 context.

- */

-const char* ff_h264_sei_stereo_mode(H264Context *h);

-

 /*

  * o-o o-o

  *  / / /

@@ -395,7 +395,7 @@ single_col:

              (l1ref0[0] < 0 && !l1ref1[0] &&

               FFABS(l1mv1[0][0]) <= 1 &&

               FFABS(l1mv1[0][1]) <= 1 &&

-              h->x264_build > 33U))) {

+              h->sei.unregistered.x264_build > 33U))) {

             a = b = 0;

             if (ref[0] > 0)

                 a = mv[0];

@@ -430,7 +430,7 @@ single_col:

                 (l1ref0[i8] == 0 ||

                  (l1ref0[i8] < 0 &&

                   l1ref1[i8] == 0 &&

-                  h->x264_build > 33U))) {

+                  h->sei.unregistered.x264_build > 33U))) {

                 const int16_t (*l1mv)[2] = l1ref0[i8] == 0 ? l1mv0 : l1mv1;

                 if (IS_SUB_8X8(sub_mb_type)) {

                     const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];

@@ -636,7 +636,7 @@ static av_always_inline void hl_decode_mb_predict_luma(const H264Context *h,

                 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) {

+                    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),

@@ -39,6 +39,7 @@

 #include "get_bits.h"

 #include "golomb.h"

 #include "h264.h"

+#include "h264_sei.h"

 #include "h264data.h"

 #include "internal.h"

 #include "mpegutils.h"

@@ -50,6 +51,7 @@ typedef struct H264ParseContext {

     H264ParamSets ps;

     H264DSPContext h264dsp;

     H264POCContext poc;

+    H264SEIContext sei;

     int got_first;

 } H264ParseContext;

@@ -249,8 +251,8 @@ static inline int parse_nal_units(AVCodecParserContext *s,

     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;

@@ -318,12 +320,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,

                                                  nal.size_bits);

             break;

         case NAL_SEI:

-            {

-                H264ParamSets ps = h->ps;

-                h->ps = p->ps;

-                ff_h264_decode_sei(h);

-                h->ps = ps;

-            }

+            ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);

             break;

         case NAL_IDR_SLICE:

             s->key_frame = 1;

@@ -337,7 +334,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,

             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;

             }

@@ -462,7 +459,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,

             }

             if (sps->pic_struct_present_flag) {

-                switch (h->sei_pic_struct) {

+                switch (p->sei.picture_timing.pic_struct) {

                 case SEI_PIC_STRUCT_TOP_FIELD:

                 case SEI_PIC_STRUCT_BOTTOM_FIELD:

                     s->repeat_pict = 0;

@@ -493,7 +490,7 @@ static inline int parse_nal_units(AVCodecParserContext *s,

             if (h->picture_structure == PICT_FRAME) {

                 s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;

                 if (sps->pic_struct_present_flag) {

-                    switch (h->sei_pic_struct) {

+                    switch (p->sei.picture_timing.pic_struct) {

                     case SEI_PIC_STRUCT_TOP_BOTTOM:

                     case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:

                         s->field_order = AV_FIELD_TT;

@@ -603,10 +600,10 @@ static int h264_parse(AVCodecParserContext *s,

     if (avctx->framerate.num)

         avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));

-    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 (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;

@@ -669,6 +666,8 @@ static void h264_close(AVCodecParserContext *s)

     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]);

@@ -26,124 +26,124 @@

  */

 #include "avcodec.h"

+#include "get_bits.h"

 #include "golomb.h"

 #include "h264.h"

+#include "h264_sei.h"

 #include "internal.h"

 static const uint8_t sei_num_clock_ts_table[9] = {

     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->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 H264ParamSets *ps, void *logctx)

 {

-    const SPS *sps = h->ps.sps;

     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_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;

-        h->sei_pic_struct = get_bits(&h->gb, 4);

-        h->sei_ct_type    = 0;

+        h->pic_struct = get_bits(gb, 4);

+        h->ct_type    = 0;

-        if (h->sei_pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING)

+        if (h->pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING)

             return AVERROR_INVALIDDATA;

-        num_clock_ts = sei_num_clock_ts_table[h->sei_pic_struct];

+        num_clock_ts = sei_num_clock_ts_table[h->pic_struct];

         for (i = 0; i < num_clock_ts; i++) {

-            if (get_bits(&h->gb, 1)) {                /* clock_timestamp_flag */

+            if (get_bits(gb, 1)) {                /* clock_timestamp_flag */

                 unsigned int full_timestamp_flag;

-                h->sei_ct_type |= 1 << get_bits(&h->gb, 2);

-                skip_bits(&h->gb, 1);                 /* nuit_field_based_flag */

-                skip_bits(&h->gb, 5);                 /* counting_type */

-                full_timestamp_flag = get_bits(&h->gb, 1);

-                skip_bits(&h->gb, 1);                 /* discontinuity_flag */

-                skip_bits(&h->gb, 1);                 /* cnt_dropped_flag */

-                skip_bits(&h->gb, 8);                 /* n_frames */

+                h->ct_type |= 1 << get_bits(gb, 2);

+                skip_bits(gb, 1);                 /* nuit_field_based_flag */

+                skip_bits(gb, 5);                 /* counting_type */

+                full_timestamp_flag = get_bits(gb, 1);

+                skip_bits(gb, 1);                 /* discontinuity_flag */

+                skip_bits(gb, 1);                 /* cnt_dropped_flag */

+                skip_bits(gb, 8);                 /* n_frames */

                 if (full_timestamp_flag) {

-                    skip_bits(&h->gb, 6);             /* seconds_value 0..59 */

-                    skip_bits(&h->gb, 6);             /* minutes_value 0..59 */

-                    skip_bits(&h->gb, 5);             /* hours_value 0..23 */

+                    skip_bits(gb, 6);             /* seconds_value 0..59 */

+                    skip_bits(gb, 6);             /* minutes_value 0..59 */

+                    skip_bits(gb, 5);             /* hours_value 0..23 */

                 } else {

-                    if (get_bits(&h->gb, 1)) {        /* seconds_flag */

-                        skip_bits(&h->gb, 6);         /* seconds_value range 0..59 */

-                        if (get_bits(&h->gb, 1)) {    /* minutes_flag */

-                            skip_bits(&h->gb, 6);     /* minutes_value 0..59 */

-                            if (get_bits(&h->gb, 1))  /* hours_flag */

-                                skip_bits(&h->gb, 5); /* hours_value 0..23 */

+                    if (get_bits(gb, 1)) {        /* seconds_flag */

+                        skip_bits(gb, 6);         /* seconds_value range 0..59 */

+                        if (get_bits(gb, 1)) {    /* minutes_flag */

+                            skip_bits(gb, 6);     /* minutes_value 0..59 */

+                            if (get_bits(gb, 1))  /* hours_flag */

+                                skip_bits(gb, 5); /* hours_value 0..23 */

                         }

                     }

                 }

                 if (sps->time_offset_length > 0)

-                    skip_bits(&h->gb,

+                    skip_bits(gb,

                               sps->time_offset_length); /* time_offset */

             }

         }

-        if (h->avctx->debug & FF_DEBUG_PICT_INFO)

-            av_log(h->avctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",

-                   h->sei_ct_type, h->sei_pic_struct);

+        av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",

+               h->ct_type, h->pic_struct);

     }

     return 0;

 }

-static int decode_registered_user_data_afd(H264Context *h, int size)

+static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)

 {

     int flag;

     if (size-- < 1)

         return AVERROR_INVALIDDATA;

-    skip_bits(&h->gb, 1);               // 0

-    flag = get_bits(&h->gb, 1);         // active_format_flag

-    skip_bits(&h->gb, 6);               // reserved

+    skip_bits(gb, 1);               // 0

+    flag = get_bits(gb, 1);         // active_format_flag

+    skip_bits(gb, 6);               // reserved

     if (flag) {

         if (size-- < 1)

             return AVERROR_INVALIDDATA;

-        skip_bits(&h->gb, 4);           // reserved

-        h->active_format_description   = get_bits(&h->gb, 4);

-        h->sei_reguserdata_afd_present = 1;

-#if FF_API_AFD

-FF_DISABLE_DEPRECATION_WARNINGS

-        h->avctx->dtg_active_format = h->active_format_description;

-FF_ENABLE_DEPRECATION_WARNINGS

-#endif /* FF_API_AFD */

+        skip_bits(gb, 4);           // reserved

+        h->active_format_description = get_bits(gb, 4);

+        h->present                   = 1;

     }

     return 0;

 }

-static int decode_registered_user_data_closed_caption(H264Context *h, int size)

+static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h,

+                                                     GetBitContext *gb, void *logctx,

+                                                     int size)

 {

     int flag;

     int user_data_type_code;

@@ -152,15 +152,15 @@ static int decode_registered_user_data_closed_caption(H264Context *h, int size)

     if (size < 3)

         return AVERROR(EINVAL);

-    user_data_type_code = get_bits(&h->gb, 8);

+    user_data_type_code = get_bits(gb, 8);

     if (user_data_type_code == 0x3) {

-        skip_bits(&h->gb, 1);           // reserved

+        skip_bits(gb, 1);           // reserved

-        flag = get_bits(&h->gb, 1);     // process_cc_data_flag

+        flag = get_bits(gb, 1);     // process_cc_data_flag

         if (flag) {

-            skip_bits(&h->gb, 1);       // zero bit

-            cc_count = get_bits(&h->gb, 5);

-            skip_bits(&h->gb, 8);       // reserved

+            skip_bits(gb, 1);       // zero bit

+            cc_count = get_bits(gb, 5);

+            skip_bits(gb, 8);       // reserved

             size -= 2;

             if (cc_count && size >= cc_count * 3) {

@@ -177,24 +177,25 @@ static int decode_registered_user_data_closed_caption(H264Context *h, int size)

                     return ret;

                 for (i = 0; i < cc_count; i++) {

-                    h->a53_caption[h->a53_caption_size++] = get_bits(&h->gb, 8);

-                    h->a53_caption[h->a53_caption_size++] = get_bits(&h->gb, 8);

-                    h->a53_caption[h->a53_caption_size++] = get_bits(&h->gb, 8);

+                    h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);

+                    h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);

+                    h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);

                 }

-                skip_bits(&h->gb, 8);   // marker_bits

+                skip_bits(gb, 8);   // marker_bits

             }

         }

     } else {

         int i;

         for (i = 0; i < size - 1; i++)

-            skip_bits(&h->gb, 8);

+            skip_bits(gb, 8);

     }

     return 0;

 }

-static int decode_registered_user_data(H264Context *h, int size)

+static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb,

+                                       void *logctx, int size)

 {

     uint32_t country_code;

     uint32_t user_identifier;

@@ -203,31 +204,33 @@ static int decode_registered_user_data(H264Context *h, int size)

         return AVERROR_INVALIDDATA;

     size -= 7;

-    country_code = get_bits(&h->gb, 8); // itu_t_t35_country_code

+    country_code = get_bits(gb, 8); // itu_t_t35_country_code

     if (country_code == 0xFF) {

-        skip_bits(&h->gb, 8);           // itu_t_t35_country_code_extension_byte

+        skip_bits(gb, 8);           // itu_t_t35_country_code_extension_byte

         size--;

     }

     /* itu_t_t35_payload_byte follows */

-    skip_bits(&h->gb, 8);              // terminal provider code

-    skip_bits(&h->gb, 8);              // terminal provider oriented code

-    user_identifier = get_bits_long(&h->gb, 32);

+    skip_bits(gb, 8);              // terminal provider code

+    skip_bits(gb, 8);              // terminal provider oriented code

+    user_identifier = get_bits_long(gb, 32);

     switch (user_identifier) {

         case MKBETAG('D', 'T', 'G', '1'):       // afd_data

-            return decode_registered_user_data_afd(h, size);

+            return decode_registered_user_data_afd(&h->afd, gb, size);

         case MKBETAG('G', 'A', '9', '4'):       // closed captions

-            return decode_registered_user_data_closed_caption(h, size);

+            return decode_registered_user_data_closed_caption(&h->a53_caption, gb,

+                                                              logctx, size);

         default:

-            skip_bits(&h->gb, size * 8);

+            skip_bits(gb, size * 8);

             break;

     }

     return 0;

 }

-static int decode_unregistered_user_data(H264Context *h, int size)

+static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb,

+                                         void *logctx, int size)

 {

     uint8_t *user_data;

     int e, build, i;

@@ -240,7 +243,7 @@ static int decode_unregistered_user_data(H264Context *h, int size)

         return AVERROR(ENOMEM);

     for (i = 0; i < size + 16; i++)

-        user_data[i] = get_bits(&h->gb, 8);

+        user_data[i] = get_bits(gb, 8);

     user_data[i] = 0;

     e = sscanf(user_data + 16, "x264 - core %d", &build);

@@ -250,114 +253,100 @@ static int decode_unregistered_user_data(H264Context *h, int size)

         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_long(gb);

     /* 1b exact_match_flag,

      * 1b broken_link_flag,

      * 2b changing_slice_group_idc */

-    skip_bits(&h->gb, 4);

-