X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=libavcodec%2Fh264.h;h=cd4bf87690404df62042787677d807892eb5b9a0;hb=45ce880a9b3e50cfa088f111dffaf8685bd7bc6b;hp=45c134e8775f67197b47e5edd08f23b146d20c09;hpb=2c541554076cc8a72e7145d4da30389ca763f32f;p=ffmpeg diff --git a/libavcodec/h264.h b/libavcodec/h264.h index 45c134e8775..cd4bf876904 100644 --- a/libavcodec/h264.h +++ b/libavcodec/h264.h @@ -30,13 +30,21 @@ #include "libavutil/intreadwrite.h" #include "cabac.h" +#include "error_resilience.h" #include "get_bits.h" -#include "mpegvideo.h" #include "h264chroma.h" #include "h264dsp.h" #include "h264pred.h" #include "h264qpel.h" +#include "me_cmp.h" +#include "mpegutils.h" +#include "parser.h" +#include "qpeldsp.h" #include "rectangle.h" +#include "videodsp.h" + +#define H264_MAX_PICTURE_COUNT 32 +#define H264_MAX_THREADS 16 #define MAX_SPS_COUNT 32 #define MAX_PPS_COUNT 256 @@ -58,19 +66,19 @@ #define MAX_SLICES 16 #ifdef ALLOW_INTERLACE -#define MB_MBAFF h->mb_mbaff -#define MB_FIELD h->mb_field_decoding_flag -#define FRAME_MBAFF h->mb_aff_frame -#define FIELD_PICTURE (h->picture_structure != PICT_FRAME) +#define MB_MBAFF(h) h->mb_mbaff +#define MB_FIELD(h) h->mb_field_decoding_flag +#define FRAME_MBAFF(h) h->mb_aff_frame +#define FIELD_PICTURE(h) (h->picture_structure != PICT_FRAME) #define LEFT_MBS 2 #define LTOP 0 #define LBOT 1 #define LEFT(i) (i) #else -#define MB_MBAFF 0 -#define MB_FIELD 0 -#define FRAME_MBAFF 0 -#define FIELD_PICTURE 0 +#define MB_MBAFF(h) 0 +#define MB_FIELD(h) 0 +#define FRAME_MBAFF(h) 0 +#define FIELD_PICTURE(h) 0 #undef IS_INTERLACED #define IS_INTERLACED(mb_type) 0 #define LEFT_MBS 1 @@ -78,14 +86,14 @@ #define LBOT 0 #define LEFT(i) 0 #endif -#define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE) +#define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h)) #ifndef CABAC -#define CABAC h->pps.cabac +#define CABAC(h) h->pps.cabac #endif -#define CHROMA422 (h->sps.chroma_format_idc == 2) -#define CHROMA444 (h->sps.chroma_format_idc == 3) +#define CHROMA422(h) (h->sps.chroma_format_idc == 2) +#define CHROMA444(h) (h->sps.chroma_format_idc == 3) #define EXTENDED_SAR 255 @@ -98,19 +106,19 @@ /* NAL unit types */ enum { - NAL_SLICE = 1, - NAL_DPA, - NAL_DPB, - NAL_DPC, - NAL_IDR_SLICE, - NAL_SEI, - NAL_SPS, - NAL_PPS, - NAL_AUD, - NAL_END_SEQUENCE, - NAL_END_STREAM, - NAL_FILLER_DATA, - NAL_SPS_EXT, + NAL_SLICE = 1, + NAL_DPA = 2, + NAL_DPB = 3, + NAL_DPC = 4, + NAL_IDR_SLICE = 5, + NAL_SEI = 6, + NAL_SPS = 7, + NAL_PPS = 8, + NAL_AUD = 9, + NAL_END_SEQUENCE = 10, + NAL_END_STREAM = 11, + NAL_FILLER_DATA = 12, + NAL_SPS_EXT = 13, NAL_AUXILIARY_SLICE = 19, NAL_FF_IGNORE = 0xff0f001, }; @@ -119,10 +127,12 @@ enum { * SEI message types */ typedef enum { - SEI_BUFFERING_PERIOD = 0, ///< buffering period (H.264, D.1.1) + SEI_TYPE_BUFFERING_PERIOD = 0, ///< buffering period (H.264, D.1.1) SEI_TYPE_PIC_TIMING = 1, ///< picture timing SEI_TYPE_USER_DATA_UNREGISTERED = 5, ///< unregistered user data - SEI_TYPE_RECOVERY_POINT = 6 ///< recovery point (frame # to decoder sync) + 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; /** @@ -144,6 +154,7 @@ typedef enum { * Sequence parameter set */ typedef struct SPS { + unsigned int sps_id; int profile_idc; int level_idc; int chroma_format_idc; @@ -163,6 +174,8 @@ typedef struct SPS { int mb_aff; ///< mb_adaptive_frame_field_flag int direct_8x8_inference_flag; int crop; ///< frame_cropping_flag + + /* those 4 are already in luma samples */ unsigned int crop_left; ///< frame_cropping_rect_left_offset unsigned int crop_right; ///< frame_cropping_rect_right_offset unsigned int crop_top; ///< frame_cropping_rect_top_offset @@ -247,34 +260,69 @@ typedef struct MMCO { int long_arg; ///< index, pic_num, or num long refs depending on opcode } MMCO; +typedef struct H264Picture { + struct AVFrame f; + ThreadFrame tf; + + AVBufferRef *qscale_table_buf; + int8_t *qscale_table; + + AVBufferRef *motion_val_buf[2]; + int16_t (*motion_val[2])[2]; + + AVBufferRef *mb_type_buf; + uint32_t *mb_type; + + AVBufferRef *hwaccel_priv_buf; + void *hwaccel_picture_private; ///< hardware accelerator private data + + AVBufferRef *ref_index_buf[2]; + int8_t *ref_index[2]; + + int field_poc[2]; ///< top/bottom POC + int poc; ///< frame POC + int frame_num; ///< frame_num (raw frame_num from slice header) + int mmco_reset; /**< MMCO_RESET set this 1. Reordering code must + not mix pictures before and after MMCO_RESET. */ + int pic_id; /**< pic_num (short -> no wrap version of pic_num, + pic_num & max_pic_num; long -> long_pic_num) */ + int long_ref; ///< 1->long term reference 0->short term reference + int ref_poc[2][2][32]; ///< POCs of the frames used as reference (FIXME need per slice) + int ref_count[2][2]; ///< number of entries in ref_poc (FIXME need per slice) + int mbaff; ///< 1 -> MBAFF frame 0-> not MBAFF + int field_picture; ///< whether or not picture was encoded in separate fields + + int needs_realloc; ///< picture needs to be reallocated (eg due to a frame size change) + int reference; + int recovered; ///< picture at IDR or recovery point + recovery count +} H264Picture; + /** * H264Context */ typedef struct H264Context { AVCodecContext *avctx; - DSPContext dsp; + MECmpContext mecc; VideoDSPContext vdsp; H264DSPContext h264dsp; H264ChromaContext h264chroma; H264QpelContext h264qpel; - MotionEstContext me; ParseContext parse_context; GetBitContext gb; ERContext er; - Picture *DPB; - Picture *cur_pic_ptr; - Picture cur_pic; - int picture_count; - int picture_range_start, picture_range_end; + H264Picture *DPB; + H264Picture *cur_pic_ptr; + H264Picture cur_pic; int pixel_shift; ///< 0 for 8-bit H264, 1 for high-bit-depth H264 int chroma_qp[2]; // QPc int qp_thresh; ///< QP threshold to skip loopfilter + /* coded dimensions -- 16 * mb w/h */ int width, height; - int linesize, uvlinesize; + ptrdiff_t linesize, uvlinesize; int chroma_x_shift, chroma_y_shift; int qscale; @@ -347,19 +395,11 @@ typedef struct H264Context { uint32_t *mb2br_xy; int b_stride; // FIXME use s->b4_stride - int mb_linesize; ///< may be equal to s->linesize or s->linesize * 2, for mbaff - int mb_uvlinesize; - - int emu_edge_width; - int emu_edge_height; + ptrdiff_t mb_linesize; ///< may be equal to s->linesize or s->linesize * 2, for mbaff + ptrdiff_t mb_uvlinesize; - unsigned current_sps_id; ///< id of the current SPS SPS sps; ///< current sps - - /** - * current pps - */ - PPS pps; // FIXME move to Picture perhaps? (->no) do we need that? + PPS pps; ///< current pps uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16]; // FIXME should these be moved down? uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64]; @@ -405,7 +445,7 @@ typedef struct H264Context { unsigned int ref_count[2]; ///< counts frames or fields, depending on current mb mode unsigned int list_count; uint8_t *list_counts; ///< Array of list_count per MB specifying the slice type - Picture ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs. + H264Picture ref_list[2][48]; /**< 0..15: frame refs, 16..47: mbaff field refs. * Reordered version of default_ref_list * according to picture reordering in slice header */ int ref2frm[MAX_SLICES][2][64]; ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1 @@ -416,6 +456,7 @@ typedef struct H264Context { GetBitContext *intra_gb_ptr; GetBitContext *inter_gb_ptr; + const uint8_t *intra_pcm_ptr; DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2]; ///< as a dct coeffecient is int32_t in high depth, we need to reserve twice the space. DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2]; int16_t mb_padding[256 * 2]; ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too large or ensure that there is some unused stuff after mb @@ -519,12 +560,12 @@ typedef struct H264Context { int redundant_pic_count; - Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture - Picture *short_ref[32]; - Picture *long_ref[32]; - Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size? + H264Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture + H264Picture *short_ref[32]; + H264Picture *long_ref[32]; + H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size? int last_pocs[MAX_DELAYED_PIC_COUNT]; - Picture *next_output_pic; + H264Picture *next_output_pic; int outputed_poc; int next_outputed_poc; @@ -544,7 +585,7 @@ typedef struct H264Context { * @name Members for slice based multithreading * @{ */ - struct H264Context *thread_context[MAX_THREADS]; + struct H264Context *thread_context[H264_MAX_THREADS]; /** * current slice number, used to initalize slice_num of each thread/context @@ -585,6 +626,21 @@ 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; + /** * 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 @@ -611,6 +667,27 @@ typedef struct H264Context { */ int sei_recovery_frame_cnt; + /** + * recovery_frame is the frame_num at which the next frame should + * be fully constructed. + * + * Set to -1 when not expecting a recovery point. + */ + int recovery_frame; + +/** + * We have seen an IDR, so all the following frames in coded order are correctly + * decodable. + */ +#define FRAME_RECOVERED_IDR (1 << 0) +/** + * Sufficient number of frames have been decoded since a SEI recovery point, + * so all the following frames in presentation order are correct. + */ +#define FRAME_RECOVERED_SEI (1 << 1) + + int frame_recovered; ///< Initial frame has been completely recovered + int luma_weight_flag[2]; ///< 7.4.3.2 luma_weight_lX_flag int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag @@ -622,6 +699,15 @@ typedef struct H264Context { uint8_t *bipred_scratchpad; uint8_t *edge_emu_buffer; int16_t *dc_val_base; + + AVBufferPool *qscale_table_pool; + AVBufferPool *mb_type_pool; + AVBufferPool *motion_val_pool; + AVBufferPool *ref_index_pool; + + /* Motion Estimation */ + qpel_mc_func (*qpel_put)[16]; + qpel_mc_func (*qpel_avg)[16]; } H264Context; extern const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM + 1]; ///< One chroma qp table for each supported bit depth (8, 9, 10). @@ -662,7 +748,7 @@ const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, * Free any data that may have been allocated in the H264 context * like SPS, PPS etc. */ -av_cold void ff_h264_free_context(H264Context *h); +void ff_h264_free_context(H264Context *h); /** * Reconstruct bitstream slice_type. @@ -707,10 +793,9 @@ int ff_h264_check_intra4x4_pred_mode(H264Context *h); int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma); void ff_h264_hl_decode_mb(H264Context *h); -int ff_h264_frame_start(H264Context *h); int ff_h264_decode_extradata(H264Context *h); -av_cold int ff_h264_decode_init(AVCodecContext *avctx); -av_cold void ff_h264_decode_init_vlc(void); +int ff_h264_decode_init(AVCodecContext *avctx); +void ff_h264_decode_init_vlc(void); /** * Decode a macroblock @@ -726,6 +811,8 @@ int ff_h264_decode_mb_cabac(H264Context *h); void ff_h264_init_cabac_states(H264Context *h); +void h264_init_dequant_tables(H264Context *h); + void ff_h264_direct_dist_scale_factor(H264Context *const h); void ff_h264_direct_ref_list_init(H264Context *const h); void ff_h264_pred_direct_motion(H264Context *const h, int *mb_type); @@ -877,13 +964,13 @@ static av_always_inline void write_back_motion_list(H264Context *h, int b_xy, int b8_xy, int mb_type, int list) { - int16_t(*mv_dst)[2] = &h->cur_pic.f.motion_val[list][b_xy]; + int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy]; int16_t(*mv_src)[2] = &h->mv_cache[list][scan8[0]]; AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0); AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1); AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2); AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3); - if (CABAC) { + if (CABAC(h)) { uint8_t (*mvd_dst)[2] = &h->mvd_table[list][FMO ? 8 * h->mb_xy : h->mb2br_xy[h->mb_xy]]; uint8_t(*mvd_src)[2] = &h->mvd_cache[list][scan8[0]]; @@ -898,7 +985,7 @@ static av_always_inline void write_back_motion_list(H264Context *h, } { - int8_t *ref_index = &h->cur_pic.f.ref_index[list][b8_xy]; + int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy]; int8_t *ref_cache = h->ref_cache[list]; ref_index[0 + 0 * 2] = ref_cache[scan8[0]]; ref_index[1 + 0 * 2] = ref_cache[scan8[4]]; @@ -916,13 +1003,13 @@ static av_always_inline void write_back_motion(H264Context *h, int mb_type) if (USES_LIST(mb_type, 0)) { write_back_motion_list(h, b_stride, b_xy, b8_xy, mb_type, 0); } else { - fill_rectangle(&h->cur_pic.f.ref_index[0][b8_xy], + fill_rectangle(&h->cur_pic.ref_index[0][b8_xy], 2, 2, 2, (uint8_t)LIST_NOT_USED, 1); } if (USES_LIST(mb_type, 1)) write_back_motion_list(h, b_stride, b_xy, b8_xy, mb_type, 1); - if (h->slice_type_nos == AV_PICTURE_TYPE_B && CABAC) { + if (h->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) { if (IS_8X8(mb_type)) { uint8_t *direct_table = &h->direct_table[4 * h->mb_xy]; direct_table[1] = h->sub_mb_type[1] >> 1; @@ -944,6 +1031,26 @@ static av_always_inline int get_dct8x8_allowed(H264Context *h) 0x0001000100010001ULL)); } +int ff_h264_field_end(H264Context *h, int in_setup); + +int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src); +void ff_h264_unref_picture(H264Context *h, H264Picture *pic); + +int ff_h264_context_init(H264Context *h); +int ff_h264_set_parameter_from_sps(H264Context *h); + void ff_h264_draw_horiz_band(H264Context *h, int y, int height); +int ff_init_poc(H264Context *h, int pic_field_poc[2], int *pic_poc); +int ff_pred_weight_table(H264Context *h); +int ff_set_ref_count(H264Context *h); + +int ff_h264_decode_slice_header(H264Context *h, H264Context *h0); +int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count); +int ff_h264_update_thread_context(AVCodecContext *dst, + const AVCodecContext *src); + +void ff_h264_flush_change(H264Context *h); + +void ff_h264_free_tables(H264Context *h, int free_rbsp); #endif /* AVCODEC_H264_H */