blob: 8fc026cf1e17fe8f91ba6c04c27f8ccc9c6eae50
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 "golomb.h" |
26 | #include "hevcdec.h" |
27 | |
28 | enum HEVC_SEI_TYPE { |
29 | SEI_TYPE_BUFFERING_PERIOD = 0, |
30 | SEI_TYPE_PICTURE_TIMING = 1, |
31 | SEI_TYPE_PAN_SCAN_RECT = 2, |
32 | SEI_TYPE_FILLER_PAYLOAD = 3, |
33 | SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35 = 4, |
34 | SEI_TYPE_USER_DATA_UNREGISTERED = 5, |
35 | SEI_TYPE_RECOVERY_POINT = 6, |
36 | SEI_TYPE_SCENE_INFO = 9, |
37 | SEI_TYPE_FULL_FRAME_SNAPSHOT = 15, |
38 | SEI_TYPE_PROGRESSIVE_REFINEMENT_SEGMENT_START = 16, |
39 | SEI_TYPE_PROGRESSIVE_REFINEMENT_SEGMENT_END = 17, |
40 | SEI_TYPE_FILM_GRAIN_CHARACTERISTICS = 19, |
41 | SEI_TYPE_POST_FILTER_HINT = 22, |
42 | SEI_TYPE_TONE_MAPPING_INFO = 23, |
43 | SEI_TYPE_FRAME_PACKING = 45, |
44 | SEI_TYPE_DISPLAY_ORIENTATION = 47, |
45 | SEI_TYPE_SOP_DESCRIPTION = 128, |
46 | SEI_TYPE_ACTIVE_PARAMETER_SETS = 129, |
47 | SEI_TYPE_DECODING_UNIT_INFO = 130, |
48 | SEI_TYPE_TEMPORAL_LEVEL0_INDEX = 131, |
49 | SEI_TYPE_DECODED_PICTURE_HASH = 132, |
50 | SEI_TYPE_SCALABLE_NESTING = 133, |
51 | SEI_TYPE_REGION_REFRESH_INFO = 134, |
52 | SEI_TYPE_MASTERING_DISPLAY_INFO = 137, |
53 | SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO = 144, |
54 | }; |
55 | |
56 | static int decode_nal_sei_decoded_picture_hash(HEVCContext *s) |
57 | { |
58 | int cIdx, i; |
59 | uint8_t hash_type; |
60 | //uint16_t picture_crc; |
61 | //uint32_t picture_checksum; |
62 | GetBitContext *gb = &s->HEVClc->gb; |
63 | hash_type = get_bits(gb, 8); |
64 | |
65 | for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) { |
66 | if (hash_type == 0) { |
67 | s->is_md5 = 1; |
68 | for (i = 0; i < 16; i++) |
69 | s->md5[cIdx][i] = get_bits(gb, 8); |
70 | } else if (hash_type == 1) { |
71 | // picture_crc = get_bits(gb, 16); |
72 | skip_bits(gb, 16); |
73 | } else if (hash_type == 2) { |
74 | // picture_checksum = get_bits_long(gb, 32); |
75 | skip_bits(gb, 32); |
76 | } |
77 | } |
78 | return 0; |
79 | } |
80 | |
81 | static int decode_nal_sei_mastering_display_info(HEVCContext *s) |
82 | { |
83 | GetBitContext *gb = &s->HEVClc->gb; |
84 | int i; |
85 | // Mastering primaries |
86 | for (i = 0; i < 3; i++) { |
87 | s->display_primaries[i][0] = get_bits(gb, 16); |
88 | s->display_primaries[i][1] = get_bits(gb, 16); |
89 | } |
90 | // White point (x, y) |
91 | s->white_point[0] = get_bits(gb, 16); |
92 | s->white_point[1] = get_bits(gb, 16); |
93 | |
94 | // Max and min luminance of mastering display |
95 | s->max_mastering_luminance = get_bits_long(gb, 32); |
96 | s->min_mastering_luminance = get_bits_long(gb, 32); |
97 | |
98 | // As this SEI message comes before the first frame that references it, |
99 | // initialize the flag to 2 and decrement on IRAP access unit so it |
100 | // persists for the coded video sequence (e.g., between two IRAPs) |
101 | s->sei_mastering_display_info_present = 2; |
102 | return 0; |
103 | } |
104 | |
105 | static int decode_nal_sei_frame_packing_arrangement(HEVCContext *s) |
106 | { |
107 | GetBitContext *gb = &s->HEVClc->gb; |
108 | |
109 | get_ue_golomb_long(gb); // frame_packing_arrangement_id |
110 | s->sei_frame_packing_present = !get_bits1(gb); |
111 | |
112 | if (s->sei_frame_packing_present) { |
113 | s->frame_packing_arrangement_type = get_bits(gb, 7); |
114 | s->quincunx_subsampling = get_bits1(gb); |
115 | s->content_interpretation_type = get_bits(gb, 6); |
116 | |
117 | // the following skips spatial_flipping_flag frame0_flipped_flag |
118 | // field_views_flag current_frame_is_frame0_flag |
119 | // frame0_self_contained_flag frame1_self_contained_flag |
120 | skip_bits(gb, 6); |
121 | |
122 | if (!s->quincunx_subsampling && s->frame_packing_arrangement_type != 5) |
123 | skip_bits(gb, 16); // frame[01]_grid_position_[xy] |
124 | skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte |
125 | skip_bits1(gb); // frame_packing_arrangement_persistence_flag |
126 | } |
127 | skip_bits1(gb); // upsampled_aspect_ratio_flag |
128 | return 0; |
129 | } |
130 | |
131 | static int decode_nal_sei_display_orientation(HEVCContext *s) |
132 | { |
133 | GetBitContext *gb = &s->HEVClc->gb; |
134 | |
135 | s->sei_display_orientation_present = !get_bits1(gb); |
136 | |
137 | if (s->sei_display_orientation_present) { |
138 | s->sei_hflip = get_bits1(gb); // hor_flip |
139 | s->sei_vflip = get_bits1(gb); // ver_flip |
140 | |
141 | s->sei_anticlockwise_rotation = get_bits(gb, 16); |
142 | skip_bits1(gb); // display_orientation_persistence_flag |
143 | } |
144 | |
145 | return 0; |
146 | } |
147 | |
148 | static int decode_pic_timing(HEVCContext *s) |
149 | { |
150 | GetBitContext *gb = &s->HEVClc->gb; |
151 | HEVCSPS *sps; |
152 | |
153 | if (!s->ps.sps_list[s->active_seq_parameter_set_id]) |
154 | return(AVERROR(ENOMEM)); |
155 | sps = (HEVCSPS*)s->ps.sps_list[s->active_seq_parameter_set_id]->data; |
156 | |
157 | if (sps->vui.frame_field_info_present_flag) { |
158 | int pic_struct = get_bits(gb, 4); |
159 | s->picture_struct = AV_PICTURE_STRUCTURE_UNKNOWN; |
160 | if (pic_struct == 2) { |
161 | av_log(s->avctx, AV_LOG_DEBUG, "BOTTOM Field\n"); |
162 | s->picture_struct = AV_PICTURE_STRUCTURE_BOTTOM_FIELD; |
163 | } else if (pic_struct == 1) { |
164 | av_log(s->avctx, AV_LOG_DEBUG, "TOP Field\n"); |
165 | s->picture_struct = AV_PICTURE_STRUCTURE_TOP_FIELD; |
166 | } |
167 | get_bits(gb, 2); // source_scan_type |
168 | get_bits(gb, 1); // duplicate_flag |
169 | } |
170 | return 1; |
171 | } |
172 | |
173 | static int decode_registered_user_data_closed_caption(HEVCContext *s, int size) |
174 | { |
175 | int flag; |
176 | int user_data_type_code; |
177 | int cc_count; |
178 | |
179 | GetBitContext *gb = &s->HEVClc->gb; |
180 | |
181 | if (size < 3) |
182 | return AVERROR(EINVAL); |
183 | |
184 | user_data_type_code = get_bits(gb, 8); |
185 | if (user_data_type_code == 0x3) { |
186 | skip_bits(gb, 1); // reserved |
187 | |
188 | flag = get_bits(gb, 1); // process_cc_data_flag |
189 | if (flag) { |
190 | skip_bits(gb, 1); |
191 | cc_count = get_bits(gb, 5); |
192 | skip_bits(gb, 8); // reserved |
193 | size -= 2; |
194 | |
195 | if (cc_count && size >= cc_count * 3) { |
196 | const uint64_t new_size = (s->a53_caption_size + cc_count |
197 | * UINT64_C(3)); |
198 | int i, ret; |
199 | |
200 | if (new_size > INT_MAX) |
201 | return AVERROR(EINVAL); |
202 | |
203 | /* Allow merging of the cc data from two fields. */ |
204 | ret = av_reallocp(&s->a53_caption, new_size); |
205 | if (ret < 0) |
206 | return ret; |
207 | |
208 | for (i = 0; i < cc_count; i++) { |
209 | s->a53_caption[s->a53_caption_size++] = get_bits(gb, 8); |
210 | s->a53_caption[s->a53_caption_size++] = get_bits(gb, 8); |
211 | s->a53_caption[s->a53_caption_size++] = get_bits(gb, 8); |
212 | } |
213 | skip_bits(gb, 8); // marker_bits |
214 | } |
215 | } |
216 | } else { |
217 | int i; |
218 | for (i = 0; i < size - 1; i++) |
219 | skip_bits(gb, 8); |
220 | } |
221 | |
222 | return 0; |
223 | } |
224 | |
225 | static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCContext *s, int size) |
226 | { |
227 | uint32_t country_code; |
228 | uint32_t user_identifier; |
229 | |
230 | GetBitContext *gb = &s->HEVClc->gb; |
231 | |
232 | if (size < 7) |
233 | return AVERROR(EINVAL); |
234 | size -= 7; |
235 | |
236 | country_code = get_bits(gb, 8); |
237 | if (country_code == 0xFF) { |
238 | skip_bits(gb, 8); |
239 | size--; |
240 | } |
241 | |
242 | skip_bits(gb, 8); |
243 | skip_bits(gb, 8); |
244 | |
245 | user_identifier = get_bits_long(gb, 32); |
246 | |
247 | switch (user_identifier) { |
248 | case MKBETAG('G', 'A', '9', '4'): |
249 | return decode_registered_user_data_closed_caption(s, size); |
250 | default: |
251 | skip_bits_long(gb, size * 8); |
252 | break; |
253 | } |
254 | return 0; |
255 | } |
256 | |
257 | static int active_parameter_sets(HEVCContext *s) |
258 | { |
259 | GetBitContext *gb = &s->HEVClc->gb; |
260 | int num_sps_ids_minus1; |
261 | int i; |
262 | unsigned active_seq_parameter_set_id; |
263 | |
264 | get_bits(gb, 4); // active_video_parameter_set_id |
265 | get_bits(gb, 1); // self_contained_cvs_flag |
266 | get_bits(gb, 1); // num_sps_ids_minus1 |
267 | num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1 |
268 | |
269 | if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) { |
270 | av_log(s->avctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1); |
271 | return AVERROR_INVALIDDATA; |
272 | } |
273 | |
274 | active_seq_parameter_set_id = get_ue_golomb_long(gb); |
275 | if (active_seq_parameter_set_id >= HEVC_MAX_SPS_COUNT) { |
276 | av_log(s->avctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id); |
277 | return AVERROR_INVALIDDATA; |
278 | } |
279 | s->active_seq_parameter_set_id = active_seq_parameter_set_id; |
280 | |
281 | for (i = 1; i <= num_sps_ids_minus1; i++) |
282 | get_ue_golomb_long(gb); // active_seq_parameter_set_id[i] |
283 | |
284 | return 0; |
285 | } |
286 | |
287 | static int decode_nal_sei_prefix(HEVCContext *s, int type, int size) |
288 | { |
289 | GetBitContext *gb = &s->HEVClc->gb; |
290 | |
291 | switch (type) { |
292 | case 256: // Mismatched value from HM 8.1 |
293 | return decode_nal_sei_decoded_picture_hash(s); |
294 | case SEI_TYPE_FRAME_PACKING: |
295 | return decode_nal_sei_frame_packing_arrangement(s); |
296 | case SEI_TYPE_DISPLAY_ORIENTATION: |
297 | return decode_nal_sei_display_orientation(s); |
298 | case SEI_TYPE_PICTURE_TIMING: |
299 | { |
300 | int ret = decode_pic_timing(s); |
301 | av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type); |
302 | skip_bits(gb, 8 * size); |
303 | return ret; |
304 | } |
305 | case SEI_TYPE_MASTERING_DISPLAY_INFO: |
306 | return decode_nal_sei_mastering_display_info(s); |
307 | case SEI_TYPE_ACTIVE_PARAMETER_SETS: |
308 | active_parameter_sets(s); |
309 | av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type); |
310 | return 0; |
311 | case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35: |
312 | return decode_nal_sei_user_data_registered_itu_t_t35(s, size); |
313 | default: |
314 | av_log(s->avctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type); |
315 | skip_bits_long(gb, 8 * size); |
316 | return 0; |
317 | } |
318 | } |
319 | |
320 | static int decode_nal_sei_suffix(HEVCContext *s, int type, int size) |
321 | { |
322 | GetBitContext *gb = &s->HEVClc->gb; |
323 | |
324 | switch (type) { |
325 | case SEI_TYPE_DECODED_PICTURE_HASH: |
326 | return decode_nal_sei_decoded_picture_hash(s); |
327 | default: |
328 | av_log(s->avctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type); |
329 | skip_bits_long(gb, 8 * size); |
330 | return 0; |
331 | } |
332 | } |
333 | |
334 | static int decode_nal_sei_message(HEVCContext *s) |
335 | { |
336 | GetBitContext *gb = &s->HEVClc->gb; |
337 | |
338 | int payload_type = 0; |
339 | int payload_size = 0; |
340 | int byte = 0xFF; |
341 | av_log(s->avctx, AV_LOG_DEBUG, "Decoding SEI\n"); |
342 | |
343 | while (byte == 0xFF) { |
344 | byte = get_bits(gb, 8); |
345 | payload_type += byte; |
346 | } |
347 | byte = 0xFF; |
348 | while (byte == 0xFF) { |
349 | byte = get_bits(gb, 8); |
350 | payload_size += byte; |
351 | } |
352 | if (s->nal_unit_type == HEVC_NAL_SEI_PREFIX) { |
353 | return decode_nal_sei_prefix(s, payload_type, payload_size); |
354 | } else { /* nal_unit_type == NAL_SEI_SUFFIX */ |
355 | return decode_nal_sei_suffix(s, payload_type, payload_size); |
356 | } |
357 | } |
358 | |
359 | static int more_rbsp_data(GetBitContext *gb) |
360 | { |
361 | return get_bits_left(gb) > 0 && show_bits(gb, 8) != 0x80; |
362 | } |
363 | |
364 | int ff_hevc_decode_nal_sei(HEVCContext *s) |
365 | { |
366 | int ret; |
367 | |
368 | do { |
369 | ret = decode_nal_sei_message(s); |
370 | if (ret < 0) |
371 | return(AVERROR(ENOMEM)); |
372 | } while (more_rbsp_data(&s->HEVClc->gb)); |
373 | return 1; |
374 | } |
375 | |
376 | void ff_hevc_reset_sei(HEVCContext *s) |
377 | { |
378 | s->a53_caption_size = 0; |
379 | av_freep(&s->a53_caption); |
380 | } |
381 |