FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 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 "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 #define AVERROR_PS_NOT_FOUND FFERRTAG(0xF8,'?','P','S')
36 
37 static const uint8_t sei_num_clock_ts_table[9] = {
38  1, 1, 1, 2, 2, 3, 3, 2, 3
39 };
40 
42 {
44 
47 
48  h->picture_timing.present = 0;
50  h->frame_packing.present = 0;
52  h->afd.present = 0;
53 
55 }
56 
58  const H264ParamSets *ps, void *logctx)
59 {
60  int i;
61  const SPS *sps = ps->sps;
62 
63  for (i = 0; i<MAX_SPS_COUNT; i++)
64  if ((!sps || !sps->log2_max_frame_num) && ps->sps_list[i])
65  sps = (const SPS *)ps->sps_list[i]->data;
66 
67  if (!sps) {
68  av_log(logctx, AV_LOG_ERROR, "SPS unavailable in decode_picture_timing\n");
69  return AVERROR_PS_NOT_FOUND;
70  }
71 
76  }
77  if (sps->pic_struct_present_flag) {
78  unsigned int i, num_clock_ts;
79 
80  h->pic_struct = get_bits(gb, 4);
81  h->ct_type = 0;
82 
84  return AVERROR_INVALIDDATA;
85 
86  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
87 
88  for (i = 0; i < num_clock_ts; i++) {
89  if (get_bits(gb, 1)) { /* clock_timestamp_flag */
90  unsigned int full_timestamp_flag;
91 
92  h->ct_type |= 1 << get_bits(gb, 2);
93  skip_bits(gb, 1); /* nuit_field_based_flag */
94  skip_bits(gb, 5); /* counting_type */
95  full_timestamp_flag = get_bits(gb, 1);
96  skip_bits(gb, 1); /* discontinuity_flag */
97  skip_bits(gb, 1); /* cnt_dropped_flag */
98  skip_bits(gb, 8); /* n_frames */
99  if (full_timestamp_flag) {
100  skip_bits(gb, 6); /* seconds_value 0..59 */
101  skip_bits(gb, 6); /* minutes_value 0..59 */
102  skip_bits(gb, 5); /* hours_value 0..23 */
103  } else {
104  if (get_bits(gb, 1)) { /* seconds_flag */
105  skip_bits(gb, 6); /* seconds_value range 0..59 */
106  if (get_bits(gb, 1)) { /* minutes_flag */
107  skip_bits(gb, 6); /* minutes_value 0..59 */
108  if (get_bits(gb, 1)) /* hours_flag */
109  skip_bits(gb, 5); /* hours_value 0..23 */
110  }
111  }
112  }
113  if (sps->time_offset_length > 0)
114  skip_bits(gb,
115  sps->time_offset_length); /* time_offset */
116  }
117  }
118 
119  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
120  h->ct_type, h->pic_struct);
121  }
122 
123  h->present = 1;
124  return 0;
125 }
126 
128 {
129  int flag;
130 
131  if (size-- < 1)
132  return AVERROR_INVALIDDATA;
133  skip_bits(gb, 1); // 0
134  flag = get_bits(gb, 1); // active_format_flag
135  skip_bits(gb, 6); // reserved
136 
137  if (flag) {
138  if (size-- < 1)
139  return AVERROR_INVALIDDATA;
140  skip_bits(gb, 4); // reserved
142  h->present = 1;
143  }
144 
145  return 0;
146 }
147 
149  GetBitContext *gb, void *logctx,
150  int size)
151 {
152  int flag;
153  int user_data_type_code;
154  int cc_count;
155 
156  if (size < 3)
157  return AVERROR(EINVAL);
158 
159  user_data_type_code = get_bits(gb, 8);
160  if (user_data_type_code == 0x3) {
161  skip_bits(gb, 1); // reserved
162 
163  flag = get_bits(gb, 1); // process_cc_data_flag
164  if (flag) {
165  skip_bits(gb, 1); // zero bit
166  cc_count = get_bits(gb, 5);
167  skip_bits(gb, 8); // reserved
168  size -= 2;
169 
170  if (cc_count && size >= cc_count * 3) {
171  int old_size = h->buf_ref ? h->buf_ref->size : 0;
172  const uint64_t new_size = (old_size + cc_count
173  * UINT64_C(3));
174  int i, ret;
175 
176  if (new_size > INT_MAX)
177  return AVERROR(EINVAL);
178 
179  /* Allow merging of the cc data from two fields. */
180  ret = av_buffer_realloc(&h->buf_ref, new_size);
181  if (ret < 0)
182  return ret;
183 
184  /* Use of av_buffer_realloc assumes buffer is writeable */
185  for (i = 0; i < cc_count; i++) {
186  h->buf_ref->data[old_size++] = get_bits(gb, 8);
187  h->buf_ref->data[old_size++] = get_bits(gb, 8);
188  h->buf_ref->data[old_size++] = get_bits(gb, 8);
189  }
190 
191  skip_bits(gb, 8); // marker_bits
192  }
193  }
194  } else {
195  int i;
196  for (i = 0; i < size - 1; i++)
197  skip_bits(gb, 8);
198  }
199 
200  return 0;
201 }
202 
204  void *logctx, int size)
205 {
206  uint32_t country_code;
207  uint32_t user_identifier;
208 
209  if (size < 7)
210  return AVERROR_INVALIDDATA;
211  size -= 7;
212 
213  country_code = get_bits(gb, 8); // itu_t_t35_country_code
214  if (country_code == 0xFF) {
215  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
216  size--;
217  }
218 
219  /* itu_t_t35_payload_byte follows */
220  skip_bits(gb, 8); // terminal provider code
221  skip_bits(gb, 8); // terminal provider oriented code
222  user_identifier = get_bits_long(gb, 32);
223 
224  switch (user_identifier) {
225  case MKBETAG('D', 'T', 'G', '1'): // afd_data
226  return decode_registered_user_data_afd(&h->afd, gb, size);
227  case MKBETAG('G', 'A', '9', '4'): // closed captions
229  logctx, size);
230  default:
231  skip_bits(gb, size * 8);
232  break;
233  }
234 
235  return 0;
236 }
237 
239  void *logctx, int size)
240 {
242  int e, build, i;
243 
244  if (size < 16 || size >= INT_MAX - 16)
245  return AVERROR_INVALIDDATA;
246 
247  user_data = av_malloc(16 + size + 1);
248  if (!user_data)
249  return AVERROR(ENOMEM);
250 
251  for (i = 0; i < size + 16; i++)
252  user_data[i] = get_bits(gb, 8);
253 
254  user_data[i] = 0;
255  e = sscanf(user_data + 16, "x264 - core %d", &build);
256  if (e == 1 && build > 0)
257  h->x264_build = build;
258  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
259  h->x264_build = 67;
260 
261  av_free(user_data);
262  return 0;
263 }
264 
266 {
267  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
268 
269  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
270  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
271  return AVERROR_INVALIDDATA;
272  }
273 
274  h->recovery_frame_cnt = recovery_frame_cnt;
275  /* 1b exact_match_flag,
276  * 1b broken_link_flag,
277  * 2b changing_slice_group_idc */
278  skip_bits(gb, 4);
279 
280  return 0;
281 }
282 
284  const H264ParamSets *ps, void *logctx)
285 {
286  unsigned int sps_id;
287  int sched_sel_idx;
288  const SPS *sps;
289 
290  sps_id = get_ue_golomb_31(gb);
291  if (sps_id > 31 || !ps->sps_list[sps_id]) {
292  av_log(logctx, AV_LOG_ERROR,
293  "non-existing SPS %d referenced in buffering period\n", sps_id);
294  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
295  }
296  sps = (const SPS*)ps->sps_list[sps_id]->data;
297 
298  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
300  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
301  h->initial_cpb_removal_delay[sched_sel_idx] =
303  // initial_cpb_removal_delay_offset
305  }
306  }
308  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
309  h->initial_cpb_removal_delay[sched_sel_idx] =
311  // initial_cpb_removal_delay_offset
313  }
314  }
315 
316  h->present = 1;
317  return 0;
318 }
319 
321  GetBitContext *gb)
322 {
326 
327  if (h->present) {
328  h->arrangement_type = get_bits(gb, 7);
331 
332  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
333  skip_bits(gb, 3);
335  // frame0_self_contained_flag, frame1_self_contained_flag
336  skip_bits(gb, 2);
337 
338  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
339  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
340  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
342  }
343  skip_bits1(gb); // frame_packing_arrangement_extension_flag
344 
345  return 0;
346 }
347 
349  GetBitContext *gb)
350 {
351  h->present = !get_bits1(gb);
352 
353  if (h->present) {
354  h->hflip = get_bits1(gb); // hor_flip
355  h->vflip = get_bits1(gb); // ver_flip
356 
357  h->anticlockwise_rotation = get_bits(gb, 16);
358  get_ue_golomb_long(gb); // display_orientation_repetition_period
359  skip_bits1(gb); // display_orientation_extension_flag
360  }
361 
362  return 0;
363 }
364 
366 {
367  h->green_metadata_type = get_bits(gb, 8);
368 
369  if (h->green_metadata_type == 0) {
370  h->period_type = get_bits(gb, 8);
371 
372  if (h->period_type == 2)
373  h->num_seconds = get_bits(gb, 16);
374  else if (h->period_type == 3)
375  h->num_pictures = get_bits(gb, 16);
376 
381 
382  } else if (h->green_metadata_type == 1) {
383  h->xsd_metric_type = get_bits(gb, 8);
384  h->xsd_metric_value = get_bits(gb, 16);
385  }
386 
387  return 0;
388 }
389 
391  GetBitContext *gb)
392 {
393  h->present = 1;
395  return 0;
396 }
397 
399  const H264ParamSets *ps, void *logctx)
400 {
401  int master_ret = 0;
402 
403  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
404  int type = 0;
405  unsigned size = 0;
406  unsigned next;
407  int ret = 0;
408 
409  do {
410  if (get_bits_left(gb) < 8)
411  return AVERROR_INVALIDDATA;
412  type += show_bits(gb, 8);
413  } while (get_bits(gb, 8) == 255);
414 
415  do {
416  if (get_bits_left(gb) < 8)
417  return AVERROR_INVALIDDATA;
418  size += show_bits(gb, 8);
419  } while (get_bits(gb, 8) == 255);
420 
421  if (size > get_bits_left(gb) / 8) {
422  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
423  type, 8*size, get_bits_left(gb));
424  return AVERROR_INVALIDDATA;
425  }
426  next = get_bits_count(gb) + 8 * size;
427 
428  switch (type) {
429  case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
430  ret = decode_picture_timing(&h->picture_timing, gb, ps, logctx);
431  break;
433  ret = decode_registered_user_data(h, gb, logctx, size);
434  break;
436  ret = decode_unregistered_user_data(&h->unregistered, gb, logctx, size);
437  break;
439  ret = decode_recovery_point(&h->recovery_point, gb, logctx);
440  break;
442  ret = decode_buffering_period(&h->buffering_period, gb, ps, logctx);
443  break;
446  break;
449  break;
451  ret = decode_green_metadata(&h->green_metadata, gb);
452  break;
455  break;
456  default:
457  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
458  }
459  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
460  return ret;
461  if (ret < 0)
462  master_ret = ret;
463 
464  skip_bits_long(gb, next - get_bits_count(gb));
465 
466  // FIXME check bits here
467  align_get_bits(gb);
468  }
469 
470  return master_ret;
471 }
472 
474 {
475  if (h->arrangement_cancel_flag == 0) {
476  switch (h->arrangement_type) {
478  if (h->content_interpretation_type == 2)
479  return "checkerboard_rl";
480  else
481  return "checkerboard_lr";
483  if (h->content_interpretation_type == 2)
484  return "col_interleaved_rl";
485  else
486  return "col_interleaved_lr";
488  if (h->content_interpretation_type == 2)
489  return "row_interleaved_rl";
490  else
491  return "row_interleaved_lr";
493  if (h->content_interpretation_type == 2)
494  return "right_left";
495  else
496  return "left_right";
498  if (h->content_interpretation_type == 2)
499  return "bottom_top";
500  else
501  return "top_bottom";
503  if (h->content_interpretation_type == 2)
504  return "block_rl";
505  else
506  return "block_lr";
508  default:
509  return "mono";
510  }
511  } else if (h->arrangement_cancel_flag == 1) {
512  return "mono";
513  } else {
514  return NULL;
515  }
516 }
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:113
#define MAX_SPS_COUNT
Definition: h264_ps.h:37
uint16_t num_pictures
Definition: h264_sei.h:142
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:381
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:139
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:293
Sequence parameter set.
Definition: h264_ps.h:44
H264SEIAlternativeTransfer alternative_transfer
Definition: h264_sei.h:166
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:41
H264SEIDisplayOrientation display_orientation
Definition: h264_sei.h:164
int current_frame_is_frame0_flag
Definition: h264_sei.h:129
H264SEIGreenMetaData green_metadata
Definition: h264_sei.h:165
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:473
AVBufferRef * buf_ref
Definition: h264_sei.h:98
uint8_t
uint8_t green_metadata_type
Definition: h264_sei.h:139
#define av_malloc(s)
unregistered user data
Definition: h264_sei.h:33
display orientation
Definition: h264_sei.h:36
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:238
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:101
H264SEIAFD afd
Definition: h264_sei.h:158
alternative transfer
Definition: h264_sei.h:39
#define av_log(a,...)
uint16_t num_seconds
Definition: h264_sei.h:141
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:145
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:814
H.264 parameter set handling.
buffering period (H.264, D.1.1)
Definition: h264_sei.h:28
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AVERROR(e)
Definition: error.h:43
H264_SEI_FpaType arrangement_type
Definition: h264_sei.h:125
int present
Buffering period SEI flag.
Definition: h264_sei.h:117
int time_offset_length
Definition: h264_ps.h:93
AVS_Value void * user_data
Definition: avisynth_c.h:699
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int arrangement_repetition_period
Definition: h264_sei.h:126
H264SEIUnregistered unregistered
Definition: h264_sei.h:160
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
Definition: buffer.c:169
static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
Definition: h264_sei.c:127
uint8_t active_format_description
Definition: h264_sei.h:94
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:348
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:143
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:72
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:95
int ct_type
Bit set of clock types for fields/frames in picture timing SEI message.
Definition: h264_sei.h:79
picture timing
Definition: h264_sei.h:29
int initial_cpb_removal_delay[32]
Initial timestamps for CPBs.
Definition: h264_sei.h:118
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:443
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:265
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:89
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:57
int quincunx_sampling_flag
Definition: h264_sei.h:128
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:103
int vcl_hrd_parameters_present_flag
Definition: h264_ps.h:91
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:118
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264_ps.h:97
uint8_t * data
The data buffer.
Definition: buffer.h:89
GreenMPEG information.
Definition: h264_sei.h:37
H264SEIA53Caption a53_caption
Definition: h264_sei.h:159
GLint GLenum type
Definition: opengl_enc.c:105
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:487
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:523
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:460
static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, GetBitContext *gb)
Definition: h264_sei.c:390
int content_interpretation_type
Definition: h264_sei.h:127
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:162
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
recovery point (frame # to decoder sync)
Definition: h264_sei.h:34
#define AVERROR_PS_NOT_FOUND
Definition: h264_sei.c:35
uint8_t percent_intra_coded_macroblocks
Definition: h264_sei.h:144
const SPS * sps
Definition: h264_ps.h:146
registered user data as specified by Rec. ITU-T T.35
Definition: h264_sei.h:32
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:157
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:161
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:531
static const uint8_t sei_num_clock_ts_table[9]
Definition: h264_sei.c:37
int size
Size of data in bytes.
Definition: buffer.h:93
int pic_struct_present_flag
Definition: h264_ps.h:92
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:320
uint8_t xsd_metric_type
Definition: h264_sei.h:147
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
uint16_t xsd_metric_value
Definition: h264_sei.h:148
common internal api header.
if(ret< 0)
Definition: vf_mcdeint.c:279
int dpb_output_delay
dpb_output_delay in picture timing SEI message, see H.264 C.2.2
Definition: h264_sei.h:84
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:90
#define flag(name)
Definition: cbs_av1.c:588
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264SEIFramePacking frame_packing
Definition: h264_sei.h:163
#define MKBETAG(a, b, c, d)
Definition: common.h:367
int present
Definition: h264_sei.h:93
#define av_free(p)
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:658
int cpb_cnt
See H.264 E.1.2.
Definition: h264_ps.h:94
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:398
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:203
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:96
static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
Definition: h264_sei.c:365
exp golomb vlc stuff
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:148
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:124
frame packing arrangement
Definition: h264_sei.h:35
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:146
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:283