28 #ifndef AVCODEC_H264DEC_H 29 #define AVCODEC_H264DEC_H 52 #define H264_MAX_PICTURE_COUNT 36 54 #define MAX_MMCO_COUNT 66 56 #define MAX_DELAYED_PIC_COUNT 16 60 #define ALLOW_INTERLACE 70 #ifdef ALLOW_INTERLACE 71 #define MB_MBAFF(h) (h)->mb_mbaff 72 #define MB_FIELD(sl) (sl)->mb_field_decoding_flag 73 #define FRAME_MBAFF(h) (h)->mb_aff_frame 74 #define FIELD_PICTURE(h) ((h)->picture_structure != PICT_FRAME) 81 #define MB_FIELD(sl) 0 82 #define FRAME_MBAFF(h) 0 83 #define FIELD_PICTURE(h) 0 85 #define IS_INTERLACED(mb_type) 0 91 #define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h)) 94 #define CABAC(h) (h)->ps.pps->cabac 97 #define CHROMA(h) ((h)->ps.sps->chroma_format_idc) 98 #define CHROMA422(h) ((h)->ps.sps->chroma_format_idc == 2) 99 #define CHROMA444(h) ((h)->ps.sps->chroma_format_idc == 3) 101 #define MB_TYPE_REF0 MB_TYPE_ACPRED // dirty but it fits in 16 bit 102 #define MB_TYPE_8x8DCT 0x01000000 103 #define IS_REF0(a) ((a) & MB_TYPE_REF0) 104 #define IS_8x8DCT(a) ((a) & MB_TYPE_8x8DCT) 136 int16_t (*motion_val[2])[2];
145 int8_t *ref_index[2];
155 int ref_poc[2][2][32];
205 int8_t intra4x4_pred_mode_cache[5 * 8];
259 int dist_scale_factor[32];
260 int dist_scale_factor_field[2][32];
261 int map_col_to_list0[2][16 + 32];
262 int map_col_to_list0_field[2][2][16 + 32];
267 unsigned int ref_count[2];
275 } ref_modifications[2][32];
276 int nb_ref_modifications[2];
288 int top_borders_allocated[2];
311 int16_t mb_padding[256 * 2];
385 int8_t(*intra4x4_pred_mode);
390 #define LIST_NOT_USED -1 // FIXME rename? 391 #define PART_NOT_AVAILABLE -2 397 int block_offset[2 * (16 * 3)];
517 #define FRAME_RECOVERED_IDR (1 << 0) 522 #define FRAME_RECOVERED_SEI (1 << 1) 605 unsigned int linesize,
unsigned int uvlinesize);
608 unsigned int linesize,
unsigned int uvlinesize);
640 #define LUMA_DC_BLOCK_INDEX 48 641 #define CHROMA_DC_BLOCK_INDEX 49 645 4 + 1 * 8, 5 + 1 * 8, 4 + 2 * 8, 5 + 2 * 8,
646 6 + 1 * 8, 7 + 1 * 8, 6 + 2 * 8, 7 + 2 * 8,
647 4 + 3 * 8, 5 + 3 * 8, 4 + 4 * 8, 5 + 4 * 8,
648 6 + 3 * 8, 7 + 3 * 8, 6 + 4 * 8, 7 + 4 * 8,
649 4 + 6 * 8, 5 + 6 * 8, 4 + 7 * 8, 5 + 7 * 8,
650 6 + 6 * 8, 7 + 6 * 8, 6 + 7 * 8, 7 + 7 * 8,
651 4 + 8 * 8, 5 + 8 * 8, 4 + 9 * 8, 5 + 9 * 8,
652 6 + 8 * 8, 7 + 8 * 8, 6 + 9 * 8, 7 + 9 * 8,
653 4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
654 6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
655 4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
656 6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
657 0 + 0 * 8, 0 + 5 * 8, 0 + 10 * 8
663 return (b & 0xFFFF) + (a << 16);
665 return (a & 0xFFFF) + (b << 16);
672 return (b & 0xFF) + (a << 8);
674 return (a & 0xFF) + (b << 8);
692 const int index8 =
scan8[
n];
697 ff_tlog(h->
avctx,
"mode:%d %d min:%d\n", left, top, min);
712 i4x4[4] = i4x4_cache[7 + 8 * 3];
713 i4x4[5] = i4x4_cache[7 + 8 * 2];
714 i4x4[6] = i4x4_cache[7 + 8 * 1];
720 const int mb_xy = sl->
mb_xy;
724 AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
725 AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
726 AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
727 AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
728 AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
729 AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
730 AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
731 AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
734 AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
735 AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
736 AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
737 AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
745 int mb_type,
int list)
749 AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
750 AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
751 AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
752 AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
761 AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
762 AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
763 AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
770 ref_index[0 + 0 * 2] = ref_cache[
scan8[0]];
771 ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
772 ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
773 ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
783 const int b8_xy = 4 * sl->
mb_xy;
809 0x0001000100010001ULL));
813 0x0001000100010001ULL));
817 int buf_index,
int next_avc)
823 return FFMIN(buf_index, buf_size);
void ff_h264_decode_init_vlc(void)
struct H264Context * h264
const uint8_t * left_block
Memory management control operation.
int long_ref
1->long term reference 0->short term reference
int sei_recovery_frame_cnt
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
This structure describes decoded (raw) audio or video data.
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
ptrdiff_t const GLvoid * data
int neighbor_transform_size
number of neighbors (top and/or left) that used 8x8 dct
int edge_emu_buffer_allocated
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
Decode a CABAC coded macroblock.
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
unsigned int topleft_samples_available
H264ChromaContext h264chroma
uint8_t mvd_cache[2][5 *8][2]
AVBufferRef * mb_type_buf
int bipred_scratchpad_allocated
AVBufferPool * mb_type_pool
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
int16_t(*[2] motion_val)[2]
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
static int find_start_code(const uint8_t *buf, int buf_size, int buf_index, int next_avc)
int is_avc
Used to parse AVC variant of H.264.
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
AVBufferPool * ref_index_pool
static const uint8_t zigzag_scan8x8_cavlc[64+1]
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
static const uint8_t field_scan[16+1]
uint8_t * chroma_pred_mode_table
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
#define USES_LIST(a, list)
uint16_t sub_mb_type[4]
as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
int short_pic_num
pic_num without wrapping (pic_num & max_pic_num)
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)
int slice_alpha_c0_offset
int field_picture
whether or not picture was encoded in separate fields
void ff_h264_flush_change(H264Context *h)
Context for storing H.264 prediction functions.
void ff_h264_remove_all_refs(H264Context *h)
int frame_recovered
Initial frame has been completely recovered.
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
static av_always_inline int pred_intra_mode(const H264Context *h, H264SliceContext *sl, int n)
Get the predicted intra4x4 prediction mode.
AVBufferRef * qscale_table_buf
int has_slice
slice NAL is found in the packet, set by decode_nal_units, its state does not need to be preserved ou...
int recovered
picture at IDR or recovery point + recovery count
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
static av_always_inline void write_back_motion(const H264Context *h, H264SliceContext *sl, int mb_type)
unsigned int topright_samples_available
H.264 parameter set handling.
int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
Init context Allocate buffers which are not shared amongst multiple threads.
void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl, int *mb_type)
void * hwaccel_picture_private
hardware accelerator private data
int8_t intra4x4_pred_mode_cache[5 *8]
static const uint8_t field_scan8x8[64+1]
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
int prev_interlaced_frame
Complement sei_pic_struct SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced...
int direct_spatial_mv_pred
unsigned int top_samples_available
int frame_num
frame_num (raw frame_num from slice header)
MMCOOpcode
Memory management control operation opcode.
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
int valid_recovery_point
Are the SEI recovery points looking valid.
uint8_t * list_counts
Array of list_count per MB specifying the slice type.
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
static av_always_inline uint16_t pack8to16(unsigned a, unsigned b)
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
AVBufferRef * hwaccel_priv_buf
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl)
static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
useful rectangle filling function
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
Context for storing H.264 DSP functions.
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
unsigned int first_mb_addr
int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
int long_ref_count
number of actual long term references
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
uint8_t chroma_qp_table[2][QP_MAX_NUM+1]
pre-scaled (with chroma_qp_index_offset) version of qp_table
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
H264SliceContext * slice_ctx
int direct_8x8_inference_flag
static void fill_rectangle(int x, int y, int w, int h)
const uint16_t ff_h264_mb_sizes[4]
uint8_t * edge_emu_buffer
int bit_depth_luma
luma bit depth from sps to detect changes
int chroma_format_idc
chroma format from sps to detect changes
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
#define MAX_DELAYED_PIC_COUNT
int recovery_frame
recovery_frame is the frame_num at which the next frame should be fully constructed.
main external API structure.
int qp_thresh
QP threshold to skip loopfilter.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
static const uint8_t scan8[16 *3+3]
static const uint8_t field_scan8x8_cavlc[64+1]
Describe the class of an AVClass context structure.
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
int mmco_reset
MMCO_RESET set this 1.
H264Picture * cur_pic_ptr
refcounted data buffer API
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
ptrdiff_t mb_linesize
may be equal to s->linesize or s->linesize * 2, for mbaff
H.264 / AVC / MPEG-4 prediction functions.
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
int mbaff
1 -> MBAFF frame 0-> not MBAFF
A reference to a data buffer.
AVBufferPool * qscale_table_pool
H264Picture * next_output_pic
AVBufferPool * motion_val_pool
static av_always_inline void write_back_non_zero_count(const H264Context *h, H264SliceContext *sl)
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num) ...
#define MAX_SLICES
The maximum number of slices supported by the decoder.
common internal api header.
static av_always_inline void write_back_motion_list(const H264Context *h, H264SliceContext *sl, int b_stride, int b_xy, int b8_xy, int mb_type, int list)
uint16_t * slice_table_base
void ff_h264_free_tables(H264Context *h)
int cur_chroma_format_idc
int8_t * intra4x4_pred_mode
int long_arg
index, pic_num, or num long refs depending on opcode
Core video DSP helper functions.
int8_t ref_cache[2][5 *8]
Decoded Picture Buffer (DPB).
int current_slice
current slice number, used to initialize slice_num of each thread/context
H264Picture last_pic_for_ec
const uint8_t * intra_pcm_ptr
unsigned int left_samples_available
uint8_t(*[2] mvd_table)[2]
int8_t * intra4x4_pred_mode
int mb_field_decoding_flag
uint8_t(* non_zero_count)[48]
H.264 decoder/parser shared code.
uint8_t * bipred_scratchpad
Context Adaptive Binary Arithmetic Coder.
static av_always_inline void write_back_intra_pred_mode(const H264Context *h, H264SliceContext *sl)
#define H264_MAX_PICTURE_COUNT
int short_ref_count
number of actual short term references