FFmpeg
hevc_sei.c
Go to the documentation of this file.
1 /*
2  * HEVC Supplementary Enhancement Information messages
3  *
4  * Copyright (C) 2012 - 2013 Guillaume Martres
5  * Copyright (C) 2012 - 2013 Gildas Cocherel
6  * Copyright (C) 2013 Vittorio Giovara
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 #include "atsc_a53.h"
26 #include "dynamic_hdr10_plus.h"
27 #include "golomb.h"
28 #include "hevc_ps.h"
29 #include "hevc_sei.h"
30 
32 {
33  int cIdx, i;
34  uint8_t hash_type;
35  //uint16_t picture_crc;
36  //uint32_t picture_checksum;
37  hash_type = get_bits(gb, 8);
38 
39  for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) {
40  if (hash_type == 0) {
41  s->is_md5 = 1;
42  for (i = 0; i < 16; i++)
43  s->md5[cIdx][i] = get_bits(gb, 8);
44  } else if (hash_type == 1) {
45  // picture_crc = get_bits(gb, 16);
46  skip_bits(gb, 16);
47  } else if (hash_type == 2) {
48  // picture_checksum = get_bits_long(gb, 32);
49  skip_bits(gb, 32);
50  }
51  }
52  return 0;
53 }
54 
56 {
57  int i;
58  // Mastering primaries
59  for (i = 0; i < 3; i++) {
60  s->display_primaries[i][0] = get_bits(gb, 16);
61  s->display_primaries[i][1] = get_bits(gb, 16);
62  }
63  // White point (x, y)
64  s->white_point[0] = get_bits(gb, 16);
65  s->white_point[1] = get_bits(gb, 16);
66 
67  // Max and min luminance of mastering display
68  s->max_luminance = get_bits_long(gb, 32);
69  s->min_luminance = get_bits_long(gb, 32);
70 
71  // As this SEI message comes before the first frame that references it,
72  // initialize the flag to 2 and decrement on IRAP access unit so it
73  // persists for the coded video sequence (e.g., between two IRAPs)
74  s->present = 2;
75  return 0;
76 }
77 
79 {
80  // Max and average light levels
81  s->max_content_light_level = get_bits(gb, 16);
83  // As this SEI message comes before the first frame that references it,
84  // initialize the flag to 2 and decrement on IRAP access unit so it
85  // persists for the coded video sequence (e.g., between two IRAPs)
86  s->present = 2;
87  return 0;
88 }
89 
91 {
92  get_ue_golomb_long(gb); // frame_packing_arrangement_id
93  s->present = !get_bits1(gb);
94 
95  if (s->present) {
96  s->arrangement_type = get_bits(gb, 7);
99 
100  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
101  skip_bits(gb, 3);
103  // frame0_self_contained_flag, frame1_self_contained_flag
104  skip_bits(gb, 2);
105 
106  if (!s->quincunx_subsampling && s->arrangement_type != 5)
107  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
108  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
109  skip_bits1(gb); // frame_packing_arrangement_persistence_flag
110  }
111  skip_bits1(gb); // upsampled_aspect_ratio_flag
112  return 0;
113 }
114 
116 {
117  s->present = !get_bits1(gb);
118 
119  if (s->present) {
120  s->hflip = get_bits1(gb); // hor_flip
121  s->vflip = get_bits1(gb); // ver_flip
122 
123  s->anticlockwise_rotation = get_bits(gb, 16);
124  skip_bits1(gb); // display_orientation_persistence_flag
125  }
126 
127  return 0;
128 }
129 
131  void *logctx, int size)
132 {
134  HEVCSPS *sps;
135 
137  return(AVERROR(ENOMEM));
139 
141  int pic_struct = get_bits(gb, 4);
143  if (pic_struct == 2 || pic_struct == 10 || pic_struct == 12) {
144  av_log(logctx, AV_LOG_DEBUG, "BOTTOM Field\n");
146  } else if (pic_struct == 1 || pic_struct == 9 || pic_struct == 11) {
147  av_log(logctx, AV_LOG_DEBUG, "TOP Field\n");
149  } else if (pic_struct == 7) {
150  av_log(logctx, AV_LOG_DEBUG, "Frame/Field Doubling\n");
152  } else if (pic_struct == 8) {
153  av_log(logctx, AV_LOG_DEBUG, "Frame/Field Tripling\n");
155  }
156  get_bits(gb, 2); // source_scan_type
157  get_bits(gb, 1); // duplicate_flag
158  skip_bits1(gb);
159  size--;
160  }
161  skip_bits_long(gb, 8 * size);
162 
163  return 0;
164 }
165 
167  int size)
168 {
169  int ret;
170 
171  if (size < 3)
172  return AVERROR_INVALIDDATA;
173 
174  ret = ff_parse_a53_cc(&s->buf_ref, gb->buffer + get_bits_count(gb) / 8, size);
175 
176  if (ret < 0)
177  return ret;
178 
179  skip_bits_long(gb, size * 8);
180 
181  return 0;
182 }
183 
185  int size)
186 {
187  AVBufferRef *buf_ref, **tmp;
188 
189  if (size < 16 || size >= INT_MAX - 1)
190  return AVERROR_INVALIDDATA;
191 
192  tmp = av_realloc_array(s->buf_ref, s->nb_buf_ref + 1, sizeof(*s->buf_ref));
193  if (!tmp)
194  return AVERROR(ENOMEM);
195  s->buf_ref = tmp;
196 
197  buf_ref = av_buffer_alloc(size + 1);
198  if (!buf_ref)
199  return AVERROR(ENOMEM);
200 
201  for (int i = 0; i < size; i++)
202  buf_ref->data[i] = get_bits(gb, 8);
203  buf_ref->data[size] = 0;
204  buf_ref->size = size;
205  s->buf_ref[s->nb_buf_ref++] = buf_ref;
206 
207  return 0;
208 }
209 
211  GetBitContext *gb, int size)
212 {
213  size_t meta_size;
214  int err;
215  AVDynamicHDRPlus *metadata = av_dynamic_hdr_plus_alloc(&meta_size);
216  if (!metadata)
217  return AVERROR(ENOMEM);
218 
220  gb->buffer + get_bits_count(gb) / 8, size);
221  if (err < 0) {
222  av_free(metadata);
223  return err;
224  }
225 
226  av_buffer_unref(&s->info);
227  s->info = av_buffer_create((uint8_t *)metadata, meta_size, NULL, NULL, 0);
228  if (!s->info) {
229  av_free(metadata);
230  return AVERROR(ENOMEM);
231  }
232 
233  skip_bits_long(gb, size * 8);
234 
235  return 0;
236 }
237 
239  void *logctx, int size)
240 {
241  int country_code, provider_code;
242 
243  if (size < 3)
244  return AVERROR_INVALIDDATA;
245  size -= 3;
246 
247  country_code = get_bits(gb, 8);
248  if (country_code == 0xFF) {
249  if (size < 1)
250  return AVERROR_INVALIDDATA;
251 
252  skip_bits(gb, 8);
253  size--;
254  }
255 
256  if (country_code != 0xB5) { // usa_country_code
257  av_log(logctx, AV_LOG_VERBOSE,
258  "Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n",
259  country_code);
260  goto end;
261  }
262 
263  provider_code = get_bits(gb, 16);
264 
265  switch (provider_code) {
266  case 0x3C: { // smpte_provider_code
267  // A/341 Amendment - 2094-40
268  const uint16_t smpte2094_40_provider_oriented_code = 0x0001;
269  const uint8_t smpte2094_40_application_identifier = 0x04;
270  uint16_t provider_oriented_code;
271  uint8_t application_identifier;
272 
273  if (size < 3)
274  return AVERROR_INVALIDDATA;
275  size -= 3;
276 
277  provider_oriented_code = get_bits(gb, 16);
278  application_identifier = get_bits(gb, 8);
279  if (provider_oriented_code == smpte2094_40_provider_oriented_code &&
280  application_identifier == smpte2094_40_application_identifier) {
282  }
283  break;
284  }
285  case 0x31: { // atsc_provider_code
286  uint32_t user_identifier;
287 
288  if (size < 4)
289  return AVERROR_INVALIDDATA;
290  size -= 4;
291 
292  user_identifier = get_bits_long(gb, 32);
293  switch (user_identifier) {
294  case MKBETAG('G', 'A', '9', '4'):
296  default:
297  av_log(logctx, AV_LOG_VERBOSE,
298  "Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n",
299  user_identifier);
300  break;
301  }
302  break;
303  }
304  default:
305  av_log(logctx, AV_LOG_VERBOSE,
306  "Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n",
307  provider_code);
308  break;
309  }
310 
311 end:
312  skip_bits_long(gb, size * 8);
313  return 0;
314 }
315 
317 {
318  int num_sps_ids_minus1;
319  int i;
320  unsigned active_seq_parameter_set_id;
321 
322  get_bits(gb, 4); // active_video_parameter_set_id
323  get_bits(gb, 1); // self_contained_cvs_flag
324  get_bits(gb, 1); // num_sps_ids_minus1
325  num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1
326 
327  if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) {
328  av_log(logctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1);
329  return AVERROR_INVALIDDATA;
330  }
331 
332  active_seq_parameter_set_id = get_ue_golomb_long(gb);
333  if (active_seq_parameter_set_id >= HEVC_MAX_SPS_COUNT) {
334  av_log(logctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id);
335  return AVERROR_INVALIDDATA;
336  }
337  s->active_seq_parameter_set_id = active_seq_parameter_set_id;
338 
339  for (i = 1; i <= num_sps_ids_minus1; i++)
340  get_ue_golomb_long(gb); // active_seq_parameter_set_id[i]
341 
342  return 0;
343 }
344 
346 {
347  s->present = 1;
349  return 0;
350 }
351 
353 {
354  s->num_clock_ts = get_bits(gb, 2);
355 
356  for (int i = 0; i < s->num_clock_ts; i++) {
357  s->clock_timestamp_flag[i] = get_bits(gb, 1);
358 
359  if (s->clock_timestamp_flag[i]) {
360  s->units_field_based_flag[i] = get_bits(gb, 1);
361  s->counting_type[i] = get_bits(gb, 5);
362  s->full_timestamp_flag[i] = get_bits(gb, 1);
363  s->discontinuity_flag[i] = get_bits(gb, 1);
364  s->cnt_dropped_flag[i] = get_bits(gb, 1);
365 
366  s->n_frames[i] = get_bits(gb, 9);
367 
368  if (s->full_timestamp_flag[i]) {
369  s->seconds_value[i] = av_clip(get_bits(gb, 6), 0, 59);
370  s->minutes_value[i] = av_clip(get_bits(gb, 6), 0, 59);
371  s->hours_value[i] = av_clip(get_bits(gb, 5), 0, 23);
372  } else {
373  s->seconds_flag[i] = get_bits(gb, 1);
374  if (s->seconds_flag[i]) {
375  s->seconds_value[i] = av_clip(get_bits(gb, 6), 0, 59);
376  s->minutes_flag[i] = get_bits(gb, 1);
377  if (s->minutes_flag[i]) {
378  s->minutes_value[i] = av_clip(get_bits(gb, 6), 0, 59);
379  s->hours_flag[i] = get_bits(gb, 1);
380  if (s->hours_flag[i]) {
381  s->hours_value[i] = av_clip(get_bits(gb, 5), 0, 23);
382  }
383  }
384  }
385  }
386 
387  s->time_offset_length[i] = get_bits(gb, 5);
388  if (s->time_offset_length[i] > 0) {
390  }
391  }
392  }
393 
394  s->present = 1;
395  return 0;
396 }
397 
398 
399 static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s,
400  const HEVCParamSets *ps, int type, int size)
401 {
402  switch (type) {
403  case 256: // Mismatched value from HM 8.1
409  case SEI_TYPE_PIC_TIMING:
410  return decode_nal_sei_pic_timing(s, gb, ps, logctx, size);
416  return decode_nal_sei_active_parameter_sets(s, gb, logctx);
418  return decode_nal_sei_user_data_registered_itu_t_t35(s, gb, logctx, size);
423  case SEI_TYPE_TIME_CODE:
424  return decode_nal_sei_timecode(&s->timecode, gb);
425  default:
426  av_log(logctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
427  skip_bits_long(gb, 8 * size);
428  return 0;
429  }
430 }
431 
432 static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s,
433  int type, int size)
434 {
435  switch (type) {
438  default:
439  av_log(logctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type);
440  skip_bits_long(gb, 8 * size);
441  return 0;
442  }
443 }
444 
445 static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s,
446  const HEVCParamSets *ps, int nal_unit_type)
447 {
448  int payload_type = 0;
449  int payload_size = 0;
450  int byte = 0xFF;
451  av_log(logctx, AV_LOG_DEBUG, "Decoding SEI\n");
452 
453  while (byte == 0xFF) {
454  if (get_bits_left(gb) < 16 || payload_type > INT_MAX - 255)
455  return AVERROR_INVALIDDATA;
456  byte = get_bits(gb, 8);
457  payload_type += byte;
458  }
459  byte = 0xFF;
460  while (byte == 0xFF) {
461  if (get_bits_left(gb) < 8 + 8LL*payload_size)
462  return AVERROR_INVALIDDATA;
463  byte = get_bits(gb, 8);
464  payload_size += byte;
465  }
466  if (get_bits_left(gb) < 8LL*payload_size)
467  return AVERROR_INVALIDDATA;
468  if (nal_unit_type == HEVC_NAL_SEI_PREFIX) {
469  return decode_nal_sei_prefix(gb, logctx, s, ps, payload_type, payload_size);
470  } else { /* nal_unit_type == NAL_SEI_SUFFIX */
471  return decode_nal_sei_suffix(gb, logctx, s, payload_type, payload_size);
472  }
473 }
474 
476 {
477  return get_bits_left(gb) > 0 && show_bits(gb, 8) != 0x80;
478 }
479 
481  const HEVCParamSets *ps, int type)
482 {
483  int ret;
484 
485  do {
486  ret = decode_nal_sei_message(gb, logctx, s, ps, type);
487  if (ret < 0)
488  return ret;
489  } while (more_rbsp_data(gb));
490  return 1;
491 }
492 
494 {
496 
497  for (int i = 0; i < s->unregistered.nb_buf_ref; i++)
499  s->unregistered.nb_buf_ref = 0;
502 }
static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s, int type, int size)
Definition: hevc_sei.c:432
#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 current_frame_is_frame0_flag
Definition: hevc_sei.h:45
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
AVBufferRef * buf_ref
Definition: hevc_sei.h:59
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
VUI vui
Definition: hevc_ps.h:178
const uint8_t * buffer
Definition: get_bits.h:62
uint8_t hours_flag[3]
Definition: hevc_sei.h:105
static int decode_nal_sei_display_orientation(HEVCSEIDisplayOrientation *s, GetBitContext *gb)
Definition: hevc_sei.c:115
GLint GLenum type
Definition: opengl_enc.c:104
uint8_t counting_type[3]
Definition: hevc_sei.h:95
uint8_t clock_timestamp_flag[3]
Definition: hevc_sei.h:93
AVDynamicHDRPlus * av_dynamic_hdr_plus_alloc(size_t *size)
Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
uint8_t is_md5
Definition: hevc_sei.h:37
uint8_t minutes_flag[3]
Definition: hevc_sei.h:104
static int more_rbsp_data(GetBitContext *gb)
Definition: hevc_sei.c:475
HEVCSEIMasteringDisplay mastering_display
Definition: hevc_sei.h:117
uint8_t seconds_flag[3]
Definition: hevc_sei.h:103
uint8_t discontinuity_flag[3]
Definition: hevc_sei.h:97
uint8_t cnt_dropped_flag[3]
Definition: hevc_sei.h:98
static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int nal_unit_type)
Definition: hevc_sei.c:445
AVBufferRef * sps_list[HEVC_MAX_SPS_COUNT]
Definition: hevc_ps.h:329
HEVCSEIContentLight content_light
Definition: hevc_sei.h:119
uint8_t
static int decode_nal_sei_alternative_transfer(HEVCSEIAlternativeTransfer *s, GetBitContext *gb)
Definition: hevc_sei.c:345
int ff_parse_itu_t_t35_to_dynamic_hdr10_plus(AVDynamicHDRPlus *s, const uint8_t *data, int size)
Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).
int active_seq_parameter_set_id
Definition: hevc_sei.h:120
int frame_field_info_present_flag
Definition: hevc_ps.h:69
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
#define av_clip
Definition: common.h:122
HEVCSEIUnregistered unregistered
Definition: hevc_sei.h:116
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
int quincunx_subsampling
Definition: hevc_sei.h:44
HEVCSEIDynamicHDRPlus dynamic_hdr_plus
Definition: hevc_sei.h:118
ptrdiff_t size
Definition: opengl_enc.c:100
uint8_t time_offset_length[3]
Definition: hevc_sei.h:106
static int decode_nal_sei_content_light_info(HEVCSEIContentLight *s, GetBitContext *gb)
Definition: hevc_sei.c:78
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
uint8_t hours_value[3]
Definition: hevc_sei.h:102
uint16_t n_frames[3]
Definition: hevc_sei.h:99
#define av_log(a,...)
static int decode_registered_user_data_closed_caption(HEVCSEIA53Caption *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:166
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
int32_t time_offset_value[3]
Definition: hevc_sei.h:107
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int content_interpretation_type
Definition: hevc_sei.h:43
uint8_t md5[3][16]
Definition: hevc_sei.h:36
static int decode_nal_sei_active_parameter_sets(HEVCSEI *s, GetBitContext *gb, void *logctx)
Definition: hevc_sei.c:316
AVBufferRef ** buf_ref
Definition: hevc_sei.h:63
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int preferred_transfer_characteristics
Definition: hevc_sei.h:87
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
uint8_t units_field_based_flag[3]
Definition: hevc_sei.h:94
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
#define s(width, name)
Definition: cbs_vp9.c:257
static int decode_nal_sei_user_data_unregistered(HEVCSEIUnregistered *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:184
if(ret)
uint8_t full_timestamp_flag[3]
Definition: hevc_sei.h:96
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
static int decode_registered_user_data_dynamic_hdr_plus(HEVCSEIDynamicHDRPlus *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:210
void ff_hevc_reset_sei(HEVCSEI *s)
Reset SEI values that are stored on the Context.
Definition: hevc_sei.c:493
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:91
uint8_t * data
The data buffer.
Definition: buffer.h:89
static int decode_nal_sei_timecode(HEVCSEITimeCode *s, GetBitContext *gb)
Definition: hevc_sei.c:352
uint8_t minutes_value[3]
Definition: hevc_sei.h:101
static int decode_nal_sei_frame_packing_arrangement(HEVCSEIFramePacking *s, GetBitContext *gb)
Definition: hevc_sei.c:90
HEVCSEIFramePacking frame_packing
Definition: hevc_sei.h:112
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
uint16_t max_pic_average_light_level
Definition: hevc_sei.h:82
uint8_t num_clock_ts
Definition: hevc_sei.h:92
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
HEVCSEIPictureHash picture_hash
Definition: hevc_sei.h:111
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
int size
Size of data in bytes.
Definition: buffer.h:93
static int decode_nal_sei_decoded_picture_hash(HEVCSEIPictureHash *s, GetBitContext *gb)
Definition: hevc_sei.c:31
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:114
static int decode_nal_sei_pic_timing(HEVCSEI *s, GetBitContext *gb, const HEVCParamSets *ps, void *logctx, int size)
Definition: hevc_sei.c:130
A reference to a data buffer.
Definition: buffer.h:81
HEVCSEIAlternativeTransfer alternative_transfer
Definition: hevc_sei.h:121
HEVCSEIDisplayOrientation display_orientation
Definition: hevc_sei.h:113
uint16_t max_content_light_level
Definition: hevc_sei.h:81
uint32_t max_luminance
Definition: hevc_sei.h:71
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define av_free(p)
static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int type, int size)
Definition: hevc_sei.c:399
HEVCSEITimeCode timecode
Definition: hevc_sei.h:122
uint8_t seconds_value[3]
Definition: hevc_sei.h:100
uint32_t min_luminance
Definition: hevc_sei.h:72
static int decode_nal_sei_mastering_display_info(HEVCSEIMasteringDisplay *s, GetBitContext *gb)
Definition: hevc_sei.c:55
HEVCSEIA53Caption a53_caption
Definition: hevc_sei.h:115
static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCSEI *s, GetBitContext *gb, void *logctx, int size)
Definition: hevc_sei.c:238
#define av_freep(p)
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
exp golomb vlc stuff
uint16_t white_point[2]
Definition: hevc_sei.h:70
AVBufferRef * info
Definition: hevc_sei.h:76
int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int type)
Definition: hevc_sei.c:480
int i
Definition: input.c:407
uint16_t display_primaries[3][2]
Definition: hevc_sei.h:69
static uint8_t tmp[11]
Definition: aes_ctr.c:27