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