1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
26
28 const int *ref_count, int slice_type_nos,
30 int picture_structure, void *logctx)
31 {
32 int list, i, j;
33 int luma_def, chroma_def;
34
37
42 }
44
50 }
52 }
53
54 for (list = 0; list < 2; list++) {
57 for (i = 0; i < ref_count[list]; i++) {
58 int luma_weight_flag, chroma_weight_flag;
59
61 if (luma_weight_flag) {
66 goto out_range_weight;
71 }
72 } else {
75 }
76
79 if (chroma_weight_flag) {
80 int j;
81 for (j = 0; j < 2; j++) {
88 goto out_range_weight;
89 }
94 }
95 }
96 } else {
97 int j;
98 for (j = 0; j < 2; j++) {
101 }
102 }
103 }
104
105 // for MBAFF
110 for (j = 0; j < 2; j++) {
113 }
114 }
115 }
116 }
118 break;
119 }
121 return 0;
122 out_range_weight:
125 }
126
127 /**
128 * Check if the top & left blocks are available if needed and
129 * change the dc mode so it only uses the available blocks.
130 */
132 int top_samples_available, int left_samples_available)
133 {
134 static const int8_t top[12] = {
136 };
137 static const int8_t left[12] = {
139 };
140 int i;
141
142 if (!(top_samples_available & 0x8000)) {
143 for (i = 0; i < 4; i++) {
144 int status = top[pred_mode_cache[
scan8[0] + i]];
145 if (status < 0) {
147 "top block unavailable for requested intra mode %d\n",
148 status);
150 } else if (status) {
151 pred_mode_cache[scan8[0] + i] = status;
152 }
153 }
154 }
155
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])) {
160 int status = left[pred_mode_cache[
scan8[0] + 8 * i]];
161 if (status < 0) {
163 "left block unavailable for requested intra4x4 mode %d\n",
164 status);
166 } else if (status) {
167 pred_mode_cache[scan8[0] + 8 * i] = status;
168 }
169 }
170 }
171
172 return 0;
173 }
174
175 /**
176 * Check if the top & left blocks are available if needed and
177 * change the dc mode so it only uses the available blocks.
178 */
180 int left_samples_available,
181 int mode,
int is_chroma)
182 {
185
188 "out of range intra chroma pred mode\n");
190 }
191
192 if (!(top_samples_available & 0x8000)) {
194 if (mode < 0) {
196 "top block unavailable for requested intra mode\n");
198 }
199 }
200
201 if ((left_samples_available & 0x8080) != 0x8080) {
203 if (mode < 0) {
205 "left block unavailable for requested intra mode\n");
207 }
208 if (is_chroma && (left_samples_available & 0x8080)) {
209 // mad cow disease mode, aka MBAFF + constrained_intra_pred
211 (!(left_samples_available & 0x8000)) +
213 }
214 }
215
217 }
218
221 int slice_type_nos, int picture_structure, void *logctx)
222 {
223 int list_count;
224 int num_ref_idx_active_override_flag;
225
226 // set defaults, might be overridden a few lines later
229
231 unsigned max[2];
232 max[0] = max[1] = picture_structure ==
PICT_FRAME ? 15 : 31;
233
234 num_ref_idx_active_override_flag =
get_bits1(gb);
235
236 if (num_ref_idx_active_override_flag) {
240 } else
241 // full range is spec-ok in this case, even for frames
242 ref_count[1] = 1;
243 }
244
245 if (ref_count[0] - 1 > max[0] || ref_count[1] - 1 > max[1]) {
247 ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]);
248 ref_count[0] = ref_count[1] = 0;
249 *plist_count = 0;
251 }
252
254 list_count = 2;
255 else
256 list_count = 1;
257 } else {
258 list_count = 0;
259 ref_count[0] = ref_count[1] = 0;
260 }
261
262 *plist_count = list_count;
263
264 return 0;
266 *plist_count = 0;
267 ref_count[0] = 0;
268 ref_count[1] = 0;
270 }
271
274 int picture_structure, int nal_ref_idc)
275 {
277 int64_t field_poc[2];
278
282
285
292 else
294 field_poc[0] =
299 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
300 int i;
301
304 else
305 abs_frame_num = 0;
306
307 if (nal_ref_idc == 0 && abs_frame_num > 0)
308 abs_frame_num--;
309
310 expected_delta_per_poc_cycle = 0;
312 // FIXME integrate during sps parse
314
315 if (abs_frame_num > 0) {
318
319 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
320 for (i = 0; i <= frame_num_in_poc_cycle; i++)
322 } else
323 expectedpoc = 0;
324
325 if (nal_ref_idc == 0)
327
328 field_poc[0] = expectedpoc + pc->
delta_poc[0];
330
333 } else {
335
336 if (!nal_ref_idc)
337 poc--;
338
339 field_poc[0] = poc;
340 field_poc[1] = poc;
341 }
342
343 if ( field_poc[0] != (int)field_poc[0]
344 || field_poc[1] != (
int)field_poc[1])
346
348 pic_field_poc[0] = field_poc[0];
350 pic_field_poc[1] = field_poc[1];
351 *pic_poc =
FFMIN(pic_field_poc[0], pic_field_poc[1]);
352
353 return 0;
354 }
355
357 int is_avc, void *logctx)
358 {
360 int i, ret = 0;
361
363 if (ret < 0) {
364 ret = 0;
366 }
367
368 for (i = 0; i < pkt.
nb_nals; i++) {
373 if (ret < 0)
375 break;
379 if (ret < 0)
381 break;
382 default:
385 break;
386 }
387 }
388
391 return ret;
392 }
393
394 /* There are (invalid) samples in the wild with mp4-style extradata, where the
395 * parameter sets are stored unescaped (i.e. as RBSP).
396 * This function catches the parameter set decoding failure and tries again
397 * after escaping it */
399 int err_recognition, void *logctx)
400 {
401 int ret;
402
408 int escaped_buf_size;
409
411 "SPS decoding failure, trying again after escaping the NAL\n");
412
417 if (!escaped_buf)
419
422
425 bytestream2_peek_be24(&gbc) <= 3) {
426 bytestream2_put_be24(&pbc, 3);
428 } else
429 bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
430 }
431
433 AV_WB16(escaped_buf, escaped_buf_size - 2);
434
436 // lorex.mp4 decodes ok even with extradata decoding failing
438 }
439
440 return 0;
441 }
442
444 int *is_avc, int *nal_length_size,
445 int err_recognition, void *logctx)
446 {
447 int ret;
448
449 if (!data || size <= 0)
450 return -1;
451
452 if (data[0] == 1) {
453 int i, cnt, nalsize;
455
456 *is_avc = 1;
457
458 if (size < 7) {
461 }
462
463 // Decode sps from avcC
464 cnt = *(p + 5) & 0x1f; // Number of sps
465 p += 6;
466 for (i = 0; i < cnt; i++) {
468 if (nalsize > size - (p - data))
471 if (ret < 0) {
473 "Decoding sps %d from avcC failed\n", i);
474 return ret;
475 }
476 p += nalsize;
477 }
478 // Decode pps from avcC
479 cnt = *(p++); // Number of pps
480 for (i = 0; i < cnt; i++) {
482 if (nalsize > size - (p - data))
485 if (ret < 0) {
487 "Decoding pps %d from avcC failed\n", i);
488 return ret;
489 }
490 p += nalsize;
491 }
492 // Store right nal length size that will be used to parse all other nals
493 *nal_length_size = (data[4] & 0x03) + 1;
494 } else {
495 *is_avc = 0;
497 if (ret < 0)
498 return ret;
499 }
501 }
502
503 /**
504 * Compute profile from profile_idc and constraint_set?_flags.
505 *
506 * @param sps SPS
507 *
508 * @return profile as defined by FF_PROFILE_H264_*
509 */
511 {
513
516 // constraint_set1_flag set to 1
518 break;
522 // constraint_set3_flag set to 1
524 break;
525 }
526
528 }
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
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)
Split an input packet into NAL units.
#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
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
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
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
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]
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
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
#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
short offset_for_ref_frame[256]
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)
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
#define FF_PROFILE_H264_CONSTRAINED
H.264 decoder/parser shared code.
#define FF_PROFILE_H264_HIGH_10
mode
Use these values in ebur128_init (or'ed).