28 const int *ref_count,
int slice_type_nos,
30 int picture_structure,
void *logctx)
33 int luma_def, chroma_def;
54 for (list = 0; list < 2; list++) {
57 for (i = 0; i < ref_count[
list]; i++) {
58 int luma_weight_flag, chroma_weight_flag;
61 if (luma_weight_flag) {
66 goto out_range_weight;
79 if (chroma_weight_flag) {
81 for (j = 0; j < 2; j++) {
88 goto out_range_weight;
98 for (j = 0; j < 2; j++) {
110 for (j = 0; j < 2; j++) {
132 int top_samples_available,
int left_samples_available)
134 static const int8_t top[12] = {
137 static const int8_t
left[12] = {
142 if (!(top_samples_available & 0x8000)) {
143 for (i = 0; i < 4; i++) {
147 "top block unavailable for requested intra mode %d\n",
151 pred_mode_cache[scan8[0] +
i] =
status;
156 if ((left_samples_available & 0x8888) != 0x8888) {
157 static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 };
158 for (i = 0; i < 4; i++)
159 if (!(left_samples_available & mask[i])) {
163 "left block unavailable for requested intra4x4 mode %d\n",
167 pred_mode_cache[scan8[0] + 8 *
i] =
status;
180 int left_samples_available,
181 int mode,
int is_chroma)
188 "out of range intra chroma pred mode\n");
192 if (!(top_samples_available & 0x8000)) {
196 "top block unavailable for requested intra mode\n");
201 if ((left_samples_available & 0x8080) != 0x8080) {
205 "left block unavailable for requested intra mode\n");
208 if (is_chroma && (left_samples_available & 0x8080)) {
211 (!(left_samples_available & 0x8000)) +
221 int slice_type_nos,
int picture_structure,
void *logctx)
224 int num_ref_idx_active_override_flag;
232 max[0] = max[1] = picture_structure ==
PICT_FRAME ? 15 : 31;
234 num_ref_idx_active_override_flag =
get_bits1(gb);
236 if (num_ref_idx_active_override_flag) {
250 if (ref_count[0] - 1 > max[0] || (list_count == 2 && (ref_count[1] - 1 > max[1]))) {
252 ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]);
253 ref_count[0] = ref_count[1] = 0;
256 }
else if (ref_count[1] - 1 > max[1]) {
258 ref_count[1] - 1, max[1]);
264 ref_count[0] = ref_count[1] = 0;
267 *plist_count = list_count;
279 int picture_structure,
int nal_ref_idc)
282 int64_t field_poc[2];
307 int64_t expected_delta_per_poc_cycle, expectedpoc;
315 if (nal_ref_idc == 0 && abs_frame_num > 0)
318 expected_delta_per_poc_cycle = 0;
323 if (abs_frame_num > 0) {
327 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
328 for (i = 0; i <= frame_num_in_poc_cycle; i++)
333 if (nal_ref_idc == 0)
336 field_poc[0] = expectedpoc + pc->
delta_poc[0];
351 if ( field_poc[0] != (
int)field_poc[0]
352 || field_poc[1] != (
int)field_poc[1])
356 pic_field_poc[0] = field_poc[0];
358 pic_field_poc[1] = field_poc[1];
359 *pic_poc =
FFMIN(pic_field_poc[0], pic_field_poc[1]);
365 int is_avc,
void *logctx)
376 for (i = 0; i < pkt.
nb_nals; i++) {
385 "SPS decoding failure, trying again with the complete NAL\n");
418 int err_recognition,
void *logctx)
427 int escaped_buf_size;
430 "SPS decoding failure, trying again after escaping the NAL\n");
444 bytestream2_peek_be24(&gbc) <= 3) {
445 bytestream2_put_be24(&pbc, 3);
448 bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
452 AV_WB16(escaped_buf, escaped_buf_size - 2);
463 int *is_avc,
int *nal_length_size,
464 int err_recognition,
void *logctx)
468 if (!data || size <= 0)
483 cnt = *(p + 5) & 0x1f;
485 for (i = 0; i < cnt; i++) {
487 if (nalsize > size - (p - data))
492 "Decoding sps %d from avcC failed\n", i);
499 for (i = 0; i < cnt; i++) {
501 if (nalsize > size - (p - data))
506 "Decoding pps %d from avcC failed\n", i);
512 *nal_length_size = (data[4] & 0x03) + 1;
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
ptrdiff_t const GLvoid * data
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
#define AV_LOG_WARNING
Something somehow does not look correct.
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
#define avpriv_request_sample(...)
static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps, int err_recognition, void *logctx)
int chroma_weight[48][2][2][2]
#define FF_PROFILE_H264_INTRA
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
int size_bits
Size, in bits, of just the data, excluding the stop bit and any trailing padding. ...
#define FF_PROFILE_H264_HIGH_444_PREDICTIVE
#define FF_PROFILE_H264_BASELINE
int offset_for_non_ref_pic
int frame_num_offset
for POC type 2
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int is_nalff, int nal_length_size, enum AVCodecID codec_id, int small_padding, int use_ref)
Split an input packet into NAL units.
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, int *is_avc, int *nal_length_size, int err_recognition, void *logctx)
#define PICT_BOTTOM_FIELD
bitstream reader API header.
#define AV_LOG_VERBOSE
Detailed information.
int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, int top_samples_available, int left_samples_available)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps, int is_avc, void *logctx)
int luma_weight[48][2][2]
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
H.264 common definitions.
H.264 parameter set handling.
int chroma_log2_weight_denom
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
int poc_type
pic_order_cnt_type
static const uint16_t mask[17]
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#define ALZHEIMER_DC_L0T_PRED8x8
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define FF_PROFILE_H264_HIGH_422
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
int offset_for_top_to_bottom_field
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure, void *logctx)
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
int luma_log2_weight_denom
H.264 / AVC / MPEG-4 part10 codec.
#define AV_EF_EXPLODE
abort decoding on minor error detection
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
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]
int constraint_set_flags
constraint_set[0-3]_flag
static unsigned int get_bits1(GetBitContext *s)
int prev_frame_num
frame_num of the last pic for POC type 1/2
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, int left_samples_available, int mode, int is_chroma)
Check if the top & left blocks are available if needed and change the dc mode so it only uses the ava...
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt, int picture_structure, void *logctx)
int prev_frame_num_offset
for POC type 2
int32_t offset_for_ref_frame[256]
#define FF_PROFILE_H264_CONSTRAINED
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 all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
H.264 decoder/parser shared code.
#define FF_PROFILE_H264_HIGH_10
mode
Use these values in ebur128_init (or'ed).