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  for (int i = 0; i < h->unregistered.nb_buf_ref; i++)
57  h->unregistered.nb_buf_ref = 0;
59 }
60 
62  void *logctx)
63 {
64  GetBitContext gb;
65 
67 
72  }
73  if (sps->pic_struct_present_flag) {
74  unsigned int i, num_clock_ts;
75 
76  h->pic_struct = get_bits(&gb, 4);
77  h->ct_type = 0;
78 
80  return AVERROR_INVALIDDATA;
81 
82  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
83  h->timecode_cnt = 0;
84  for (i = 0; i < num_clock_ts; i++) {
85  if (get_bits(&gb, 1)) { /* clock_timestamp_flag */
87  unsigned int full_timestamp_flag;
88  unsigned int counting_type, cnt_dropped_flag;
89  h->ct_type |= 1 << get_bits(&gb, 2);
90  skip_bits(&gb, 1); /* nuit_field_based_flag */
91  counting_type = get_bits(&gb, 5); /* counting_type */
92  full_timestamp_flag = get_bits(&gb, 1);
93  skip_bits(&gb, 1); /* discontinuity_flag */
94  cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */
95  if (cnt_dropped_flag && counting_type > 1 && counting_type < 7)
96  tc->dropframe = 1;
97  tc->frame = get_bits(&gb, 8); /* n_frames */
98  if (full_timestamp_flag) {
99  tc->full = 1;
100  tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */
101  tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */
102  tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */
103  } else {
104  tc->seconds = tc->minutes = tc->hours = tc->full = 0;
105  if (get_bits(&gb, 1)) { /* seconds_flag */
106  tc->seconds = get_bits(&gb, 6);
107  if (get_bits(&gb, 1)) { /* minutes_flag */
108  tc->minutes = get_bits(&gb, 6);
109  if (get_bits(&gb, 1)) /* hours_flag */
110  tc->hours = get_bits(&gb, 5);
111  }
112  }
113  }
114 
115  if (sps->time_offset_length > 0)
116  skip_bits(&gb,
117  sps->time_offset_length); /* time_offset */
118  }
119  }
120 
121  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
122  h->ct_type, h->pic_struct);
123  }
124 
125  return 0;
126 }
127 
129  void *logctx)
130 {
131  int index = get_bits_count(gb);
132  int size_bits = get_bits_left(gb);
133  int size = (size_bits + 7) / 8;
134 
135  if (index & 7) {
136  av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n");
137  return AVERROR_INVALIDDATA;
138  }
139  if (size > sizeof(h->payload)) {
140  av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n");
141  return AVERROR_INVALIDDATA;
142  }
143  memcpy(h->payload, gb->buffer + index / 8, size);
144 
145  h->payload_size_bits = size_bits;
146 
147  h->present = 1;
148  return 0;
149 }
150 
152 {
153  int flag;
154 
155  if (size-- < 1)
156  return AVERROR_INVALIDDATA;
157  skip_bits(gb, 1); // 0
158  flag = get_bits(gb, 1); // active_format_flag
159  skip_bits(gb, 6); // reserved
160 
161  if (flag) {
162  if (size-- < 1)
163  return AVERROR_INVALIDDATA;
164  skip_bits(gb, 4); // reserved
166  h->present = 1;
167  }
168 
169  return 0;
170 }
171 
173  GetBitContext *gb, void *logctx,
174  int size)
175 {
176  int flag;
177  int user_data_type_code;
178  int cc_count;
179 
180  if (size < 3)
181  return AVERROR(EINVAL);
182 
183  user_data_type_code = get_bits(gb, 8);
184  if (user_data_type_code == 0x3) {
185  skip_bits(gb, 1); // reserved
186 
187  flag = get_bits(gb, 1); // process_cc_data_flag
188  if (flag) {
189  skip_bits(gb, 1); // zero bit
190  cc_count = get_bits(gb, 5);
191  skip_bits(gb, 8); // reserved
192  size -= 2;
193 
194  if (cc_count && size >= cc_count * 3) {
195  int old_size = h->buf_ref ? h->buf_ref->size : 0;
196  const uint64_t new_size = (old_size + cc_count
197  * UINT64_C(3));
198  int i, ret;
199 
200  if (new_size > INT_MAX)
201  return AVERROR(EINVAL);
202 
203  /* Allow merging of the cc data from two fields. */
204  ret = av_buffer_realloc(&h->buf_ref, new_size);
205  if (ret < 0)
206  return ret;
207 
208  /* Use of av_buffer_realloc assumes buffer is writeable */
209  for (i = 0; i < cc_count; i++) {
210  h->buf_ref->data[old_size++] = get_bits(gb, 8);
211  h->buf_ref->data[old_size++] = get_bits(gb, 8);
212  h->buf_ref->data[old_size++] = get_bits(gb, 8);
213  }
214 
215  skip_bits(gb, 8); // marker_bits
216  }
217  }
218  } else {
219  int i;
220  for (i = 0; i < size - 1; i++)
221  skip_bits(gb, 8);
222  }
223 
224  return 0;
225 }
226 
228  void *logctx, int size)
229 {
230  uint32_t country_code;
231  uint32_t user_identifier;
232 
233  if (size < 7)
234  return AVERROR_INVALIDDATA;
235  size -= 7;
236 
237  country_code = get_bits(gb, 8); // itu_t_t35_country_code
238  if (country_code == 0xFF) {
239  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
240  size--;
241  }
242 
243  /* itu_t_t35_payload_byte follows */
244  skip_bits(gb, 8); // terminal provider code
245  skip_bits(gb, 8); // terminal provider oriented code
246  user_identifier = get_bits_long(gb, 32);
247 
248  switch (user_identifier) {
249  case MKBETAG('D', 'T', 'G', '1'): // afd_data
250  return decode_registered_user_data_afd(&h->afd, gb, size);
251  case MKBETAG('G', 'A', '9', '4'): // closed captions
253  logctx, size);
254  default:
255  skip_bits(gb, size * 8);
256  break;
257  }
258 
259  return 0;
260 }
261 
263  void *logctx, int size)
264 {
266  int e, build, i;
267  AVBufferRef *buf_ref, **tmp;
268 
269  if (size < 16 || size >= INT_MAX - 1)
270  return AVERROR_INVALIDDATA;
271 
272  tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref));
273  if (!tmp)
274  return AVERROR(ENOMEM);
275  h->buf_ref = tmp;
276 
277  buf_ref = av_buffer_alloc(size + 1);
278  if (!buf_ref)
279  return AVERROR(ENOMEM);
280  user_data = buf_ref->data;
281 
282  for (i = 0; i < size; i++)
283  user_data[i] = get_bits(gb, 8);
284 
285  user_data[i] = 0;
286  buf_ref->size = size;
287  h->buf_ref[h->nb_buf_ref++] = buf_ref;
288 
289  e = sscanf(user_data + 16, "x264 - core %d", &build);
290  if (e == 1 && build > 0)
291  h->x264_build = build;
292  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
293  h->x264_build = 67;
294 
295  return 0;
296 }
297 
299 {
300  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
301 
302  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
303  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
304  return AVERROR_INVALIDDATA;
305  }
306 
307  h->recovery_frame_cnt = recovery_frame_cnt;
308  /* 1b exact_match_flag,
309  * 1b broken_link_flag,
310  * 2b changing_slice_group_idc */
311  skip_bits(gb, 4);
312 
313  return 0;
314 }
315 
317  const H264ParamSets *ps, void *logctx)
318 {
319  unsigned int sps_id;
320  int sched_sel_idx;
321  const SPS *sps;
322 
323  sps_id = get_ue_golomb_31(gb);
324  if (sps_id > 31 || !ps->sps_list[sps_id]) {
325  av_log(logctx, AV_LOG_ERROR,
326  "non-existing SPS %d referenced in buffering period\n", sps_id);
327  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
328  }
329  sps = (const SPS*)ps->sps_list[sps_id]->data;
330 
331  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
333  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
334  h->initial_cpb_removal_delay[sched_sel_idx] =
336  // initial_cpb_removal_delay_offset
338  }
339  }
341  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
342  h->initial_cpb_removal_delay[sched_sel_idx] =
344  // initial_cpb_removal_delay_offset
346  }
347  }
348 
349  h->present = 1;
350  return 0;
351 }
352 
354  GetBitContext *gb)
355 {
359 
360  if (h->present) {
361  h->arrangement_type = get_bits(gb, 7);
364 
365  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
366  skip_bits(gb, 3);
368  // frame0_self_contained_flag, frame1_self_contained_flag
369  skip_bits(gb, 2);
370 
371  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
372  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
373  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
375  }
376  skip_bits1(gb); // frame_packing_arrangement_extension_flag
377 
378  return 0;
379 }
380 
382  GetBitContext *gb)
383 {
384  h->present = !get_bits1(gb);
385 
386  if (h->present) {
387  h->hflip = get_bits1(gb); // hor_flip
388  h->vflip = get_bits1(gb); // ver_flip
389 
390  h->anticlockwise_rotation = get_bits(gb, 16);
391  get_ue_golomb_long(gb); // display_orientation_repetition_period
392  skip_bits1(gb); // display_orientation_extension_flag
393  }
394 
395  return 0;
396 }
397 
399 {
400  h->green_metadata_type = get_bits(gb, 8);
401 
402  if (h->green_metadata_type == 0) {
403  h->period_type = get_bits(gb, 8);
404 
405  if (h->period_type == 2)
406  h->num_seconds = get_bits(gb, 16);
407  else if (h->period_type == 3)
408  h->num_pictures = get_bits(gb, 16);
409 
414 
415  } else if (h->green_metadata_type == 1) {
416  h->xsd_metric_type = get_bits(gb, 8);
417  h->xsd_metric_value = get_bits(gb, 16);
418  }
419 
420  return 0;
421 }
422 
424  GetBitContext *gb)
425 {
426  h->present = 1;
428  return 0;
429 }
430 
432  const H264ParamSets *ps, void *logctx)
433 {
434  int master_ret = 0;
435 
436  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
437  GetBitContext gb_payload;
438  int type = 0;
439  unsigned size = 0;
440  int ret = 0;
441 
442  do {
443  if (get_bits_left(gb) < 8)
444  return AVERROR_INVALIDDATA;
445  type += show_bits(gb, 8);
446  } while (get_bits(gb, 8) == 255);
447 
448  do {
449  if (get_bits_left(gb) < 8)
450  return AVERROR_INVALIDDATA;
451  size += show_bits(gb, 8);
452  } while (get_bits(gb, 8) == 255);
453 
454  if (size > get_bits_left(gb) / 8) {
455  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
456  type, 8*size, get_bits_left(gb));
457  return AVERROR_INVALIDDATA;
458  }
459 
460  ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size);
461  if (ret < 0)
462  return ret;
463 
464  switch (type) {
465  case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
466  ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx);
467  break;
469  ret = decode_registered_user_data(h, &gb_payload, logctx, size);
470  break;
472  ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size);
473  break;
475  ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
476  break;
478  ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx);
479  break;
481  ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload);
482  break;
484  ret = decode_display_orientation(&h->display_orientation, &gb_payload);
485  break;
487  ret = decode_green_metadata(&h->green_metadata, &gb_payload);
488  break;
490  ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload);
491  break;
492  default:
493  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
494  }
495  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
496  return ret;
497  if (ret < 0)
498  master_ret = ret;
499 
500  if (get_bits_left(&gb_payload) < 0) {
501  av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n",
502  type, -get_bits_left(&gb_payload));
503  }
504 
505  skip_bits_long(gb, 8 * size);
506  }
507 
508  return master_ret;
509 }
510 
512 {
513  if (h->arrangement_cancel_flag == 0) {
514  switch (h->arrangement_type) {
516  if (h->content_interpretation_type == 2)
517  return "checkerboard_rl";
518  else
519  return "checkerboard_lr";
521  if (h->content_interpretation_type == 2)
522  return "col_interleaved_rl";
523  else
524  return "col_interleaved_lr";
526  if (h->content_interpretation_type == 2)
527  return "row_interleaved_rl";
528  else
529  return "row_interleaved_lr";
531  if (h->content_interpretation_type == 2)
532  return "right_left";
533  else
534  return "left_right";
536  if (h->content_interpretation_type == 2)
537  return "bottom_top";
538  else
539  return "top_bottom";
541  if (h->content_interpretation_type == 2)
542  return "block_rl";
543  else
544  return "block_lr";
546  default:
547  return "mono";
548  }
549  } else if (h->arrangement_cancel_flag == 1) {
550  return "mono";
551  } else {
552  return NULL;
553  }
554 }
#define NULL
Definition: coverity.c:32
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:128
#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:141
uint16_t num_pictures
Definition: h264_sei.h:170
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:200
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:194
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:192
int current_frame_is_frame0_flag
Definition: h264_sei.h:157
H264SEIGreenMetaData green_metadata
Definition: h264_sei.h:193
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:511
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:61
uint8_t
uint8_t green_metadata_type
Definition: h264_sei.h:167
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:262
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:186
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
alternative transfer
Definition: h264_sei.h:40
#define av_log(a,...)
uint16_t num_seconds
Definition: h264_sei.h:169
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:173
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.
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:194
H264_SEI_FpaType arrangement_type
Definition: h264_sei.h:153
int present
Buffering period SEI flag.
Definition: h264_sei.h:145
int time_offset_length
Definition: h264_ps.h:95
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int arrangement_repetition_period
Definition: h264_sei.h:154
H264SEIUnregistered unregistered
Definition: h264_sei.h:188
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:151
uint8_t active_format_description
Definition: h264_sei.h:120
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:381
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:171
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:146
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:298
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:156
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:106
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:122
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
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:187
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:423
int content_interpretation_type
Definition: h264_sei.h:155
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:190
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:172
registered user data as specified by Rec. ITU-T T.35
Definition: h264_sei.h:33
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:185
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:189
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:353
uint8_t xsd_metric_type
Definition: h264_sei.h:175
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
uint16_t xsd_metric_value
Definition: h264_sei.h:176
A reference to a data buffer.
Definition: buffer.h:81
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:552
H264SEIFramePacking frame_packing
Definition: h264_sei.h:191
#define MKBETAG(a, b, c, d)
Definition: common.h:407
AVBufferRef ** buf_ref
Definition: h264_sei.h:129
int present
Definition: h264_sei.h:119
int cpb_cnt
See H.264 E.1.2.
Definition: h264_ps.h:96
#define av_freep(p)
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:431
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:227
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:398
exp golomb vlc stuff
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:172
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:152
int i
Definition: input.c:407
frame packing arrangement
Definition: h264_sei.h:36
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:174
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:316
static uint8_t tmp[11]
Definition: aes_ctr.c:26