FFmpeg  4.4.4
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);
82  s->max_pic_average_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);
97  s->quincunx_subsampling = get_bits1(gb);
98  s->content_interpretation_type = get_bits(gb, 6);
99 
100  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
101  skip_bits(gb, 3);
102  s->current_frame_is_frame0_flag = get_bits1(gb);
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 {
133  HEVCSEIPictureTiming *h = &s->picture_timing;
134  HEVCSPS *sps;
135 
136  if (!ps->sps_list[s->active_seq_parameter_set_id])
137  return(AVERROR(ENOMEM));
138  sps = (HEVCSPS*)ps->sps_list[s->active_seq_parameter_set_id]->data;
139 
140  if (sps->vui.frame_field_info_present_flag) {
141  int pic_struct = get_bits(gb, 4);
142  h->picture_struct = AV_PICTURE_STRUCTURE_UNKNOWN;
143  if (pic_struct == 2 || pic_struct == 10 || pic_struct == 12) {
144  av_log(logctx, AV_LOG_DEBUG, "BOTTOM Field\n");
145  h->picture_struct = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
146  } else if (pic_struct == 1 || pic_struct == 9 || pic_struct == 11) {
147  av_log(logctx, AV_LOG_DEBUG, "TOP Field\n");
148  h->picture_struct = AV_PICTURE_STRUCTURE_TOP_FIELD;
149  } else if (pic_struct == 7) {
150  av_log(logctx, AV_LOG_DEBUG, "Frame/Field Doubling\n");
151  h->picture_struct = HEVC_SEI_PIC_STRUCT_FRAME_DOUBLING;
152  } else if (pic_struct == 8) {
153  av_log(logctx, AV_LOG_DEBUG, "Frame/Field Tripling\n");
154  h->picture_struct = HEVC_SEI_PIC_STRUCT_FRAME_TRIPLING;
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) {
281  return decode_registered_user_data_dynamic_hdr_plus(&s->dynamic_hdr_plus, gb, size);
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'):
295  return decode_registered_user_data_closed_caption(&s->a53_caption, gb, size);
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;
348  s->preferred_transfer_characteristics = get_bits(gb, 8);
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) {
389  s->time_offset_value[i] = get_bits_long(gb, s->time_offset_length[i]);
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
404  return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb);
406  return decode_nal_sei_frame_packing_arrangement(&s->frame_packing, gb);
408  return decode_nal_sei_display_orientation(&s->display_orientation, gb);
409  case SEI_TYPE_PIC_TIMING:
410  return decode_nal_sei_pic_timing(s, gb, ps, logctx, size);
412  return decode_nal_sei_mastering_display_info(&s->mastering_display, gb);
414  return decode_nal_sei_content_light_info(&s->content_light, gb);
416  return decode_nal_sei_active_parameter_sets(s, gb, logctx);
420  return decode_nal_sei_user_data_unregistered(&s->unregistered, gb, size);
422  return decode_nal_sei_alternative_transfer(&s->alternative_transfer, gb);
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) {
437  return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb);
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 {
495  av_buffer_unref(&s->a53_caption.buf_ref);
496 
497  for (int i = 0; i < s->unregistered.nb_buf_ref; i++)
498  av_buffer_unref(&s->unregistered.buf_ref[i]);
499  s->unregistered.nb_buf_ref = 0;
500  av_freep(&s->unregistered.buf_ref);
501  av_buffer_unref(&s->dynamic_hdr_plus.info);
502 }
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
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
#define s(width, name)
Definition: cbs_vp9.c:257
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define av_clip
Definition: common.h:122
#define NULL
Definition: coverity.c:32
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).
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 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
exp golomb vlc stuff
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
@ AV_PICTURE_STRUCTURE_BOTTOM_FIELD
Definition: avcodec.h:3373
@ AV_PICTURE_STRUCTURE_TOP_FIELD
Definition: avcodec.h:3372
@ AV_PICTURE_STRUCTURE_UNKNOWN
Definition: avcodec.h:3371
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_create(uint8_t *data, buffer_size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:29
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_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
AVDynamicHDRPlus * av_dynamic_hdr_plus_alloc(size_t *size)
Copyright (c) 2018 Mohammad Izadi <moh.izadi at gmail.com>
static int decode_nal_sei_alternative_transfer(HEVCSEIAlternativeTransfer *s, GetBitContext *gb)
Definition: hevc_sei.c:345
static int more_rbsp_data(GetBitContext *gb)
Definition: hevc_sei.c:475
static int decode_nal_sei_user_data_unregistered(HEVCSEIUnregistered *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:184
static int decode_registered_user_data_closed_caption(HEVCSEIA53Caption *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:166
static int decode_nal_sei_frame_packing_arrangement(HEVCSEIFramePacking *s, GetBitContext *gb)
Definition: hevc_sei.c:90
static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s, int type, int size)
Definition: hevc_sei.c:432
static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int nal_unit_type)
Definition: hevc_sei.c:445
static int decode_nal_sei_timecode(HEVCSEITimeCode *s, GetBitContext *gb)
Definition: hevc_sei.c:352
int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int type)
Definition: hevc_sei.c:480
static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCSEI *s, GetBitContext *gb, void *logctx, int size)
Definition: hevc_sei.c:238
static int decode_nal_sei_display_orientation(HEVCSEIDisplayOrientation *s, GetBitContext *gb)
Definition: hevc_sei.c:115
void ff_hevc_reset_sei(HEVCSEI *s)
Reset SEI values that are stored on the Context.
Definition: hevc_sei.c:493
static int decode_nal_sei_pic_timing(HEVCSEI *s, GetBitContext *gb, const HEVCParamSets *ps, void *logctx, int size)
Definition: hevc_sei.c:130
static int decode_nal_sei_decoded_picture_hash(HEVCSEIPictureHash *s, GetBitContext *gb)
Definition: hevc_sei.c:31
static int decode_nal_sei_mastering_display_info(HEVCSEIMasteringDisplay *s, GetBitContext *gb)
Definition: hevc_sei.c:55
static int decode_nal_sei_content_light_info(HEVCSEIContentLight *s, GetBitContext *gb)
Definition: hevc_sei.c:78
static int decode_nal_sei_active_parameter_sets(HEVCSEI *s, GetBitContext *gb, void *logctx)
Definition: hevc_sei.c:316
static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int type, int size)
Definition: hevc_sei.c:399
static int decode_registered_user_data_dynamic_hdr_plus(HEVCSEIDynamicHDRPlus *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:210
@ HEVC_SEI_PIC_STRUCT_FRAME_DOUBLING
Definition: hevc_sei.h:31
@ HEVC_SEI_PIC_STRUCT_FRAME_TRIPLING
Definition: hevc_sei.h:32
cl_device_type type
int i
Definition: input.c:407
@ HEVC_NAL_SEI_PREFIX
Definition: hevc.h:68
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:112
@ SEI_TYPE_DECODED_PICTURE_HASH
Definition: sei.h:91
@ SEI_TYPE_PIC_TIMING
Definition: sei.h:31
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
@ SEI_TYPE_ACTIVE_PARAMETER_SETS
Definition: sei.h:87
@ 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_USER_DATA_UNREGISTERED
Definition: sei.h:35
@ SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO
Definition: sei.h:103
@ SEI_TYPE_TIME_CODE
Definition: sei.h:95
@ SEI_TYPE_MASTERING_DISPLAY_COLOUR_VOLUME
Definition: sei.h:96
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
This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...
const uint8_t * buffer
Definition: get_bits.h:62
AVBufferRef * sps_list[HEVC_MAX_SPS_COUNT]
Definition: hevc_ps.h:329
#define av_free(p)
#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