GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* H.26L/H.264/AVC/JVT/14496-10/... SEI decoding |
||
3 |
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> |
||
4 |
* |
||
5 |
* This file is part of FFmpeg. |
||
6 |
* |
||
7 |
* FFmpeg is free software; you can redistribute it and/or |
||
8 |
* modify it under the terms of the GNU Lesser General Public |
||
9 |
* License as published by the Free Software Foundation; either |
||
10 |
* version 2.1 of the License, or (at your option) any later version. |
||
11 |
* |
||
12 |
* FFmpeg is distributed in the hope that it will be useful, |
||
13 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
14 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
15 |
* Lesser General Public License for more details. |
||
16 |
* |
||
17 |
* You should have received a copy of the GNU Lesser General Public |
||
18 |
* License along with FFmpeg; if not, write to the Free Software |
||
19 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
20 |
*/ |
||
21 |
|||
22 |
/** |
||
23 |
* @file |
||
24 |
* H.264 / AVC / MPEG-4 part10 SEI decoding. |
||
25 |
* @author Michael Niedermayer <michaelni@gmx.at> |
||
26 |
*/ |
||
27 |
|||
28 |
#include "atsc_a53.h" |
||
29 |
#include "avcodec.h" |
||
30 |
#include "get_bits.h" |
||
31 |
#include "golomb.h" |
||
32 |
#include "h264_ps.h" |
||
33 |
#include "h264_sei.h" |
||
34 |
#include "internal.h" |
||
35 |
|||
36 |
#define AVERROR_PS_NOT_FOUND FFERRTAG(0xF8,'?','P','S') |
||
37 |
|||
38 |
static const uint8_t sei_num_clock_ts_table[9] = { |
||
39 |
1, 1, 1, 2, 2, 3, 3, 2, 3 |
||
40 |
}; |
||
41 |
|||
42 |
50802 |
void ff_h264_sei_uninit(H264SEIContext *h) |
|
43 |
{ |
||
44 |
50802 |
h->recovery_point.recovery_frame_cnt = -1; |
|
45 |
|||
46 |
50802 |
h->picture_timing.dpb_output_delay = 0; |
|
47 |
50802 |
h->picture_timing.cpb_removal_delay = -1; |
|
48 |
|||
49 |
50802 |
h->picture_timing.present = 0; |
|
50 |
50802 |
h->buffering_period.present = 0; |
|
51 |
50802 |
h->frame_packing.present = 0; |
|
52 |
50802 |
h->display_orientation.present = 0; |
|
53 |
50802 |
h->afd.present = 0; |
|
54 |
|||
55 |
50802 |
av_buffer_unref(&h->a53_caption.buf_ref); |
|
56 |
✓✓ | 50881 |
for (int i = 0; i < h->unregistered.nb_buf_ref; i++) |
57 |
79 |
av_buffer_unref(&h->unregistered.buf_ref[i]); |
|
58 |
50802 |
h->unregistered.nb_buf_ref = 0; |
|
59 |
50802 |
av_freep(&h->unregistered.buf_ref); |
|
60 |
50802 |
} |
|
61 |
|||
62 |
2766 |
int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, |
|
63 |
void *logctx) |
||
64 |
{ |
||
65 |
GetBitContext gb; |
||
66 |
|||
67 |
2766 |
init_get_bits(&gb, h->payload, h->payload_size_bits); |
|
68 |
|||
69 |
✓✓ | 2766 |
if (sps->nal_hrd_parameters_present_flag || |
70 |
✗✓ | 1485 |
sps->vcl_hrd_parameters_present_flag) { |
71 |
1281 |
h->cpb_removal_delay = get_bits_long(&gb, sps->cpb_removal_delay_length); |
|
72 |
1281 |
h->dpb_output_delay = get_bits_long(&gb, sps->dpb_output_delay_length); |
|
73 |
} |
||
74 |
✓✓ | 2766 |
if (sps->pic_struct_present_flag) { |
75 |
unsigned int i, num_clock_ts; |
||
76 |
|||
77 |
2746 |
h->pic_struct = get_bits(&gb, 4); |
|
78 |
2746 |
h->ct_type = 0; |
|
79 |
|||
80 |
✗✓ | 2746 |
if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING) |
81 |
return AVERROR_INVALIDDATA; |
||
82 |
|||
83 |
2746 |
num_clock_ts = sei_num_clock_ts_table[h->pic_struct]; |
|
84 |
2746 |
h->timecode_cnt = 0; |
|
85 |
✓✓ | 7446 |
for (i = 0; i < num_clock_ts; i++) { |
86 |
✓✓ | 4700 |
if (get_bits(&gb, 1)) { /* clock_timestamp_flag */ |
87 |
1552 |
H264SEITimeCode *tc = &h->timecode[h->timecode_cnt++]; |
|
88 |
unsigned int full_timestamp_flag; |
||
89 |
unsigned int counting_type, cnt_dropped_flag; |
||
90 |
1552 |
h->ct_type |= 1 << get_bits(&gb, 2); |
|
91 |
1552 |
skip_bits(&gb, 1); /* nuit_field_based_flag */ |
|
92 |
1552 |
counting_type = get_bits(&gb, 5); /* counting_type */ |
|
93 |
1552 |
full_timestamp_flag = get_bits(&gb, 1); |
|
94 |
1552 |
skip_bits(&gb, 1); /* discontinuity_flag */ |
|
95 |
1552 |
cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */ |
|
96 |
✗✓✗✗ ✗✗ |
1552 |
if (cnt_dropped_flag && counting_type > 1 && counting_type < 7) |
97 |
tc->dropframe = 1; |
||
98 |
1552 |
tc->frame = get_bits(&gb, 8); /* n_frames */ |
|
99 |
✓✓ | 1552 |
if (full_timestamp_flag) { |
100 |
1202 |
tc->full = 1; |
|
101 |
1202 |
tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */ |
|
102 |
1202 |
tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */ |
|
103 |
1202 |
tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */ |
|
104 |
} else { |
||
105 |
350 |
tc->seconds = tc->minutes = tc->hours = tc->full = 0; |
|
106 |
✓✓ | 350 |
if (get_bits(&gb, 1)) { /* seconds_flag */ |
107 |
81 |
tc->seconds = get_bits(&gb, 6); |
|
108 |
✗✓ | 81 |
if (get_bits(&gb, 1)) { /* minutes_flag */ |
109 |
tc->minutes = get_bits(&gb, 6); |
||
110 |
if (get_bits(&gb, 1)) /* hours_flag */ |
||
111 |
tc->hours = get_bits(&gb, 5); |
||
112 |
} |
||
113 |
} |
||
114 |
} |
||
115 |
|||
116 |
✓✗ | 1552 |
if (sps->time_offset_length > 0) |
117 |
1552 |
skip_bits(&gb, |
|
118 |
sps->time_offset_length); /* time_offset */ |
||
119 |
} |
||
120 |
} |
||
121 |
|||
122 |
2746 |
av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n", |
|
123 |
2746 |
h->ct_type, h->pic_struct); |
|
124 |
} |
||
125 |
|||
126 |
2766 |
return 0; |
|
127 |
} |
||
128 |
|||
129 |
3412 |
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, |
|
130 |
void *logctx) |
||
131 |
{ |
||
132 |
3412 |
int index = get_bits_count(gb); |
|
133 |
3412 |
int size_bits = get_bits_left(gb); |
|
134 |
3412 |
int size = (size_bits + 7) / 8; |
|
135 |
|||
136 |
✗✓ | 3412 |
if (index & 7) { |
137 |
av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n"); |
||
138 |
return AVERROR_INVALIDDATA; |
||
139 |
} |
||
140 |
✗✓ | 3412 |
if (size > sizeof(h->payload)) { |
141 |
av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n"); |
||
142 |
return AVERROR_INVALIDDATA; |
||
143 |
} |
||
144 |
3412 |
memcpy(h->payload, gb->buffer + index / 8, size); |
|
145 |
|||
146 |
3412 |
h->payload_size_bits = size_bits; |
|
147 |
|||
148 |
3412 |
h->present = 1; |
|
149 |
3412 |
return 0; |
|
150 |
} |
||
151 |
|||
152 |
639 |
static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size) |
|
153 |
{ |
||
154 |
int flag; |
||
155 |
|||
156 |
✗✓ | 639 |
if (size-- < 1) |
157 |
return AVERROR_INVALIDDATA; |
||
158 |
639 |
skip_bits(gb, 1); // 0 |
|
159 |
639 |
flag = get_bits(gb, 1); // active_format_flag |
|
160 |
639 |
skip_bits(gb, 6); // reserved |
|
161 |
|||
162 |
✓✗ | 639 |
if (flag) { |
163 |
✗✓ | 639 |
if (size-- < 1) |
164 |
return AVERROR_INVALIDDATA; |
||
165 |
639 |
skip_bits(gb, 4); // reserved |
|
166 |
639 |
h->active_format_description = get_bits(gb, 4); |
|
167 |
639 |
h->present = 1; |
|
168 |
} |
||
169 |
|||
170 |
639 |
return 0; |
|
171 |
} |
||
172 |
|||
173 |
6 |
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, |
|
174 |
GetBitContext *gb, void *logctx, |
||
175 |
int size) |
||
176 |
{ |
||
177 |
✗✓ | 6 |
if (size < 3) |
178 |
return AVERROR(EINVAL); |
||
179 |
|||
180 |
6 |
return ff_parse_a53_cc(&h->buf_ref, gb->buffer + get_bits_count(gb) / 8, size); |
|
181 |
} |
||
182 |
|||
183 |
645 |
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, |
|
184 |
void *logctx, int size) |
||
185 |
{ |
||
186 |
int country_code, provider_code; |
||
187 |
|||
188 |
✗✓ | 645 |
if (size < 3) |
189 |
return AVERROR_INVALIDDATA; |
||
190 |
645 |
size -= 3; |
|
191 |
|||
192 |
645 |
country_code = get_bits(gb, 8); // itu_t_t35_country_code |
|
193 |
✗✓ | 645 |
if (country_code == 0xFF) { |
194 |
if (size < 1) |
||
195 |
return AVERROR_INVALIDDATA; |
||
196 |
|||
197 |
skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte |
||
198 |
size--; |
||
199 |
} |
||
200 |
|||
201 |
✗✓ | 645 |
if (country_code != 0xB5) { // usa_country_code |
202 |
av_log(logctx, AV_LOG_VERBOSE, |
||
203 |
"Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n", |
||
204 |
country_code); |
||
205 |
return 0; |
||
206 |
} |
||
207 |
|||
208 |
/* itu_t_t35_payload_byte follows */ |
||
209 |
645 |
provider_code = get_bits(gb, 16); |
|
210 |
|||
211 |
✓✗ | 645 |
switch (provider_code) { |
212 |
645 |
case 0x31: { // atsc_provider_code |
|
213 |
uint32_t user_identifier; |
||
214 |
|||
215 |
✗✓ | 645 |
if (size < 4) |
216 |
return AVERROR_INVALIDDATA; |
||
217 |
645 |
size -= 4; |
|
218 |
|||
219 |
645 |
user_identifier = get_bits_long(gb, 32); |
|
220 |
switch (user_identifier) { |
||
221 |
639 |
case MKBETAG('D', 'T', 'G', '1'): // afd_data |
|
222 |
639 |
return decode_registered_user_data_afd(&h->afd, gb, size); |
|
223 |
6 |
case MKBETAG('G', 'A', '9', '4'): // closed captions |
|
224 |
6 |
return decode_registered_user_data_closed_caption(&h->a53_caption, gb, |
|
225 |
logctx, size); |
||
226 |
default: |
||
227 |
av_log(logctx, AV_LOG_VERBOSE, |
||
228 |
"Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n", |
||
229 |
user_identifier); |
||
230 |
break; |
||
231 |
} |
||
232 |
break; |
||
233 |
} |
||
234 |
default: |
||
235 |
av_log(logctx, AV_LOG_VERBOSE, |
||
236 |
"Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n", |
||
237 |
provider_code); |
||
238 |
break; |
||
239 |
} |
||
240 |
|||
241 |
return 0; |
||
242 |
} |
||
243 |
|||
244 |
248 |
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, |
|
245 |
void *logctx, int size) |
||
246 |
{ |
||
247 |
uint8_t *user_data; |
||
248 |
int e, build, i; |
||
249 |
AVBufferRef *buf_ref, **tmp; |
||
250 |
|||
251 |
✓✗✗✓ |
248 |
if (size < 16 || size >= INT_MAX - 1) |
252 |
return AVERROR_INVALIDDATA; |
||
253 |
|||
254 |
248 |
tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref)); |
|
255 |
✗✓ | 248 |
if (!tmp) |
256 |
return AVERROR(ENOMEM); |
||
257 |
248 |
h->buf_ref = tmp; |
|
258 |
|||
259 |
248 |
buf_ref = av_buffer_alloc(size + 1); |
|
260 |
✗✓ | 248 |
if (!buf_ref) |
261 |
return AVERROR(ENOMEM); |
||
262 |
248 |
user_data = buf_ref->data; |
|
263 |
|||
264 |
✓✓ | 52451 |
for (i = 0; i < size; i++) |
265 |
52203 |
user_data[i] = get_bits(gb, 8); |
|
266 |
|||
267 |
248 |
user_data[i] = 0; |
|
268 |
248 |
buf_ref->size = size; |
|
269 |
248 |
h->buf_ref[h->nb_buf_ref++] = buf_ref; |
|
270 |
|||
271 |
248 |
e = sscanf(user_data + 16, "x264 - core %d", &build); |
|
272 |
✓✓✓✓ |
248 |
if (e == 1 && build > 0) |
273 |
77 |
h->x264_build = build; |
|
274 |
✓✓✗✓ ✗✗ |
248 |
if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16)) |
275 |
h->x264_build = 67; |
||
276 |
|||
277 |
248 |
return 0; |
|
278 |
} |
||
279 |
|||
280 |
63 |
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx) |
|
281 |
{ |
||
282 |
63 |
unsigned recovery_frame_cnt = get_ue_golomb_long(gb); |
|
283 |
|||
284 |
✗✓ | 63 |
if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) { |
285 |
av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt); |
||
286 |
return AVERROR_INVALIDDATA; |
||
287 |
} |
||
288 |
|||
289 |
63 |
h->recovery_frame_cnt = recovery_frame_cnt; |
|
290 |
/* 1b exact_match_flag, |
||
291 |
* 1b broken_link_flag, |
||
292 |
* 2b changing_slice_group_idc */ |
||
293 |
63 |
skip_bits(gb, 4); |
|
294 |
|||
295 |
63 |
return 0; |
|
296 |
} |
||
297 |
|||
298 |
736 |
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, |
|
299 |
const H264ParamSets *ps, void *logctx) |
||
300 |
{ |
||
301 |
unsigned int sps_id; |
||
302 |
int sched_sel_idx; |
||
303 |
const SPS *sps; |
||
304 |
|||
305 |
736 |
sps_id = get_ue_golomb_31(gb); |
|
306 |
✓✗✓✓ |
736 |
if (sps_id > 31 || !ps->sps_list[sps_id]) { |
307 |
4 |
av_log(logctx, AV_LOG_ERROR, |
|
308 |
"non-existing SPS %d referenced in buffering period\n", sps_id); |
||
309 |
✗✓ | 4 |
return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND; |
310 |
} |
||
311 |
732 |
sps = (const SPS*)ps->sps_list[sps_id]->data; |
|
312 |
|||
313 |
// NOTE: This is really so duplicated in the standard... See H.264, D.1.1 |
||
314 |
✓✓ | 732 |
if (sps->nal_hrd_parameters_present_flag) { |
315 |
✓✓ | 586 |
for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) { |
316 |
293 |
h->initial_cpb_removal_delay[sched_sel_idx] = |
|
317 |
293 |
get_bits_long(gb, sps->initial_cpb_removal_delay_length); |
|
318 |
// initial_cpb_removal_delay_offset |
||
319 |
293 |
skip_bits(gb, sps->initial_cpb_removal_delay_length); |
|
320 |
} |
||
321 |
} |
||
322 |
✓✓ | 732 |
if (sps->vcl_hrd_parameters_present_flag) { |
323 |
✓✓ | 360 |
for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) { |
324 |
180 |
h->initial_cpb_removal_delay[sched_sel_idx] = |
|
325 |
180 |
get_bits_long(gb, sps->initial_cpb_removal_delay_length); |
|
326 |
// initial_cpb_removal_delay_offset |
||
327 |
180 |
skip_bits(gb, sps->initial_cpb_removal_delay_length); |
|
328 |
} |
||
329 |
} |
||
330 |
|||
331 |
732 |
h->present = 1; |
|
332 |
732 |
return 0; |
|
333 |
} |
||
334 |
|||
335 |
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, |
||
336 |
GetBitContext *gb) |
||
337 |
{ |
||
338 |
h->arrangement_id = get_ue_golomb_long(gb); |
||
339 |
h->arrangement_cancel_flag = get_bits1(gb); |
||
340 |
h->present = !h->arrangement_cancel_flag; |
||
341 |
|||
342 |
if (h->present) { |
||
343 |
h->arrangement_type = get_bits(gb, 7); |
||
344 |
h->quincunx_sampling_flag = get_bits1(gb); |
||
345 |
h->content_interpretation_type = get_bits(gb, 6); |
||
346 |
|||
347 |
// spatial_flipping_flag, frame0_flipped_flag, field_views_flag |
||
348 |
skip_bits(gb, 3); |
||
349 |
h->current_frame_is_frame0_flag = get_bits1(gb); |
||
350 |
// frame0_self_contained_flag, frame1_self_contained_flag |
||
351 |
skip_bits(gb, 2); |
||
352 |
|||
353 |
if (!h->quincunx_sampling_flag && h->arrangement_type != 5) |
||
354 |
skip_bits(gb, 16); // frame[01]_grid_position_[xy] |
||
355 |
skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte |
||
356 |
h->arrangement_repetition_period = get_ue_golomb_long(gb); |
||
357 |
} |
||
358 |
skip_bits1(gb); // frame_packing_arrangement_extension_flag |
||
359 |
|||
360 |
return 0; |
||
361 |
} |
||
362 |
|||
363 |
2 |
static int decode_display_orientation(H264SEIDisplayOrientation *h, |
|
364 |
GetBitContext *gb) |
||
365 |
{ |
||
366 |
2 |
h->present = !get_bits1(gb); |
|
367 |
|||
368 |
✓✗ | 2 |
if (h->present) { |
369 |
2 |
h->hflip = get_bits1(gb); // hor_flip |
|
370 |
2 |
h->vflip = get_bits1(gb); // ver_flip |
|
371 |
|||
372 |
2 |
h->anticlockwise_rotation = get_bits(gb, 16); |
|
373 |
2 |
get_ue_golomb_long(gb); // display_orientation_repetition_period |
|
374 |
2 |
skip_bits1(gb); // display_orientation_extension_flag |
|
375 |
} |
||
376 |
|||
377 |
2 |
return 0; |
|
378 |
} |
||
379 |
|||
380 |
static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb) |
||
381 |
{ |
||
382 |
h->green_metadata_type = get_bits(gb, 8); |
||
383 |
|||
384 |
if (h->green_metadata_type == 0) { |
||
385 |
h->period_type = get_bits(gb, 8); |
||
386 |
|||
387 |
if (h->period_type == 2) |
||
388 |
h->num_seconds = get_bits(gb, 16); |
||
389 |
else if (h->period_type == 3) |
||
390 |
h->num_pictures = get_bits(gb, 16); |
||
391 |
|||
392 |
h->percent_non_zero_macroblocks = get_bits(gb, 8); |
||
393 |
h->percent_intra_coded_macroblocks = get_bits(gb, 8); |
||
394 |
h->percent_six_tap_filtering = get_bits(gb, 8); |
||
395 |
h->percent_alpha_point_deblocking_instance = get_bits(gb, 8); |
||
396 |
|||
397 |
} else if (h->green_metadata_type == 1) { |
||
398 |
h->xsd_metric_type = get_bits(gb, 8); |
||
399 |
h->xsd_metric_value = get_bits(gb, 16); |
||
400 |
} |
||
401 |
|||
402 |
return 0; |
||
403 |
} |
||
404 |
|||
405 |
static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, |
||
406 |
GetBitContext *gb) |
||
407 |
{ |
||
408 |
h->present = 1; |
||
409 |
h->preferred_transfer_characteristics = get_bits(gb, 8); |
||
410 |
return 0; |
||
411 |
} |
||
412 |
|||
413 |
4047 |
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, |
|
414 |
const H264ParamSets *ps, void *logctx) |
||
415 |
{ |
||
416 |
4047 |
int master_ret = 0; |
|
417 |
|||
418 |
✓✓✓✓ |
9404 |
while (get_bits_left(gb) > 16 && show_bits(gb, 16)) { |
419 |
GetBitContext gb_payload; |
||
420 |
5364 |
int type = 0; |
|
421 |
5364 |
unsigned size = 0; |
|
422 |
5364 |
int ret = 0; |
|
423 |
|||
424 |
do { |
||
425 |
✗✓ | 5388 |
if (get_bits_left(gb) < 8) |
426 |
7 |
return AVERROR_INVALIDDATA; |
|
427 |
5388 |
type += show_bits(gb, 8); |
|
428 |
✓✓ | 5388 |
} while (get_bits(gb, 8) == 255); |
429 |
|||
430 |
do { |
||
431 |
✗✓ | 5520 |
if (get_bits_left(gb) < 8) |
432 |
return AVERROR_INVALIDDATA; |
||
433 |
5520 |
size += show_bits(gb, 8); |
|
434 |
✓✓ | 5520 |
} while (get_bits(gb, 8) == 255); |
435 |
|||
436 |
✓✓ | 5364 |
if (size > get_bits_left(gb) / 8) { |
437 |
7 |
av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n", |
|
438 |
type, 8*size, get_bits_left(gb)); |
||
439 |
7 |
return AVERROR_INVALIDDATA; |
|
440 |
} |
||
441 |
|||
442 |
5357 |
ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size); |
|
443 |
✗✓ | 5357 |
if (ret < 0) |
444 |
return ret; |
||
445 |
|||
446 |
✓✓✓✓ ✓✗✓✗ ✗✓ |
5357 |
switch (type) { |
447 |
3412 |
case SEI_TYPE_PIC_TIMING: // Picture timing SEI |
|
448 |
3412 |
ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx); |
|
449 |
3412 |
break; |
|
450 |
645 |
case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35: |
|
451 |
645 |
ret = decode_registered_user_data(h, &gb_payload, logctx, size); |
|
452 |
645 |
break; |
|
453 |
248 |
case SEI_TYPE_USER_DATA_UNREGISTERED: |
|
454 |
248 |
ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size); |
|
455 |
248 |
break; |
|
456 |
63 |
case SEI_TYPE_RECOVERY_POINT: |
|
457 |
63 |
ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx); |
|
458 |
63 |
break; |
|
459 |
736 |
case SEI_TYPE_BUFFERING_PERIOD: |
|
460 |
736 |
ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx); |
|
461 |
736 |
break; |
|
462 |
case SEI_TYPE_FRAME_PACKING_ARRANGEMENT: |
||
463 |
ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload); |
||
464 |
break; |
||
465 |
2 |
case SEI_TYPE_DISPLAY_ORIENTATION: |
|
466 |
2 |
ret = decode_display_orientation(&h->display_orientation, &gb_payload); |
|
467 |
2 |
break; |
|
468 |
case SEI_TYPE_GREEN_METADATA: |
||
469 |
ret = decode_green_metadata(&h->green_metadata, &gb_payload); |
||
470 |
break; |
||
471 |
case SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS: |
||
472 |
ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload); |
||
473 |
break; |
||
474 |
251 |
default: |
|
475 |
251 |
av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type); |
|
476 |
} |
||
477 |
✓✓✗✓ |
5357 |
if (ret < 0 && ret != AVERROR_PS_NOT_FOUND) |
478 |
return ret; |
||
479 |
✓✓ | 5357 |
if (ret < 0) |
480 |
4 |
master_ret = ret; |
|
481 |
|||
482 |
✓✓ | 5357 |
if (get_bits_left(&gb_payload) < 0) { |
483 |
2 |
av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n", |
|
484 |
2 |
type, -get_bits_left(&gb_payload)); |
|
485 |
} |
||
486 |
|||
487 |
5357 |
skip_bits_long(gb, 8 * size); |
|
488 |
} |
||
489 |
|||
490 |
4040 |
return master_ret; |
|
491 |
} |
||
492 |
|||
493 |
22292 |
const char *ff_h264_sei_stereo_mode(const H264SEIFramePacking *h) |
|
494 |
{ |
||
495 |
✗✓ | 22292 |
if (h->arrangement_cancel_flag == 0) { |
496 |
switch (h->arrangement_type) { |
||
497 |
case H264_SEI_FPA_TYPE_CHECKERBOARD: |
||
498 |
if (h->content_interpretation_type == 2) |
||
499 |
return "checkerboard_rl"; |
||
500 |
else |
||
501 |
return "checkerboard_lr"; |
||
502 |
case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN: |
||
503 |
if (h->content_interpretation_type == 2) |
||
504 |
return "col_interleaved_rl"; |
||
505 |
else |
||
506 |
return "col_interleaved_lr"; |
||
507 |
case H264_SEI_FPA_TYPE_INTERLEAVE_ROW: |
||
508 |
if (h->content_interpretation_type == 2) |
||
509 |
return "row_interleaved_rl"; |
||
510 |
else |
||
511 |
return "row_interleaved_lr"; |
||
512 |
case H264_SEI_FPA_TYPE_SIDE_BY_SIDE: |
||
513 |
if (h->content_interpretation_type == 2) |
||
514 |
return "right_left"; |
||
515 |
else |
||
516 |
return "left_right"; |
||
517 |
case H264_SEI_FPA_TYPE_TOP_BOTTOM: |
||
518 |
if (h->content_interpretation_type == 2) |
||
519 |
return "bottom_top"; |
||
520 |
else |
||
521 |
return "top_bottom"; |
||
522 |
case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL: |
||
523 |
if (h->content_interpretation_type == 2) |
||
524 |
return "block_rl"; |
||
525 |
else |
||
526 |
return "block_lr"; |
||
527 |
case H264_SEI_FPA_TYPE_2D: |
||
528 |
default: |
||
529 |
return "mono"; |
||
530 |
} |
||
531 |
✗✓ | 22292 |
} else if (h->arrangement_cancel_flag == 1) { |
532 |
return "mono"; |
||
533 |
} else { |
||
534 |
22292 |
return NULL; |
|
535 |
} |
||
536 |
} |
Generated by: GCOVR (Version 4.2) |