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  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  h->timecode_cnt = 0;
88  for (i = 0; i < num_clock_ts; i++) {
89  if (get_bits(gb, 1)) { /* clock_timestamp_flag */
91  unsigned int full_timestamp_flag;
92  unsigned int counting_type, cnt_dropped_flag;
93  h->ct_type |= 1 << get_bits(gb, 2);
94  skip_bits(gb, 1); /* nuit_field_based_flag */
95  counting_type = get_bits(gb, 5); /* counting_type */
96  full_timestamp_flag = get_bits(gb, 1);
97  skip_bits(gb, 1); /* discontinuity_flag */
98  cnt_dropped_flag = get_bits(gb, 1); /* cnt_dropped_flag */
99  if (cnt_dropped_flag && counting_type > 1 && counting_type < 7)
100  tc->dropframe = 1;
101  tc->frame = get_bits(gb, 8); /* n_frames */
102  if (full_timestamp_flag) {
103  tc->full = 1;
104  tc->seconds = get_bits(gb, 6); /* seconds_value 0..59 */
105  tc->minutes = get_bits(gb, 6); /* minutes_value 0..59 */
106  tc->hours = get_bits(gb, 5); /* hours_value 0..23 */
107  } else {
108  tc->seconds = tc->minutes = tc->hours = tc->full = 0;
109  if (get_bits(gb, 1)) { /* seconds_flag */
110  tc->seconds = get_bits(gb, 6);
111  if (get_bits(gb, 1)) { /* minutes_flag */
112  tc->minutes = get_bits(gb, 6);
113  if (get_bits(gb, 1)) /* hours_flag */
114  tc->hours = get_bits(gb, 5);
115  }
116  }
117  }
118 
119  if (sps->time_offset_length > 0)
120  skip_bits(gb,
121  sps->time_offset_length); /* time_offset */
122  }
123  }
124 
125  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
126  h->ct_type, h->pic_struct);
127  }
128 
129  h->present = 1;
130  return 0;
131 }
132 
134 {
135  int flag;
136 
137  if (size-- < 1)
138  return AVERROR_INVALIDDATA;
139  skip_bits(gb, 1); // 0
140  flag = get_bits(gb, 1); // active_format_flag
141  skip_bits(gb, 6); // reserved
142 
143  if (flag) {
144  if (size-- < 1)
145  return AVERROR_INVALIDDATA;
146  skip_bits(gb, 4); // reserved
148  h->present = 1;
149  }
150 
151  return 0;
152 }
153 
155  GetBitContext *gb, void *logctx,
156  int size)
157 {
158  int flag;
159  int user_data_type_code;
160  int cc_count;
161 
162  if (size < 3)
163  return AVERROR(EINVAL);
164 
165  user_data_type_code = get_bits(gb, 8);
166  if (user_data_type_code == 0x3) {
167  skip_bits(gb, 1); // reserved
168 
169  flag = get_bits(gb, 1); // process_cc_data_flag
170  if (flag) {
171  skip_bits(gb, 1); // zero bit
172  cc_count = get_bits(gb, 5);
173  skip_bits(gb, 8); // reserved
174  size -= 2;
175 
176  if (cc_count && size >= cc_count * 3) {
177  int old_size = h->buf_ref ? h->buf_ref->size : 0;
178  const uint64_t new_size = (old_size + cc_count
179  * UINT64_C(3));
180  int i, ret;
181 
182  if (new_size > INT_MAX)
183  return AVERROR(EINVAL);
184 
185  /* Allow merging of the cc data from two fields. */
186  ret = av_buffer_realloc(&h->buf_ref, new_size);
187  if (ret < 0)
188  return ret;
189 
190  /* Use of av_buffer_realloc assumes buffer is writeable */
191  for (i = 0; i < cc_count; i++) {
192  h->buf_ref->data[old_size++] = get_bits(gb, 8);
193  h->buf_ref->data[old_size++] = get_bits(gb, 8);
194  h->buf_ref->data[old_size++] = get_bits(gb, 8);
195  }
196 
197  skip_bits(gb, 8); // marker_bits
198  }
199  }
200  } else {
201  int i;
202  for (i = 0; i < size - 1; i++)
203  skip_bits(gb, 8);
204  }
205 
206  return 0;
207 }
208 
210  void *logctx, int size)
211 {
212  uint32_t country_code;
213  uint32_t user_identifier;
214 
215  if (size < 7)
216  return AVERROR_INVALIDDATA;
217  size -= 7;
218 
219  country_code = get_bits(gb, 8); // itu_t_t35_country_code
220  if (country_code == 0xFF) {
221  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
222  size--;
223  }
224 
225  /* itu_t_t35_payload_byte follows */
226  skip_bits(gb, 8); // terminal provider code
227  skip_bits(gb, 8); // terminal provider oriented code
228  user_identifier = get_bits_long(gb, 32);
229 
230  switch (user_identifier) {
231  case MKBETAG('D', 'T', 'G', '1'): // afd_data
232  return decode_registered_user_data_afd(&h->afd, gb, size);
233  case MKBETAG('G', 'A', '9', '4'): // closed captions
235  logctx, size);
236  default:
237  skip_bits(gb, size * 8);
238  break;
239  }
240 
241  return 0;
242 }
243 
245  void *logctx, int size)
246 {
248  int e, build, i;
249 
250  if (size < 16 || size >= INT_MAX - 16)
251  return AVERROR_INVALIDDATA;
252 
253  user_data = av_malloc(16 + size + 1);
254  if (!user_data)
255  return AVERROR(ENOMEM);
256 
257  for (i = 0; i < size + 16; i++)
258  user_data[i] = get_bits(gb, 8);
259 
260  user_data[i] = 0;
261  e = sscanf(user_data + 16, "x264 - core %d", &build);
262  if (e == 1 && build > 0)
263  h->x264_build = build;
264  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
265  h->x264_build = 67;
266 
267  av_free(user_data);
268  return 0;
269 }
270 
272 {
273  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
274 
275  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
276  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
277  return AVERROR_INVALIDDATA;
278  }
279 
280  h->recovery_frame_cnt = recovery_frame_cnt;
281  /* 1b exact_match_flag,
282  * 1b broken_link_flag,
283  * 2b changing_slice_group_idc */
284  skip_bits(gb, 4);
285 
286  return 0;
287 }
288 
290  const H264ParamSets *ps, void *logctx)
291 {
292  unsigned int sps_id;
293  int sched_sel_idx;
294  const SPS *sps;
295 
296  sps_id = get_ue_golomb_31(gb);
297  if (sps_id > 31 || !ps->sps_list[sps_id]) {
298  av_log(logctx, AV_LOG_ERROR,
299  "non-existing SPS %d referenced in buffering period\n", sps_id);
300  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
301  }
302  sps = (const SPS*)ps->sps_list[sps_id]->data;
303 
304  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
306  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
307  h->initial_cpb_removal_delay[sched_sel_idx] =
309  // initial_cpb_removal_delay_offset
311  }
312  }
314  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
315  h->initial_cpb_removal_delay[sched_sel_idx] =
317  // initial_cpb_removal_delay_offset
319  }
320  }
321 
322  h->present = 1;
323  return 0;
324 }
325 
327  GetBitContext *gb)
328 {
332 
333  if (h->present) {
334  h->arrangement_type = get_bits(gb, 7);
337 
338  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
339  skip_bits(gb, 3);
341  // frame0_self_contained_flag, frame1_self_contained_flag
342  skip_bits(gb, 2);
343 
344  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
345  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
346  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
348  }
349  skip_bits1(gb); // frame_packing_arrangement_extension_flag
350 
351  return 0;
352 }
353 
355  GetBitContext *gb)
356 {
357  h->present = !get_bits1(gb);
358 
359  if (h->present) {
360  h->hflip = get_bits1(gb); // hor_flip
361  h->vflip = get_bits1(gb); // ver_flip
362 
363  h->anticlockwise_rotation = get_bits(gb, 16);
364  get_ue_golomb_long(gb); // display_orientation_repetition_period
365  skip_bits1(gb); // display_orientation_extension_flag
366  }
367 
368  return 0;
369 }
370 
372 {
373  h->green_metadata_type = get_bits(gb, 8);
374 
375  if (h->green_metadata_type == 0) {
376  h->period_type = get_bits(gb, 8);
377 
378  if (h->period_type == 2)
379  h->num_seconds = get_bits(gb, 16);
380  else if (h->period_type == 3)
381  h->num_pictures = get_bits(gb, 16);
382 
387 
388  } else if (h->green_metadata_type == 1) {
389  h->xsd_metric_type = get_bits(gb, 8);
390  h->xsd_metric_value = get_bits(gb, 16);
391  }
392 
393  return 0;
394 }
395 
397  GetBitContext *gb)
398 {
399  h->present = 1;
401  return 0;
402 }
403 
405  const H264ParamSets *ps, void *logctx)
406 {
407  int master_ret = 0;
408 
409  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
410  int type = 0;
411  unsigned size = 0;
412  unsigned next;
413  int ret = 0;
414 
415  do {
416  if (get_bits_left(gb) < 8)
417  return AVERROR_INVALIDDATA;
418  type += show_bits(gb, 8);
419  } while (get_bits(gb, 8) == 255);
420 
421  do {
422  if (get_bits_left(gb) < 8)
423  return AVERROR_INVALIDDATA;
424  size += show_bits(gb, 8);
425  } while (get_bits(gb, 8) == 255);
426 
427  if (size > get_bits_left(gb) / 8) {
428  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
429  type, 8*size, get_bits_left(gb));
430  return AVERROR_INVALIDDATA;
431  }
432  next = get_bits_count(gb) + 8 * size;
433 
434  switch (type) {
435  case H264_SEI_TYPE_PIC_TIMING: // Picture timing SEI
436  ret = decode_picture_timing(&h->picture_timing, gb, ps, logctx);
437  break;
439  ret = decode_registered_user_data(h, gb, logctx, size);
440  break;
442  ret = decode_unregistered_user_data(&h->unregistered, gb, logctx, size);
443  break;
445  ret = decode_recovery_point(&h->recovery_point, gb, logctx);
446  break;
448  ret = decode_buffering_period(&h->buffering_period, gb, ps, logctx);
449  break;
452  break;
455  break;
457  ret = decode_green_metadata(&h->green_metadata, gb);
458  break;
461  break;
462  default:
463  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
464  }
465  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
466  return ret;
467  if (ret < 0)
468  master_ret = ret;
469 
470  skip_bits_long(gb, next - get_bits_count(gb));
471 
472  // FIXME check bits here
473  align_get_bits(gb);
474  }
475 
476  return master_ret;
477 }
478 
480 {
481  if (h->arrangement_cancel_flag == 0) {
482  switch (h->arrangement_type) {
484  if (h->content_interpretation_type == 2)
485  return "checkerboard_rl";
486  else
487  return "checkerboard_lr";
489  if (h->content_interpretation_type == 2)
490  return "col_interleaved_rl";
491  else
492  return "col_interleaved_lr";
494  if (h->content_interpretation_type == 2)
495  return "row_interleaved_rl";
496  else
497  return "row_interleaved_lr";
499  if (h->content_interpretation_type == 2)
500  return "right_left";
501  else
502  return "left_right";
504  if (h->content_interpretation_type == 2)
505  return "bottom_top";
506  else
507  return "top_bottom";
509  if (h->content_interpretation_type == 2)
510  return "block_rl";
511  else
512  return "block_lr";
514  default:
515  return "mono";
516  }
517  } else if (h->arrangement_cancel_flag == 1) {
518  return "mono";
519  } else {
520  return NULL;
521  }
522 }
#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:134
#define MAX_SPS_COUNT
Definition: h264_ps.h:37
uint16_t num_pictures
Definition: h264_sei.h:163
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
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:291
Sequence parameter set.
Definition: h264_ps.h:44
H264SEIAlternativeTransfer alternative_transfer
Definition: h264_sei.h:187
#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:185
int current_frame_is_frame0_flag
Definition: h264_sei.h:150
H264SEIGreenMetaData green_metadata
Definition: h264_sei.h:186
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:479
AVBufferRef * buf_ref
Definition: h264_sei.h:119
uint8_t
uint8_t green_metadata_type
Definition: h264_sei.h:160
#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:244
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:179
alternative transfer
Definition: h264_sei.h:39
#define av_log(a,...)
uint16_t num_seconds
Definition: h264_sei.h:162
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:166
int timecode_cnt
Number of timecode in use.
Definition: h264_sei.h:110
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:259
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
H264_SEI_FpaType arrangement_type
Definition: h264_sei.h:146
int present
Buffering period SEI flag.
Definition: h264_sei.h:138
int time_offset_length
Definition: h264_ps.h:93
AVS_Value void * user_data
Definition: avisynth_c.h:775
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int arrangement_repetition_period
Definition: h264_sei.h:147
H264SEIUnregistered unregistered
Definition: h264_sei.h:181
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:133
uint8_t active_format_description
Definition: h264_sei.h:115
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:354
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:164
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:83
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:90
picture timing
Definition: h264_sei.h:29
int initial_cpb_removal_delay[32]
Initial timestamps for CPBs.
Definition: h264_sei.h:139
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:271
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:100
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:149
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
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:120
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
H264SEITimeCode timecode[3]
Maximum three timecodes in a pic_timing SEI.
Definition: h264_sei.h:105
GreenMPEG information.
Definition: h264_sei.h:37
H264SEIA53Caption a53_caption
Definition: h264_sei.h:180
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
static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, GetBitContext *gb)
Definition: h264_sei.c:396
int content_interpretation_type
Definition: h264_sei.h:148
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:183
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:165
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:178
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:182
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:92
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:326
uint8_t xsd_metric_type
Definition: h264_sei.h:168
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
uint16_t xsd_metric_value
Definition: h264_sei.h:169
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:95
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:90
#define flag(name)
Definition: cbs_av1.c:553
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264SEIFramePacking frame_packing
Definition: h264_sei.h:184
#define MKBETAG(a, b, c, d)
Definition: common.h:367
int present
Definition: h264_sei.h:114
#define av_free(p)
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
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:404
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:209
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:96
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:371
exp golomb vlc stuff
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:154
int arrangement_cancel_flag
is previous arrangement canceled, -1 if never received
Definition: h264_sei.h:145
frame packing arrangement
Definition: h264_sei.h:35
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:167
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:289