FFmpeg  4.4
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 {
44  h->recovery_point.recovery_frame_cnt = -1;
45 
46  h->picture_timing.dpb_output_delay = 0;
47  h->picture_timing.cpb_removal_delay = -1;
48 
49  h->picture_timing.present = 0;
50  h->buffering_period.present = 0;
51  h->frame_packing.present = 0;
52  h->display_orientation.present = 0;
53  h->afd.present = 0;
54 
55  av_buffer_unref(&h->a53_caption.buf_ref);
56  for (int i = 0; i < h->unregistered.nb_buf_ref; i++)
57  av_buffer_unref(&h->unregistered.buf_ref[i]);
58  h->unregistered.nb_buf_ref = 0;
59  av_freep(&h->unregistered.buf_ref);
60 }
61 
63  void *logctx)
64 {
65  GetBitContext gb;
66 
67  init_get_bits(&gb, h->payload, h->payload_size_bits);
68 
69  if (sps->nal_hrd_parameters_present_flag ||
70  sps->vcl_hrd_parameters_present_flag) {
71  h->cpb_removal_delay = get_bits_long(&gb, sps->cpb_removal_delay_length);
72  h->dpb_output_delay = get_bits_long(&gb, sps->dpb_output_delay_length);
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 
80  if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING)
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 */
87  H264SEITimeCode *tc = &h->timecode[h->timecode_cnt++];
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
166  h->active_format_description = get_bits(gb, 4);
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
224  return decode_registered_user_data_closed_caption(&h->a53_caption, gb,
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
314  if (sps->nal_hrd_parameters_present_flag) {
315  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
316  h->initial_cpb_removal_delay[sched_sel_idx] =
317  get_bits_long(gb, sps->initial_cpb_removal_delay_length);
318  // initial_cpb_removal_delay_offset
319  skip_bits(gb, sps->initial_cpb_removal_delay_length);
320  }
321  }
322  if (sps->vcl_hrd_parameters_present_flag) {
323  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
324  h->initial_cpb_removal_delay[sched_sel_idx] =
325  get_bits_long(gb, sps->initial_cpb_removal_delay_length);
326  // initial_cpb_removal_delay_offset
327  skip_bits(gb, sps->initial_cpb_removal_delay_length);
328  }
329  }
330 
331  h->present = 1;
332  return 0;
333 }
334 
336  GetBitContext *gb)
337 {
338  h->arrangement_id = get_ue_golomb_long(gb);
339  h->arrangement_cancel_flag = get_bits1(gb);
340  h->present = !h->arrangement_cancel_flag;
341 
342  if (h->present) {
343  h->arrangement_type = get_bits(gb, 7);
344  h->quincunx_sampling_flag = get_bits1(gb);
345  h->content_interpretation_type = get_bits(gb, 6);
346 
347  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
348  skip_bits(gb, 3);
349  h->current_frame_is_frame0_flag = get_bits1(gb);
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
356  h->arrangement_repetition_period = get_ue_golomb_long(gb);
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 
392  h->percent_non_zero_macroblocks = get_bits(gb, 8);
393  h->percent_intra_coded_macroblocks = get_bits(gb, 8);
394  h->percent_six_tap_filtering = get_bits(gb, 8);
395  h->percent_alpha_point_deblocking_instance = get_bits(gb, 8);
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;
409  h->preferred_transfer_characteristics = get_bits(gb, 8);
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 }
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
uint8_t
Libavcodec external API header.
#define flag(name)
Definition: cbs_av1.c:553
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define NULL
Definition: coverity.c:32
bitstream reader API header.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
exp golomb vlc stuff
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:122
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
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
AVBufferRef * av_buffer_alloc(buffer_size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
int index
Definition: gxfenc.c:89
H.264 parameter set handling.
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
#define AVERROR_PS_NOT_FOUND
Definition: h264_sei.c:36
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
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:413
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:244
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:42
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:335
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:129
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:183
static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
Definition: h264_sei.c:380
static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
Definition: h264_sei.c:152
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:280
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:173
static const uint8_t sei_num_clock_ts_table[9]
Definition: h264_sei.c:38
static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, GetBitContext *gb)
Definition: h264_sei.c:405
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:363
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
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:298
@ H264_SEI_FPA_TYPE_2D
Definition: h264_sei.h:52
@ H264_SEI_FPA_TYPE_INTERLEAVE_ROW
Definition: h264_sei.h:48
@ H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
Definition: h264_sei.h:51
@ H264_SEI_FPA_TYPE_TOP_BOTTOM
Definition: h264_sei.h:50
@ H264_SEI_FPA_TYPE_CHECKERBOARD
Definition: h264_sei.h:46
@ H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN
Definition: h264_sei.h:47
@ H264_SEI_FPA_TYPE_SIDE_BY_SIDE
Definition: h264_sei.h:49
@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:39
cl_device_type type
int i
Definition: input.c:407
common internal API header
#define tc
Definition: regdef.h:69
@ SEI_TYPE_RECOVERY_POINT
Definition: sei.h:36
@ SEI_TYPE_PIC_TIMING
Definition: sei.h:31
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
@ SEI_TYPE_DISPLAY_ORIENTATION
Definition: sei.h:77
@ SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS
Definition: sei.h:106
@ SEI_TYPE_FRAME_PACKING_ARRANGEMENT
Definition: sei.h:75
@ SEI_TYPE_GREEN_METADATA
Definition: sei.h:85
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
@ SEI_TYPE_BUFFERING_PERIOD
Definition: sei.h:30
A reference to a data buffer.
Definition: buffer.h:84
int size
Size of data in bytes.
Definition: buffer.h:97
uint8_t * data
The data buffer.
Definition: buffer.h:92
const uint8_t * buffer
Definition: get_bits.h:62
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:144
Sequence parameter set.
Definition: h264_ps.h:44
#define av_freep(p)
#define av_log(a,...)
static uint8_t tmp[11]
Definition: aes_ctr.c:27
int size
if(ret< 0)
Definition: vf_mcdeint.c:282