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 "golomb.h"
26 #include "hevc_ps.h"
27 #include "hevc_sei.h"
28 
30 {
31  int cIdx, i;
32  uint8_t hash_type;
33  //uint16_t picture_crc;
34  //uint32_t picture_checksum;
35  hash_type = get_bits(gb, 8);
36 
37  for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) {
38  if (hash_type == 0) {
39  s->is_md5 = 1;
40  for (i = 0; i < 16; i++)
41  s->md5[cIdx][i] = get_bits(gb, 8);
42  } else if (hash_type == 1) {
43  // picture_crc = get_bits(gb, 16);
44  skip_bits(gb, 16);
45  } else if (hash_type == 2) {
46  // picture_checksum = get_bits_long(gb, 32);
47  skip_bits(gb, 32);
48  }
49  }
50  return 0;
51 }
52 
54 {
55  int i;
56  // Mastering primaries
57  for (i = 0; i < 3; i++) {
58  s->display_primaries[i][0] = get_bits(gb, 16);
59  s->display_primaries[i][1] = get_bits(gb, 16);
60  }
61  // White point (x, y)
62  s->white_point[0] = get_bits(gb, 16);
63  s->white_point[1] = get_bits(gb, 16);
64 
65  // Max and min luminance of mastering display
66  s->max_luminance = get_bits_long(gb, 32);
67  s->min_luminance = get_bits_long(gb, 32);
68 
69  // As this SEI message comes before the first frame that references it,
70  // initialize the flag to 2 and decrement on IRAP access unit so it
71  // persists for the coded video sequence (e.g., between two IRAPs)
72  s->present = 2;
73  return 0;
74 }
75 
77 {
78  // Max and average light levels
79  s->max_content_light_level = get_bits(gb, 16);
81  // As this SEI message comes before the first frame that references it,
82  // initialize the flag to 2 and decrement on IRAP access unit so it
83  // persists for the coded video sequence (e.g., between two IRAPs)
84  s->present = 2;
85  return 0;
86 }
87 
89 {
90  get_ue_golomb_long(gb); // frame_packing_arrangement_id
91  s->present = !get_bits1(gb);
92 
93  if (s->present) {
94  s->arrangement_type = get_bits(gb, 7);
97 
98  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
99  skip_bits(gb, 3);
101  // frame0_self_contained_flag, frame1_self_contained_flag
102  skip_bits(gb, 2);
103 
104  if (!s->quincunx_subsampling && s->arrangement_type != 5)
105  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
106  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
107  skip_bits1(gb); // frame_packing_arrangement_persistence_flag
108  }
109  skip_bits1(gb); // upsampled_aspect_ratio_flag
110  return 0;
111 }
112 
114 {
115  s->present = !get_bits1(gb);
116 
117  if (s->present) {
118  s->hflip = get_bits1(gb); // hor_flip
119  s->vflip = get_bits1(gb); // ver_flip
120 
121  s->anticlockwise_rotation = get_bits(gb, 16);
122  skip_bits1(gb); // display_orientation_persistence_flag
123  }
124 
125  return 0;
126 }
127 
129  void *logctx, int size)
130 {
132  HEVCSPS *sps;
133 
135  return(AVERROR(ENOMEM));
137 
139  int pic_struct = get_bits(gb, 4);
141  if (pic_struct == 2 || pic_struct == 10 || pic_struct == 12) {
142  av_log(logctx, AV_LOG_DEBUG, "BOTTOM Field\n");
144  } else if (pic_struct == 1 || pic_struct == 9 || pic_struct == 11) {
145  av_log(logctx, AV_LOG_DEBUG, "TOP Field\n");
147  } else if (pic_struct == 7) {
148  av_log(logctx, AV_LOG_DEBUG, "Frame/Field Doubling\n");
150  } else if (pic_struct == 8) {
151  av_log(logctx, AV_LOG_DEBUG, "Frame/Field Tripling\n");
153  }
154  get_bits(gb, 2); // source_scan_type
155  get_bits(gb, 1); // duplicate_flag
156  skip_bits1(gb);
157  size--;
158  }
159  skip_bits_long(gb, 8 * size);
160 
161  return 0;
162 }
163 
165  int size)
166 {
167  int flag;
168  int user_data_type_code;
169  int cc_count;
170 
171  if (size < 3)
172  return AVERROR(EINVAL);
173 
174  user_data_type_code = get_bits(gb, 8);
175  if (user_data_type_code == 0x3) {
176  skip_bits(gb, 1); // reserved
177 
178  flag = get_bits(gb, 1); // process_cc_data_flag
179  if (flag) {
180  skip_bits(gb, 1);
181  cc_count = get_bits(gb, 5);
182  skip_bits(gb, 8); // reserved
183  size -= 2;
184 
185  if (cc_count && size >= cc_count * 3) {
186  int old_size = s->buf_ref ? s->buf_ref->size : 0;
187  const uint64_t new_size = (old_size + cc_count
188  * UINT64_C(3));
189  int i, ret;
190 
191  if (new_size > INT_MAX)
192  return AVERROR(EINVAL);
193 
194  /* Allow merging of the cc data from two fields. */
195  ret = av_buffer_realloc(&s->buf_ref, new_size);
196  if (ret < 0)
197  return ret;
198 
199  for (i = 0; i < cc_count; i++) {
200  s->buf_ref->data[old_size++] = get_bits(gb, 8);
201  s->buf_ref->data[old_size++] = get_bits(gb, 8);
202  s->buf_ref->data[old_size++] = get_bits(gb, 8);
203  }
204  skip_bits(gb, 8); // marker_bits
205  }
206  }
207  } else {
208  int i;
209  for (i = 0; i < size - 1; i++)
210  skip_bits(gb, 8);
211  }
212 
213  return 0;
214 }
215 
217  int size)
218 {
219  AVBufferRef *buf_ref, **tmp;
220 
221  if (size < 16 || size >= INT_MAX - 1)
222  return AVERROR_INVALIDDATA;
223 
224  tmp = av_realloc_array(s->buf_ref, s->nb_buf_ref + 1, sizeof(*s->buf_ref));
225  if (!tmp)
226  return AVERROR(ENOMEM);
227  s->buf_ref = tmp;
228 
229  buf_ref = av_buffer_alloc(size + 1);
230  if (!buf_ref)
231  return AVERROR(ENOMEM);
232 
233  for (int i = 0; i < size; i++)
234  buf_ref->data[i] = get_bits(gb, 8);
235  buf_ref->data[size] = 0;
236  buf_ref->size = size;
237  s->buf_ref[s->nb_buf_ref++] = buf_ref;
238 
239  return 0;
240 }
241 
243  int size)
244 {
245  uint32_t country_code;
246  uint32_t user_identifier;
247 
248  if (size < 7)
249  return AVERROR(EINVAL);
250  size -= 7;
251 
252  country_code = get_bits(gb, 8);
253  if (country_code == 0xFF) {
254  skip_bits(gb, 8);
255  size--;
256  }
257 
258  skip_bits(gb, 8);
259  skip_bits(gb, 8);
260 
261  user_identifier = get_bits_long(gb, 32);
262 
263  switch (user_identifier) {
264  case MKBETAG('G', 'A', '9', '4'):
266  default:
267  skip_bits_long(gb, size * 8);
268  break;
269  }
270  return 0;
271 }
272 
274 {
275  int num_sps_ids_minus1;
276  int i;
277  unsigned active_seq_parameter_set_id;
278 
279  get_bits(gb, 4); // active_video_parameter_set_id
280  get_bits(gb, 1); // self_contained_cvs_flag
281  get_bits(gb, 1); // num_sps_ids_minus1
282  num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1
283 
284  if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) {
285  av_log(logctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1);
286  return AVERROR_INVALIDDATA;
287  }
288 
289  active_seq_parameter_set_id = get_ue_golomb_long(gb);
290  if (active_seq_parameter_set_id >= HEVC_MAX_SPS_COUNT) {
291  av_log(logctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id);
292  return AVERROR_INVALIDDATA;
293  }
294  s->active_seq_parameter_set_id = active_seq_parameter_set_id;
295 
296  for (i = 1; i <= num_sps_ids_minus1; i++)
297  get_ue_golomb_long(gb); // active_seq_parameter_set_id[i]
298 
299  return 0;
300 }
301 
303 {
304  s->present = 1;
306  return 0;
307 }
308 
310 {
311  s->num_clock_ts = get_bits(gb, 2);
312 
313  for (int i = 0; i < s->num_clock_ts; i++) {
314  s->clock_timestamp_flag[i] = get_bits(gb, 1);
315 
316  if (s->clock_timestamp_flag[i]) {
317  s->units_field_based_flag[i] = get_bits(gb, 1);
318  s->counting_type[i] = get_bits(gb, 5);
319  s->full_timestamp_flag[i] = get_bits(gb, 1);
320  s->discontinuity_flag[i] = get_bits(gb, 1);
321  s->cnt_dropped_flag[i] = get_bits(gb, 1);
322 
323  s->n_frames[i] = get_bits(gb, 9);
324 
325  if (s->full_timestamp_flag[i]) {
326  s->seconds_value[i] = av_clip(get_bits(gb, 6), 0, 59);
327  s->minutes_value[i] = av_clip(get_bits(gb, 6), 0, 59);
328  s->hours_value[i] = av_clip(get_bits(gb, 5), 0, 23);
329  } else {
330  s->seconds_flag[i] = get_bits(gb, 1);
331  if (s->seconds_flag[i]) {
332  s->seconds_value[i] = av_clip(get_bits(gb, 6), 0, 59);
333  s->minutes_flag[i] = get_bits(gb, 1);
334  if (s->minutes_flag[i]) {
335  s->minutes_value[i] = av_clip(get_bits(gb, 6), 0, 59);
336  s->hours_flag[i] = get_bits(gb, 1);
337  if (s->hours_flag[i]) {
338  s->hours_value[i] = av_clip(get_bits(gb, 5), 0, 23);
339  }
340  }
341  }
342  }
343 
344  s->time_offset_length[i] = get_bits(gb, 5);
345  if (s->time_offset_length[i] > 0) {
347  }
348  }
349  }
350 
351  s->present = 1;
352  return 0;
353 }
354 
355 
356 static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s,
357  const HEVCParamSets *ps, int type, int size)
358 {
359  switch (type) {
360  case 256: // Mismatched value from HM 8.1
367  return decode_nal_sei_pic_timing(s, gb, ps, logctx, size);
373  return decode_nal_sei_active_parameter_sets(s, gb, logctx);
381  return decode_nal_sei_timecode(&s->timecode, gb);
382  default:
383  av_log(logctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
384  skip_bits_long(gb, 8 * size);
385  return 0;
386  }
387 }
388 
389 static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s,
390  int type, int size)
391 {
392  switch (type) {
395  default:
396  av_log(logctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type);
397  skip_bits_long(gb, 8 * size);
398  return 0;
399  }
400 }
401 
402 static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s,
403  const HEVCParamSets *ps, int nal_unit_type)
404 {
405  int payload_type = 0;
406  int payload_size = 0;
407  int byte = 0xFF;
408  av_log(logctx, AV_LOG_DEBUG, "Decoding SEI\n");
409 
410  while (byte == 0xFF) {
411  if (get_bits_left(gb) < 16 || payload_type > INT_MAX - 255)
412  return AVERROR_INVALIDDATA;
413  byte = get_bits(gb, 8);
414  payload_type += byte;
415  }
416  byte = 0xFF;
417  while (byte == 0xFF) {
418  if (get_bits_left(gb) < 8 + 8LL*payload_size)
419  return AVERROR_INVALIDDATA;
420  byte = get_bits(gb, 8);
421  payload_size += byte;
422  }
423  if (nal_unit_type == HEVC_NAL_SEI_PREFIX) {
424  return decode_nal_sei_prefix(gb, logctx, s, ps, payload_type, payload_size);
425  } else { /* nal_unit_type == NAL_SEI_SUFFIX */
426  return decode_nal_sei_suffix(gb, logctx, s, payload_type, payload_size);
427  }
428 }
429 
431 {
432  return get_bits_left(gb) > 0 && show_bits(gb, 8) != 0x80;
433 }
434 
436  const HEVCParamSets *ps, int type)
437 {
438  int ret;
439 
440  do {
441  ret = decode_nal_sei_message(gb, logctx, s, ps, type);
442  if (ret < 0)
443  return ret;
444  } while (more_rbsp_data(gb));
445  return 1;
446 }
447 
449 {
451 
452  for (int i = 0; i < s->unregistered.nb_buf_ref; i++)
454  s->unregistered.nb_buf_ref = 0;
456 }
static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s, int type, int size)
Definition: hevc_sei.c:389
#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:77
AVBufferRef * buf_ref
Definition: hevc_sei.h:91
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
uint8_t hours_flag[3]
Definition: hevc_sei.h:133
static int decode_nal_sei_display_orientation(HEVCSEIDisplayOrientation *s, GetBitContext *gb)
Definition: hevc_sei.c:113
GLint GLenum type
Definition: opengl_enc.c:104
uint8_t counting_type[3]
Definition: hevc_sei.h:123
uint8_t clock_timestamp_flag[3]
Definition: hevc_sei.h:121
uint8_t is_md5
Definition: hevc_sei.h:69
uint8_t minutes_flag[3]
Definition: hevc_sei.h:132
static int more_rbsp_data(GetBitContext *gb)
Definition: hevc_sei.c:430
HEVCSEIMasteringDisplay mastering_display
Definition: hevc_sei.h:145
uint8_t seconds_flag[3]
Definition: hevc_sei.h:131
uint8_t discontinuity_flag[3]
Definition: hevc_sei.h:125
uint8_t cnt_dropped_flag[3]
Definition: hevc_sei.h:126
static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int nal_unit_type)
Definition: hevc_sei.c:402
AVBufferRef * sps_list[HEVC_MAX_SPS_COUNT]
Definition: hevc_ps.h:329
HEVCSEIContentLight content_light
Definition: hevc_sei.h:146
uint8_t
static int decode_nal_sei_alternative_transfer(HEVCSEIAlternativeTransfer *s, GetBitContext *gb)
Definition: hevc_sei.c:302
int active_seq_parameter_set_id
Definition: hevc_sei.h:147
int frame_field_info_present_flag
Definition: hevc_ps.h:69
HEVCSEIUnregistered unregistered
Definition: hevc_sei.h:144
int quincunx_subsampling
Definition: hevc_sei.h:76
ptrdiff_t size
Definition: opengl_enc.c:100
uint8_t time_offset_length[3]
Definition: hevc_sei.h:134
static int decode_nal_sei_content_light_info(HEVCSEIContentLight *s, GetBitContext *gb)
Definition: hevc_sei.c:76
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:130
uint16_t n_frames[3]
Definition: hevc_sei.h:127
#define av_log(a,...)
static int decode_registered_user_data_closed_caption(HEVCSEIA53Caption *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:164
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
int32_t time_offset_value[3]
Definition: hevc_sei.h:135
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int content_interpretation_type
Definition: hevc_sei.h:75
uint8_t md5[3][16]
Definition: hevc_sei.h:68
static int decode_nal_sei_active_parameter_sets(HEVCSEI *s, GetBitContext *gb, void *logctx)
Definition: hevc_sei.c:273
AVBufferRef ** buf_ref
Definition: hevc_sei.h:95
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
uint8_t units_field_based_flag[3]
Definition: hevc_sei.h:122
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
Definition: buffer.c:169
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:216
if(ret)
uint8_t full_timestamp_flag[3]
Definition: hevc_sei.h:124
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
void ff_hevc_reset_sei(HEVCSEI *s)
Reset SEI values that are stored on the Context.
Definition: hevc_sei.c:448
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:87
static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCSEI *s, GetBitContext *gb, int size)
Definition: hevc_sei.c:242
uint8_t * data
The data buffer.
Definition: buffer.h:89
static int decode_nal_sei_timecode(HEVCSEITimeCode *s, GetBitContext *gb)
Definition: hevc_sei.c:309
uint8_t minutes_value[3]
Definition: hevc_sei.h:129
static int decode_nal_sei_frame_packing_arrangement(HEVCSEIFramePacking *s, GetBitContext *gb)
Definition: hevc_sei.c:88
HEVCSEIFramePacking frame_packing
Definition: hevc_sei.h:140
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:110
uint8_t num_clock_ts
Definition: hevc_sei.h:120
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
HEVCSEIPictureHash picture_hash
Definition: hevc_sei.h:139
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:29
HEVCSEIPictureTiming picture_timing
Definition: hevc_sei.h:142
static int decode_nal_sei_pic_timing(HEVCSEI *s, GetBitContext *gb, const HEVCParamSets *ps, void *logctx, int size)
Definition: hevc_sei.c:128
A reference to a data buffer.
Definition: buffer.h:81
#define flag(name)
Definition: cbs_av1.c:552
HEVCSEIAlternativeTransfer alternative_transfer
Definition: hevc_sei.h:148
HEVCSEIDisplayOrientation display_orientation
Definition: hevc_sei.h:141
uint16_t max_content_light_level
Definition: hevc_sei.h:109
#define MKBETAG(a, b, c, d)
Definition: common.h:407
static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int type, int size)
Definition: hevc_sei.c:356
HEVCSEITimeCode timecode
Definition: hevc_sei.h:149
uint8_t seconds_value[3]
Definition: hevc_sei.h:128
static int decode_nal_sei_mastering_display_info(HEVCSEIMasteringDisplay *s, GetBitContext *gb)
Definition: hevc_sei.c:53
HEVCSEIA53Caption a53_caption
Definition: hevc_sei.h:143
#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:102
int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, int type)
Definition: hevc_sei.c:435
int i
Definition: input.c:406
uint16_t display_primaries[3][2]
Definition: hevc_sei.h:101
static uint8_t tmp[11]
Definition: aes_ctr.c:26