[FFmpeg-cvslog] Merge commit '728d90a0c1973661a9e73da697bf4f90c9d19577'
Clément Bœsch
git at videolan.org
Sat Jun 18 14:08:14 CEST 2016
ffmpeg | branch: master | Clément Bœsch <u at pkh.me> | Sat Jun 18 14:04:17 2016 +0200| [5584f019b5ebb943cd45f848e88f9e59c03f2b41] | committer: Clément Bœsch
Merge commit '728d90a0c1973661a9e73da697bf4f90c9d19577'
* 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 at stupeflix.com>
Signed-off-by: Hendrik Leppkes <h.leppkes at gmail.com>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=5584f019b5ebb943cd45f848e88f9e59c03f2b41
---
libavcodec/h264.c | 93 +++++++------
libavcodec/h264.h | 156 +---------------------
libavcodec/h264_direct.c | 4 +-
libavcodec/h264_mb.c | 2 +-
libavcodec/h264_parser.c | 29 ++--
libavcodec/h264_sei.c | 329 ++++++++++++++++++++++------------------------
libavcodec/h264_sei.h | 173 ++++++++++++++++++++++++
libavcodec/h264_slice.c | 8 +-
8 files changed, 407 insertions(+), 387 deletions(-)
diff --git a/libavcodec/h264.c b/libavcodec/h264.c
index 795e599..831d918 100644
--- a/libavcodec/h264.c
+++ b/libavcodec/h264.c
@@ -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]);
diff --git a/libavcodec/h264.h b/libavcodec/h264.h
index b156805..ba6f43c 100644
--- a/libavcodec/h264.h
+++ b/libavcodec/h264.h
@@ -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
* / / /
diff --git a/libavcodec/h264_direct.c b/libavcodec/h264_direct.c
index 0b3c025..9da6745 100644
--- a/libavcodec/h264_direct.c
+++ b/libavcodec/h264_direct.c
@@ -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];
diff --git a/libavcodec/h264_mb.c b/libavcodec/h264_mb.c
index 75535ad..c9fdf7a 100644
--- a/libavcodec/h264_mb.c
+++ b/libavcodec/h264_mb.c
@@ -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),
diff --git a/libavcodec/h264_parser.c b/libavcodec/h264_parser.c
index e0977ea..9fccdc9 100644
--- a/libavcodec/h264_parser.c
+++ b/libavcodec/h264_parser.c
@@ -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]);
diff --git a/libavcodec/h264_sei.c b/libavcodec/h264_sei.c
index 8fcaa61..d0596dc 100644
--- a/libavcodec/h264_sei.c
+++ b/libavcodec/h264_sei.c
@@ -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);
-
- if (h->avctx->debug & FF_DEBUG_PICT_INFO)
- av_log(h->avctx, AV_LOG_DEBUG, "sei_recovery_frame_cnt: %d\n", h->sei_recovery_frame_cnt);
-
- h->has_recovery_point = 1;
+ skip_bits(gb, 4);
return 0;
}
-static int decode_buffering_period(H264Context *h)
+static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb,
+ const H264ParamSets *ps, void *logctx)
{
unsigned int sps_id;
int sched_sel_idx;
SPS *sps;
- sps_id = get_ue_golomb_31(&h->gb);
- if (sps_id > 31 || !h->ps.sps_list[sps_id]) {
- av_log(h->avctx, AV_LOG_ERROR,
+ sps_id = get_ue_golomb_31(gb);
+ if (sps_id > 31 || !ps->sps_list[sps_id]) {
+ av_log(logctx, AV_LOG_ERROR,
"non-existing SPS %d referenced in buffering period\n", sps_id);
return AVERROR_INVALIDDATA;
}
- sps = (SPS*)h->ps.sps_list[sps_id]->data;
+ sps = (SPS*)ps->sps_list[sps_id]->data;
// NOTE: This is really so duplicated in the standard... See H.264, D.1.1
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_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_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);
}
}
- h->sei_buffering_period_present = 1;
+ h->present = 1;
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);
+ 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->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_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
+ 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_long(gb); // display_orientation_repetition_period
+ skip_bits1(gb); // display_orientation_extension_flag
}
return 0;
@@ -388,107 +377,105 @@ static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
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 && show_bits(gb, 16)) {
int type = 0;
unsigned size = 0;
unsigned next;
int ret = 0;
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);
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 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, 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;
case SEI_TYPE_GREEN_METADATA:
- ret = decode_green_metadata(&h->sei_green_metadata, &h->gb);
+ 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);
}
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)
+const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
{
- if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 0) {
- switch (h->sei_fpa.frame_packing_arrangement_type) {
+ 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:
- if (h->sei_fpa.content_interpretation_type == 2)
+ if (h->content_interpretation_type == 2)
return "block_rl";
else
return "block_lr";
@@ -496,7 +483,7 @@ const char* ff_h264_sei_stereo_mode(H264Context *h)
default:
return "mono";
}
- } else if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 1) {
+ } else if (h->frame_packing_arrangement_cancel_flag == 1) {
return "mono";
} else {
return NULL;
diff --git a/libavcodec/h264_sei.h b/libavcodec/h264_sei.h
new file mode 100644
index 0000000..9197795
--- /dev/null
+++ b/libavcodec/h264_sei.h
@@ -0,0 +1,173 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * 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.
+ *
+ * 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
+ * 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 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 */
diff --git a/libavcodec/h264_slice.c b/libavcodec/h264_slice.c
index 25dbf6c..45e076b 100644
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@ -418,7 +418,7 @@ int ff_h264_update_thread_context(AVCodecContext *dst,
// 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);
@@ -486,7 +486,7 @@ static int h264_frame_start(H264Context *h)
pic->mmco_reset = 0;
pic->recovered = 0;
pic->invalid_gap = 0;
- pic->sei_recovery_frame_cnt = h->sei_recovery_frame_cnt;
+ pic->sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
if ((ret = alloc_picture(h, pic)) < 0)
return ret;
@@ -913,7 +913,7 @@ static int h264_slice_header_init(H264Context *h)
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 * h->avctx->ticks_per_frame, den, 1 << 30);
@@ -1126,7 +1126,7 @@ int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
(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_frame_cnt < 0) ||
+ (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;
}
======================================================================
diff --cc libavcodec/h264.c
index 795e599,060feb9..831d918
--- a/libavcodec/h264.c
+++ b/libavcodec/h264.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->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++)
@@@ -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;
@@@ -655,14 -602,17 +656,14 @@@
}
}
- 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;
@@@ -673,7 -623,7 +674,7 @@@
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;
@@@ -689,48 -639,50 +690,52 @@@
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;
}
@@@ -1165,12 -1035,11 +1172,17 @@@
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]);
diff --cc libavcodec/h264.h
index b156805,a7e926b..ba6f43c
--- a/libavcodec/h264.h
+++ b/libavcodec/h264.h
@@@ -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;
@@@ -721,62 -615,6 +645,11 @@@
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,20 -641,10 +680,18 @@@
* 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;
@@@ -829,10 -653,6 +700,7 @@@
/* 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];
diff --cc libavcodec/h264_mb.c
index 75535ad,b6773e6..c9fdf7a
--- a/libavcodec/h264_mb.c
+++ b/libavcodec/h264_mb.c
@@@ -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,
diff --cc libavcodec/h264_parser.c
index e0977ea,7c674b8..9fccdc9
--- a/libavcodec/h264_parser.c
+++ b/libavcodec/h264_parser.c
@@@ -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;
@@@ -334,10 -283,10 +331,10 @@@
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 (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;
@@@ -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]);
diff --cc libavcodec/h264_sei.c
index 8fcaa61,5e794d6..d0596dc
--- a/libavcodec/h264_sei.c
+++ b/libavcodec/h264_sei.c
@@@ -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);
}
}
@@@ -309,196 -300,109 +308,184 @@@
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;
+ case SEI_TYPE_GREEN_METADATA:
- ret = decode_green_metadata(&h->sei_green_metadata, &h->gb);
++ 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)
++const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
+{
- if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 0) {
- switch (h->sei_fpa.frame_packing_arrangement_type) {
++ 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:
- if (h->sei_fpa.content_interpretation_type == 2)
++ if (h->content_interpretation_type == 2)
+ return "block_rl";
+ else
+ return "block_lr";
+ case SEI_FPA_TYPE_2D:
+ default:
+ return "mono";
+ }
- } else if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 1) {
++ } else if (h->frame_packing_arrangement_cancel_flag == 1) {
+ return "mono";
+ } else {
+ return NULL;
+ }
+}
diff --cc libavcodec/h264_sei.h
index 0000000,58f5ecc..9197795
mode 000000,100644..100644
--- a/libavcodec/h264_sei.h
+++ b/libavcodec/h264_sei.h
@@@ -1,0 -1,137 +1,173 @@@
+ /*
- * This file is part of Libav.
++ * This file is part of FFmpeg.
+ *
- * Libav is free software; you can redistribute it and/or
++ * 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.
+ *
- * Libav is distributed in the hope that it will be useful,
++ * 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
- * License along with Libav; if not, write to the Free Software
++ * 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 arrangement_type;
++ 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_subsampling;
++ 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 */
diff --cc libavcodec/h264_slice.c
index 25dbf6c,5cbfee1..45e076b
--- a/libavcodec/h264_slice.c
+++ b/libavcodec/h264_slice.c
@@@ -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->invalid_gap = 0;
- pic->sei_recovery_frame_cnt = h->sei_recovery_frame_cnt;
++ 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;
}
+ 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_frame_cnt < 0) ||
++ (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;
More information about the ffmpeg-cvslog
mailing list