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 <limits.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include "libavutil/common.h"
32 #include "libavutil/error.h"
33 #include "libavutil/log.h"
34 #include "libavutil/mem.h"
35 #include "atsc_a53.h"
36 #include "get_bits.h"
37 #include "golomb.h"
38 #include "h264_ps.h"
39 #include "h264_sei.h"
40 #include "sei.h"
41 
42 #define AVERROR_PS_NOT_FOUND FFERRTAG(0xF8,'?','P','S')
43 
44 static const uint8_t sei_num_clock_ts_table[9] = {
45  1, 1, 1, 2, 2, 3, 3, 2, 3
46 };
47 
49 {
50  h->recovery_point.recovery_frame_cnt = -1;
51 
52  h->picture_timing.dpb_output_delay = 0;
53  h->picture_timing.cpb_removal_delay = -1;
54 
55  h->picture_timing.present = 0;
56  h->buffering_period.present = 0;
57  h->frame_packing.present = 0;
58  h->film_grain_characteristics.present = 0;
59  h->display_orientation.present = 0;
60  h->afd.present = 0;
61 
62  av_buffer_unref(&h->a53_caption.buf_ref);
63  for (int i = 0; i < h->unregistered.nb_buf_ref; i++)
64  av_buffer_unref(&h->unregistered.buf_ref[i]);
65  h->unregistered.nb_buf_ref = 0;
66  av_freep(&h->unregistered.buf_ref);
67 }
68 
70  void *logctx)
71 {
72  GetBitContext gb;
73 
74  init_get_bits(&gb, h->payload, h->payload_size_bits);
75 
76  if (sps->nal_hrd_parameters_present_flag ||
77  sps->vcl_hrd_parameters_present_flag) {
78  h->cpb_removal_delay = get_bits_long(&gb, sps->cpb_removal_delay_length);
79  h->dpb_output_delay = get_bits_long(&gb, sps->dpb_output_delay_length);
80  }
81  if (sps->pic_struct_present_flag) {
82  unsigned int i, num_clock_ts;
83 
84  h->pic_struct = get_bits(&gb, 4);
85  h->ct_type = 0;
86 
87  if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING)
88  return AVERROR_INVALIDDATA;
89 
90  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
91  h->timecode_cnt = 0;
92  for (i = 0; i < num_clock_ts; i++) {
93  if (get_bits(&gb, 1)) { /* clock_timestamp_flag */
94  H264SEITimeCode *tc = &h->timecode[h->timecode_cnt++];
95  unsigned int full_timestamp_flag;
96  unsigned int counting_type, cnt_dropped_flag;
97  h->ct_type |= 1 << get_bits(&gb, 2);
98  skip_bits(&gb, 1); /* nuit_field_based_flag */
99  counting_type = get_bits(&gb, 5); /* counting_type */
100  full_timestamp_flag = get_bits(&gb, 1);
101  skip_bits(&gb, 1); /* discontinuity_flag */
102  cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */
103  if (cnt_dropped_flag && counting_type > 1 && counting_type < 7)
104  tc->dropframe = 1;
105  tc->frame = get_bits(&gb, 8); /* n_frames */
106  if (full_timestamp_flag) {
107  tc->full = 1;
108  tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */
109  tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */
110  tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */
111  } else {
112  tc->seconds = tc->minutes = tc->hours = tc->full = 0;
113  if (get_bits(&gb, 1)) { /* seconds_flag */
114  tc->seconds = get_bits(&gb, 6);
115  if (get_bits(&gb, 1)) { /* minutes_flag */
116  tc->minutes = get_bits(&gb, 6);
117  if (get_bits(&gb, 1)) /* hours_flag */
118  tc->hours = get_bits(&gb, 5);
119  }
120  }
121  }
122 
123  if (sps->time_offset_length > 0)
124  skip_bits(&gb,
125  sps->time_offset_length); /* time_offset */
126  }
127  }
128 
129  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
130  h->ct_type, h->pic_struct);
131  }
132 
133  return 0;
134 }
135 
137  void *logctx)
138 {
139  int index = get_bits_count(gb);
140  int size_bits = get_bits_left(gb);
141  int size = (size_bits + 7) / 8;
142 
143  if (index & 7) {
144  av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n");
145  return AVERROR_INVALIDDATA;
146  }
147  if (size > sizeof(h->payload)) {
148  av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n");
149  return AVERROR_INVALIDDATA;
150  }
151  memcpy(h->payload, gb->buffer + index / 8, size);
152 
153  h->payload_size_bits = size_bits;
154 
155  h->present = 1;
156  return 0;
157 }
158 
160 {
161  int flag;
162 
163  if (size-- < 1)
164  return AVERROR_INVALIDDATA;
165  skip_bits(gb, 1); // 0
166  flag = get_bits(gb, 1); // active_format_flag
167  skip_bits(gb, 6); // reserved
168 
169  if (flag) {
170  if (size-- < 1)
171  return AVERROR_INVALIDDATA;
172  skip_bits(gb, 4); // reserved
173  h->active_format_description = get_bits(gb, 4);
174  h->present = 1;
175  }
176 
177  return 0;
178 }
179 
181  GetBitContext *gb, void *logctx,
182  int size)
183 {
184  if (size < 3)
185  return AVERROR(EINVAL);
186 
187  return ff_parse_a53_cc(&h->buf_ref, gb->buffer + get_bits_count(gb) / 8, size);
188 }
189 
191  void *logctx, int size)
192 {
193  int country_code, provider_code;
194 
195  if (size < 3)
196  return AVERROR_INVALIDDATA;
197  size -= 3;
198 
199  country_code = get_bits(gb, 8); // itu_t_t35_country_code
200  if (country_code == 0xFF) {
201  if (size < 1)
202  return AVERROR_INVALIDDATA;
203 
204  skip_bits(gb, 8); // itu_t_t35_country_code_extension_byte
205  size--;
206  }
207 
208  if (country_code != 0xB5) { // usa_country_code
209  av_log(logctx, AV_LOG_VERBOSE,
210  "Unsupported User Data Registered ITU-T T35 SEI message (country_code = %d)\n",
211  country_code);
212  return 0;
213  }
214 
215  /* itu_t_t35_payload_byte follows */
216  provider_code = get_bits(gb, 16);
217 
218  switch (provider_code) {
219  case 0x31: { // atsc_provider_code
220  uint32_t user_identifier;
221 
222  if (size < 4)
223  return AVERROR_INVALIDDATA;
224  size -= 4;
225 
226  user_identifier = get_bits_long(gb, 32);
227  switch (user_identifier) {
228  case MKBETAG('D', 'T', 'G', '1'): // afd_data
229  return decode_registered_user_data_afd(&h->afd, gb, size);
230  case MKBETAG('G', 'A', '9', '4'): // closed captions
231  return decode_registered_user_data_closed_caption(&h->a53_caption, gb,
232  logctx, size);
233  default:
234  av_log(logctx, AV_LOG_VERBOSE,
235  "Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n",
236  user_identifier);
237  break;
238  }
239  break;
240  }
241  default:
242  av_log(logctx, AV_LOG_VERBOSE,
243  "Unsupported User Data Registered ITU-T T35 SEI message (provider_code = %d)\n",
244  provider_code);
245  break;
246  }
247 
248  return 0;
249 }
250 
252  void *logctx, int size)
253 {
254  uint8_t *user_data;
255  int e, build, i;
256  AVBufferRef *buf_ref, **tmp;
257 
258  if (size < 16 || size >= INT_MAX - 1)
259  return AVERROR_INVALIDDATA;
260 
261  tmp = av_realloc_array(h->buf_ref, h->nb_buf_ref + 1, sizeof(*h->buf_ref));
262  if (!tmp)
263  return AVERROR(ENOMEM);
264  h->buf_ref = tmp;
265 
266  buf_ref = av_buffer_alloc(size + 1);
267  if (!buf_ref)
268  return AVERROR(ENOMEM);
269  user_data = buf_ref->data;
270 
271  for (i = 0; i < size; i++)
272  user_data[i] = get_bits(gb, 8);
273 
274  user_data[i] = 0;
275  buf_ref->size = size;
276  h->buf_ref[h->nb_buf_ref++] = buf_ref;
277 
278  e = sscanf(user_data + 16, "x264 - core %d", &build);
279  if (e == 1 && build > 0)
280  h->x264_build = build;
281  if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
282  h->x264_build = 67;
283 
284  return 0;
285 }
286 
288 {
289  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
290 
291  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
292  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
293  return AVERROR_INVALIDDATA;
294  }
295 
296  h->recovery_frame_cnt = recovery_frame_cnt;
297  /* 1b exact_match_flag,
298  * 1b broken_link_flag,
299  * 2b changing_slice_group_idc */
300  skip_bits(gb, 4);
301 
302  return 0;
303 }
304 
306  const H264ParamSets *ps, void *logctx)
307 {
308  unsigned int sps_id;
309  int sched_sel_idx;
310  const SPS *sps;
311 
312  sps_id = get_ue_golomb_31(gb);
313  if (sps_id > 31 || !ps->sps_list[sps_id]) {
314  av_log(logctx, AV_LOG_ERROR,
315  "non-existing SPS %d referenced in buffering period\n", sps_id);
316  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
317  }
318  sps = (const SPS*)ps->sps_list[sps_id]->data;
319 
320  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
321  if (sps->nal_hrd_parameters_present_flag) {
322  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
323  h->initial_cpb_removal_delay[sched_sel_idx] =
324  get_bits_long(gb, sps->initial_cpb_removal_delay_length);
325  // initial_cpb_removal_delay_offset
326  skip_bits(gb, sps->initial_cpb_removal_delay_length);
327  }
328  }
329  if (sps->vcl_hrd_parameters_present_flag) {
330  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
331  h->initial_cpb_removal_delay[sched_sel_idx] =
332  get_bits_long(gb, sps->initial_cpb_removal_delay_length);
333  // initial_cpb_removal_delay_offset
334  skip_bits(gb, sps->initial_cpb_removal_delay_length);
335  }
336  }
337 
338  h->present = 1;
339  return 0;
340 }
341 
343  GetBitContext *gb)
344 {
345  h->arrangement_id = get_ue_golomb_long(gb);
346  h->arrangement_cancel_flag = get_bits1(gb);
347  h->present = !h->arrangement_cancel_flag;
348 
349  if (h->present) {
350  h->arrangement_type = get_bits(gb, 7);
351  h->quincunx_sampling_flag = get_bits1(gb);
352  h->content_interpretation_type = get_bits(gb, 6);
353 
354  // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
355  skip_bits(gb, 3);
356  h->current_frame_is_frame0_flag = get_bits1(gb);
357  // frame0_self_contained_flag, frame1_self_contained_flag
358  skip_bits(gb, 2);
359 
360  if (!h->quincunx_sampling_flag && h->arrangement_type != 5)
361  skip_bits(gb, 16); // frame[01]_grid_position_[xy]
362  skip_bits(gb, 8); // frame_packing_arrangement_reserved_byte
363  h->arrangement_repetition_period = get_ue_golomb_long(gb);
364  }
365  skip_bits1(gb); // frame_packing_arrangement_extension_flag
366 
367  return 0;
368 }
369 
371  GetBitContext *gb)
372 {
373  h->present = !get_bits1(gb);
374 
375  if (h->present) {
376  h->hflip = get_bits1(gb); // hor_flip
377  h->vflip = get_bits1(gb); // ver_flip
378 
379  h->anticlockwise_rotation = get_bits(gb, 16);
380  get_ue_golomb_long(gb); // display_orientation_repetition_period
381  skip_bits1(gb); // display_orientation_extension_flag
382  }
383 
384  return 0;
385 }
386 
388 {
389  h->green_metadata_type = get_bits(gb, 8);
390 
391  if (h->green_metadata_type == 0) {
392  h->period_type = get_bits(gb, 8);
393 
394  if (h->period_type == 2)
395  h->num_seconds = get_bits(gb, 16);
396  else if (h->period_type == 3)
397  h->num_pictures = get_bits(gb, 16);
398 
399  h->percent_non_zero_macroblocks = get_bits(gb, 8);
400  h->percent_intra_coded_macroblocks = get_bits(gb, 8);
401  h->percent_six_tap_filtering = get_bits(gb, 8);
402  h->percent_alpha_point_deblocking_instance = get_bits(gb, 8);
403 
404  } else if (h->green_metadata_type == 1) {
405  h->xsd_metric_type = get_bits(gb, 8);
406  h->xsd_metric_value = get_bits(gb, 16);
407  }
408 
409  return 0;
410 }
411 
413  GetBitContext *gb)
414 {
415  h->present = 1;
416  h->preferred_transfer_characteristics = get_bits(gb, 8);
417  return 0;
418 }
419 
421  GetBitContext *gb)
422 {
423  h->present = !get_bits1(gb); // film_grain_characteristics_cancel_flag
424 
425  if (h->present) {
426  memset(h, 0, sizeof(*h));
427  h->model_id = get_bits(gb, 8);
428  h->separate_colour_description_present_flag = get_bits1(gb);
429  if (h->separate_colour_description_present_flag) {
430  h->bit_depth_luma = get_bits(gb, 3) + 8;
431  h->bit_depth_chroma = get_bits(gb, 3) + 8;
432  h->full_range = get_bits1(gb);
433  h->color_primaries = get_bits(gb, 8);
434  h->transfer_characteristics = get_bits(gb, 8);
435  h->matrix_coeffs = get_bits(gb, 8);
436  }
437  h->blending_mode_id = get_bits(gb, 2);
438  h->log2_scale_factor = get_bits(gb, 4);
439  for (int c = 0; c < 3; c++)
440  h->comp_model_present_flag[c] = get_bits1(gb);
441  for (int c = 0; c < 3; c++) {
442  if (h->comp_model_present_flag[c]) {
443  h->num_intensity_intervals[c] = get_bits(gb, 8) + 1;
444  h->num_model_values[c] = get_bits(gb, 3) + 1;
445  if (h->num_model_values[c] > 6)
446  return AVERROR_INVALIDDATA;
447  for (int i = 0; i < h->num_intensity_intervals[c]; i++) {
448  h->intensity_interval_lower_bound[c][i] = get_bits(gb, 8);
449  h->intensity_interval_upper_bound[c][i] = get_bits(gb, 8);
450  for (int j = 0; j < h->num_model_values[c]; j++)
451  h->comp_model_value[c][i][j] = get_se_golomb_long(gb);
452  }
453  }
454  }
455  h->repetition_period = get_ue_golomb_long(gb);
456 
457  h->present = 1;
458  }
459 
460  return 0;
461 }
462 
464  const H264ParamSets *ps, void *logctx)
465 {
466  int master_ret = 0;
467 
468  while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
469  GetBitContext gb_payload;
470  int type = 0;
471  unsigned size = 0;
472  int ret = 0;
473 
474  do {
475  if (get_bits_left(gb) < 8)
476  return AVERROR_INVALIDDATA;
477  type += show_bits(gb, 8);
478  } while (get_bits(gb, 8) == 255);
479 
480  do {
481  if (get_bits_left(gb) < 8)
482  return AVERROR_INVALIDDATA;
483  size += show_bits(gb, 8);
484  } while (get_bits(gb, 8) == 255);
485 
486  if (size > get_bits_left(gb) / 8) {
487  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
488  type, 8*size, get_bits_left(gb));
489  return AVERROR_INVALIDDATA;
490  }
491 
492  ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size);
493  if (ret < 0)
494  return ret;
495 
496  switch (type) {
497  case SEI_TYPE_PIC_TIMING: // Picture timing SEI
498  ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx);
499  break;
501  ret = decode_registered_user_data(h, &gb_payload, logctx, size);
502  break;
504  ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size);
505  break;
507  ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
508  break;
510  ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx);
511  break;
513  ret = decode_frame_packing_arrangement(&h->frame_packing, &gb_payload);
514  break;
516  ret = decode_display_orientation(&h->display_orientation, &gb_payload);
517  break;
519  ret = decode_green_metadata(&h->green_metadata, &gb_payload);
520  break;
522  ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload);
523  break;
525  ret = decode_film_grain_characteristics(&h->film_grain_characteristics, &gb_payload);
526  break;
527  default:
528  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
529  }
530  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
531  return ret;
532  if (ret < 0)
533  master_ret = ret;
534 
535  if (get_bits_left(&gb_payload) < 0) {
536  av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n",
537  type, -get_bits_left(&gb_payload));
538  }
539 
540  skip_bits_long(gb, 8 * size);
541  }
542 
543  return master_ret;
544 }
545 
547 {
548  if (h->arrangement_cancel_flag == 0) {
549  switch (h->arrangement_type) {
551  if (h->content_interpretation_type == 2)
552  return "checkerboard_rl";
553  else
554  return "checkerboard_lr";
556  if (h->content_interpretation_type == 2)
557  return "col_interleaved_rl";
558  else
559  return "col_interleaved_lr";
561  if (h->content_interpretation_type == 2)
562  return "row_interleaved_rl";
563  else
564  return "row_interleaved_lr";
566  if (h->content_interpretation_type == 2)
567  return "right_left";
568  else
569  return "left_right";
571  if (h->content_interpretation_type == 2)
572  return "bottom_top";
573  else
574  return "top_bottom";
576  if (h->content_interpretation_type == 2)
577  return "block_rl";
578  else
579  return "block_lr";
581  default:
582  return "mono";
583  }
584  } else if (h->arrangement_cancel_flag == 1) {
585  return "mono";
586  } else {
587  return NULL;
588  }
589 }
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVERROR_PS_NOT_FOUND
#define AVERROR_PS_NOT_FOUND
Definition: h264_sei.c:42
ff_h264_sei_uninit
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:48
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
AVERROR
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
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:296
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
SEI_TYPE_FILM_GRAIN_CHARACTERISTICS
@ SEI_TYPE_FILM_GRAIN_CHARACTERISTICS
Definition: sei.h:49
SEI_TYPE_DISPLAY_ORIENTATION
@ SEI_TYPE_DISPLAY_ORIENTATION
Definition: sei.h:77
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:547
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
index
fg index
Definition: ffmpeg_filter.c:168
H264_SEI_FPA_TYPE_CHECKERBOARD
@ H264_SEI_FPA_TYPE_CHECKERBOARD
Definition: h264_sei.h:46
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS
@ SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS
Definition: sei.h:106
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
H264SEIAFD
Definition: h264_sei.h:102
sei_num_clock_ts_table
static const uint8_t sei_num_clock_ts_table[9]
Definition: h264_sei.c:44
H264SEIA53Caption
Definition: h264_sei.h:107
ff_h264_sei_decode
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:463
GetBitContext
Definition: get_bits.h:62
decode_recovery_point
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:287
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_h264_sei_process_picture_timing
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:69
H264_SEI_FPA_TYPE_SIDE_BY_SIDE
@ H264_SEI_FPA_TYPE_SIDE_BY_SIDE
Definition: h264_sei.h:49
H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
@ H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
Definition: h264_sei.h:51
H264SEIAlternativeTransfer
Definition: h264_sei.h:163
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
H264_SEI_FPA_TYPE_TOP_BOTTOM
@ H264_SEI_FPA_TYPE_TOP_BOTTOM
Definition: h264_sei.h:50
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:204
SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
@ SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35
Definition: sei.h:34
SEI_TYPE_PIC_TIMING
@ SEI_TYPE_PIC_TIMING
Definition: sei.h:31
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
limits.h
H264ParamSets::sps_list
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:144
if
if(ret)
Definition: filter_design.txt:179
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:63
ff_parse_a53_cc
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
NULL
#define NULL
Definition: coverity.c:32
H264SEIContext
Definition: h264_sei.h:189
av_buffer_unref
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
H264SEIUnregistered
Definition: h264_sei.h:111
SPS
Sequence parameter set.
Definition: h264_ps.h:44
decode_registered_user_data_closed_caption
static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:180
sei.h
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
SEI_TYPE_FRAME_PACKING_ARRANGEMENT
@ SEI_TYPE_FRAME_PACKING_ARRANGEMENT
Definition: sei.h:75
H264SEIGreenMetaData
Definition: h264_sei.h:150
H264SEIRecoveryPoint
Definition: h264_sei.h:117
h264_ps.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
error.h
ff_h264_sei_stereo_mode
const char * ff_h264_sei_stereo_mode(const H264SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:546
H264SEIPictureTiming
Definition: h264_sei.h:66
SEI_TYPE_RECOVERY_POINT
@ SEI_TYPE_RECOVERY_POINT
Definition: sei.h:36
decode_film_grain_characteristics
static int decode_film_grain_characteristics(H264SEIFilmGrainCharacteristics *h, GetBitContext *gb)
Definition: h264_sei.c:420
H264SEIFramePacking
Definition: h264_sei.h:133
size
int size
Definition: twinvq_data.h:10344
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
user_data
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
Definition: cbs_mpeg2_syntax_template.c:59
decode_unregistered_user_data
static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:251
decode_registered_user_data
static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb, void *logctx, int size)
Definition: h264_sei.c:190
MAX_LOG2_MAX_FRAME_NUM
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN
@ H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN
Definition: h264_sei.h:47
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:539
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
decode_green_metadata
static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
Definition: h264_sei.c:387
decode_alternative_transfer
static int decode_alternative_transfer(H264SEIAlternativeTransfer *h, GetBitContext *gb)
Definition: h264_sei.c:412
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
H264_SEI_PIC_STRUCT_FRAME_TRIPLING
@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:39
flag
#define flag(name)
Definition: cbs_av1.c:553
h264_sei.h
H264SEIFilmGrainCharacteristics
Definition: h264_sei.h:168
i
int i
Definition: input.c:406
log.h
H264SEITimeCode
Definition: h264_sei.h:55
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
common.h
decode_picture_timing
static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:136
H264SEIBufferingPeriod
Definition: h264_sei.h:128
H264_SEI_FPA_TYPE_INTERLEAVE_ROW
@ H264_SEI_FPA_TYPE_INTERLEAVE_ROW
Definition: h264_sei.h:48
ret
ret
Definition: filter_design.txt:187
atsc_a53.h
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:122
H264ParamSets
Definition: h264_ps.h:143
decode_frame_packing_arrangement
static int decode_frame_packing_arrangement(H264SEIFramePacking *h, GetBitContext *gb)
Definition: h264_sei.c:342
H264SEIDisplayOrientation
Definition: h264_sei.h:144
tc
#define tc
Definition: regdef.h:69
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
get_ue_golomb_long
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
decode_buffering_period
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:305
H264_SEI_FPA_TYPE_2D
@ H264_SEI_FPA_TYPE_2D
Definition: h264_sei.h:52
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
decode_registered_user_data_afd
static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
Definition: h264_sei.c:159
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
SEI_TYPE_GREEN_METADATA
@ SEI_TYPE_GREEN_METADATA
Definition: sei.h:85
decode_display_orientation
static int decode_display_orientation(H264SEIDisplayOrientation *h, GetBitContext *gb)
Definition: h264_sei.c:370
h
h
Definition: vp9dsp_template.c:2038
SEI_TYPE_BUFFERING_PERIOD
@ SEI_TYPE_BUFFERING_PERIOD
Definition: sei.h:30