GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* HEVC Supplementary Enhancement Information messages |
||
3 |
* |
||
4 |
* Copyright (C) 2012 - 2013 Guillaume Martres |
||
5 |
* Copyright (C) 2012 - 2013 Gildas Cocherel |
||
6 |
* Copyright (C) 2013 Vittorio Giovara |
||
7 |
* |
||
8 |
* This file is part of FFmpeg. |
||
9 |
* |
||
10 |
* FFmpeg is free software; you can redistribute it and/or |
||
11 |
* modify it under the terms of the GNU Lesser General Public |
||
12 |
* License as published by the Free Software Foundation; either |
||
13 |
* version 2.1 of the License, or (at your option) any later version. |
||
14 |
* |
||
15 |
* FFmpeg is distributed in the hope that it will be useful, |
||
16 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
17 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
||
18 |
* Lesser General Public License for more details. |
||
19 |
* |
||
20 |
* You should have received a copy of the GNU Lesser General Public |
||
21 |
* License along with FFmpeg; if not, write to the Free Software |
||
22 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
23 |
*/ |
||
24 |
|||
25 |
#include "atsc_a53.h" |
||
26 |
#include "dynamic_hdr10_plus.h" |
||
27 |
#include "golomb.h" |
||
28 |
#include "hevc_ps.h" |
||
29 |
#include "hevc_sei.h" |
||
30 |
|||
31 |
6848 |
static int decode_nal_sei_decoded_picture_hash(HEVCSEIPictureHash *s, GetBitContext *gb) |
|
32 |
{ |
||
33 |
int cIdx, i; |
||
34 |
uint8_t hash_type; |
||
35 |
//uint16_t picture_crc; |
||
36 |
//uint32_t picture_checksum; |
||
37 |
6848 |
hash_type = get_bits(gb, 8); |
|
38 |
|||
39 |
✓✓ | 27392 |
for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) { |
40 |
✓✓ | 20544 |
if (hash_type == 0) { |
41 |
19497 |
s->is_md5 = 1; |
|
42 |
✓✓ | 331449 |
for (i = 0; i < 16; i++) |
43 |
311952 |
s->md5[cIdx][i] = get_bits(gb, 8); |
|
44 |
✓✓ | 1047 |
} else if (hash_type == 1) { |
45 |
// picture_crc = get_bits(gb, 16); |
||
46 |
291 |
skip_bits(gb, 16); |
|
47 |
✓✗ | 756 |
} else if (hash_type == 2) { |
48 |
// picture_checksum = get_bits_long(gb, 32); |
||
49 |
756 |
skip_bits(gb, 32); |
|
50 |
} |
||
51 |
} |
||
52 |
6848 |
return 0; |
|
53 |
} |
||
54 |
|||
55 |
3 |
static int decode_nal_sei_mastering_display_info(HEVCSEIMasteringDisplay *s, GetBitContext *gb) |
|
56 |
{ |
||
57 |
int i; |
||
58 |
// Mastering primaries |
||
59 |
✓✓ | 12 |
for (i = 0; i < 3; i++) { |
60 |
9 |
s->display_primaries[i][0] = get_bits(gb, 16); |
|
61 |
9 |
s->display_primaries[i][1] = get_bits(gb, 16); |
|
62 |
} |
||
63 |
// White point (x, y) |
||
64 |
3 |
s->white_point[0] = get_bits(gb, 16); |
|
65 |
3 |
s->white_point[1] = get_bits(gb, 16); |
|
66 |
|||
67 |
// Max and min luminance of mastering display |
||
68 |
3 |
s->max_luminance = get_bits_long(gb, 32); |
|
69 |
3 |
s->min_luminance = get_bits_long(gb, 32); |
|
70 |
|||
71 |
// As this SEI message comes before the first frame that references it, |
||
72 |
// initialize the flag to 2 and decrement on IRAP access unit so it |
||
73 |
// persists for the coded video sequence (e.g., between two IRAPs) |
||
74 |
3 |
s->present = 2; |
|
75 |
3 |
return 0; |
|
76 |
} |
||
77 |
|||
78 |
3 |
static int decode_nal_sei_content_light_info(HEVCSEIContentLight *s, GetBitContext *gb) |
|
79 |
{ |
||
80 |
// Max and average light levels |
||
81 |
3 |
s->max_content_light_level = get_bits(gb, 16); |
|
82 |
3 |
s->max_pic_average_light_level = get_bits(gb, 16); |
|
83 |
// As this SEI message comes before the first frame that references it, |
||
84 |
// initialize the flag to 2 and decrement on IRAP access unit so it |
||
85 |
// persists for the coded video sequence (e.g., between two IRAPs) |
||
86 |
3 |
s->present = 2; |
|
87 |
3 |
return 0; |
|
88 |
} |
||
89 |
|||
90 |
static int decode_nal_sei_frame_packing_arrangement(HEVCSEIFramePacking *s, GetBitContext *gb) |
||
91 |
{ |
||
92 |
get_ue_golomb_long(gb); // frame_packing_arrangement_id |
||
93 |
s->present = !get_bits1(gb); |
||
94 |
|||
95 |
if (s->present) { |
||
96 |
s->arrangement_type = get_bits(gb, 7); |
||
97 |
s->quincunx_subsampling = get_bits1(gb); |
||
98 |
s->content_interpretation_type = get_bits(gb, 6); |
||
99 |
|||
100 |
// spatial_flipping_flag, frame0_flipped_flag, field_views_flag |
||
101 |
skip_bits(gb, 3); |
||
102 |
s->current_frame_is_frame0_flag = get_bits1(gb); |
||
103 |
// frame0_self_contained_flag, frame1_self_contained_flag |
||
104 |
skip_bits(gb, 2); |
||
105 |
|||
106 |
if (!s->quincunx_subsampling && s->arrangement_type != 5) |
||
107 |
skip_bits(gb, 16); // frame[01]_grid_position_[xy] |
||
108 |
skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte |
||
109 |
skip_bits1(gb); // frame_packing_arrangement_persistence_flag |
||
110 |
} |
||
111 |
skip_bits1(gb); // upsampled_aspect_ratio_flag |
||
112 |
return 0; |
||
113 |
} |
||
114 |
|||
115 |
static int decode_nal_sei_display_orientation(HEVCSEIDisplayOrientation *s, GetBitContext *gb) |
||
116 |
{ |
||
117 |
s->present = !get_bits1(gb); |
||
118 |
|||
119 |
if (s->present) { |
||
120 |
s->hflip = get_bits1(gb); // hor_flip |
||
121 |
s->vflip = get_bits1(gb); // ver_flip |
||
122 |
|||
123 |
s->anticlockwise_rotation = get_bits(gb, 16); |
||
124 |
skip_bits1(gb); // display_orientation_persistence_flag |
||
125 |
} |
||
126 |
|||
127 |
return 0; |
||
128 |
} |
||
129 |
|||
130 |
1204 |
static int decode_nal_sei_pic_timing(HEVCSEI *s, GetBitContext *gb, const HEVCParamSets *ps, |
|
131 |
void *logctx, int size) |
||
132 |
{ |
||
133 |
1204 |
HEVCSEIPictureTiming *h = &s->picture_timing; |
|
134 |
HEVCSPS *sps; |
||
135 |
|||
136 |
✓✓ | 1204 |
if (!ps->sps_list[s->active_seq_parameter_set_id]) |
137 |
44 |
return(AVERROR(ENOMEM)); |
|
138 |
1160 |
sps = (HEVCSPS*)ps->sps_list[s->active_seq_parameter_set_id]->data; |
|
139 |
|||
140 |
✓✓ | 1160 |
if (sps->vui.frame_field_info_present_flag) { |
141 |
677 |
int pic_struct = get_bits(gb, 4); |
|
142 |
677 |
h->picture_struct = AV_PICTURE_STRUCTURE_UNKNOWN; |
|
143 |
✓✗✓✓ ✗✓ |
677 |
if (pic_struct == 2 || pic_struct == 10 || pic_struct == 12) { |
144 |
10 |
av_log(logctx, AV_LOG_DEBUG, "BOTTOM Field\n"); |
|
145 |
10 |
h->picture_struct = AV_PICTURE_STRUCTURE_BOTTOM_FIELD; |
|
146 |
✓✗✓✗ ✓✓ |
667 |
} else if (pic_struct == 1 || pic_struct == 9 || pic_struct == 11) { |
147 |
11 |
av_log(logctx, AV_LOG_DEBUG, "TOP Field\n"); |
|
148 |
11 |
h->picture_struct = AV_PICTURE_STRUCTURE_TOP_FIELD; |
|
149 |
✗✓ | 656 |
} else if (pic_struct == 7) { |
150 |
av_log(logctx, AV_LOG_DEBUG, "Frame/Field Doubling\n"); |
||
151 |
h->picture_struct = HEVC_SEI_PIC_STRUCT_FRAME_DOUBLING; |
||
152 |
✗✓ | 656 |
} else if (pic_struct == 8) { |
153 |
av_log(logctx, AV_LOG_DEBUG, "Frame/Field Tripling\n"); |
||
154 |
h->picture_struct = HEVC_SEI_PIC_STRUCT_FRAME_TRIPLING; |
||
155 |
} |
||
156 |
677 |
get_bits(gb, 2); // source_scan_type |
|
157 |
677 |
get_bits(gb, 1); // duplicate_flag |
|
158 |
677 |
skip_bits1(gb); |
|
159 |
677 |
size--; |
|
160 |
} |
||
161 |
1160 |
skip_bits_long(gb, 8 * size); |
|
162 |
|||
163 |
1160 |
return 0; |
|
164 |
} |
||
165 |
|||
166 |
static int decode_registered_user_data_closed_caption(HEVCSEIA53Caption *s, GetBitContext *gb, |
||
167 |
int size) |
||
168 |
{ |
||
169 |
int ret; |
||
170 |
|||
171 |
if (size < 3) |
||
172 |
return AVERROR_INVALIDDATA; |
||
173 |
|||
174 |
ret = ff_parse_a53_cc(&s->buf_ref, gb->buffer + get_bits_count(gb) / 8, size); |
||
175 |
|||
176 |
if (ret < 0) |
||
177 |
return ret; |
||
178 |
|||
179 |
skip_bits_long(gb, size * 8); |
||
180 |
|||
181 |
return 0; |
||
182 |
} |
||
183 |
|||
184 |
9 |
static int decode_nal_sei_user_data_unregistered(HEVCSEIUnregistered *s, GetBitContext *gb, |
|
185 |
int size) |
||
186 |
{ |
||
187 |
AVBufferRef *buf_ref, **tmp; |
||
188 |
|||
189 |
✓✗✗✓ |
9 |
if (size < 16 || size >= INT_MAX - 1) |
190 |
return AVERROR_INVALIDDATA; |
||
191 |
|||
192 |
9 |
tmp = av_realloc_array(s->buf_ref, s->nb_buf_ref + 1, sizeof(*s->buf_ref)); |
|
193 |
✗✓ | 9 |
if (!tmp) |
194 |
return AVERROR(ENOMEM); |
||
195 |
9 |
s->buf_ref = tmp; |
|
196 |
|||
197 |
9 |
buf_ref = av_buffer_alloc(size + 1); |
|
198 |
✗✓ | 9 |
if (!buf_ref) |
199 |
return AVERROR(ENOMEM); |
||
200 |
|||
201 |
✓✓ | 12059 |
for (int i = 0; i < size; i++) |
202 |
12050 |
buf_ref->data[i] = get_bits(gb, 8); |
|
203 |
9 |
buf_ref->data[size] = 0; |
|
204 |
9 |
buf_ref->size = size; |
|
205 |
9 |
s->buf_ref[s->nb_buf_ref++] = buf_ref; |
|
206 |
|||
207 |
9 |
return 0; |
|
208 |
} |
||
209 |
|||
210 |
3 |
static int decode_registered_user_data_dynamic_hdr_plus(HEVCSEIDynamicHDRPlus *s, |
|
211 |
GetBitContext *gb, int size) |
||
212 |
{ |
||
213 |
size_t meta_size; |
||
214 |
int err; |
||
215 |
3 |
AVDynamicHDRPlus *metadata = av_dynamic_hdr_plus_alloc(&meta_size); |
|
216 |
✗✓ | 3 |
if (!metadata) |
217 |
return AVERROR(ENOMEM); |
||
218 |
|||
219 |
3 |
err = ff_parse_itu_t_t35_to_dynamic_hdr10_plus(metadata, |
|
220 |
3 |
gb->buffer + get_bits_count(gb) / 8, size); |
|
221 |
✗✓ | 3 |
if (err < 0) { |
222 |
av_free(metadata); |
||
223 |
return err; |
||
224 |
} |
||
225 |
|||
226 |
3 |
av_buffer_unref(&s->info); |
|
227 |
3 |
s->info = av_buffer_create((uint8_t *)metadata, meta_size, NULL, NULL, 0); |
|
228 |
✗✓ | 3 |
if (!s->info) { |
229 |
av_free(metadata); |
||
230 |
return AVERROR(ENOMEM); |
||
231 |
} |
||
232 |
|||
233 |
3 |
skip_bits_long(gb, size * 8); |
|
234 |
|||
235 |
3 |
return 0; |
|
236 |
} |
||
237 |
|||
238 |
67 |
static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCSEI *s, GetBitContext *gb, |
|
239 |
void *logctx, int size) |
||
240 |
{ |
||
241 |
int country_code, provider_code; |
||
242 |
|||
243 |
✗✓ | 67 |
if (size < 3) |
244 |
return AVERROR_INVALIDDATA; |
||
245 |
67 |
size -= 3; |
|
246 |
|||
247 |
67 |
country_code = get_bits(gb, 8); |
|
248 |
✗✓ | 67 |
if (country_code == 0xFF) { |
249 |
if (size < 1) |
||
250 |
return AVERROR_INVALIDDATA; |
||
251 |
|||
252 |
skip_bits(gb, 8); |
||
253 |
size--; |
||
254 |
} |
||
255 |
|||
256 |
✗✓ | 67 |
if (country_code != 0xB5) { // usa_country_code |
257 |
av_log(logctx, AV_LOG_VERBOSE, |
||
258 |
"Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n", |
||
259 |
country_code); |
||
260 |
goto end; |
||
261 |
} |
||
262 |
|||
263 |
67 |
provider_code = get_bits(gb, 16); |
|
264 |
|||
265 |
✓✓✗ | 67 |
switch (provider_code) { |
266 |
3 |
case 0x3C: { // smpte_provider_code |
|
267 |
// A/341 Amendment - 2094-40 |
||
268 |
3 |
const uint16_t smpte2094_40_provider_oriented_code = 0x0001; |
|
269 |
3 |
const uint8_t smpte2094_40_application_identifier = 0x04; |
|
270 |
uint16_t provider_oriented_code; |
||
271 |
uint8_t application_identifier; |
||
272 |
|||
273 |
✗✓ | 3 |
if (size < 3) |
274 |
return AVERROR_INVALIDDATA; |
||
275 |
3 |
size -= 3; |
|
276 |
|||
277 |
3 |
provider_oriented_code = get_bits(gb, 16); |
|
278 |
3 |
application_identifier = get_bits(gb, 8); |
|
279 |
✓✗✓✗ |
3 |
if (provider_oriented_code == smpte2094_40_provider_oriented_code && |
280 |
application_identifier == smpte2094_40_application_identifier) { |
||
281 |
3 |
return decode_registered_user_data_dynamic_hdr_plus(&s->dynamic_hdr_plus, gb, size); |
|
282 |
} |
||
283 |
break; |
||
284 |
} |
||
285 |
64 |
case 0x31: { // atsc_provider_code |
|
286 |
uint32_t user_identifier; |
||
287 |
|||
288 |
✗✓ | 64 |
if (size < 4) |
289 |
return AVERROR_INVALIDDATA; |
||
290 |
64 |
size -= 4; |
|
291 |
|||
292 |
64 |
user_identifier = get_bits_long(gb, 32); |
|
293 |
switch (user_identifier) { |
||
294 |
case MKBETAG('G', 'A', '9', '4'): |
||
295 |
return decode_registered_user_data_closed_caption(&s->a53_caption, gb, size); |
||
296 |
64 |
default: |
|
297 |
64 |
av_log(logctx, AV_LOG_VERBOSE, |
|
298 |
"Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n", |
||
299 |
user_identifier); |
||
300 |
64 |
break; |
|
301 |
} |
||
302 |
64 |
break; |
|
303 |
} |
||
304 |
default: |
||
305 |
av_log(logctx, AV_LOG_VERBOSE, |
||
306 |
"Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n", |
||
307 |
provider_code); |
||
308 |
break; |
||
309 |
} |
||
310 |
|||
311 |
64 |
end: |
|
312 |
64 |
skip_bits_long(gb, size * 8); |
|
313 |
64 |
return 0; |
|
314 |
} |
||
315 |
|||
316 |
30 |
static int decode_nal_sei_active_parameter_sets(HEVCSEI *s, GetBitContext *gb, void *logctx) |
|
317 |
{ |
||
318 |
int num_sps_ids_minus1; |
||
319 |
int i; |
||
320 |
unsigned active_seq_parameter_set_id; |
||
321 |
|||
322 |
30 |
get_bits(gb, 4); // active_video_parameter_set_id |
|
323 |
30 |
get_bits(gb, 1); // self_contained_cvs_flag |
|
324 |
30 |
get_bits(gb, 1); // num_sps_ids_minus1 |
|
325 |
30 |
num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1 |
|
326 |
|||
327 |
✓✗✗✓ |
30 |
if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) { |
328 |
av_log(logctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1); |
||
329 |
return AVERROR_INVALIDDATA; |
||
330 |
} |
||
331 |
|||
332 |
30 |
active_seq_parameter_set_id = get_ue_golomb_long(gb); |
|
333 |
✗✓ | 30 |
if (active_seq_parameter_set_id >= HEVC_MAX_SPS_COUNT) { |
334 |
av_log(logctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id); |
||
335 |
return AVERROR_INVALIDDATA; |
||
336 |
} |
||
337 |
30 |
s->active_seq_parameter_set_id = active_seq_parameter_set_id; |
|
338 |
|||
339 |
✗✓ | 30 |
for (i = 1; i <= num_sps_ids_minus1; i++) |
340 |
get_ue_golomb_long(gb); // active_seq_parameter_set_id[i] |
||
341 |
|||
342 |
30 |
return 0; |
|
343 |
} |
||
344 |
|||
345 |
static int decode_nal_sei_alternative_transfer(HEVCSEIAlternativeTransfer *s, GetBitContext *gb) |
||
346 |
{ |
||
347 |
s->present = 1; |
||
348 |
s->preferred_transfer_characteristics = get_bits(gb, 8); |
||
349 |
return 0; |
||
350 |
} |
||
351 |
|||
352 |
64 |
static int decode_nal_sei_timecode(HEVCSEITimeCode *s, GetBitContext *gb) |
|
353 |
{ |
||
354 |
64 |
s->num_clock_ts = get_bits(gb, 2); |
|
355 |
|||
356 |
✓✓ | 128 |
for (int i = 0; i < s->num_clock_ts; i++) { |
357 |
64 |
s->clock_timestamp_flag[i] = get_bits(gb, 1); |
|
358 |
|||
359 |
✗✓ | 64 |
if (s->clock_timestamp_flag[i]) { |
360 |
s->units_field_based_flag[i] = get_bits(gb, 1); |
||
361 |
s->counting_type[i] = get_bits(gb, 5); |
||
362 |
s->full_timestamp_flag[i] = get_bits(gb, 1); |
||
363 |
s->discontinuity_flag[i] = get_bits(gb, 1); |
||
364 |
s->cnt_dropped_flag[i] = get_bits(gb, 1); |
||
365 |
|||
366 |
s->n_frames[i] = get_bits(gb, 9); |
||
367 |
|||
368 |
if (s->full_timestamp_flag[i]) { |
||
369 |
s->seconds_value[i] = av_clip(get_bits(gb, 6), 0, 59); |
||
370 |
s->minutes_value[i] = av_clip(get_bits(gb, 6), 0, 59); |
||
371 |
s->hours_value[i] = av_clip(get_bits(gb, 5), 0, 23); |
||
372 |
} else { |
||
373 |
s->seconds_flag[i] = get_bits(gb, 1); |
||
374 |
if (s->seconds_flag[i]) { |
||
375 |
s->seconds_value[i] = av_clip(get_bits(gb, 6), 0, 59); |
||
376 |
s->minutes_flag[i] = get_bits(gb, 1); |
||
377 |
if (s->minutes_flag[i]) { |
||
378 |
s->minutes_value[i] = av_clip(get_bits(gb, 6), 0, 59); |
||
379 |
s->hours_flag[i] = get_bits(gb, 1); |
||
380 |
if (s->hours_flag[i]) { |
||
381 |
s->hours_value[i] = av_clip(get_bits(gb, 5), 0, 23); |
||
382 |
} |
||
383 |
} |
||
384 |
} |
||
385 |
} |
||
386 |
|||
387 |
s->time_offset_length[i] = get_bits(gb, 5); |
||
388 |
if (s->time_offset_length[i] > 0) { |
||
389 |
s->time_offset_value[i] = get_bits(gb, s->time_offset_length[i]); |
||
390 |
} |
||
391 |
} |
||
392 |
} |
||
393 |
|||
394 |
64 |
s->present = 1; |
|
395 |
64 |
return 0; |
|
396 |
} |
||
397 |
|||
398 |
|||
399 |
1470 |
static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s, |
|
400 |
const HEVCParamSets *ps, int type, int size) |
||
401 |
{ |
||
402 |
✗✗✗✓ ✓✓✓✓ ✓✗✓✓ |
1470 |
switch (type) { |
403 |
case 256: // Mismatched value from HM 8.1 |
||
404 |
return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb); |
||
405 |
case SEI_TYPE_FRAME_PACKING_ARRANGEMENT: |
||
406 |
return decode_nal_sei_frame_packing_arrangement(&s->frame_packing, gb); |
||
407 |
case SEI_TYPE_DISPLAY_ORIENTATION: |
||
408 |
return decode_nal_sei_display_orientation(&s->display_orientation, gb); |
||
409 |
1204 |
case SEI_TYPE_PIC_TIMING: |
|
410 |
1204 |
return decode_nal_sei_pic_timing(s, gb, ps, logctx, size); |
|
411 |
3 |
case SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME: |
|
412 |
3 |
return decode_nal_sei_mastering_display_info(&s->mastering_display, gb); |
|
413 |
3 |
case SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO: |
|
414 |
3 |
return decode_nal_sei_content_light_info(&s->content_light, gb); |
|
415 |
30 |
case SEI_TYPE_ACTIVE_PARAMETER_SETS: |
|
416 |
30 |
return decode_nal_sei_active_parameter_sets(s, gb, logctx); |
|
417 |
67 |
case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35: |
|
418 |
67 |
return decode_nal_sei_user_data_registered_itu_t_t35(s, gb, logctx, size); |
|
419 |
9 |
case SEI_TYPE_USER_DATA_UNREGISTERED: |
|
420 |
9 |
return decode_nal_sei_user_data_unregistered(&s->unregistered, gb, size); |
|
421 |
case SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS: |
||
422 |
return decode_nal_sei_alternative_transfer(&s->alternative_transfer, gb); |
||
423 |
64 |
case SEI_TYPE_TIME_CODE: |
|
424 |
64 |
return decode_nal_sei_timecode(&s->timecode, gb); |
|
425 |
90 |
default: |
|
426 |
90 |
av_log(logctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type); |
|
427 |
90 |
skip_bits_long(gb, 8 * size); |
|
428 |
90 |
return 0; |
|
429 |
} |
||
430 |
} |
||
431 |
|||
432 |
6848 |
static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s, |
|
433 |
int type, int size) |
||
434 |
{ |
||
435 |
✓✗ | 6848 |
switch (type) { |
436 |
6848 |
case SEI_TYPE_DECODED_PICTURE_HASH: |
|
437 |
6848 |
return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb); |
|
438 |
default: |
||
439 |
av_log(logctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type); |
||
440 |
skip_bits_long(gb, 8 * size); |
||
441 |
return 0; |
||
442 |
} |
||
443 |
} |
||
444 |
|||
445 |
8382 |
static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s, |
|
446 |
const HEVCParamSets *ps, int nal_unit_type) |
||
447 |
{ |
||
448 |
8382 |
int payload_type = 0; |
|
449 |
8382 |
int payload_size = 0; |
|
450 |
8382 |
int byte = 0xFF; |
|
451 |
8382 |
av_log(logctx, AV_LOG_DEBUG, "Decoding SEI\n"); |
|
452 |
|||
453 |
✓✓ | 16700 |
while (byte == 0xFF) { |
454 |
✓✓✗✓ |
8382 |
if (get_bits_left(gb) < 16 || payload_type > INT_MAX - 255) |
455 |
64 |
return AVERROR_INVALIDDATA; |
|
456 |
8318 |
byte = get_bits(gb, 8); |
|
457 |
8318 |
payload_type += byte; |
|
458 |
} |
||
459 |
8318 |
byte = 0xFF; |
|
460 |
✓✓ | 16679 |
while (byte == 0xFF) { |
461 |
✗✓ | 8361 |
if (get_bits_left(gb) < 8 + 8LL*payload_size) |
462 |
return AVERROR_INVALIDDATA; |
||
463 |
8361 |
byte = get_bits(gb, 8); |
|
464 |
8361 |
payload_size += byte; |
|
465 |
} |
||
466 |
✗✓ | 8318 |
if (get_bits_left(gb) < 8LL*payload_size) |
467 |
return AVERROR_INVALIDDATA; |
||
468 |
✓✓ | 8318 |
if (nal_unit_type == HEVC_NAL_SEI_PREFIX) { |
469 |
1470 |
return decode_nal_sei_prefix(gb, logctx, s, ps, payload_type, payload_size); |
|
470 |
} else { /* nal_unit_type == NAL_SEI_SUFFIX */ |
||
471 |
6848 |
return decode_nal_sei_suffix(gb, logctx, s, payload_type, payload_size); |
|
472 |
} |
||
473 |
} |
||
474 |
|||
475 |
8274 |
static int more_rbsp_data(GetBitContext *gb) |
|
476 |
{ |
||
477 |
✓✓✓✗ |
8274 |
return get_bits_left(gb) > 0 && show_bits(gb, 8) != 0x80; |
478 |
} |
||
479 |
|||
480 |
8382 |
int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEI *s, |
|
481 |
const HEVCParamSets *ps, int type) |
||
482 |
{ |
||
483 |
int ret; |
||
484 |
|||
485 |
do { |
||
486 |
8382 |
ret = decode_nal_sei_message(gb, logctx, s, ps, type); |
|
487 |
✓✓ | 8382 |
if (ret < 0) |
488 |
108 |
return ret; |
|
489 |
✓✓ | 8274 |
} while (more_rbsp_data(gb)); |
490 |
8201 |
return 1; |
|
491 |
} |
||
492 |
|||
493 |
12409 |
void ff_hevc_reset_sei(HEVCSEI *s) |
|
494 |
{ |
||
495 |
12409 |
av_buffer_unref(&s->a53_caption.buf_ref); |
|
496 |
|||
497 |
✓✓ | 12412 |
for (int i = 0; i < s->unregistered.nb_buf_ref; i++) |
498 |
3 |
av_buffer_unref(&s->unregistered.buf_ref[i]); |
|
499 |
12409 |
s->unregistered.nb_buf_ref = 0; |
|
500 |
12409 |
av_freep(&s->unregistered.buf_ref); |
|
501 |
12409 |
av_buffer_unref(&s->dynamic_hdr_plus.info); |
|
502 |
12409 |
} |
Generated by: GCOVR (Version 4.2) |