blob: e21582b46f73da5ffa3e33485a57c46e41f61c99
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 | |
19 | #include "bytestream.h" |
20 | #include "get_bits.h" |
21 | #include "golomb.h" |
22 | #include "h264.h" |
23 | #include "h264dec.h" |
24 | #include "h264_parse.h" |
25 | #include "h264_ps.h" |
26 | |
27 | int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, |
28 | const int *ref_count, int slice_type_nos, |
29 | H264PredWeightTable *pwt, void *logctx) |
30 | { |
31 | int list, i, j; |
32 | int luma_def, chroma_def; |
33 | |
34 | pwt->use_weight = 0; |
35 | pwt->use_weight_chroma = 0; |
36 | pwt->luma_log2_weight_denom = get_ue_golomb(gb); |
37 | if (sps->chroma_format_idc) |
38 | pwt->chroma_log2_weight_denom = get_ue_golomb(gb); |
39 | |
40 | if (pwt->luma_log2_weight_denom > 7U) { |
41 | av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom); |
42 | pwt->luma_log2_weight_denom = 0; |
43 | } |
44 | if (pwt->chroma_log2_weight_denom > 7U) { |
45 | av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom); |
46 | pwt->chroma_log2_weight_denom = 0; |
47 | } |
48 | |
49 | luma_def = 1 << pwt->luma_log2_weight_denom; |
50 | chroma_def = 1 << pwt->chroma_log2_weight_denom; |
51 | |
52 | for (list = 0; list < 2; list++) { |
53 | pwt->luma_weight_flag[list] = 0; |
54 | pwt->chroma_weight_flag[list] = 0; |
55 | for (i = 0; i < ref_count[list]; i++) { |
56 | int luma_weight_flag, chroma_weight_flag; |
57 | |
58 | luma_weight_flag = get_bits1(gb); |
59 | if (luma_weight_flag) { |
60 | pwt->luma_weight[i][list][0] = get_se_golomb(gb); |
61 | pwt->luma_weight[i][list][1] = get_se_golomb(gb); |
62 | if ((int8_t)pwt->luma_weight[i][list][0] != pwt->luma_weight[i][list][0] || |
63 | (int8_t)pwt->luma_weight[i][list][1] != pwt->luma_weight[i][list][1]) |
64 | goto out_range_weight; |
65 | if (pwt->luma_weight[i][list][0] != luma_def || |
66 | pwt->luma_weight[i][list][1] != 0) { |
67 | pwt->use_weight = 1; |
68 | pwt->luma_weight_flag[list] = 1; |
69 | } |
70 | } else { |
71 | pwt->luma_weight[i][list][0] = luma_def; |
72 | pwt->luma_weight[i][list][1] = 0; |
73 | } |
74 | |
75 | if (sps->chroma_format_idc) { |
76 | chroma_weight_flag = get_bits1(gb); |
77 | if (chroma_weight_flag) { |
78 | int j; |
79 | for (j = 0; j < 2; j++) { |
80 | pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb); |
81 | pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb); |
82 | if ((int8_t)pwt->chroma_weight[i][list][j][0] != pwt->chroma_weight[i][list][j][0] || |
83 | (int8_t)pwt->chroma_weight[i][list][j][1] != pwt->chroma_weight[i][list][j][1]) |
84 | goto out_range_weight; |
85 | if (pwt->chroma_weight[i][list][j][0] != chroma_def || |
86 | pwt->chroma_weight[i][list][j][1] != 0) { |
87 | pwt->use_weight_chroma = 1; |
88 | pwt->chroma_weight_flag[list] = 1; |
89 | } |
90 | } |
91 | } else { |
92 | int j; |
93 | for (j = 0; j < 2; j++) { |
94 | pwt->chroma_weight[i][list][j][0] = chroma_def; |
95 | pwt->chroma_weight[i][list][j][1] = 0; |
96 | } |
97 | } |
98 | } |
99 | |
100 | // for MBAFF |
101 | pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0]; |
102 | pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1]; |
103 | for (j = 0; j < 2; j++) { |
104 | pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0]; |
105 | pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1]; |
106 | } |
107 | } |
108 | if (slice_type_nos != AV_PICTURE_TYPE_B) |
109 | break; |
110 | } |
111 | pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma; |
112 | return 0; |
113 | out_range_weight: |
114 | avpriv_request_sample(logctx, "Out of range weight\n"); |
115 | return AVERROR_INVALIDDATA; |
116 | } |
117 | |
118 | /** |
119 | * Check if the top & left blocks are available if needed and |
120 | * change the dc mode so it only uses the available blocks. |
121 | */ |
122 | int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx, |
123 | int top_samples_available, int left_samples_available) |
124 | { |
125 | static const int8_t top[12] = { |
126 | -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0 |
127 | }; |
128 | static const int8_t left[12] = { |
129 | 0, -1, TOP_DC_PRED, 0, -1, -1, -1, 0, -1, DC_128_PRED |
130 | }; |
131 | int i; |
132 | |
133 | if (!(top_samples_available & 0x8000)) { |
134 | for (i = 0; i < 4; i++) { |
135 | int status = top[pred_mode_cache[scan8[0] + i]]; |
136 | if (status < 0) { |
137 | av_log(logctx, AV_LOG_ERROR, |
138 | "top block unavailable for requested intra mode %d\n", |
139 | status); |
140 | return AVERROR_INVALIDDATA; |
141 | } else if (status) { |
142 | pred_mode_cache[scan8[0] + i] = status; |
143 | } |
144 | } |
145 | } |
146 | |
147 | if ((left_samples_available & 0x8888) != 0x8888) { |
148 | static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 }; |
149 | for (i = 0; i < 4; i++) |
150 | if (!(left_samples_available & mask[i])) { |
151 | int status = left[pred_mode_cache[scan8[0] + 8 * i]]; |
152 | if (status < 0) { |
153 | av_log(logctx, AV_LOG_ERROR, |
154 | "left block unavailable for requested intra4x4 mode %d\n", |
155 | status); |
156 | return AVERROR_INVALIDDATA; |
157 | } else if (status) { |
158 | pred_mode_cache[scan8[0] + 8 * i] = status; |
159 | } |
160 | } |
161 | } |
162 | |
163 | return 0; |
164 | } |
165 | |
166 | /** |
167 | * Check if the top & left blocks are available if needed and |
168 | * change the dc mode so it only uses the available blocks. |
169 | */ |
170 | int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available, |
171 | int left_samples_available, |
172 | int mode, int is_chroma) |
173 | { |
174 | static const int8_t top[4] = { LEFT_DC_PRED8x8, 1, -1, -1 }; |
175 | static const int8_t left[5] = { TOP_DC_PRED8x8, -1, 2, -1, DC_128_PRED8x8 }; |
176 | |
177 | if (mode > 3U) { |
178 | av_log(logctx, AV_LOG_ERROR, |
179 | "out of range intra chroma pred mode\n"); |
180 | return AVERROR_INVALIDDATA; |
181 | } |
182 | |
183 | if (!(top_samples_available & 0x8000)) { |
184 | mode = top[mode]; |
185 | if (mode < 0) { |
186 | av_log(logctx, AV_LOG_ERROR, |
187 | "top block unavailable for requested intra mode\n"); |
188 | return AVERROR_INVALIDDATA; |
189 | } |
190 | } |
191 | |
192 | if ((left_samples_available & 0x8080) != 0x8080) { |
193 | mode = left[mode]; |
194 | if (mode < 0) { |
195 | av_log(logctx, AV_LOG_ERROR, |
196 | "left block unavailable for requested intra mode\n"); |
197 | return AVERROR_INVALIDDATA; |
198 | } |
199 | if (is_chroma && (left_samples_available & 0x8080)) { |
200 | // mad cow disease mode, aka MBAFF + constrained_intra_pred |
201 | mode = ALZHEIMER_DC_L0T_PRED8x8 + |
202 | (!(left_samples_available & 0x8000)) + |
203 | 2 * (mode == DC_128_PRED8x8); |
204 | } |
205 | } |
206 | |
207 | return mode; |
208 | } |
209 | |
210 | int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], |
211 | GetBitContext *gb, const PPS *pps, |
212 | int slice_type_nos, int picture_structure, void *logctx) |
213 | { |
214 | int list_count; |
215 | int num_ref_idx_active_override_flag; |
216 | |
217 | // set defaults, might be overridden a few lines later |
218 | ref_count[0] = pps->ref_count[0]; |
219 | ref_count[1] = pps->ref_count[1]; |
220 | |
221 | if (slice_type_nos != AV_PICTURE_TYPE_I) { |
222 | unsigned max[2]; |
223 | max[0] = max[1] = picture_structure == PICT_FRAME ? 15 : 31; |
224 | |
225 | num_ref_idx_active_override_flag = get_bits1(gb); |
226 | |
227 | if (num_ref_idx_active_override_flag) { |
228 | ref_count[0] = get_ue_golomb(gb) + 1; |
229 | if (slice_type_nos == AV_PICTURE_TYPE_B) { |
230 | ref_count[1] = get_ue_golomb(gb) + 1; |
231 | } else |
232 | // full range is spec-ok in this case, even for frames |
233 | ref_count[1] = 1; |
234 | } |
235 | |
236 | if (ref_count[0] - 1 > max[0] || ref_count[1] - 1 > max[1]) { |
237 | av_log(logctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n", |
238 | ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]); |
239 | ref_count[0] = ref_count[1] = 0; |
240 | *plist_count = 0; |
241 | goto fail; |
242 | } |
243 | |
244 | if (slice_type_nos == AV_PICTURE_TYPE_B) |
245 | list_count = 2; |
246 | else |
247 | list_count = 1; |
248 | } else { |
249 | list_count = 0; |
250 | ref_count[0] = ref_count[1] = 0; |
251 | } |
252 | |
253 | *plist_count = list_count; |
254 | |
255 | return 0; |
256 | fail: |
257 | *plist_count = 0; |
258 | ref_count[0] = 0; |
259 | ref_count[1] = 0; |
260 | return AVERROR_INVALIDDATA; |
261 | } |
262 | |
263 | int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, |
264 | const SPS *sps, H264POCContext *pc, |
265 | int picture_structure, int nal_ref_idc) |
266 | { |
267 | const int max_frame_num = 1 << sps->log2_max_frame_num; |
268 | int field_poc[2]; |
269 | |
270 | pc->frame_num_offset = pc->prev_frame_num_offset; |
271 | if (pc->frame_num < pc->prev_frame_num) |
272 | pc->frame_num_offset += max_frame_num; |
273 | |
274 | if (sps->poc_type == 0) { |
275 | const int max_poc_lsb = 1 << sps->log2_max_poc_lsb; |
276 | |
277 | if (pc->poc_lsb < pc->prev_poc_lsb && |
278 | pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2) |
279 | pc->poc_msb = pc->prev_poc_msb + max_poc_lsb; |
280 | else if (pc->poc_lsb > pc->prev_poc_lsb && |
281 | pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2) |
282 | pc->poc_msb = pc->prev_poc_msb - max_poc_lsb; |
283 | else |
284 | pc->poc_msb = pc->prev_poc_msb; |
285 | field_poc[0] = |
286 | field_poc[1] = pc->poc_msb + pc->poc_lsb; |
287 | if (picture_structure == PICT_FRAME) |
288 | field_poc[1] += pc->delta_poc_bottom; |
289 | } else if (sps->poc_type == 1) { |
290 | int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; |
291 | int i; |
292 | |
293 | if (sps->poc_cycle_length != 0) |
294 | abs_frame_num = pc->frame_num_offset + pc->frame_num; |
295 | else |
296 | abs_frame_num = 0; |
297 | |
298 | if (nal_ref_idc == 0 && abs_frame_num > 0) |
299 | abs_frame_num--; |
300 | |
301 | expected_delta_per_poc_cycle = 0; |
302 | for (i = 0; i < sps->poc_cycle_length; i++) |
303 | // FIXME integrate during sps parse |
304 | expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i]; |
305 | |
306 | if (abs_frame_num > 0) { |
307 | int poc_cycle_cnt = (abs_frame_num - 1) / sps->poc_cycle_length; |
308 | int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length; |
309 | |
310 | expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; |
311 | for (i = 0; i <= frame_num_in_poc_cycle; i++) |
312 | expectedpoc = expectedpoc + sps->offset_for_ref_frame[i]; |
313 | } else |
314 | expectedpoc = 0; |
315 | |
316 | if (nal_ref_idc == 0) |
317 | expectedpoc = expectedpoc + sps->offset_for_non_ref_pic; |
318 | |
319 | field_poc[0] = expectedpoc + pc->delta_poc[0]; |
320 | field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field; |
321 | |
322 | if (picture_structure == PICT_FRAME) |
323 | field_poc[1] += pc->delta_poc[1]; |
324 | } else { |
325 | int poc = 2 * (pc->frame_num_offset + pc->frame_num); |
326 | |
327 | if (!nal_ref_idc) |
328 | poc--; |
329 | |
330 | field_poc[0] = poc; |
331 | field_poc[1] = poc; |
332 | } |
333 | |
334 | if (picture_structure != PICT_BOTTOM_FIELD) |
335 | pic_field_poc[0] = field_poc[0]; |
336 | if (picture_structure != PICT_TOP_FIELD) |
337 | pic_field_poc[1] = field_poc[1]; |
338 | *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]); |
339 | |
340 | return 0; |
341 | } |
342 | |
343 | static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps, |
344 | int is_avc, void *logctx) |
345 | { |
346 | H2645Packet pkt = { 0 }; |
347 | int i, ret = 0; |
348 | |
349 | ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264, 1); |
350 | if (ret < 0) { |
351 | ret = 0; |
352 | goto fail; |
353 | } |
354 | |
355 | for (i = 0; i < pkt.nb_nals; i++) { |
356 | H2645NAL *nal = &pkt.nals[i]; |
357 | switch (nal->type) { |
358 | case H264_NAL_SPS: |
359 | ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps, 0); |
360 | if (ret < 0) |
361 | goto fail; |
362 | break; |
363 | case H264_NAL_PPS: |
364 | ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps, |
365 | nal->size_bits); |
366 | if (ret < 0) |
367 | goto fail; |
368 | break; |
369 | default: |
370 | av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n", |
371 | nal->type); |
372 | break; |
373 | } |
374 | } |
375 | |
376 | fail: |
377 | ff_h2645_packet_uninit(&pkt); |
378 | return ret; |
379 | } |
380 | |
381 | /* There are (invalid) samples in the wild with mp4-style extradata, where the |
382 | * parameter sets are stored unescaped (i.e. as RBSP). |
383 | * This function catches the parameter set decoding failure and tries again |
384 | * after escaping it */ |
385 | static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps, |
386 | int err_recognition, void *logctx) |
387 | { |
388 | int ret; |
389 | |
390 | ret = decode_extradata_ps(buf, buf_size, ps, 1, logctx); |
391 | if (ret < 0 && !(err_recognition & AV_EF_EXPLODE)) { |
392 | GetByteContext gbc; |
393 | PutByteContext pbc; |
394 | uint8_t *escaped_buf; |
395 | int escaped_buf_size; |
396 | |
397 | av_log(logctx, AV_LOG_WARNING, |
398 | "SPS decoding failure, trying again after escaping the NAL\n"); |
399 | |
400 | if (buf_size / 2 >= (INT16_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 3) |
401 | return AVERROR(ERANGE); |
402 | escaped_buf_size = buf_size * 3 / 2 + AV_INPUT_BUFFER_PADDING_SIZE; |
403 | escaped_buf = av_mallocz(escaped_buf_size); |
404 | if (!escaped_buf) |
405 | return AVERROR(ENOMEM); |
406 | |
407 | bytestream2_init(&gbc, buf, buf_size); |
408 | bytestream2_init_writer(&pbc, escaped_buf, escaped_buf_size); |
409 | |
410 | while (bytestream2_get_bytes_left(&gbc)) { |
411 | if (bytestream2_get_bytes_left(&gbc) >= 3 && |
412 | bytestream2_peek_be24(&gbc) <= 3) { |
413 | bytestream2_put_be24(&pbc, 3); |
414 | bytestream2_skip(&gbc, 2); |
415 | } else |
416 | bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc)); |
417 | } |
418 | |
419 | escaped_buf_size = bytestream2_tell_p(&pbc); |
420 | AV_WB16(escaped_buf, escaped_buf_size - 2); |
421 | |
422 | ret = decode_extradata_ps(escaped_buf, escaped_buf_size, ps, 1, logctx); |
423 | av_freep(&escaped_buf); |
424 | if (ret < 0) |
425 | return ret; |
426 | } |
427 | |
428 | return 0; |
429 | } |
430 | |
431 | int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps, |
432 | int *is_avc, int *nal_length_size, |
433 | int err_recognition, void *logctx) |
434 | { |
435 | int ret; |
436 | |
437 | if (!data || size <= 0) |
438 | return -1; |
439 | |
440 | if (data[0] == 1) { |
441 | int i, cnt, nalsize; |
442 | const uint8_t *p = data; |
443 | |
444 | *is_avc = 1; |
445 | |
446 | if (size < 7) { |
447 | av_log(logctx, AV_LOG_ERROR, "avcC %d too short\n", size); |
448 | return AVERROR_INVALIDDATA; |
449 | } |
450 | |
451 | // Decode sps from avcC |
452 | cnt = *(p + 5) & 0x1f; // Number of sps |
453 | p += 6; |
454 | for (i = 0; i < cnt; i++) { |
455 | nalsize = AV_RB16(p) + 2; |
456 | if (nalsize > size - (p - data)) |
457 | return AVERROR_INVALIDDATA; |
458 | if (nalsize < 0) |
459 | return AVERROR_INVALIDDATA; |
460 | |
461 | ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx); |
462 | if (ret < 0) { |
463 | av_log(logctx, AV_LOG_ERROR, |
464 | "Decoding sps %d from avcC failed\n", i); |
465 | return ret; |
466 | } |
467 | p += nalsize; |
468 | } |
469 | // Decode pps from avcC |
470 | cnt = *(p++); // Number of pps |
471 | for (i = 0; i < cnt; i++) { |
472 | nalsize = AV_RB16(p) + 2; |
473 | if (nalsize > size - (p - data)) |
474 | return AVERROR_INVALIDDATA; |
475 | if (nalsize < 0) |
476 | return AVERROR_INVALIDDATA; |
477 | ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx); |
478 | if (ret < 0) { |
479 | av_log(logctx, AV_LOG_ERROR, |
480 | "Decoding pps %d from avcC failed\n", i); |
481 | return ret; |
482 | } |
483 | p += nalsize; |
484 | } |
485 | // Store right nal length size that will be used to parse all other nals |
486 | *nal_length_size = (data[4] & 0x03) + 1; |
487 | } else { |
488 | *is_avc = 0; |
489 | ret = decode_extradata_ps(data, size, ps, 0, logctx); |
490 | if (ret < 0) |
491 | return ret; |
492 | } |
493 | return size; |
494 | } |
495 | |
496 | /** |
497 | * Compute profile from profile_idc and constraint_set?_flags. |
498 | * |
499 | * @param sps SPS |
500 | * |
501 | * @return profile as defined by FF_PROFILE_H264_* |
502 | */ |
503 | int ff_h264_get_profile(const SPS *sps) |
504 | { |
505 | int profile = sps->profile_idc; |
506 | |
507 | switch (sps->profile_idc) { |
508 | case FF_PROFILE_H264_BASELINE: |
509 | // constraint_set1_flag set to 1 |
510 | profile |= (sps->constraint_set_flags & 1 << 1) ? FF_PROFILE_H264_CONSTRAINED : 0; |
511 | break; |
512 | case FF_PROFILE_H264_HIGH_10: |
513 | case FF_PROFILE_H264_HIGH_422: |
514 | case FF_PROFILE_H264_HIGH_444_PREDICTIVE: |
515 | // constraint_set3_flag set to 1 |
516 | profile |= (sps->constraint_set_flags & 1 << 3) ? FF_PROFILE_H264_INTRA : 0; |
517 | break; |
518 | } |
519 | |
520 | return profile; |
521 | } |
522 |