Libav
h264_sei.c
Go to the documentation of this file.
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "golomb.h"
31 #include "h264_ps.h"
32 #include "h264_sei.h"
33 #include "internal.h"
34 
35 static const uint8_t sei_num_clock_ts_table[9] = {
36  1, 1, 1, 2, 2, 3, 3, 2, 3
37 };
38 
40 {
41  h->unregistered.x264_build = -1;
43 
46 
48  h->frame_packing.present = 0;
50  h->afd.present = 0;
51 
54 }
55 
57  const SPS *sps, void *logctx)
58 {
59  if (!sps)
60  return AVERROR_INVALIDDATA;
61 
66  }
67  if (sps->pic_struct_present_flag) {
68  unsigned int i, num_clock_ts;
69 
70  h->pic_struct = get_bits(gb, 4);
71  h->ct_type = 0;
72 
74  return AVERROR_INVALIDDATA;
75 
76  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
77 
78  for (i = 0; i < num_clock_ts; i++) {
79  if (get_bits(gb, 1)) { /* clock_timestamp_flag */
80  unsigned int full_timestamp_flag;
81 
82  h->ct_type |= 1 << get_bits(gb, 2);
83  skip_bits(gb, 1); /* nuit_field_based_flag */
84  skip_bits(gb, 5); /* counting_type */
85  full_timestamp_flag = get_bits(gb, 1);
86  skip_bits(gb, 1); /* discontinuity_flag */
87  skip_bits(gb, 1); /* cnt_dropped_flag */
88  skip_bits(gb, 8); /* n_frames */
89  if (full_timestamp_flag) {
90  skip_bits(gb, 6); /* seconds_value 0..59 */
91  skip_bits(gb, 6); /* minutes_value 0..59 */
92  skip_bits(gb, 5); /* hours_value 0..23 */
93  } else {
94  if (get_bits(gb, 1)) { /* seconds_flag */
95  skip_bits(gb, 6); /* seconds_value range 0..59 */
96  if (get_bits(gb, 1)) { /* minutes_flag */
97  skip_bits(gb, 6); /* minutes_value 0..59 */
98  if (get_bits(gb, 1)) /* hours_flag */
99  skip_bits(gb, 5); /* hours_value 0..23 */
100  }
101  }
102  }
103  if (sps->time_offset_length > 0)
104  skip_bits(gb,
105  sps->time_offset_length); /* time_offset */
106  }
107  }
108 
109  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
110  h->ct_type, h->pic_struct);
111  }
112  return 0;
113 }
114 
116 {
117  int flag;
118 
119  if (size-- < 1)
120  return AVERROR_INVALIDDATA;
121  skip_bits(gb, 1); // 0
122  flag = get_bits(gb, 1); // active_format_flag
123  skip_bits(gb, 6); // reserved
124 
125  if (flag) {
126  if (size-- < 1)
127  return AVERROR_INVALIDDATA;
128  skip_bits(gb, 4); // reserved
130  h->present = 1;
131  }
132 
133  return 0;
134 }
135 
137  GetBitContext *gb, void *logctx,
138  int size)
139 {
140  int flag;
141  int user_data_type_code;
142  int cc_count;
143 
144  if (size < 3)
145  return AVERROR(EINVAL);
146 
147  user_data_type_code = get_bits(gb, 8);
148  if (user_data_type_code == 0x3) {
149  skip_bits(gb, 1); // reserved
150 
151  flag = get_bits(gb, 1); // process_cc_data_flag
152  if (flag) {
153  skip_bits(gb, 1); // zero bit
154  cc_count = get_bits(gb, 5);
155  skip_bits(gb, 8); // reserved
156  size -= 2;
157 
158  if (cc_count && size >= cc_count * 3) {
159  const uint64_t new_size = (h->a53_caption_size + cc_count
160  * UINT64_C(3));
161  int i, ret;
162 
163  if (new_size > INT_MAX)
164  return AVERROR(EINVAL);
165 
166  /* Allow merging of the cc data from two fields. */
167  ret = av_reallocp(&h->a53_caption, new_size);
168  if (ret < 0)
169  return ret;
170 
171  for (i = 0; i < cc_count; i++) {
172  h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
173  h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
174  h->a53_caption[h->a53_caption_size++] = get_bits(gb, 8);
175  }
176 
177  skip_bits(gb, 8); // marker_bits
178  }
179  }
180  } else {
181  int i;
182  avpriv_request_sample(logctx, "Subtitles with data type 0x%02x",
183  user_data_type_code);
184  for (i = 0; i < size - 1; i++)
185  skip_bits(gb, 8);
186  }
187 
188  return 0;
189 }
190 
192  void *logctx, int size)
193 {
194  uint32_t country_code;
195  uint32_t user_identifier;
196 
197  if (size < 7)
198  return AVERROR_INVALIDDATA;
199  size -= 7;
200 
201  country_code = get_bits(gb, 8); // itu_t_t35_country_code
202  if (country_code == 0xFF) {
203  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
204  size--;
205  }
206 
207  /* itu_t_t35_payload_byte follows */
208  skip_bits(gb, 8); // terminal provider code
209  skip_bits(gb, 8); // terminal provider oriented code
210  user_identifier = get_bits_long(gb, 32);
211 
212  switch (user_identifier) {
213  case MKBETAG('D', 'T', 'G', '1'): // afd_data
214  return decode_registered_user_data_afd(&h->afd, gb, size);
215  case MKBETAG('G', 'A', '9', '4'): // closed captions
217  logctx, size);
218  default:
219  skip_bits(gb, size * 8);
220  break;
221  }
222 
223  return 0;
224 }
225 
227  void *logctx, int size)
228 {
229  uint8_t *user_data;
230  int e, build, i;
231 
232  if (size < 16 || size >= INT_MAX - 16)
233  return AVERROR_INVALIDDATA;
234 
235  user_data = av_malloc(16 + size + 1);
236  if (!user_data)
237  return AVERROR(ENOMEM);
238 
239  for (i = 0; i < size + 16; i++)
240  user_data[i] = get_bits(gb, 8);
241 
242  user_data[i] = 0;
243  e = sscanf(user_data + 16, "x264 - core %d", &build);
244  if (e == 1 && build > 0)
245  h->x264_build = build;
246 
247  if (strlen(user_data + 16) > 0)
248  av_log(logctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data + 16);
249 
250  av_free(user_data);
251  return 0;
252 }
253 
255 {
257 
258  /* 1b exact_match_flag,
259  * 1b broken_link_flag,
260  * 2b changing_slice_group_idc */
261  skip_bits(gb, 4);
262 
263  return 0;
264 }
265 
267  const H264ParamSets *ps, void *logctx)
268 {
269  unsigned int sps_id;
270  int sched_sel_idx;
271  SPS *sps;
272 
273  sps_id = get_ue_golomb_31(gb);
274  if (sps_id > 31 || !ps->sps_list[sps_id]) {
275  av_log(logctx, AV_LOG_ERROR,
276  "non-existing SPS %d referenced in buffering period\n", sps_id);
277  return AVERROR_INVALIDDATA;
278  }
279  sps = (SPS*)ps->sps_list[sps_id]->data;
280 
281  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
283  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
284  h->initial_cpb_removal_delay[sched_sel_idx] =
286  // initial_cpb_removal_delay_offset
288  }
289  }
291  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
292  h->initial_cpb_removal_delay[sched_sel_idx] =
294  // initial_cpb_removal_delay_offset
296  }
297  }
298 
299  h->present = 1;
300  return 0;
301 }
302 
304  GetBitContext *gb)
305 {
306  get_ue_golomb(gb); // frame_packing_arrangement_id
307  h->present = !get_bits1(gb);
308 
309  if (h->present) {
310  h->arrangement_type = get_bits(gb, 7);
313 
314  // the following skips: spatial_flipping_flag, frame0_flipped_flag,
315  // field_views_flag, current_frame_is_frame0_flag,
316  // frame0_self_contained_flag, frame1_self_contained_flag
317  skip_bits(gb, 6);
318 
319  if (!h->quincunx_subsampling && h->arrangement_type != 5)
320  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
321  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
322  get_ue_golomb(gb); // frame_packing_arrangement_repetition_period
323  }
324  skip_bits1(gb); // frame_packing_arrangement_extension_flag
325 
326  return 0;
327 }
328 
330  GetBitContext *gb)
331 {
332  h->present = !get_bits1(gb);
333 
334  if (h->present) {
335  h->hflip = get_bits1(gb); // hor_flip
336  h->vflip = get_bits1(gb); // ver_flip
337 
338  h->anticlockwise_rotation = get_bits(gb, 16);
339  get_ue_golomb(gb); // display_orientation_repetition_period
340  skip_bits1(gb); // display_orientation_extension_flag
341  }
342 
343  return 0;
344 }
345 
347  const H264ParamSets *ps, void *logctx)
348 {
349  while (get_bits_left(gb) > 16) {
350  int size = 0;
351  int type = 0;
352  int ret = 0;
353  int last = 0;
354 
355  while (get_bits_left(gb) >= 8 &&
356  (last = get_bits(gb, 8)) == 255) {
357  type += 255;
358  }
359  type += last;
360 
361  last = 0;
362  while (get_bits_left(gb) >= 8 &&
363  (last = get_bits(gb, 8)) == 255) {
364  size += 255;
365  }
366  size += last;
367 
368  if (size > get_bits_left(gb) / 8) {
369  av_log(logctx, AV_LOG_ERROR, "SEI type %d truncated at %d\n",
370  type, get_bits_left(gb));
371  return AVERROR_INVALIDDATA;
372  }
373 
374  switch (type) {
375  case SEI_TYPE_PIC_TIMING: // Picture timing SEI
376  ret = decode_picture_timing(&h->picture_timing, gb, ps->sps, logctx);
377  break;
379  ret = decode_registered_user_data(h, gb, logctx, size);
380  break;
382  ret = decode_unregistered_user_data(&h->unregistered, gb, logctx, size);
383  break;
385  ret = decode_recovery_point(&h->recovery_point, gb);
386  break;
388  ret = decode_buffering_period(&h->buffering_period, gb, ps, logctx);
389  break;
392  break;
395  break;
396  default:
397  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
398  skip_bits(gb, 8 * size);
399  }
400  if (ret < 0)
401  return ret;
402 
403  // FIXME check bits here
404  align_get_bits(gb);
405  }
406 
407  return 0;
408 }
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, const SPS *sps, void *logctx)
Definition: h264_sei.c:56
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int size
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:95
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:134
Sequence parameter set.
Definition: h264_ps.h:43
picture timing
Definition: h264_sei.h:29
int flag
Definition: cpu.c:35
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
display orientation
Definition: h264_sei.h:34
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:39
H264SEIDisplayOrientation display_orientation
Definition: h264_sei.h:124
8: frame tripling
Definition: h264_sei.h:49
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:202
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb)
Definition: h264_sei.c:254
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
int av_reallocp(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:140
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:226
bitstream reader API header.
H264SEIAFD afd
Definition: h264_sei.h:118
int a53_caption_size
Definition: h264_sei.h:79
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:526
H.264 parameter set handling.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:190
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
Definition: golomb.h:53
#define AVERROR(e)
Definition: error.h:43
int present
Buffering period SEI flag.
Definition: h264_sei.h:99
int time_offset_length
Definition: h264_ps.h:92
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:145
registered user data as specified by Rec. ITU-T T.35
Definition: h264_sei.h:30
H264SEIUnregistered unregistered
Definition: h264_sei.h:120
static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
Definition: h264_sei.c:115
uint8_t active_format_description
Definition: h264_sei.h:75
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:329
recovery point (frame # to decoder sync)
Definition: h264_sei.h:32
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:94
int ct_type
Bit set of clock types for fields/frames in picture timing SEI message.
Definition: h264_sei.h:60
int initial_cpb_removal_delay[32]
Initial timestamps for CPBs.
Definition: h264_sei.h:100
buffering period (H.264, D.1.1)
Definition: h264_sei.h:28
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:70
uint8_t * a53_caption
Definition: h264_sei.h:80
if(ac->has_optimized_func)
int vcl_hrd_parameters_present_flag
Definition: h264_ps.h:90
Libavcodec external API header.
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:96
SEI_PicStructType pic_struct
Definition: h264_sei.h:53
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264_ps.h:96
uint8_t * data
The data buffer.
Definition: buffer.h:89
H264SEIA53Caption a53_caption
Definition: h264_sei.h:119
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:292
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:259
int content_interpretation_type
Definition: h264_sei.h:106
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:122
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:117
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:121
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:300
static const uint8_t sei_num_clock_ts_table[9]
Definition: h264_sei.c:35
int pic_struct_present_flag
Definition: h264_ps.h:91
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:303
common internal api header.
int dpb_output_delay
dpb_output_delay in picture timing SEI message, see H.264 C.2.2
Definition: h264_sei.h:65
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:89
H264SEIFramePacking frame_packing
Definition: h264_sei.h:123
unregistered user data
Definition: h264_sei.h:31
#define MKBETAG(a, b, c, d)
Definition: common.h:257
int present
Definition: h264_sei.h:74
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:403
int cpb_cnt
See H.264 E.1.2.
Definition: h264_ps.h:93
SPS * sps
Definition: h264_ps.h:140
frame packing arrangement
Definition: h264_sei.h:33
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:346
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:191
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:95
exp golomb vlc stuff
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:136
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:266