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 "atsc_a53.h"
29 #include "avcodec.h"
30 #include "get_bits.h"
31 #include "golomb.h"
32 #include "h264_ps.h"
33 #include "h264_sei.h"
34 #include "internal.h"
35 
36 #define AVERROR_PS_NOT_FOUND FFERRTAG(0xF8,'?','P','S')
37 
38 static const uint8_t sei_num_clock_ts_table[9] = {
39  1, 1, 1, 2, 2, 3, 3, 2, 3
40 };
41 
43 {
45 
48 
49  h->picture_timing.present = 0;
51  h->frame_packing.present = 0;
53  h->afd.present = 0;
54 
56  for (int i = 0; i < h->unregistered.nb_buf_ref; i++)
58  h->unregistered.nb_buf_ref = 0;
60 }
61 
63  void *logctx)
64 {
65  GetBitContext gb;
66 
68 
73  }
74  if (sps->pic_struct_present_flag) {
75  unsigned int i, num_clock_ts;
76 
77  h->pic_struct = get_bits(&gb, 4);
78  h->ct_type = 0;
79 
81  return AVERROR_INVALIDDATA;
82 
83  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
84  h->timecode_cnt = 0;
85  for (i = 0; i < num_clock_ts; i++) {
86  if (get_bits(&gb, 1)) { /* clock_timestamp_flag */
88  unsigned int full_timestamp_flag;
89  unsigned int counting_type, cnt_dropped_flag;
90  h->ct_type |= 1 << get_bits(&gb, 2);
91  skip_bits(&gb, 1); /* nuit_field_based_flag */
92  counting_type = get_bits(&gb, 5); /* counting_type */
93  full_timestamp_flag = get_bits(&gb, 1);
94  skip_bits(&gb, 1); /* discontinuity_flag */
95  cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */
96  if (cnt_dropped_flag && counting_type > 1 && counting_type < 7)
97  tc->dropframe = 1;
98  tc->frame = get_bits(&gb, 8); /* n_frames */
99  if (full_timestamp_flag) {
100  tc->full = 1;
101  tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */
102  tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */
103  tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */
104  } else {
105  tc->seconds = tc->minutes = tc->hours = tc->full = 0;
106  if (get_bits(&gb, 1)) { /* seconds_flag */
107  tc->seconds = get_bits(&gb, 6);
108  if (get_bits(&gb, 1)) { /* minutes_flag */
109  tc->minutes = get_bits(&gb, 6);
110  if (get_bits(&gb, 1)) /* hours_flag */
111  tc->hours = get_bits(&gb, 5);
112  }
113  }
114  }
115 
116  if (sps->time_offset_length > 0)
117  skip_bits(&gb,
118  sps->time_offset_length); /* time_offset */
119  }
120  }
121 
122  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
123  h->ct_type, h->pic_struct);
124  }
125 
126  return 0;
127 }
128 
130  void *logctx)
131 {
132  int index = get_bits_count(gb);
133  int size_bits = get_bits_left(gb);
134  int size = (size_bits + 7) / 8;
135 
136  if (index & 7) {
137  av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n");
138  return AVERROR_INVALIDDATA;
139  }
140  if (size > sizeof(h->payload)) {
141  av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n");
142  return AVERROR_INVALIDDATA;
143  }
144  memcpy(h->payload, gb->buffer + index / 8, size);
145 
146  h->payload_size_bits = size_bits;
147 
148  h->present = 1;
149  return 0;
150 }
151 
153 {
154  int flag;
155 
156  if (size-- < 1)
157  return AVERROR_INVALIDDATA;
158  skip_bits(gb, 1); // 0
159  flag = get_bits(gb, 1); // active_format_flag
160  skip_bits(gb, 6); // reserved
161 
162  if (flag) {
163  if (size-- < 1)
164  return AVERROR_INVALIDDATA;
165  skip_bits(gb, 4); // reserved
167  h->present = 1;
168  }
169 
170  return 0;
171 }
172 
174  GetBitContext *gb, void *logctx,
175  int size)
176 {
177  if (size < 3)
178  return AVERROR(EINVAL);
179 
180  return ff_parse_a53_cc(&h->buf_ref, gb->buffer + get_bits_count(gb) / 8, size);
181 }
182 
184  void *logctx, int size)
185 {
186  uint32_t country_code;
187  uint32_t user_identifier;
188 
189  if (size < 7)
190  return AVERROR_INVALIDDATA;
191  size -= 7;
192 
193  country_code = get_bits(gb, 8); // itu_t_t35_country_code
194  if (country_code == 0xFF) {
195  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
196  size--;
197  }
198 
199  /* itu_t_t35_payload_byte follows */
200  skip_bits(gb, 8); // terminal provider code
201  skip_bits(gb, 8); // terminal provider oriented code
202  user_identifier = get_bits_long(gb, 32);
203 
204  switch (user_identifier) {
205  case MKBETAG('D', 'T', 'G', '1'): // afd_data
206  return decode_registered_user_data_afd(&h->afd, gb, size);
207  case MKBETAG('G', 'A', '9', '4'): // closed captions
209  logctx, size);
210  default:
211  skip_bits(gb, size * 8);
212  break;
213  }
214 
215  return 0;
216 }
217 
219  void *logctx, int size)
220 {
222  int e, build, i;
223  AVBufferRef *buf_ref, **tmp;
224 
225  if (size < 16 || size >= INT_MAX - 1)
226  return AVERROR_INVALIDDATA;
227 
228  tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref));
229  if (!tmp)
230  return AVERROR(ENOMEM);
231  h->buf_ref = tmp;
232 
233  buf_ref = av_buffer_alloc(size + 1);
234  if (!buf_ref)
235  return AVERROR(ENOMEM);
236  user_data = buf_ref->data;
237 
238  for (i = 0; i < size; i++)
239  user_data[i] = get_bits(gb, 8);
240 
241  user_data[i] = 0;
242  buf_ref->size = size;
243  h->buf_ref[h->nb_buf_ref++] = buf_ref;
244 
245  e = sscanf(user_data + 16, "x264 - core %d", &build);
246  if (e == 1 && build > 0)
247  h->x264_build = build;
248  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
249  h->x264_build = 67;
250 
251  return 0;
252 }
253 
255 {
256  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
257 
258  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
259  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
260  return AVERROR_INVALIDDATA;
261  }
262 
263  h->recovery_frame_cnt = recovery_frame_cnt;
264  /* 1b exact_match_flag,
265  * 1b broken_link_flag,
266  * 2b changing_slice_group_idc */
267  skip_bits(gb, 4);
268 
269  return 0;
270 }
271 
273  const H264ParamSets *ps, void *logctx)
274 {
275  unsigned int sps_id;
276  int sched_sel_idx;
277  const SPS *sps;
278 
279  sps_id = get_ue_golomb_31(gb);
280  if (sps_id > 31 || !ps->sps_list[sps_id]) {
281  av_log(logctx, AV_LOG_ERROR,
282  "non-existing SPS %d referenced in buffering period\n", sps_id);
283  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
284  }
285  sps = (const SPS*)ps->sps_list[sps_id]->data;
286 
287  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
289  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
290  h->initial_cpb_removal_delay[sched_sel_idx] =
292  // initial_cpb_removal_delay_offset
294  }
295  }
297  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
298  h->initial_cpb_removal_delay[sched_sel_idx] =
300  // initial_cpb_removal_delay_offset
302  }
303  }
304 
305  h->present = 1;
306  return 0;
307 }
308 
310  GetBitContext *gb)
311 {
315 
316  if (h->present) {
317  h->arrangement_type = get_bits(gb, 7);
320 
321  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
322  skip_bits(gb, 3);
324  // frame0_self_contained_flag, frame1_self_contained_flag
325  skip_bits(gb, 2);
326 
327  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
328  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
329  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
331  }
332  skip_bits1(gb); // frame_packing_arrangement_extension_flag
333 
334  return 0;
335 }
336 
338  GetBitContext *gb)
339 {
340  h->present = !get_bits1(gb);
341 
342  if (h->present) {
343  h->hflip = get_bits1(gb); // hor_flip
344  h->vflip = get_bits1(gb); // ver_flip
345 
346  h->anticlockwise_rotation = get_bits(gb, 16);
347  get_ue_golomb_long(gb); // display_orientation_repetition_period
348  skip_bits1(gb); // display_orientation_extension_flag
349  }
350 
351  return 0;
352 }
353 
355 {
356  h->green_metadata_type = get_bits(gb, 8);
357 
358  if (h->green_metadata_type == 0) {
359  h->period_type = get_bits(gb, 8);
360 
361  if (h->period_type == 2)
362  h->num_seconds = get_bits(gb, 16);
363  else if (h->period_type == 3)
364  h->num_pictures = get_bits(gb, 16);
365 
370 
371  } else if (h->green_metadata_type == 1) {
372  h->xsd_metric_type = get_bits(gb, 8);
373  h->xsd_metric_value = get_bits(gb, 16);
374  }
375 
376  return 0;
377 }
378 
380  GetBitContext *gb)
381 {
382  h->present = 1;
384  return 0;
385 }
386 
388  const H264ParamSets *ps, void *logctx)
389 {
390  int master_ret = 0;
391 
392  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
393  GetBitContext gb_payload;
394  int type = 0;
395  unsigned size = 0;
396  int ret = 0;
397 
398  do {
399  if (get_bits_left(gb) < 8)
400  return AVERROR_INVALIDDATA;
401  type += show_bits(gb, 8);
402  } while (get_bits(gb, 8) == 255);
403 
404  do {
405  if (get_bits_left(gb) < 8)
406  return AVERROR_INVALIDDATA;
407  size += show_bits(gb, 8);
408  } while (get_bits(gb, 8) == 255);
409 
410  if (size > get_bits_left(gb) / 8) {
411  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
412  type, 8*size, get_bits_left(gb));
413  return AVERROR_INVALIDDATA;
414  }
415 
416  ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size);
417  if (ret < 0)
418  return ret;
419 
420  switch (type) {
421  case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
422  ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx);
423  break;
425  ret = decode_registered_user_data(h, &gb_payload, logctx, size);
426  break;
428  ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size);
429  break;
431  ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
432  break;
434  ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx);
435  break;
437  ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload);
438  break;
440  ret = decode_display_orientation(&h->display_orientation, &gb_payload);
441  break;
443  ret = decode_green_metadata(&h->green_metadata, &gb_payload);
444  break;
446  ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload);
447  break;
448  default:
449  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
450  }
451  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
452  return ret;
453  if (ret < 0)
454  master_ret = ret;
455 
456  if (get_bits_left(&gb_payload) < 0) {
457  av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n",
458  type, -get_bits_left(&gb_payload));
459  }
460 
461  skip_bits_long(gb, 8 * size);
462  }
463 
464  return master_ret;
465 }
466 
468 {
469  if (h->arrangement_cancel_flag == 0) {
470  switch (h->arrangement_type) {
472  if (h->content_interpretation_type == 2)
473  return "checkerboard_rl";
474  else
475  return "checkerboard_lr";
477  if (h->content_interpretation_type == 2)
478  return "col_interleaved_rl";
479  else
480  return "col_interleaved_lr";
482  if (h->content_interpretation_type == 2)
483  return "row_interleaved_rl";
484  else
485  return "row_interleaved_lr";
487  if (h->content_interpretation_type == 2)
488  return "right_left";
489  else
490  return "left_right";
492  if (h->content_interpretation_type == 2)
493  return "bottom_top";
494  else
495  return "top_bottom";
497  if (h->content_interpretation_type == 2)
498  return "block_rl";
499  else
500  return "block_lr";
502  default:
503  return "mono";
504  }
505  } else if (h->arrangement_cancel_flag == 1) {
506  return "mono";
507  } else {
508  return NULL;
509  }
510 }
#define NULL
Definition: coverity.c:32
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:129
#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:42
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:467
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:62
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
int ff_parse_a53_cc(AVBufferRef **pbuf, const uint8_t *data, int size)
Parse a data array for ATSC A53 Part 4 Closed Captions and store them in an AVBufferRef.
Definition: atsc_a53.c:68
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:218
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
static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
Definition: h264_sei.c:152
uint8_t active_format_description
Definition: h264_sei.h:120
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:337
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:254
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:379
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:36
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:38
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:309
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:387
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:183
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:354
exp golomb vlc stuff
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:173
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:272
static uint8_t tmp[11]
Definition: aes_ctr.c:26