FFmpeg  4.3.7
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  void *logctx)
59 {
60  GetBitContext gb;
61 
63 
68  }
69  if (sps->pic_struct_present_flag) {
70  unsigned int i, num_clock_ts;
71 
72  h->pic_struct = get_bits(&gb, 4);
73  h->ct_type = 0;
74 
76  return AVERROR_INVALIDDATA;
77 
78  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
79  h->timecode_cnt = 0;
80  for (i = 0; i < num_clock_ts; i++) {
81  if (get_bits(&gb, 1)) { /* clock_timestamp_flag */
83  unsigned int full_timestamp_flag;
84  unsigned int counting_type, cnt_dropped_flag;
85  h->ct_type |= 1 << get_bits(&gb, 2);
86  skip_bits(&gb, 1); /* nuit_field_based_flag */
87  counting_type = get_bits(&gb, 5); /* counting_type */
88  full_timestamp_flag = get_bits(&gb, 1);
89  skip_bits(&gb, 1); /* discontinuity_flag */
90  cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */
91  if (cnt_dropped_flag && counting_type > 1 && counting_type < 7)
92  tc->dropframe = 1;
93  tc->frame = get_bits(&gb, 8); /* n_frames */
94  if (full_timestamp_flag) {
95  tc->full = 1;
96  tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */
97  tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */
98  tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */
99  } else {
100  tc->seconds = tc->minutes = tc->hours = tc->full = 0;
101  if (get_bits(&gb, 1)) { /* seconds_flag */
102  tc->seconds = get_bits(&gb, 6);
103  if (get_bits(&gb, 1)) { /* minutes_flag */
104  tc->minutes = get_bits(&gb, 6);
105  if (get_bits(&gb, 1)) /* hours_flag */
106  tc->hours = get_bits(&gb, 5);
107  }
108  }
109  }
110 
111  if (sps->time_offset_length > 0)
112  skip_bits(&gb,
113  sps->time_offset_length); /* time_offset */
114  }
115  }
116 
117  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
118  h->ct_type, h->pic_struct);
119  }
120 
121  return 0;
122 }
123 
125  void *logctx)
126 {
127  int index = get_bits_count(gb);
128  int size_bits = get_bits_left(gb);
129  int size = (size_bits + 7) / 8;
130 
131  if (index & 7) {
132  av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n");
133  return AVERROR_INVALIDDATA;
134  }
135  if (size > sizeof(h->payload)) {
136  av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n");
137  return AVERROR_INVALIDDATA;
138  }
139  memcpy(h->payload, gb->buffer + index / 8, size);
140 
141  h->payload_size_bits = size_bits;
142 
143  h->present = 1;
144  return 0;
145 }
146 
148 {
149  int flag;
150 
151  if (size-- < 1)
152  return AVERROR_INVALIDDATA;
153  skip_bits(gb, 1); // 0
154  flag = get_bits(gb, 1); // active_format_flag
155  skip_bits(gb, 6); // reserved
156 
157  if (flag) {
158  if (size-- < 1)
159  return AVERROR_INVALIDDATA;
160  skip_bits(gb, 4); // reserved
162  h->present = 1;
163  }
164 
165  return 0;
166 }
167 
169  GetBitContext *gb, void *logctx,
170  int size)
171 {
172  int flag;
173  int user_data_type_code;
174  int cc_count;
175 
176  if (size < 3)
177  return AVERROR(EINVAL);
178 
179  user_data_type_code = get_bits(gb, 8);
180  if (user_data_type_code == 0x3) {
181  skip_bits(gb, 1); // reserved
182 
183  flag = get_bits(gb, 1); // process_cc_data_flag
184  if (flag) {
185  skip_bits(gb, 1); // zero bit
186  cc_count = get_bits(gb, 5);
187  skip_bits(gb, 8); // reserved
188  size -= 2;
189 
190  if (cc_count && size >= cc_count * 3) {
191  int old_size = h->buf_ref ? h->buf_ref->size : 0;
192  const uint64_t new_size = (old_size + cc_count
193  * UINT64_C(3));
194  int i, ret;
195 
196  if (new_size > INT_MAX)
197  return AVERROR(EINVAL);
198 
199  /* Allow merging of the cc data from two fields. */
200  ret = av_buffer_realloc(&h->buf_ref, new_size);
201  if (ret < 0)
202  return ret;
203 
204  /* Use of av_buffer_realloc assumes buffer is writeable */
205  for (i = 0; i < cc_count; i++) {
206  h->buf_ref->data[old_size++] = get_bits(gb, 8);
207  h->buf_ref->data[old_size++] = get_bits(gb, 8);
208  h->buf_ref->data[old_size++] = get_bits(gb, 8);
209  }
210 
211  skip_bits(gb, 8); // marker_bits
212  }
213  }
214  } else {
215  int i;
216  for (i = 0; i < size - 1; i++)
217  skip_bits(gb, 8);
218  }
219 
220  return 0;
221 }
222 
224  void *logctx, int size)
225 {
226  uint32_t country_code;
227  uint32_t user_identifier;
228 
229  if (size < 7)
230  return AVERROR_INVALIDDATA;
231  size -= 7;
232 
233  country_code = get_bits(gb, 8); // itu_t_t35_country_code
234  if (country_code == 0xFF) {
235  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
236  size--;
237  }
238 
239  /* itu_t_t35_payload_byte follows */
240  skip_bits(gb, 8); // terminal provider code
241  skip_bits(gb, 8); // terminal provider oriented code
242  user_identifier = get_bits_long(gb, 32);
243 
244  switch (user_identifier) {
245  case MKBETAG('D', 'T', 'G', '1'): // afd_data
246  return decode_registered_user_data_afd(&h->afd, gb, size);
247  case MKBETAG('G', 'A', '9', '4'): // closed captions
249  logctx, size);
250  default:
251  skip_bits(gb, size * 8);
252  break;
253  }
254 
255  return 0;
256 }
257 
259  void *logctx, int size)
260 {
262  int e, build, i;
263 
264  if (size < 16 || size >= INT_MAX - 1)
265  return AVERROR_INVALIDDATA;
266 
267  user_data = av_malloc(size + 1);
268  if (!user_data)
269  return AVERROR(ENOMEM);
270 
271  for (i = 0; i < size; i++)
272  user_data[i] = get_bits(gb, 8);
273 
274  user_data[i] = 0;
275  e = sscanf(user_data + 16, "x264 - core %d", &build);
276  if (e == 1 && build > 0)
277  h->x264_build = build;
278  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
279  h->x264_build = 67;
280 
281  av_free(user_data);
282  return 0;
283 }
284 
286 {
287  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
288 
289  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
290  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
291  return AVERROR_INVALIDDATA;
292  }
293 
294  h->recovery_frame_cnt = recovery_frame_cnt;
295  /* 1b exact_match_flag,
296  * 1b broken_link_flag,
297  * 2b changing_slice_group_idc */
298  skip_bits(gb, 4);
299 
300  return 0;
301 }
302 
304  const H264ParamSets *ps, void *logctx)
305 {
306  unsigned int sps_id;
307  int sched_sel_idx;
308  const SPS *sps;
309 
310  sps_id = get_ue_golomb_31(gb);
311  if (sps_id > 31 || !ps->sps_list[sps_id]) {
312  av_log(logctx, AV_LOG_ERROR,
313  "non-existing SPS %d referenced in buffering period\n", sps_id);
314  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
315  }
316  sps = (const SPS*)ps->sps_list[sps_id]->data;
317 
318  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
320  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
321  h->initial_cpb_removal_delay[sched_sel_idx] =
323  // initial_cpb_removal_delay_offset
325  }
326  }
328  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
329  h->initial_cpb_removal_delay[sched_sel_idx] =
331  // initial_cpb_removal_delay_offset
333  }
334  }
335 
336  h->present = 1;
337  return 0;
338 }
339 
341  GetBitContext *gb)
342 {
346 
347  if (h->present) {
348  h->arrangement_type = get_bits(gb, 7);
351 
352  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
353  skip_bits(gb, 3);
355  // frame0_self_contained_flag, frame1_self_contained_flag
356  skip_bits(gb, 2);
357 
358  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
359  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
360  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
362  }
363  skip_bits1(gb); // frame_packing_arrangement_extension_flag
364 
365  return 0;
366 }
367 
369  GetBitContext *gb)
370 {
371  h->present = !get_bits1(gb);
372 
373  if (h->present) {
374  h->hflip = get_bits1(gb); // hor_flip
375  h->vflip = get_bits1(gb); // ver_flip
376 
377  h->anticlockwise_rotation = get_bits(gb, 16);
378  get_ue_golomb_long(gb); // display_orientation_repetition_period
379  skip_bits1(gb); // display_orientation_extension_flag
380  }
381 
382  return 0;
383 }
384 
386 {
387  h->green_metadata_type = get_bits(gb, 8);
388 
389  if (h->green_metadata_type == 0) {
390  h->period_type = get_bits(gb, 8);
391 
392  if (h->period_type == 2)
393  h->num_seconds = get_bits(gb, 16);
394  else if (h->period_type == 3)
395  h->num_pictures = get_bits(gb, 16);
396 
401 
402  } else if (h->green_metadata_type == 1) {
403  h->xsd_metric_type = get_bits(gb, 8);
404  h->xsd_metric_value = get_bits(gb, 16);
405  }
406 
407  return 0;
408 }
409 
411  GetBitContext *gb)
412 {
413  h->present = 1;
415  return 0;
416 }
417 
419  const H264ParamSets *ps, void *logctx)
420 {
421  int master_ret = 0;
422 
423  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
424  GetBitContext gb_payload;
425  int type = 0;
426  unsigned size = 0;
427  int ret = 0;
428 
429  do {
430  if (get_bits_left(gb) < 8)
431  return AVERROR_INVALIDDATA;
432  type += show_bits(gb, 8);
433  } while (get_bits(gb, 8) == 255);
434 
435  do {
436  if (get_bits_left(gb) < 8)
437  return AVERROR_INVALIDDATA;
438  size += show_bits(gb, 8);
439  } while (get_bits(gb, 8) == 255);
440 
441  if (size > get_bits_left(gb) / 8) {
442  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
443  type, 8*size, get_bits_left(gb));
444  return AVERROR_INVALIDDATA;
445  }
446 
447  ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size);
448  if (ret < 0)
449  return ret;
450 
451  switch (type) {
452  case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
453  ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx);
454  break;
456  ret = decode_registered_user_data(h, &gb_payload, logctx, size);
457  break;
459  ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size);
460  break;
462  ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
463  break;
465  ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx);
466  break;
468  ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload);
469  break;
471  ret = decode_display_orientation(&h->display_orientation, &gb_payload);
472  break;
474  ret = decode_green_metadata(&h->green_metadata, &gb_payload);
475  break;
477  ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload);
478  break;
479  default:
480  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
481  }
482  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
483  return ret;
484  if (ret < 0)
485  master_ret = ret;
486 
487  if (get_bits_left(&gb_payload) < 0) {
488  av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n",
489  type, -get_bits_left(&gb_payload));
490  }
491 
492  skip_bits_long(gb, 8 * size);
493  }
494 
495  return master_ret;
496 }
497 
499 {
500  if (h->arrangement_cancel_flag == 0) {
501  switch (h->arrangement_type) {
503  if (h->content_interpretation_type == 2)
504  return "checkerboard_rl";
505  else
506  return "checkerboard_lr";
508  if (h->content_interpretation_type == 2)
509  return "col_interleaved_rl";
510  else
511  return "col_interleaved_lr";
513  if (h->content_interpretation_type == 2)
514  return "row_interleaved_rl";
515  else
516  return "row_interleaved_lr";
518  if (h->content_interpretation_type == 2)
519  return "right_left";
520  else
521  return "left_right";
523  if (h->content_interpretation_type == 2)
524  return "bottom_top";
525  else
526  return "top_bottom";
528  if (h->content_interpretation_type == 2)
529  return "block_rl";
530  else
531  return "block_lr";
533  default:
534  return "mono";
535  }
536  } else if (h->arrangement_cancel_flag == 1) {
537  return "mono";
538  } else {
539  return NULL;
540  }
541 }
#define NULL
Definition: coverity.c:32
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:124
#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 size
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:139
uint16_t num_pictures
Definition: h264_sei.h:168
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:144
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
Sequence parameter set.
Definition: h264_ps.h:44
H264SEIAlternativeTransfer alternative_transfer
Definition: h264_sei.h:192
const uint8_t * buffer
Definition: get_bits.h:62
#define tc
Definition: regdef.h:69
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:190
int current_frame_is_frame0_flag
Definition: h264_sei.h:155
H264SEIGreenMetaData green_metadata
Definition: h264_sei.h:191
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:498
AVBufferRef * buf_ref
Definition: h264_sei.h:124
int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, void *logctx)
Parse the contents of a picture timing message given an active SPS.
Definition: h264_sei.c:57
uint8_t
uint8_t green_metadata_type
Definition: h264_sei.h:165
#define av_malloc(s)
unregistered user data
Definition: h264_sei.h:34
display orientation
Definition: h264_sei.h:37
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:258
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
bitstream reader API header.
H264SEIAFD afd
Definition: h264_sei.h:184
alternative transfer
Definition: h264_sei.h:40
#define av_log(a,...)
uint16_t num_seconds
Definition: h264_sei.h:167
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:171
int timecode_cnt
Number of timecode in use.
Definition: h264_sei.h:115
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
H.264 parameter set handling.
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
buffering period (H.264, D.1.1)
Definition: h264_sei.h:29
#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:151
int present
Buffering period SEI flag.
Definition: h264_sei.h:143
int time_offset_length
Definition: h264_ps.h:95
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int arrangement_repetition_period
Definition: h264_sei.h:152
H264SEIUnregistered unregistered
Definition: h264_sei.h:186
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:147
uint8_t active_format_description
Definition: h264_sei.h:120
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:368
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:169
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:88
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:97
int ct_type
Bit set of clock types for fields/frames in picture timing SEI message.
Definition: h264_sei.h:95
picture timing
Definition: h264_sei.h:30
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
int initial_cpb_removal_delay[32]
Initial timestamps for CPBs.
Definition: h264_sei.h:144
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:285
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:105
int quincunx_sampling_flag
Definition: h264_sei.h:154
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:105
uint8_t payload[40]
Definition: h264_sei.h:84
int vcl_hrd_parameters_present_flag
Definition: h264_ps.h:93
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:120
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264_ps.h:99
uint8_t * data
The data buffer.
Definition: buffer.h:89
H264SEITimeCode timecode[3]
Maximum three timecodes in a pic_timing SEI.
Definition: h264_sei.h:110
GreenMPEG information.
Definition: h264_sei.h:38
H264SEIA53Caption a53_caption
Definition: h264_sei.h:185
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
int index
Definition: gxfenc.c:89
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, GetBitContext *gb)
Definition: h264_sei.c:410
cl_device_type type
int content_interpretation_type
Definition: h264_sei.h:153
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:188
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
recovery point (frame # to decoder sync)
Definition: h264_sei.h:35
#define AVERROR_PS_NOT_FOUND
Definition: h264_sei.c:35
uint8_t percent_intra_coded_macroblocks
Definition: h264_sei.h:170
registered user data as specified by Rec. ITU-T T.35
Definition: h264_sei.h:33
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:183
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:187
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
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:94
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:340
uint8_t xsd_metric_type
Definition: h264_sei.h:173
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
uint16_t xsd_metric_value
Definition: h264_sei.h:174
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:100
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:92
#define flag(name)
Definition: cbs_av1.c:557
H264SEIFramePacking frame_packing
Definition: h264_sei.h:189
#define MKBETAG(a, b, c, d)
Definition: common.h:407
int present
Definition: h264_sei.h:119
#define av_free(p)
int cpb_cnt
See H.264 E.1.2.
Definition: h264_ps.h:96
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:418
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:223
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:98
static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
Definition: h264_sei.c:385
exp golomb vlc stuff
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:168
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:150
frame packing arrangement
Definition: h264_sei.h:36
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:172
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:303