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  int country_code, provider_code;
187 
188  if (size < 3)
189  return AVERROR_INVALIDDATA;
190  size -= 3;
191 
192  country_code = get_bits(gb, 8); // itu_t_t35_country_code
193  if (country_code == 0xFF) {
194  if (size < 1)
195  return AVERROR_INVALIDDATA;
196 
197  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
198  size--;
199  }
200 
201  if (country_code != 0xB5) { // usa_country_code
202  av_log(logctx, AV_LOG_VERBOSE,
203  "Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n",
204  country_code);
205  return 0;
206  }
207 
208  /* itu_t_t35_payload_byte follows */
209  provider_code = get_bits(gb, 16);
210 
211  switch (provider_code) {
212  case 0x31: { // atsc_provider_code
213  uint32_t user_identifier;
214 
215  if (size < 4)
216  return AVERROR_INVALIDDATA;
217  size -= 4;
218 
219  user_identifier = get_bits_long(gb, 32);
220  switch (user_identifier) {
221  case MKBETAG('D', 'T', 'G', '1'): // afd_data
222  return decode_registered_user_data_afd(&h->afd, gb, size);
223  case MKBETAG('G', 'A', '9', '4'): // closed captions
225  logctx, size);
226  default:
227  av_log(logctx, AV_LOG_VERBOSE,
228  "Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n",
229  user_identifier);
230  break;
231  }
232  break;
233  }
234  default:
235  av_log(logctx, AV_LOG_VERBOSE,
236  "Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n",
237  provider_code);
238  break;
239  }
240 
241  return 0;
242 }
243 
245  void *logctx, int size)
246 {
248  int e, build, i;
249  AVBufferRef *buf_ref, **tmp;
250 
251  if (size < 16 || size >= INT_MAX - 1)
252  return AVERROR_INVALIDDATA;
253 
254  tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref));
255  if (!tmp)
256  return AVERROR(ENOMEM);
257  h->buf_ref = tmp;
258 
259  buf_ref = av_buffer_alloc(size + 1);
260  if (!buf_ref)
261  return AVERROR(ENOMEM);
262  user_data = buf_ref->data;
263 
264  for (i = 0; i < size; i++)
265  user_data[i] = get_bits(gb, 8);
266 
267  user_data[i] = 0;
268  buf_ref->size = size;
269  h->buf_ref[h->nb_buf_ref++] = buf_ref;
270 
271  e = sscanf(user_data + 16, "x264 - core %d", &build);
272  if (e == 1 && build > 0)
273  h->x264_build = build;
274  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
275  h->x264_build = 67;
276 
277  return 0;
278 }
279 
281 {
282  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
283 
284  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
285  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
286  return AVERROR_INVALIDDATA;
287  }
288 
289  h->recovery_frame_cnt = recovery_frame_cnt;
290  /* 1b exact_match_flag,
291  * 1b broken_link_flag,
292  * 2b changing_slice_group_idc */
293  skip_bits(gb, 4);
294 
295  return 0;
296 }
297 
299  const H264ParamSets *ps, void *logctx)
300 {
301  unsigned int sps_id;
302  int sched_sel_idx;
303  const SPS *sps;
304 
305  sps_id = get_ue_golomb_31(gb);
306  if (sps_id > 31 || !ps->sps_list[sps_id]) {
307  av_log(logctx, AV_LOG_ERROR,
308  "non-existing SPS %d referenced in buffering period\n", sps_id);
309  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
310  }
311  sps = (const SPS*)ps->sps_list[sps_id]->data;
312 
313  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
315  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
316  h->initial_cpb_removal_delay[sched_sel_idx] =
318  // initial_cpb_removal_delay_offset
320  }
321  }
323  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
324  h->initial_cpb_removal_delay[sched_sel_idx] =
326  // initial_cpb_removal_delay_offset
328  }
329  }
330 
331  h->present = 1;
332  return 0;
333 }
334 
336  GetBitContext *gb)
337 {
341 
342  if (h->present) {
343  h->arrangement_type = get_bits(gb, 7);
346 
347  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
348  skip_bits(gb, 3);
350  // frame0_self_contained_flag, frame1_self_contained_flag
351  skip_bits(gb, 2);
352 
353  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
354  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
355  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
357  }
358  skip_bits1(gb); // frame_packing_arrangement_extension_flag
359 
360  return 0;
361 }
362 
364  GetBitContext *gb)
365 {
366  h->present = !get_bits1(gb);
367 
368  if (h->present) {
369  h->hflip = get_bits1(gb); // hor_flip
370  h->vflip = get_bits1(gb); // ver_flip
371 
372  h->anticlockwise_rotation = get_bits(gb, 16);
373  get_ue_golomb_long(gb); // display_orientation_repetition_period
374  skip_bits1(gb); // display_orientation_extension_flag
375  }
376 
377  return 0;
378 }
379 
381 {
382  h->green_metadata_type = get_bits(gb, 8);
383 
384  if (h->green_metadata_type == 0) {
385  h->period_type = get_bits(gb, 8);
386 
387  if (h->period_type == 2)
388  h->num_seconds = get_bits(gb, 16);
389  else if (h->period_type == 3)
390  h->num_pictures = get_bits(gb, 16);
391 
396 
397  } else if (h->green_metadata_type == 1) {
398  h->xsd_metric_type = get_bits(gb, 8);
399  h->xsd_metric_value = get_bits(gb, 16);
400  }
401 
402  return 0;
403 }
404 
406  GetBitContext *gb)
407 {
408  h->present = 1;
410  return 0;
411 }
412 
414  const H264ParamSets *ps, void *logctx)
415 {
416  int master_ret = 0;
417 
418  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
419  GetBitContext gb_payload;
420  int type = 0;
421  unsigned size = 0;
422  int ret = 0;
423 
424  do {
425  if (get_bits_left(gb) < 8)
426  return AVERROR_INVALIDDATA;
427  type += show_bits(gb, 8);
428  } while (get_bits(gb, 8) == 255);
429 
430  do {
431  if (get_bits_left(gb) < 8)
432  return AVERROR_INVALIDDATA;
433  size += show_bits(gb, 8);
434  } while (get_bits(gb, 8) == 255);
435 
436  if (size > get_bits_left(gb) / 8) {
437  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
438  type, 8*size, get_bits_left(gb));
439  return AVERROR_INVALIDDATA;
440  }
441 
442  ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size);
443  if (ret < 0)
444  return ret;
445 
446  switch (type) {
447  case SEI_TYPE_PIC_TIMING: // Picture timing SEI
448  ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx);
449  break;
451  ret = decode_registered_user_data(h, &gb_payload, logctx, size);
452  break;
454  ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size);
455  break;
457  ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
458  break;
460  ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx);
461  break;
463  ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload);
464  break;
466  ret = decode_display_orientation(&h->display_orientation, &gb_payload);
467  break;
469  ret = decode_green_metadata(&h->green_metadata, &gb_payload);
470  break;
472  ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload);
473  break;
474  default:
475  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
476  }
477  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
478  return ret;
479  if (ret < 0)
480  master_ret = ret;
481 
482  if (get_bits_left(&gb_payload) < 0) {
483  av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n",
484  type, -get_bits_left(&gb_payload));
485  }
486 
487  skip_bits_long(gb, 8 * size);
488  }
489 
490  return master_ret;
491 }
492 
494 {
495  if (h->arrangement_cancel_flag == 0) {
496  switch (h->arrangement_type) {
498  if (h->content_interpretation_type == 2)
499  return "checkerboard_rl";
500  else
501  return "checkerboard_lr";
503  if (h->content_interpretation_type == 2)
504  return "col_interleaved_rl";
505  else
506  return "col_interleaved_lr";
508  if (h->content_interpretation_type == 2)
509  return "row_interleaved_rl";
510  else
511  return "row_interleaved_lr";
513  if (h->content_interpretation_type == 2)
514  return "right_left";
515  else
516  return "left_right";
518  if (h->content_interpretation_type == 2)
519  return "bottom_top";
520  else
521  return "top_bottom";
523  if (h->content_interpretation_type == 2)
524  return "block_rl";
525  else
526  return "block_lr";
528  default:
529  return "mono";
530  }
531  } else if (h->arrangement_cancel_flag == 1) {
532  return "mono";
533  } else {
534  return NULL;
535  }
536 }
#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:125
uint16_t num_pictures
Definition: h264_sei.h:154
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:178
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:176
int current_frame_is_frame0_flag
Definition: h264_sei.h:141
fg index
H264SEIGreenMetaData green_metadata
Definition: h264_sei.h:177
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:493
AVBufferRef * buf_ref
Definition: h264_sei.h:108
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:151
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:244
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
bitstream reader API header.
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
ptrdiff_t size
Definition: opengl_enc.c:100
H264SEIAFD afd
Definition: h264_sei.h:170
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define av_log(a,...)
uint16_t num_seconds
Definition: h264_sei.h:153
uint8_t percent_six_tap_filtering
Definition: h264_sei.h:157
int timecode_cnt
Number of timecode in use.
Definition: h264_sei.h:99
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
H.264 parameter set handling.
#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:137
int present
Buffering period SEI flag.
Definition: h264_sei.h:129
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:138
H264SEIUnregistered unregistered
Definition: h264_sei.h:172
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:104
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:363
uint8_t percent_non_zero_macroblocks
Definition: h264_sei.h:155
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:72
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:79
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:130
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:280
int cpb_removal_delay
cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
Definition: h264_sei.h:89
int quincunx_sampling_flag
Definition: h264_sei.h:140
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:68
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(buffer_size_t 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:92
H264SEITimeCode timecode[3]
Maximum three timecodes in a pic_timing SEI.
Definition: h264_sei.h:94
H264SEIA53Caption a53_caption
Definition: h264_sei.h:171
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 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:405
int content_interpretation_type
Definition: h264_sei.h:139
H264SEIBufferingPeriod buffering_period
Definition: h264_sei.h:174
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
#define AVERROR_PS_NOT_FOUND
Definition: h264_sei.c:36
uint8_t percent_intra_coded_macroblocks
Definition: h264_sei.h:156
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:169
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:173
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:97
int pic_struct_present_flag
Definition: h264_ps.h:94
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:335
uint8_t xsd_metric_type
Definition: h264_sei.h:159
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
uint16_t xsd_metric_value
Definition: h264_sei.h:160
A reference to a data buffer.
Definition: buffer.h:84
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:84
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:92
#define flag(name)
Definition: cbs_av1.c:553
H264SEIFramePacking frame_packing
Definition: h264_sei.h:175
#define MKBETAG(a, b, c, d)
Definition: common.h:479
AVBufferRef ** buf_ref
Definition: h264_sei.h:113
int present
Definition: h264_sei.h:103
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:413
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:380
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:136
int i
Definition: input.c:407
uint8_t percent_alpha_point_deblocking_instance
Definition: h264_sei.h:158
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:298
static uint8_t tmp[11]
Definition: aes_ctr.c:27