FFmpeg
h264_metadata_bsf.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/avstring.h"
20 #include "libavutil/display.h"
21 #include "libavutil/common.h"
22 #include "libavutil/opt.h"
23 
24 #include "bsf.h"
25 #include "cbs.h"
26 #include "cbs_bsf.h"
27 #include "cbs_h264.h"
28 #include "h264.h"
29 #include "h264_levels.h"
30 #include "h264_sei.h"
31 
32 enum {
35 };
36 
37 enum {
39  LEVEL_AUTO = -1,
40 };
41 
42 typedef struct H264MetadataContext {
44 
46 
47  int aud;
49 
51 
53 
59 
61 
65 
66  int crop_left;
68  int crop_top;
70 
71  const char *sei_user_data;
73 
75 
77  double rotate;
78  int flip;
80 
81  int level;
83 
84 
87 {
89  int primary_pic_type_mask = 0xff;
90  int err, i, j;
91 
92  static const int primary_pic_type_table[] = {
93  0x084, // 2, 7
94  0x0a5, // 0, 2, 5, 7
95  0x0e7, // 0, 1, 2, 5, 6, 7
96  0x210, // 4, 9
97  0x318, // 3, 4, 8, 9
98  0x294, // 2, 4, 7, 9
99  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
100  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
101  };
102 
103  for (i = 0; i < au->nb_units; i++) {
104  if (au->units[i].type == H264_NAL_SLICE ||
105  au->units[i].type == H264_NAL_IDR_SLICE) {
106  H264RawSlice *slice = au->units[i].content;
107  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
108  if (!(primary_pic_type_table[j] &
109  (1 << slice->header.slice_type)))
110  primary_pic_type_mask &= ~(1 << j);
111  }
112  }
113  }
114  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
115  if (primary_pic_type_mask & (1 << j))
116  break;
117  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
118  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
119  "invalid slice types?\n");
120  return AVERROR_INVALIDDATA;
121  }
122 
123  ctx->aud_nal = (H264RawAUD) {
124  .nal_unit_header.nal_unit_type = H264_NAL_AUD,
125  .primary_pic_type = j,
126  };
127 
129  &ctx->aud_nal, NULL);
130  if (err < 0) {
131  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
132  return err;
133  }
134 
135  return 0;
136 }
137 
139  H264RawSPS *sps)
140 {
142  int need_vui = 0;
143  int crop_unit_x, crop_unit_y;
144 
145  if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
146  // Table E-1.
147  static const AVRational sar_idc[] = {
148  { 0, 0 }, // Unspecified (never written here).
149  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
150  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
151  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
152  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
153  };
154  int num, den, i;
155 
156  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
157  ctx->sample_aspect_ratio.den, 65535);
158 
159  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
160  if (num == sar_idc[i].num &&
161  den == sar_idc[i].den)
162  break;
163  }
164  if (i == FF_ARRAY_ELEMS(sar_idc)) {
165  sps->vui.aspect_ratio_idc = 255;
166  sps->vui.sar_width = num;
167  sps->vui.sar_height = den;
168  } else {
169  sps->vui.aspect_ratio_idc = i;
170  }
171  sps->vui.aspect_ratio_info_present_flag = 1;
172  need_vui = 1;
173  }
174 
175 #define SET_VUI_FIELD(field) do { \
176  if (ctx->field >= 0) { \
177  sps->vui.field = ctx->field; \
178  need_vui = 1; \
179  } \
180  } while (0)
181 
182  if (ctx->overscan_appropriate_flag >= 0) {
183  SET_VUI_FIELD(overscan_appropriate_flag);
184  sps->vui.overscan_info_present_flag = 1;
185  }
186 
187  if (ctx->video_format >= 0 ||
188  ctx->video_full_range_flag >= 0 ||
189  ctx->colour_primaries >= 0 ||
190  ctx->transfer_characteristics >= 0 ||
191  ctx->matrix_coefficients >= 0) {
192 
193  SET_VUI_FIELD(video_format);
194 
195  SET_VUI_FIELD(video_full_range_flag);
196 
197  if (ctx->colour_primaries >= 0 ||
198  ctx->transfer_characteristics >= 0 ||
199  ctx->matrix_coefficients >= 0) {
200 
201  SET_VUI_FIELD(colour_primaries);
203  SET_VUI_FIELD(matrix_coefficients);
204 
205  sps->vui.colour_description_present_flag = 1;
206  }
207  sps->vui.video_signal_type_present_flag = 1;
208  }
209 
210  if (ctx->chroma_sample_loc_type >= 0) {
211  sps->vui.chroma_sample_loc_type_top_field =
212  ctx->chroma_sample_loc_type;
213  sps->vui.chroma_sample_loc_type_bottom_field =
214  ctx->chroma_sample_loc_type;
215  sps->vui.chroma_loc_info_present_flag = 1;
216  need_vui = 1;
217  }
218 
219  if (ctx->tick_rate.num && ctx->tick_rate.den) {
220  int num, den;
221 
222  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
223  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
224 
225  sps->vui.time_scale = num;
226  sps->vui.num_units_in_tick = den;
227 
228  sps->vui.timing_info_present_flag = 1;
229  need_vui = 1;
230  }
231  SET_VUI_FIELD(fixed_frame_rate_flag);
232  if (ctx->zero_new_constraint_set_flags) {
233  sps->constraint_set4_flag = 0;
234  sps->constraint_set5_flag = 0;
235  }
236 
237  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
238  crop_unit_x = 1;
239  crop_unit_y = 2 - sps->frame_mbs_only_flag;
240  } else {
241  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
242  crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
243  (2 - sps->frame_mbs_only_flag);
244  }
245 #define CROP(border, unit) do { \
246  if (ctx->crop_ ## border >= 0) { \
247  if (ctx->crop_ ## border % unit != 0) { \
248  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
249  "must be a multiple of %d.\n", #border, unit); \
250  return AVERROR(EINVAL); \
251  } \
252  sps->frame_crop_ ## border ## _offset = \
253  ctx->crop_ ## border / unit; \
254  sps->frame_cropping_flag = 1; \
255  } \
256  } while (0)
257  CROP(left, crop_unit_x);
258  CROP(right, crop_unit_x);
259  CROP(top, crop_unit_y);
260  CROP(bottom, crop_unit_y);
261 #undef CROP
262 
263  if (ctx->level != LEVEL_UNSET) {
264  int level_idc;
265 
266  if (ctx->level == LEVEL_AUTO) {
267  const H264LevelDescriptor *desc;
268  int64_t bit_rate;
269  int width, height, dpb_frames;
270  int framerate;
271 
272  if (sps->vui.nal_hrd_parameters_present_flag) {
273  bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
274  (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
275  } else if (sps->vui.vcl_hrd_parameters_present_flag) {
276  bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
277  (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
278  // Adjust for VCL vs. NAL limits.
279  bit_rate = bit_rate * 6 / 5;
280  } else {
281  bit_rate = 0;
282  }
283 
284  // Don't use max_dec_frame_buffering if it is only inferred.
285  dpb_frames = sps->vui.bitstream_restriction_flag ?
286  sps->vui.max_dec_frame_buffering : H264_MAX_DPB_FRAMES;
287 
288  width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
289  height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
290  (2 - sps->frame_mbs_only_flag);
291 
292  if (sps->vui.timing_info_present_flag)
293  framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;
294  else
295  framerate = 0;
296 
297  desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,
299  if (desc) {
300  level_idc = desc->level_idc;
301  } else {
302  av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
303  "conform to any level: using level 6.2.\n");
304  level_idc = 62;
305  }
306  } else {
307  level_idc = ctx->level;
308  }
309 
310  if (level_idc == 9) {
311  if (sps->profile_idc == 66 ||
312  sps->profile_idc == 77 ||
313  sps->profile_idc == 88) {
314  sps->level_idc = 11;
315  sps->constraint_set3_flag = 1;
316  } else {
317  sps->level_idc = 9;
318  }
319  } else {
320  sps->level_idc = level_idc;
321  }
322  }
323 
324  if (need_vui)
325  sps->vui_parameters_present_flag = 1;
326 
327  return 0;
328 }
329 
331  AVPacket *pkt,
333  int seek_point)
334 {
337  int err;
338 
339  message = NULL;
340  while (ff_cbs_sei_find_message(ctx->common.output, au,
342  &message) == 0) {
343  H264RawSEIDisplayOrientation *disp = message->payload;
344  int32_t *matrix;
345 
346  matrix = av_malloc(9 * sizeof(int32_t));
347  if (!matrix)
348  return AVERROR(ENOMEM);
349 
351  disp->anticlockwise_rotation *
352  180.0 / 65536.0);
353  av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
354 
355  // If there are multiple display orientation messages in an
356  // access unit, then the last one added to the packet (i.e.
357  // the first one in the access unit) will prevail.
359  (uint8_t*)matrix,
360  9 * sizeof(int32_t));
361  if (err < 0) {
362  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
363  "displaymatrix side data to packet.\n");
364  av_free(matrix);
365  return AVERROR(ENOMEM);
366  }
367  }
368 
369  if (ctx->display_orientation == BSF_ELEMENT_REMOVE ||
370  ctx->display_orientation == BSF_ELEMENT_INSERT) {
371  ff_cbs_sei_delete_message_type(ctx->common.output, au,
373  }
374 
375  if (ctx->display_orientation == BSF_ELEMENT_INSERT) {
377  &ctx->display_orientation_payload;
378  uint8_t *data;
379  size_t size;
380  int write = 0;
381 
383  if (data && size >= 9 * sizeof(int32_t)) {
384  int32_t matrix[9];
385  double dmatrix[9];
386  int hflip, vflip, i;
387  double scale_x, scale_y, angle;
388 
389  memcpy(matrix, data, sizeof(matrix));
390 
391  for (i = 0; i < 9; i++)
392  dmatrix[i] = matrix[i] / 65536.0;
393 
394  // Extract scale factors.
395  scale_x = hypot(dmatrix[0], dmatrix[3]);
396  scale_y = hypot(dmatrix[1], dmatrix[4]);
397 
398  // Select flips to make the main diagonal positive.
399  hflip = dmatrix[0] < 0.0;
400  vflip = dmatrix[4] < 0.0;
401  if (hflip)
402  scale_x = -scale_x;
403  if (vflip)
404  scale_y = -scale_y;
405 
406  // Rescale.
407  for (i = 0; i < 9; i += 3) {
408  dmatrix[i] /= scale_x;
409  dmatrix[i + 1] /= scale_y;
410  }
411 
412  // Extract rotation.
413  angle = atan2(dmatrix[3], dmatrix[0]);
414 
415  if (!(angle >= -M_PI && angle <= M_PI) ||
416  matrix[2] != 0.0 || matrix[5] != 0.0 ||
417  matrix[6] != 0.0 || matrix[7] != 0.0) {
418  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
419  "representable in H.264 parameters.\n");
420  } else {
421  disp->hor_flip = hflip;
422  disp->ver_flip = vflip;
423  disp->anticlockwise_rotation =
424  (uint16_t)rint((angle >= 0.0 ? angle
425  : angle + 2 * M_PI) *
426  32768.0 / M_PI);
427  write = 1;
428  }
429  }
430 
431  if (seek_point) {
432  if (!isnan(ctx->rotate)) {
433  disp->anticlockwise_rotation =
434  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
435  : ctx->rotate + 360.0) *
436  65536.0 / 360.0);
437  write = 1;
438  }
439  if (ctx->flip) {
440  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
441  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
442  write = 1;
443  }
444  }
445 
446  if (write) {
448 
449  err = ff_cbs_sei_add_message(ctx->common.output, au, 1,
451  disp, NULL);
452  if (err < 0) {
453  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
454  "SEI message to access unit.\n");
455  return err;
456  }
457  }
458  }
459 
460  return 0;
461 }
462 
465 {
467  int err, i, has_sps, seek_point;
468 
469  // If an AUD is present, it must be the first NAL unit.
470  if (au->nb_units && au->units[0].type == H264_NAL_AUD) {
471  if (ctx->aud == BSF_ELEMENT_REMOVE)
472  ff_cbs_delete_unit(au, 0);
473  } else {
474  if (pkt && ctx->aud == BSF_ELEMENT_INSERT) {
475  err = h264_metadata_insert_aud(bsf, au);
476  if (err < 0)
477  return err;
478  }
479  }
480 
481  has_sps = 0;
482  for (i = 0; i < au->nb_units; i++) {
483  if (au->units[i].type == H264_NAL_SPS) {
484  err = h264_metadata_update_sps(bsf, au->units[i].content);
485  if (err < 0)
486  return err;
487  has_sps = 1;
488  }
489  }
490 
491  if (pkt) {
492  // The current packet should be treated as a seek point for metadata
493  // insertion if any of:
494  // - It is the first packet in the stream.
495  // - It contains an SPS, indicating that a sequence might start here.
496  // - It is marked as containing a key frame.
497  seek_point = !ctx->done_first_au || has_sps ||
499  } else {
500  seek_point = 0;
501  }
502 
503  if (ctx->sei_user_data && seek_point) {
504  err = ff_cbs_sei_add_message(ctx->common.output, au, 1,
506  &ctx->sei_user_data_payload, NULL);
507  if (err < 0) {
508  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
509  "message to access unit.\n");
510  return err;
511  }
512  }
513 
514  if (ctx->delete_filler) {
515  for (i = au->nb_units - 1; i >= 0; i--) {
516  if (au->units[i].type == H264_NAL_FILLER_DATA) {
517  ff_cbs_delete_unit(au, i);
518  continue;
519  }
520  }
521 
522  ff_cbs_sei_delete_message_type(ctx->common.output, au,
524  }
525 
526  if (pkt && ctx->display_orientation != BSF_ELEMENT_PASS) {
528  seek_point);
529  if (err < 0)
530  return err;
531  }
532 
533  if (pkt)
534  ctx->done_first_au = 1;
535 
536  return 0;
537 }
538 
541  .fragment_name = "access unit",
542  .unit_name = "NAL unit",
543  .update_fragment = &h264_metadata_update_fragment,
544 };
545 
547 {
549 
550  if (ctx->sei_user_data) {
551  SEIRawUserDataUnregistered *udu = &ctx->sei_user_data_payload;
552  int i, j;
553 
554  // Parse UUID. It must be a hex string of length 32, possibly
555  // containing '-'s between hex digits (which we ignore).
556  for (i = j = 0; j < 32 && i < 64 && ctx->sei_user_data[i]; i++) {
557  int c, v;
558  c = ctx->sei_user_data[i];
559  if (c == '-') {
560  continue;
561  } else if (av_isxdigit(c)) {
562  c = av_tolower(c);
563  v = (c <= '9' ? c - '0' : c - 'a' + 10);
564  } else {
565  break;
566  }
567  if (j & 1)
568  udu->uuid_iso_iec_11578[j / 2] |= v;
569  else
570  udu->uuid_iso_iec_11578[j / 2] = v << 4;
571  ++j;
572  }
573  if (j == 32 && ctx->sei_user_data[i] == '+') {
574  udu->data = (uint8_t*)ctx->sei_user_data + i + 1;
575  udu->data_length = strlen(udu->data) + 1;
576  } else {
577  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
578  "must be \"UUID+string\".\n");
579  return AVERROR(EINVAL);
580  }
581  }
582 
584 }
585 
586 #define OFFSET(x) offsetof(H264MetadataContext, x)
587 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
588 static const AVOption h264_metadata_options[] = {
589  BSF_ELEMENT_OPTIONS_PIR("aud", "Access Unit Delimiter NAL units",
590  aud, FLAGS),
591 
592  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
593  OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
594  { .dbl = 0.0 }, 0, 65535, FLAGS },
595 
596  { "overscan_appropriate_flag", "Set VUI overscan appropriate flag",
597  OFFSET(overscan_appropriate_flag), AV_OPT_TYPE_INT,
598  { .i64 = -1 }, -1, 1, FLAGS },
599 
600  { "video_format", "Set video format (table E-2)",
601  OFFSET(video_format), AV_OPT_TYPE_INT,
602  { .i64 = -1 }, -1, 7, FLAGS},
603  { "video_full_range_flag", "Set video full range flag",
604  OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
605  { .i64 = -1 }, -1, 1, FLAGS },
606  { "colour_primaries", "Set colour primaries (table E-3)",
607  OFFSET(colour_primaries), AV_OPT_TYPE_INT,
608  { .i64 = -1 }, -1, 255, FLAGS },
609  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
611  { .i64 = -1 }, -1, 255, FLAGS },
612  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
613  OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
614  { .i64 = -1 }, -1, 255, FLAGS },
615 
616  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
617  OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
618  { .i64 = -1 }, -1, 6, FLAGS },
619 
620  { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
621  OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
622  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
623  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
624  OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
625  { .i64 = -1 }, -1, 1, FLAGS },
626  { "zero_new_constraint_set_flags", "Set constraint_set4_flag / constraint_set5_flag to zero",
627  OFFSET(zero_new_constraint_set_flags), AV_OPT_TYPE_BOOL,
628  { .i64 = 0 }, 0, 1, FLAGS },
629 
630  { "crop_left", "Set left border crop offset",
631  OFFSET(crop_left), AV_OPT_TYPE_INT,
632  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
633  { "crop_right", "Set right border crop offset",
634  OFFSET(crop_right), AV_OPT_TYPE_INT,
635  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
636  { "crop_top", "Set top border crop offset",
637  OFFSET(crop_top), AV_OPT_TYPE_INT,
638  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
639  { "crop_bottom", "Set bottom border crop offset",
640  OFFSET(crop_bottom), AV_OPT_TYPE_INT,
641  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
642 
643  { "sei_user_data", "Insert SEI user data (UUID+string)",
644  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
645 
646  { "delete_filler", "Delete all filler (both NAL and SEI)",
647  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
648 
649  BSF_ELEMENT_OPTIONS_PIRE("display_orientation",
650  "Display orientation SEI",
651  display_orientation, FLAGS),
652 
653  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
655  { .dbl = NAN }, -360.0, +360.0, FLAGS },
656  { "flip", "Set flip in display orientation SEI",
658  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
659  { "horizontal", "Set hor_flip",
661  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
662  { "vertical", "Set ver_flip",
664  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
665 
666  { "level", "Set level (table A-1)",
668  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
669  { "auto", "Attempt to guess level from stream properties",
671  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
672 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
673  { .i64 = value }, .flags = FLAGS, .unit = "level"
674  { LEVEL("1", 10) },
675  { LEVEL("1b", 9) },
676  { LEVEL("1.1", 11) },
677  { LEVEL("1.2", 12) },
678  { LEVEL("1.3", 13) },
679  { LEVEL("2", 20) },
680  { LEVEL("2.1", 21) },
681  { LEVEL("2.2", 22) },
682  { LEVEL("3", 30) },
683  { LEVEL("3.1", 31) },
684  { LEVEL("3.2", 32) },
685  { LEVEL("4", 40) },
686  { LEVEL("4.1", 41) },
687  { LEVEL("4.2", 42) },
688  { LEVEL("5", 50) },
689  { LEVEL("5.1", 51) },
690  { LEVEL("5.2", 52) },
691  { LEVEL("6", 60) },
692  { LEVEL("6.1", 61) },
693  { LEVEL("6.2", 62) },
694 #undef LEVEL
695 
696  { NULL }
697 };
698 
699 static const AVClass h264_metadata_class = {
700  .class_name = "h264_metadata_bsf",
701  .item_name = av_default_item_name,
702  .option = h264_metadata_options,
703  .version = LIBAVUTIL_VERSION_INT,
704 };
705 
706 static const enum AVCodecID h264_metadata_codec_ids[] = {
708 };
709 
711  .name = "h264_metadata",
712  .priv_data_size = sizeof(H264MetadataContext),
713  .priv_class = &h264_metadata_class,
715  .close = &ff_cbs_bsf_generic_close,
718 };
ff_h264_metadata_bsf
const AVBitStreamFilter ff_h264_metadata_bsf
Definition: h264_metadata_bsf.c:710
av_isxdigit
static av_const int av_isxdigit(int c)
Locale-independent conversion of ASCII isxdigit.
Definition: avstring.h:256
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_cbs_sei_add_message
int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, int prefix, uint32_t payload_type, void *payload_data, AVBufferRef *payload_buf)
Add an SEI message to an access unit.
Definition: cbs_sei.c:247
level
uint8_t level
Definition: svq3.c:204
FLAGS
#define FLAGS
Definition: h264_metadata_bsf.c:587
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
ff_cbs_bsf_generic_init
int ff_cbs_bsf_generic_init(AVBSFContext *bsf, const CBSBSFType *type)
Initialise generic CBS BSF setup.
Definition: cbs_bsf.c:110
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
opt.h
H264MetadataContext::video_full_range_flag
int video_full_range_flag
Definition: h264_metadata_bsf.c:55
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
H264MetadataContext::sei_user_data
const char * sei_user_data
Definition: h264_metadata_bsf.c:71
CBSBSFType::codec_id
enum AVCodecID codec_id
Definition: cbs_bsf.h:32
message
Definition: api-threadmessage-test.c:46
LEVEL
#define LEVEL(name, value)
BSF_ELEMENT_INSERT
@ BSF_ELEMENT_INSERT
Definition: cbs_bsf.h:104
h264_levels.h
SEI_TYPE_DISPLAY_ORIENTATION
@ SEI_TYPE_DISPLAY_ORIENTATION
Definition: sei.h:77
H264MetadataContext::sei_user_data_payload
SEIRawUserDataUnregistered sei_user_data_payload
Definition: h264_metadata_bsf.c:72
cbs_h264.h
dpb_frames
int dpb_frames
Definition: h264_levels.c:159
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:106
AVBitStreamFilter::name
const char * name
Definition: bsf.h:91
SEIRawMessage
Definition: cbs_sei.h:68
h264_metadata_options
static const AVOption h264_metadata_options[]
Definition: h264_metadata_bsf.c:588
ff_cbs_sei_delete_message_type
void ff_cbs_sei_delete_message_type(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, uint32_t payload_type)
Delete all messages with the given payload type from an access unit.
Definition: cbs_sei.c:350
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:65
level_idc
int level_idc
Definition: h264_levels.c:25
AVOption
AVOption.
Definition: opt.h:247
H264MetadataContext::aud_nal
H264RawAUD aud_nal
Definition: h264_metadata_bsf.c:48
data
const char data[16]
Definition: mxf.c:143
CBSBSFContext
Definition: cbs_bsf.h:53
FLIP_HORIZONTAL
@ FLIP_HORIZONTAL
Definition: h264_metadata_bsf.c:33
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:73
h264_metadata_update_sps
static int h264_metadata_update_sps(AVBSFContext *bsf, H264RawSPS *sps)
Definition: h264_metadata_bsf.c:138
cbs.h
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure counterclockwise rotation by the specified angle...
Definition: display.c:50
H264MetadataContext::chroma_sample_loc_type
int chroma_sample_loc_type
Definition: h264_metadata_bsf.c:60
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
H264MetadataContext::crop_top
int crop_top
Definition: h264_metadata_bsf.c:68
H264MetadataContext::crop_right
int crop_right
Definition: h264_metadata_bsf.c:67
H264LevelDescriptor
Definition: h264_levels.h:25
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:229
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
AVBSFContext
The bitstream filter state.
Definition: bsf.h:47
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
framerate
int framerate
Definition: h264_levels.c:65
bsf.h
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:191
cbs_bsf.h
ff_h264_guess_level
const H264LevelDescriptor * ff_h264_guess_level(int profile_idc, int64_t bitrate, int framerate, int width, int height, int max_dec_frame_buffering)
Guess the level of a stream from some parameters.
Definition: h264_levels.c:79
SEIRawUserDataUnregistered::data
uint8_t * data
Definition: cbs_sei.h:45
H264MetadataContext::overscan_appropriate_flag
int overscan_appropriate_flag
Definition: h264_metadata_bsf.c:52
SEIRawUserDataUnregistered
Definition: cbs_sei.h:43
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:108
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
rotate
static void rotate(const float rot_quaternion[2][4], float *vec)
Rotate vector with given rotation quaternion.
Definition: vf_v360.c:4098
H264MetadataContext::rotate
double rotate
Definition: h264_metadata_bsf.c:77
H264MetadataContext::display_orientation
int display_orientation
Definition: h264_metadata_bsf.c:76
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:167
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
H264MetadataContext::fixed_frame_rate_flag
int fixed_frame_rate_flag
Definition: h264_metadata_bsf.c:63
BSF_ELEMENT_OPTIONS_PIRE
#define BSF_ELEMENT_OPTIONS_PIRE(name, help, field, opt_flags)
Definition: cbs_bsf.h:123
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:121
width
#define width
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:226
H264MetadataContext::common
CBSBSFContext common
Definition: h264_metadata_bsf.c:43
H264MetadataContext::transfer_characteristics
int transfer_characteristics
Definition: h264_metadata_bsf.c:57
BSF_ELEMENT_REMOVE
@ BSF_ELEMENT_REMOVE
Definition: cbs_bsf.h:106
SEIRawUserDataUnregistered::data_length
size_t data_length
Definition: cbs_sei.h:47
ctx
AVFormatContext * ctx
Definition: movenc.c:48
CROP
#define CROP(border, unit)
H264RawSEIDisplayOrientation::display_orientation_repetition_period
uint16_t display_orientation_repetition_period
Definition: cbs_h264.h:301
NAN
#define NAN
Definition: mathematics.h:64
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
h264_metadata_update_fragment
static int h264_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au)
Definition: h264_metadata_bsf.c:463
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
rint
#define rint
Definition: tablegen.h:41
NULL
#define NULL
Definition: coverity.c:32
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, AVBufferRef *content_buf)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:756
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
H264RawSEIDisplayOrientation::anticlockwise_rotation
uint16_t anticlockwise_rotation
Definition: cbs_h264.h:300
isnan
#define isnan(x)
Definition: libm.h:340
BSF_ELEMENT_PASS
@ BSF_ELEMENT_PASS
Definition: cbs_bsf.h:99
H264MetadataContext::delete_filler
int delete_filler
Definition: h264_metadata_bsf.c:74
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
FLIP_VERTICAL
@ FLIP_VERTICAL
Definition: h264_metadata_bsf.c:34
H264MetadataContext::crop_bottom
int crop_bottom
Definition: h264_metadata_bsf.c:69
h264_metadata_handle_display_orientation
static int h264_metadata_handle_display_orientation(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au, int seek_point)
Definition: h264_metadata_bsf.c:330
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
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:47
h264_metadata_type
static const CBSBSFType h264_metadata_type
Definition: h264_metadata_bsf.c:539
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:842
H264MetadataContext::flip
int flip
Definition: h264_metadata_bsf.c:78
H264RawSEIDisplayOrientation::hor_flip
uint8_t hor_flip
Definition: cbs_h264.h:298
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
SEI_TYPE_FILLER_PAYLOAD
@ SEI_TYPE_FILLER_PAYLOAD
Definition: sei.h:33
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35
H264RawSliceHeader::slice_type
uint8_t slice_type
Definition: cbs_h264.h:314
CBSBSFType
Definition: cbs_bsf.h:31
hypot
static av_const double hypot(double x, double y)
Definition: libm.h:366
size
int size
Definition: twinvq_data.h:10344
H264_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
ff_cbs_bsf_generic_close
void ff_cbs_bsf_generic_close(AVBSFContext *bsf)
Close a generic CBS BSF instance.
Definition: cbs_bsf.c:150
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:177
H264RawSEIDisplayOrientation
Definition: cbs_h264.h:296
height
#define height
LEVEL_AUTO
@ LEVEL_AUTO
Definition: h264_metadata_bsf.c:39
H264MetadataContext::aud
int aud
Definition: h264_metadata_bsf.c:47
SET_VUI_FIELD
#define SET_VUI_FIELD(field)
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
h264_metadata_init
static int h264_metadata_init(AVBSFContext *bsf)
Definition: h264_metadata_bsf.c:546
H264MetadataContext::colour_primaries
int colour_primaries
Definition: h264_metadata_bsf.c:56
M_PI
#define M_PI
Definition: mathematics.h:52
H264MetadataContext
Definition: h264_metadata_bsf.c:42
OFFSET
#define OFFSET(x)
Definition: h264_metadata_bsf.c:586
h264_sei.h
H264RawSlice::header
H264RawSliceHeader header
Definition: cbs_h264.h:389
h264_metadata_class
static const AVClass h264_metadata_class
Definition: h264_metadata_bsf.c:699
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: avpacket.c:246
ff_cbs_sei_find_message
int ff_cbs_sei_find_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, uint32_t payload_type, SEIRawMessage **iter)
Iterate over messages with the given payload type in an access unit.
Definition: cbs_sei.c:297
display.h
common.h
h264_metadata_codec_ids
static enum AVCodecID h264_metadata_codec_ids[]
Definition: h264_metadata_bsf.c:706
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:62
ff_cbs_bsf_generic_filter
int ff_cbs_bsf_generic_filter(AVBSFContext *bsf, AVPacket *pkt)
Filter operation for CBS BSF.
Definition: cbs_bsf.c:61
H264RawSEIDisplayOrientation::ver_flip
uint8_t ver_flip
Definition: cbs_h264.h:299
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
BSF_ELEMENT_OPTIONS_PIR
#define BSF_ELEMENT_OPTIONS_PIR(name, help, field, opt_flags)
Definition: cbs_bsf.h:112
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
H264MetadataContext::video_format
int video_format
Definition: h264_metadata_bsf.c:54
H264MetadataContext::display_orientation_payload
H264RawSEIDisplayOrientation display_orientation_payload
Definition: h264_metadata_bsf.c:79
H264RawAUD
Definition: cbs_h264.h:218
AVBitStreamFilter
Definition: bsf.h:90
H264MetadataContext::matrix_coefficients
int matrix_coefficients
Definition: h264_metadata_bsf.c:58
H264MetadataContext::done_first_au
int done_first_au
Definition: h264_metadata_bsf.c:45
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
LEVEL_UNSET
@ LEVEL_UNSET
Definition: h264_metadata_bsf.c:38
H264MetadataContext::tick_rate
AVRational tick_rate
Definition: h264_metadata_bsf.c:62
desc
const char * desc
Definition: libsvtav1.c:79
codec_ids
static enum AVCodecID codec_ids[]
Definition: aac_adtstoasc_bsf.c:148
H264MetadataContext::zero_new_constraint_set_flags
int zero_new_constraint_set_flags
Definition: h264_metadata_bsf.c:64
message
static int FUNC() message(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessage *current)
Definition: cbs_sei_syntax_template.c:147
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
H264MetadataContext::level
int level
Definition: h264_metadata_bsf.c:81
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:223
int32_t
int32_t
Definition: audioconvert.c:56
h264.h
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
H264MetadataContext::sample_aspect_ratio
AVRational sample_aspect_ratio
Definition: h264_metadata_bsf.c:50
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
SEIRawUserDataUnregistered::uuid_iso_iec_11578
uint8_t uuid_iso_iec_11578[16]
Definition: cbs_sei.h:44
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
H264MetadataContext::crop_left
int crop_left
Definition: h264_metadata_bsf.c:66
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
h264_metadata_insert_aud
static int h264_metadata_insert_aud(AVBSFContext *bsf, CodedBitstreamFragment *au)
Definition: h264_metadata_bsf.c:85
av_tolower
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:246
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:152
ff_cbs_delete_unit
void ff_cbs_delete_unit(CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:831
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
H264RawSlice
Definition: cbs_h264.h:388
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
H264RawSPS
Definition: cbs_h264.h:102