Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 / MPEG4 part10 sei decoding. | |
25 | * @author Michael Niedermayer <michaelni@gmx.at> | |
26 | */ | |
27 | ||
28 | #include "avcodec.h" | |
29 | #include "golomb.h" | |
30 | #include "h264.h" | |
31 | #include "internal.h" | |
32 | ||
33 | static const uint8_t sei_num_clock_ts_table[9] = { | |
34 | 1, 1, 1, 2, 2, 3, 3, 2, 3 | |
35 | }; | |
36 | ||
37 | void ff_h264_reset_sei(H264Context *h) | |
38 | { | |
39 | h->sei_recovery_frame_cnt = -1; | |
40 | h->sei_dpb_output_delay = 0; | |
41 | h->sei_cpb_removal_delay = -1; | |
42 | h->sei_buffering_period_present = 0; | |
43 | h->sei_frame_packing_present = 0; | |
44 | h->sei_display_orientation_present = 0; | |
45 | } | |
46 | ||
47 | static int decode_picture_timing(H264Context *h) | |
48 | { | |
49 | SPS *sps = &h->sps; | |
50 | int i; | |
51 | ||
52 | for (i = 0; i<MAX_SPS_COUNT; i++) | |
53 | if (!sps->log2_max_frame_num && h->sps_buffers[i]) | |
54 | sps = h->sps_buffers[i]; | |
55 | ||
56 | if (sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag) { | |
57 | h->sei_cpb_removal_delay = get_bits_long(&h->gb, | |
58 | sps->cpb_removal_delay_length); | |
59 | h->sei_dpb_output_delay = get_bits_long(&h->gb, | |
60 | sps->dpb_output_delay_length); | |
61 | } | |
62 | if (sps->pic_struct_present_flag) { | |
63 | unsigned int i, num_clock_ts; | |
64 | ||
65 | h->sei_pic_struct = get_bits(&h->gb, 4); | |
66 | h->sei_ct_type = 0; | |
67 | ||
68 | if (h->sei_pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING) | |
69 | return AVERROR_INVALIDDATA; | |
70 | ||
71 | num_clock_ts = sei_num_clock_ts_table[h->sei_pic_struct]; | |
72 | ||
73 | for (i = 0; i < num_clock_ts; i++) { | |
74 | if (get_bits(&h->gb, 1)) { /* clock_timestamp_flag */ | |
75 | unsigned int full_timestamp_flag; | |
76 | ||
77 | h->sei_ct_type |= 1 << get_bits(&h->gb, 2); | |
78 | skip_bits(&h->gb, 1); /* nuit_field_based_flag */ | |
79 | skip_bits(&h->gb, 5); /* counting_type */ | |
80 | full_timestamp_flag = get_bits(&h->gb, 1); | |
81 | skip_bits(&h->gb, 1); /* discontinuity_flag */ | |
82 | skip_bits(&h->gb, 1); /* cnt_dropped_flag */ | |
83 | skip_bits(&h->gb, 8); /* n_frames */ | |
84 | if (full_timestamp_flag) { | |
85 | skip_bits(&h->gb, 6); /* seconds_value 0..59 */ | |
86 | skip_bits(&h->gb, 6); /* minutes_value 0..59 */ | |
87 | skip_bits(&h->gb, 5); /* hours_value 0..23 */ | |
88 | } else { | |
89 | if (get_bits(&h->gb, 1)) { /* seconds_flag */ | |
90 | skip_bits(&h->gb, 6); /* seconds_value range 0..59 */ | |
91 | if (get_bits(&h->gb, 1)) { /* minutes_flag */ | |
92 | skip_bits(&h->gb, 6); /* minutes_value 0..59 */ | |
93 | if (get_bits(&h->gb, 1)) /* hours_flag */ | |
94 | skip_bits(&h->gb, 5); /* hours_value 0..23 */ | |
95 | } | |
96 | } | |
97 | } | |
98 | if (sps->time_offset_length > 0) | |
99 | skip_bits(&h->gb, | |
100 | sps->time_offset_length); /* time_offset */ | |
101 | } | |
102 | } | |
103 | ||
104 | if (h->avctx->debug & FF_DEBUG_PICT_INFO) | |
105 | av_log(h->avctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n", | |
106 | h->sei_ct_type, h->sei_pic_struct); | |
107 | } | |
108 | return 0; | |
109 | } | |
110 | ||
111 | static int decode_user_data_itu_t_t35(H264Context *h, int size) | |
112 | { | |
113 | uint32_t user_identifier; | |
114 | int dtg_active_format; | |
115 | ||
116 | if (size < 7) | |
117 | return -1; | |
118 | size -= 7; | |
119 | ||
120 | skip_bits(&h->gb, 8); // country_code | |
121 | skip_bits(&h->gb, 16); // provider_code | |
122 | user_identifier = get_bits_long(&h->gb, 32); | |
123 | ||
124 | switch (user_identifier) { | |
125 | case 0x44544731: // "DTG1" - AFD_data | |
126 | if (size < 1) | |
127 | return -1; | |
128 | skip_bits(&h->gb, 1); | |
129 | if (get_bits(&h->gb, 1)) { | |
130 | skip_bits(&h->gb, 6); | |
131 | if (size < 2) | |
132 | return -1; | |
133 | skip_bits(&h->gb, 4); | |
134 | dtg_active_format = get_bits(&h->gb, 4); | |
135 | h->avctx->dtg_active_format = dtg_active_format; | |
136 | } else { | |
137 | skip_bits(&h->gb, 6); | |
138 | } | |
139 | break; | |
140 | default: | |
141 | skip_bits(&h->gb, size * 8); | |
142 | break; | |
143 | } | |
144 | ||
145 | return 0; | |
146 | } | |
147 | ||
148 | static int decode_unregistered_user_data(H264Context *h, int size) | |
149 | { | |
150 | uint8_t user_data[16 + 256]; | |
151 | int e, build, i; | |
152 | ||
153 | if (size < 16) | |
154 | return AVERROR_INVALIDDATA; | |
155 | ||
156 | for (i = 0; i < sizeof(user_data) - 1 && i < size; i++) | |
157 | user_data[i] = get_bits(&h->gb, 8); | |
158 | ||
159 | user_data[i] = 0; | |
160 | e = sscanf(user_data + 16, "x264 - core %d", &build); | |
161 | if (e == 1 && build > 0) | |
162 | h->x264_build = build; | |
163 | if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16)) | |
164 | h->x264_build = 67; | |
165 | ||
166 | if (h->avctx->debug & FF_DEBUG_BUGS) | |
167 | av_log(h->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data + 16); | |
168 | ||
169 | for (; i < size; i++) | |
170 | skip_bits(&h->gb, 8); | |
171 | ||
172 | return 0; | |
173 | } | |
174 | ||
175 | static int decode_recovery_point(H264Context *h) | |
176 | { | |
177 | h->sei_recovery_frame_cnt = get_ue_golomb(&h->gb); | |
178 | ||
179 | /* 1b exact_match_flag, | |
180 | * 1b broken_link_flag, | |
181 | * 2b changing_slice_group_idc */ | |
182 | skip_bits(&h->gb, 4); | |
183 | ||
184 | if (h->avctx->debug & FF_DEBUG_PICT_INFO) | |
185 | av_log(h->avctx, AV_LOG_DEBUG, "sei_recovery_frame_cnt: %d\n", h->sei_recovery_frame_cnt); | |
186 | ||
187 | h->has_recovery_point = 1; | |
188 | ||
189 | return 0; | |
190 | } | |
191 | ||
192 | static int decode_buffering_period(H264Context *h) | |
193 | { | |
194 | unsigned int sps_id; | |
195 | int sched_sel_idx; | |
196 | SPS *sps; | |
197 | ||
198 | sps_id = get_ue_golomb_31(&h->gb); | |
199 | if (sps_id > 31 || !h->sps_buffers[sps_id]) { | |
200 | av_log(h->avctx, AV_LOG_ERROR, | |
201 | "non-existing SPS %d referenced in buffering period\n", sps_id); | |
202 | return AVERROR_INVALIDDATA; | |
203 | } | |
204 | sps = h->sps_buffers[sps_id]; | |
205 | ||
206 | // NOTE: This is really so duplicated in the standard... See H.264, D.1.1 | |
207 | if (sps->nal_hrd_parameters_present_flag) { | |
208 | for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) { | |
209 | h->initial_cpb_removal_delay[sched_sel_idx] = | |
210 | get_bits_long(&h->gb, sps->initial_cpb_removal_delay_length); | |
211 | // initial_cpb_removal_delay_offset | |
212 | skip_bits(&h->gb, sps->initial_cpb_removal_delay_length); | |
213 | } | |
214 | } | |
215 | if (sps->vcl_hrd_parameters_present_flag) { | |
216 | for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) { | |
217 | h->initial_cpb_removal_delay[sched_sel_idx] = | |
218 | get_bits_long(&h->gb, sps->initial_cpb_removal_delay_length); | |
219 | // initial_cpb_removal_delay_offset | |
220 | skip_bits(&h->gb, sps->initial_cpb_removal_delay_length); | |
221 | } | |
222 | } | |
223 | ||
224 | h->sei_buffering_period_present = 1; | |
225 | return 0; | |
226 | } | |
227 | ||
228 | static int decode_frame_packing_arrangement(H264Context *h) | |
229 | { | |
230 | h->sei_fpa.frame_packing_arrangement_id = get_ue_golomb(&h->gb); | |
231 | h->sei_fpa.frame_packing_arrangement_cancel_flag = get_bits1(&h->gb); | |
232 | h->sei_frame_packing_present = !h->sei_fpa.frame_packing_arrangement_cancel_flag; | |
233 | ||
234 | if (h->sei_frame_packing_present) { | |
235 | h->sei_fpa.frame_packing_arrangement_type = | |
236 | h->frame_packing_arrangement_type = get_bits(&h->gb, 7); | |
237 | h->sei_fpa.quincunx_sampling_flag = | |
238 | h->quincunx_subsampling = get_bits1(&h->gb); | |
239 | h->sei_fpa.content_interpretation_type = | |
240 | h->content_interpretation_type = get_bits(&h->gb, 6); | |
241 | ||
242 | // the following skips: spatial_flipping_flag, frame0_flipped_flag, | |
243 | // field_views_flag, current_frame_is_frame0_flag, | |
244 | // frame0_self_contained_flag, frame1_self_contained_flag | |
245 | skip_bits(&h->gb, 6); | |
246 | ||
247 | if (!h->quincunx_subsampling && h->frame_packing_arrangement_type != 5) | |
248 | skip_bits(&h->gb, 16); // frame[01]_grid_position_[xy] | |
249 | skip_bits(&h->gb, 8); // frame_packing_arrangement_reserved_byte | |
250 | h->sei_fpa.frame_packing_arrangement_repetition_period = get_ue_golomb(&h->gb) /* frame_packing_arrangement_repetition_period */; | |
251 | } | |
252 | skip_bits1(&h->gb); // frame_packing_arrangement_extension_flag | |
253 | ||
254 | if (h->avctx->debug & FF_DEBUG_PICT_INFO) | |
255 | av_log(h->avctx, AV_LOG_DEBUG, "SEI FPA %d %d %d %d %d %d\n", | |
256 | h->sei_fpa.frame_packing_arrangement_id, | |
257 | h->sei_fpa.frame_packing_arrangement_cancel_flag, | |
258 | h->sei_fpa.frame_packing_arrangement_type, | |
259 | h->sei_fpa.quincunx_sampling_flag, | |
260 | h->sei_fpa.content_interpretation_type, | |
261 | h->sei_fpa.frame_packing_arrangement_repetition_period); | |
262 | ||
263 | return 0; | |
264 | } | |
265 | ||
266 | static int decode_display_orientation(H264Context *h) | |
267 | { | |
268 | h->sei_display_orientation_present = !get_bits1(&h->gb); | |
269 | ||
270 | if (h->sei_display_orientation_present) { | |
271 | h->sei_hflip = get_bits1(&h->gb); // hor_flip | |
272 | h->sei_vflip = get_bits1(&h->gb); // ver_flip | |
273 | ||
274 | h->sei_anticlockwise_rotation = get_bits(&h->gb, 16); | |
275 | get_ue_golomb(&h->gb); // display_orientation_repetition_period | |
276 | skip_bits1(&h->gb); // display_orientation_extension_flag | |
277 | } | |
278 | ||
279 | return 0; | |
280 | } | |
281 | ||
282 | int ff_h264_decode_sei(H264Context *h) | |
283 | { | |
f6fa7814 | 284 | while (get_bits_left(&h->gb) > 16 && show_bits(&h->gb, 16)) { |
2ba45a60 DM |
285 | int type = 0; |
286 | unsigned size = 0; | |
287 | unsigned next; | |
288 | int ret = 0; | |
289 | ||
290 | do { | |
291 | if (get_bits_left(&h->gb) < 8) | |
292 | return AVERROR_INVALIDDATA; | |
293 | type += show_bits(&h->gb, 8); | |
294 | } while (get_bits(&h->gb, 8) == 255); | |
295 | ||
296 | do { | |
297 | if (get_bits_left(&h->gb) < 8) | |
298 | return AVERROR_INVALIDDATA; | |
299 | size += show_bits(&h->gb, 8); | |
300 | } while (get_bits(&h->gb, 8) == 255); | |
301 | ||
302 | if (h->avctx->debug&FF_DEBUG_STARTCODE) | |
303 | av_log(h->avctx, AV_LOG_DEBUG, "SEI %d len:%d\n", type, size); | |
304 | ||
305 | if (size > get_bits_left(&h->gb) / 8) { | |
306 | av_log(h->avctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n", | |
307 | type, 8*size, get_bits_left(&h->gb)); | |
308 | return AVERROR_INVALIDDATA; | |
309 | } | |
310 | next = get_bits_count(&h->gb) + 8 * size; | |
311 | ||
312 | switch (type) { | |
313 | case SEI_TYPE_PIC_TIMING: // Picture timing SEI | |
314 | ret = decode_picture_timing(h); | |
315 | if (ret < 0) | |
316 | return ret; | |
317 | break; | |
318 | case SEI_TYPE_USER_DATA_ITU_T_T35: | |
319 | if (decode_user_data_itu_t_t35(h, size) < 0) | |
320 | return -1; | |
321 | break; | |
322 | case SEI_TYPE_USER_DATA_UNREGISTERED: | |
323 | ret = decode_unregistered_user_data(h, size); | |
324 | if (ret < 0) | |
325 | return ret; | |
326 | break; | |
327 | case SEI_TYPE_RECOVERY_POINT: | |
328 | ret = decode_recovery_point(h); | |
329 | if (ret < 0) | |
330 | return ret; | |
331 | break; | |
332 | case SEI_TYPE_BUFFERING_PERIOD: | |
333 | ret = decode_buffering_period(h); | |
334 | if (ret < 0) | |
335 | return ret; | |
336 | break; | |
337 | case SEI_TYPE_FRAME_PACKING: | |
338 | ret = decode_frame_packing_arrangement(h); | |
339 | if (ret < 0) | |
340 | return ret; | |
341 | break; | |
342 | case SEI_TYPE_DISPLAY_ORIENTATION: | |
343 | ret = decode_display_orientation(h); | |
344 | if (ret < 0) | |
345 | return ret; | |
346 | break; | |
347 | default: | |
348 | av_log(h->avctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type); | |
349 | } | |
350 | skip_bits_long(&h->gb, next - get_bits_count(&h->gb)); | |
351 | ||
352 | // FIXME check bits here | |
353 | align_get_bits(&h->gb); | |
354 | } | |
355 | ||
356 | return 0; | |
357 | } | |
358 | ||
359 | const char* ff_h264_sei_stereo_mode(H264Context *h) | |
360 | { | |
361 | if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 0) { | |
362 | switch (h->sei_fpa.frame_packing_arrangement_type) { | |
363 | case SEI_FPA_TYPE_CHECKERBOARD: | |
364 | if (h->sei_fpa.content_interpretation_type == 2) | |
365 | return "checkerboard_rl"; | |
366 | else | |
367 | return "checkerboard_lr"; | |
368 | case SEI_FPA_TYPE_INTERLEAVE_COLUMN: | |
369 | if (h->sei_fpa.content_interpretation_type == 2) | |
370 | return "col_interleaved_rl"; | |
371 | else | |
372 | return "col_interleaved_lr"; | |
373 | case SEI_FPA_TYPE_INTERLEAVE_ROW: | |
374 | if (h->sei_fpa.content_interpretation_type == 2) | |
375 | return "row_interleaved_rl"; | |
376 | else | |
377 | return "row_interleaved_lr"; | |
378 | case SEI_FPA_TYPE_SIDE_BY_SIDE: | |
379 | if (h->sei_fpa.content_interpretation_type == 2) | |
380 | return "right_left"; | |
381 | else | |
382 | return "left_right"; | |
383 | case SEI_FPA_TYPE_TOP_BOTTOM: | |
384 | if (h->sei_fpa.content_interpretation_type == 2) | |
385 | return "bottom_top"; | |
386 | else | |
387 | return "top_bottom"; | |
388 | case SEI_FPA_TYPE_INTERLEAVE_TEMPORAL: | |
389 | if (h->sei_fpa.content_interpretation_type == 2) | |
390 | return "block_rl"; | |
391 | else | |
392 | return "block_lr"; | |
393 | case SEI_FPA_TYPE_2D: | |
394 | default: | |
395 | return "mono"; | |
396 | } | |
397 | } else if (h->sei_fpa.frame_packing_arrangement_cancel_flag == 1) { | |
398 | return "mono"; | |
399 | } else { | |
400 | return NULL; | |
401 | } | |
402 | } |