FFmpeg
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:126
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
GLint GLenum type
Definition: opengl_enc.c:104
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.
ptrdiff_t size
Definition: opengl_enc.c:100
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
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:170
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
if(ret)
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
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.
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:556
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
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
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