FFmpeg
h264_metadata.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/mem.h"
23 #include "libavutil/opt.h"
24 
25 #include "bsf.h"
26 #include "bsf_internal.h"
27 #include "cbs.h"
28 #include "cbs_bsf.h"
29 #include "cbs_h264.h"
30 #include "cbs_sei.h"
31 #include "h264.h"
32 #include "h264_levels.h"
33 #include "h2645data.h"
34 #include "sei.h"
35 
36 enum {
39 };
40 
41 enum {
43  LEVEL_AUTO = -1,
44 };
45 
46 typedef struct H264MetadataContext {
48 
50 
51  int aud;
53 
55 
57 
63 
65 
69 
70  int crop_left;
72  int crop_top;
74 
75  const char *sei_user_data;
77 
79 
81  double rotate;
82  int flip;
84 
85  int level;
87 
88 
91 {
93  int primary_pic_type_mask = 0xff;
94  int err, i, j;
95 
96  static const int primary_pic_type_table[] = {
97  0x084, // 2, 7
98  0x0a5, // 0, 2, 5, 7
99  0x0e7, // 0, 1, 2, 5, 6, 7
100  0x210, // 4, 9
101  0x318, // 3, 4, 8, 9
102  0x294, // 2, 4, 7, 9
103  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
104  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
105  };
106 
107  for (i = 0; i < au->nb_units; i++) {
108  if (au->units[i].type == H264_NAL_SLICE ||
109  au->units[i].type == H264_NAL_IDR_SLICE) {
110  H264RawSlice *slice = au->units[i].content;
111  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
112  if (!(primary_pic_type_table[j] &
113  (1 << slice->header.slice_type)))
114  primary_pic_type_mask &= ~(1 << j);
115  }
116  }
117  }
118  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
119  if (primary_pic_type_mask & (1 << j))
120  break;
121  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
122  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
123  "invalid slice types?\n");
124  return AVERROR_INVALIDDATA;
125  }
126 
127  ctx->aud_nal = (H264RawAUD) {
128  .nal_unit_header.nal_unit_type = H264_NAL_AUD,
129  .primary_pic_type = j,
130  };
131 
133  &ctx->aud_nal, NULL);
134  if (err < 0) {
135  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
136  return err;
137  }
138 
139  return 0;
140 }
141 
143  H264RawSPS *sps)
144 {
146  int need_vui = 0;
147  int crop_unit_x, crop_unit_y;
148 
149  if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
150  int num, den, i;
151 
152  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
153  ctx->sample_aspect_ratio.den, 65535);
154 
155  for (i = 1; i < FF_ARRAY_ELEMS(ff_h2645_pixel_aspect); i++) {
156  if (num == ff_h2645_pixel_aspect[i].num &&
157  den == ff_h2645_pixel_aspect[i].den)
158  break;
159  }
161  sps->vui.aspect_ratio_idc = 255;
162  sps->vui.sar_width = num;
163  sps->vui.sar_height = den;
164  } else {
165  sps->vui.aspect_ratio_idc = i;
166  }
167  sps->vui.aspect_ratio_info_present_flag = 1;
168  need_vui = 1;
169  }
170 
171 #define SET_VUI_FIELD(field) do { \
172  if (ctx->field >= 0) { \
173  sps->vui.field = ctx->field; \
174  need_vui = 1; \
175  } \
176  } while (0)
177 
178  if (ctx->overscan_appropriate_flag >= 0) {
179  SET_VUI_FIELD(overscan_appropriate_flag);
180  sps->vui.overscan_info_present_flag = 1;
181  }
182 
183  if (ctx->video_format >= 0 ||
184  ctx->video_full_range_flag >= 0 ||
185  ctx->colour_primaries >= 0 ||
186  ctx->transfer_characteristics >= 0 ||
187  ctx->matrix_coefficients >= 0) {
188 
189  SET_VUI_FIELD(video_format);
190 
191  SET_VUI_FIELD(video_full_range_flag);
192 
193  if (ctx->colour_primaries >= 0 ||
194  ctx->transfer_characteristics >= 0 ||
195  ctx->matrix_coefficients >= 0) {
196 
197  SET_VUI_FIELD(colour_primaries);
199  SET_VUI_FIELD(matrix_coefficients);
200 
201  sps->vui.colour_description_present_flag = 1;
202  }
203  sps->vui.video_signal_type_present_flag = 1;
204  }
205 
206  if (ctx->chroma_sample_loc_type >= 0) {
207  sps->vui.chroma_sample_loc_type_top_field =
208  ctx->chroma_sample_loc_type;
209  sps->vui.chroma_sample_loc_type_bottom_field =
210  ctx->chroma_sample_loc_type;
211  sps->vui.chroma_loc_info_present_flag = 1;
212  need_vui = 1;
213  }
214 
215  if (ctx->tick_rate.num && ctx->tick_rate.den) {
216  int num, den;
217 
218  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
219  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
220 
221  sps->vui.time_scale = num;
222  sps->vui.num_units_in_tick = den;
223 
224  sps->vui.timing_info_present_flag = 1;
225  need_vui = 1;
226  }
227  SET_VUI_FIELD(fixed_frame_rate_flag);
228  if (ctx->zero_new_constraint_set_flags) {
229  sps->constraint_set4_flag = 0;
230  sps->constraint_set5_flag = 0;
231  }
232 
233  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
234  crop_unit_x = 1;
235  crop_unit_y = 2 - sps->frame_mbs_only_flag;
236  } else {
237  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
238  crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
239  (2 - sps->frame_mbs_only_flag);
240  }
241 #define CROP(border, unit) do { \
242  if (ctx->crop_ ## border >= 0) { \
243  if (ctx->crop_ ## border % unit != 0) { \
244  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
245  "must be a multiple of %d.\n", #border, unit); \
246  return AVERROR(EINVAL); \
247  } \
248  sps->frame_crop_ ## border ## _offset = \
249  ctx->crop_ ## border / unit; \
250  sps->frame_cropping_flag = 1; \
251  } \
252  } while (0)
253  CROP(left, crop_unit_x);
254  CROP(right, crop_unit_x);
255  CROP(top, crop_unit_y);
256  CROP(bottom, crop_unit_y);
257 #undef CROP
258 
259  if (ctx->level != LEVEL_UNSET) {
260  int level_idc;
261 
262  if (ctx->level == LEVEL_AUTO) {
263  const H264LevelDescriptor *desc;
264  int64_t bit_rate;
265  int width, height, dpb_frames;
266  int framerate;
267 
268  if (sps->vui.nal_hrd_parameters_present_flag) {
269  bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
270  (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
271  } else if (sps->vui.vcl_hrd_parameters_present_flag) {
272  bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
273  (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
274  // Adjust for VCL vs. NAL limits.
275  bit_rate = bit_rate * 6 / 5;
276  } else {
277  bit_rate = 0;
278  }
279 
280  // Don't use max_dec_frame_buffering if it is only inferred.
281  dpb_frames = sps->vui.bitstream_restriction_flag ?
282  sps->vui.max_dec_frame_buffering : H264_MAX_DPB_FRAMES;
283 
284  width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
285  height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
286  (2 - sps->frame_mbs_only_flag);
287 
288  if (sps->vui.timing_info_present_flag)
289  framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;
290  else
291  framerate = 0;
292 
293  desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,
295  if (desc) {
296  level_idc = desc->level_idc;
297  } else {
298  av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
299  "conform to any level: using level 6.2.\n");
300  level_idc = 62;
301  }
302  } else {
303  level_idc = ctx->level;
304  }
305 
306  if (level_idc == 9) {
307  if (sps->profile_idc == 66 ||
308  sps->profile_idc == 77 ||
309  sps->profile_idc == 88) {
310  sps->level_idc = 11;
311  sps->constraint_set3_flag = 1;
312  } else {
313  sps->level_idc = 9;
314  }
315  } else {
316  sps->level_idc = level_idc;
317  }
318  }
319 
320  if (need_vui)
321  sps->vui_parameters_present_flag = 1;
322 
323  return 0;
324 }
325 
327  AVPacket *pkt,
329  int seek_point)
330 {
333  int err;
334 
335  message = NULL;
336  while (ff_cbs_sei_find_message(ctx->common.output, au,
338  &message) == 0) {
339  H264RawSEIDisplayOrientation *disp = message->payload;
340  double angle = disp->anticlockwise_rotation * 180.0 / 65536.0;
341  int32_t *matrix;
342 
343  matrix = av_malloc(9 * sizeof(int32_t));
344  if (!matrix)
345  return AVERROR(ENOMEM);
346 
347  /* av_display_rotation_set() expects the angle in the clockwise
348  * direction, hence the first minus.
349  * The below code applies the flips after the rotation, yet
350  * the H.2645 specs require flipping to be applied first.
351  * Because of R O(phi) = O(-phi) R (where R is flipping around
352  * an arbitatry axis and O(phi) is the proper rotation by phi)
353  * we can create display matrices as desired by negating
354  * the degree once for every flip applied. */
355  angle = -angle * (1 - 2 * !!disp->hor_flip) * (1 - 2 * !!disp->ver_flip);
356 
359 
360  // If there are multiple display orientation messages in an
361  // access unit, then the last one added to the packet (i.e.
362  // the first one in the access unit) will prevail.
364  (uint8_t*)matrix,
365  9 * sizeof(int32_t));
366  if (err < 0) {
367  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
368  "displaymatrix side data to packet.\n");
369  av_free(matrix);
370  return AVERROR(ENOMEM);
371  }
372  }
373 
374  if (ctx->display_orientation == BSF_ELEMENT_REMOVE ||
375  ctx->display_orientation == BSF_ELEMENT_INSERT) {
376  ff_cbs_sei_delete_message_type(ctx->common.output, au,
378  }
379 
380  if (ctx->display_orientation == BSF_ELEMENT_INSERT) {
382  &ctx->display_orientation_payload;
383  uint8_t *data;
384  size_t size;
385  int write = 0;
386 
388  if (data && size >= 9 * sizeof(int32_t)) {
389  int32_t matrix[9];
390  double dmatrix[9];
391  int hflip, vflip, i;
392  double scale_x, scale_y, angle;
393 
394  memcpy(matrix, data, sizeof(matrix));
395 
396  for (i = 0; i < 9; i++)
397  dmatrix[i] = matrix[i] / 65536.0;
398 
399  // Extract scale factors.
400  scale_x = hypot(dmatrix[0], dmatrix[3]);
401  scale_y = hypot(dmatrix[1], dmatrix[4]);
402 
403  // Select flips to make the main diagonal positive.
404  hflip = dmatrix[0] < 0.0;
405  vflip = dmatrix[4] < 0.0;
406  if (hflip)
407  scale_x = -scale_x;
408  if (vflip)
409  scale_y = -scale_y;
410 
411  // Rescale.
412  for (i = 0; i < 9; i += 3) {
413  dmatrix[i] /= scale_x;
414  dmatrix[i + 1] /= scale_y;
415  }
416 
417  // Extract rotation.
418  angle = atan2(dmatrix[3], dmatrix[0]);
419 
420  if (!(angle >= -M_PI && angle <= M_PI) ||
421  matrix[2] != 0.0 || matrix[5] != 0.0 ||
422  matrix[6] != 0.0 || matrix[7] != 0.0) {
423  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
424  "representable in H.264 parameters.\n");
425  } else {
426  disp->hor_flip = hflip;
427  disp->ver_flip = vflip;
428  disp->anticlockwise_rotation =
429  (uint16_t)rint((angle >= 0.0 ? angle
430  : angle + 2 * M_PI) *
431  32768.0 / M_PI);
432  write = 1;
433  }
434  }
435 
436  if (seek_point) {
437  if (!isnan(ctx->rotate)) {
438  disp->anticlockwise_rotation =
439  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
440  : ctx->rotate + 360.0) *
441  65536.0 / 360.0);
442  write = 1;
443  }
444  if (ctx->flip) {
445  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
446  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
447  write = 1;
448  }
449  }
450 
451  if (write) {
453 
454  err = ff_cbs_sei_add_message(ctx->common.output, au, 1,
456  disp, NULL);
457  if (err < 0) {
458  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
459  "SEI message to access unit.\n");
460  return err;
461  }
462  }
463  }
464 
465  return 0;
466 }
467 
470 {
472  int err, i, has_sps, seek_point;
473 
474  if (ctx->aud == BSF_ELEMENT_REMOVE) {
475  for (i = au->nb_units - 1; i >= 0; i--) {
476  if (au->units[i].type == H264_NAL_AUD)
477  ff_cbs_delete_unit(au, i);
478  }
479  } else if (ctx->aud == BSF_ELEMENT_INSERT) {
480  if (pkt) {
481  err = h264_metadata_insert_aud(bsf, au);
482  if (err < 0)
483  return err;
484  }
485  }
486 
487  has_sps = 0;
488  for (i = 0; i < au->nb_units; i++) {
489  if (au->units[i].type == H264_NAL_SPS) {
490  err = h264_metadata_update_sps(bsf, au->units[i].content);
491  if (err < 0)
492  return err;
493  has_sps = 1;
494  }
495  }
496 
497  if (pkt) {
498  // The current packet should be treated as a seek point for metadata
499  // insertion if any of:
500  // - It is the first packet in the stream.
501  // - It contains an SPS, indicating that a sequence might start here.
502  // - It is marked as containing a key frame.
503  seek_point = !ctx->done_first_au || has_sps ||
505  } else {
506  seek_point = 0;
507  }
508 
509  if (ctx->sei_user_data && seek_point) {
510  err = ff_cbs_sei_add_message(ctx->common.output, au, 1,
512  &ctx->sei_user_data_payload, NULL);
513  if (err < 0) {
514  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
515  "message to access unit.\n");
516  return err;
517  }
518  }
519 
520  if (ctx->delete_filler) {
521  for (i = au->nb_units - 1; i >= 0; i--) {
522  if (au->units[i].type == H264_NAL_FILLER_DATA) {
523  ff_cbs_delete_unit(au, i);
524  continue;
525  }
526  }
527 
528  ff_cbs_sei_delete_message_type(ctx->common.output, au,
530  }
531 
532  if (pkt && ctx->display_orientation != BSF_ELEMENT_PASS) {
534  seek_point);
535  if (err < 0)
536  return err;
537  }
538 
539  if (pkt)
540  ctx->done_first_au = 1;
541 
542  return 0;
543 }
544 
547  .fragment_name = "access unit",
548  .unit_name = "NAL unit",
549  .update_fragment = &h264_metadata_update_fragment,
550 };
551 
553 {
555 
556  if (ctx->sei_user_data) {
557  SEIRawUserDataUnregistered *udu = &ctx->sei_user_data_payload;
558  int i, j;
559 
560  // Parse UUID. It must be a hex string of length 32, possibly
561  // containing '-'s between hex digits (which we ignore).
562  for (i = j = 0; j < 32 && i < 64 && ctx->sei_user_data[i]; i++) {
563  int c, v;
564  c = ctx->sei_user_data[i];
565  if (c == '-') {
566  continue;
567  } else if (av_isxdigit(c)) {
568  c = av_tolower(c);
569  v = (c <= '9' ? c - '0' : c - 'a' + 10);
570  } else {
571  break;
572  }
573  if (j & 1)
574  udu->uuid_iso_iec_11578[j / 2] |= v;
575  else
576  udu->uuid_iso_iec_11578[j / 2] = v << 4;
577  ++j;
578  }
579  if (j == 32 && ctx->sei_user_data[i] == '+') {
580  udu->data = (uint8_t*)ctx->sei_user_data + i + 1;
581  udu->data_length = strlen(udu->data) + 1;
582  } else {
583  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
584  "must be \"UUID+string\".\n");
585  return AVERROR(EINVAL);
586  }
587  }
588 
590 }
591 
592 #define OFFSET(x) offsetof(H264MetadataContext, x)
593 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
594 static const AVOption h264_metadata_options[] = {
595  BSF_ELEMENT_OPTIONS_PIR("aud", "Access Unit Delimiter NAL units",
596  aud, FLAGS),
597 
598  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
599  OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
600  { .dbl = 0.0 }, 0, 65535, FLAGS },
601 
602  { "overscan_appropriate_flag", "Set VUI overscan appropriate flag",
603  OFFSET(overscan_appropriate_flag), AV_OPT_TYPE_INT,
604  { .i64 = -1 }, -1, 1, FLAGS },
605 
606  { "video_format", "Set video format (table E-2)",
607  OFFSET(video_format), AV_OPT_TYPE_INT,
608  { .i64 = -1 }, -1, 7, FLAGS},
609  { "video_full_range_flag", "Set video full range flag",
610  OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
611  { .i64 = -1 }, -1, 1, FLAGS },
612  { "colour_primaries", "Set colour primaries (table E-3)",
613  OFFSET(colour_primaries), AV_OPT_TYPE_INT,
614  { .i64 = -1 }, -1, 255, FLAGS },
615  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
617  { .i64 = -1 }, -1, 255, FLAGS },
618  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
619  OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
620  { .i64 = -1 }, -1, 255, FLAGS },
621 
622  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
623  OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
624  { .i64 = -1 }, -1, 5, FLAGS },
625 
626  { "tick_rate", "Set VUI tick rate (time_scale / num_units_in_tick)",
627  OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
628  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
629  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
630  OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
631  { .i64 = -1 }, -1, 1, FLAGS },
632  { "zero_new_constraint_set_flags", "Set constraint_set4_flag / constraint_set5_flag to zero",
633  OFFSET(zero_new_constraint_set_flags), AV_OPT_TYPE_BOOL,
634  { .i64 = 0 }, 0, 1, FLAGS },
635 
636  { "crop_left", "Set left border crop offset",
637  OFFSET(crop_left), AV_OPT_TYPE_INT,
638  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
639  { "crop_right", "Set right border crop offset",
640  OFFSET(crop_right), AV_OPT_TYPE_INT,
641  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
642  { "crop_top", "Set top border crop offset",
643  OFFSET(crop_top), AV_OPT_TYPE_INT,
644  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
645  { "crop_bottom", "Set bottom border crop offset",
646  OFFSET(crop_bottom), AV_OPT_TYPE_INT,
647  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
648 
649  { "sei_user_data", "Insert SEI user data (UUID+string)",
650  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
651 
652  { "delete_filler", "Delete all filler (both NAL and SEI)",
653  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
654 
655  BSF_ELEMENT_OPTIONS_PIRE("display_orientation",
656  "Display orientation SEI",
657  display_orientation, FLAGS),
658 
659  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
661  { .dbl = NAN }, -360.0, +360.0, FLAGS },
662  { "flip", "Set flip in display orientation SEI",
664  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, .unit = "flip" },
665  { "horizontal", "Set hor_flip",
667  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
668  { "vertical", "Set ver_flip",
670  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
671 
672  { "level", "Set level (table A-1)",
674  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, .unit = "level" },
675  { "auto", "Attempt to guess level from stream properties",
677  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
678 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
679  { .i64 = value }, .flags = FLAGS, .unit = "level"
680  { LEVEL("1", 10) },
681  { LEVEL("1b", 9) },
682  { LEVEL("1.1", 11) },
683  { LEVEL("1.2", 12) },
684  { LEVEL("1.3", 13) },
685  { LEVEL("2", 20) },
686  { LEVEL("2.1", 21) },
687  { LEVEL("2.2", 22) },
688  { LEVEL("3", 30) },
689  { LEVEL("3.1", 31) },
690  { LEVEL("3.2", 32) },
691  { LEVEL("4", 40) },
692  { LEVEL("4.1", 41) },
693  { LEVEL("4.2", 42) },
694  { LEVEL("5", 50) },
695  { LEVEL("5.1", 51) },
696  { LEVEL("5.2", 52) },
697  { LEVEL("6", 60) },
698  { LEVEL("6.1", 61) },
699  { LEVEL("6.2", 62) },
700 #undef LEVEL
701 
702  { NULL }
703 };
704 
705 static const AVClass h264_metadata_class = {
706  .class_name = "h264_metadata_bsf",
707  .item_name = av_default_item_name,
708  .option = h264_metadata_options,
709  .version = LIBAVUTIL_VERSION_INT,
710 };
711 
712 static const enum AVCodecID h264_metadata_codec_ids[] = {
714 };
715 
717  .p.name = "h264_metadata",
718  .p.codec_ids = h264_metadata_codec_ids,
719  .p.priv_class = &h264_metadata_class,
720  .priv_data_size = sizeof(H264MetadataContext),
722  .close = &ff_cbs_bsf_generic_close,
724 };
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:109
av_isxdigit
static av_const int av_isxdigit(int c)
Locale-independent conversion of ASCII isxdigit.
Definition: avstring.h:247
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
level
uint8_t level
Definition: svq3.c:205
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
bsf_internal.h
opt.h
H264MetadataContext::video_full_range_flag
int video_full_range_flag
Definition: h264_metadata.c:59
H264MetadataContext::sei_user_data
const char * sei_user_data
Definition: h264_metadata.c:75
SET_VUI_FIELD
#define SET_VUI_FIELD(field)
H264_NAL_SPS
@ H264_NAL_SPS
Definition: h264.h:41
CBSBSFType::codec_id
enum AVCodecID codec_id
Definition: cbs_bsf.h:32
message
Definition: api-threadmessage-test.c:47
h264_levels.h
ff_cbs_sei_add_message
int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, int prefix, uint32_t payload_type, void *payload_data, void *payload_ref)
Add an SEI message to an access unit.
Definition: cbs_sei.c:269
H264MetadataContext::sei_user_data_payload
SEIRawUserDataUnregistered sei_user_data_payload
Definition: h264_metadata.c:76
matrix
Definition: vc1dsp.c:43
cbs_h264.h
dpb_frames
int dpb_frames
Definition: h264_levels.c:163
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:107
AVBitStreamFilter::name
const char * name
Definition: bsf.h:112
ff_cbs_insert_unit_content
int ff_cbs_insert_unit_content(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, void *content, void *content_ref)
Insert a new unit into a fragment with the given content.
Definition: cbs.c:783
SEIRawMessage
Definition: cbs_sei.h:70
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:369
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:66
level_idc
int level_idc
Definition: h264_levels.c:29
AVOption
AVOption.
Definition: opt.h:346
H264MetadataContext::aud_nal
H264RawAUD aud_nal
Definition: h264_metadata.c:52
data
const char data[16]
Definition: mxf.c:148
h264_metadata_update_fragment
static int h264_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au)
Definition: h264_metadata.c:468
CBSBSFContext
Definition: cbs_bsf.h:53
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:74
H264_NAL_FILLER_DATA
@ H264_NAL_FILLER_DATA
Definition: h264.h:46
cbs.h
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
Definition: display.c:51
H264MetadataContext::chroma_sample_loc_type
int chroma_sample_loc_type
Definition: h264_metadata.c:64
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.c:72
H264MetadataContext::crop_right
int crop_right
Definition: h264_metadata.c:71
H264LevelDescriptor
Definition: h264_levels.h:25
AV_OPT_TYPE_RATIONAL
@ AV_OPT_TYPE_RATIONAL
Definition: opt.h:240
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:579
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
FLIP_HORIZONTAL
@ FLIP_HORIZONTAL
Definition: h264_metadata.c:37
H264_MAX_HEIGHT
@ H264_MAX_HEIGHT
Definition: h264.h:109
bsf.h
h264_metadata_update_sps
static int h264_metadata_update_sps(AVBSFContext *bsf, H264RawSPS *sps)
Definition: h264_metadata.c:142
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: packet.c:197
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
ff_h264_metadata_bsf
const FFBitStreamFilter ff_h264_metadata_bsf
Definition: h264_metadata.c:716
SEIRawUserDataUnregistered::data
uint8_t * data
RefStruct reference.
Definition: cbs_sei.h:42
H264MetadataContext::overscan_appropriate_flag
int overscan_appropriate_flag
Definition: h264_metadata.c:56
SEIRawUserDataUnregistered
Definition: cbs_sei.h:40
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
h264_metadata_options
static const AVOption h264_metadata_options[]
Definition: h264_metadata.c:594
SEI_TYPE_FILLER_PAYLOAD
@ SEI_TYPE_FILLER_PAYLOAD
Definition: sei.h:33
rotate
static void rotate(const float rot_quaternion[2][4], float *vec)
Rotate vector with given rotation quaternion.
Definition: vf_v360.c:4064
H264MetadataContext::rotate
double rotate
Definition: h264_metadata.c:81
H264MetadataContext::display_orientation
int display_orientation
Definition: h264_metadata.c:80
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:168
pkt
AVPacket * pkt
Definition: movenc.c:60
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.c:67
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:122
width
#define width
h264_metadata_insert_aud
static int h264_metadata_insert_aud(AVBSFContext *bsf, CodedBitstreamFragment *au)
Definition: h264_metadata.c:89
CROP
#define CROP(border, unit)
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:237
H264MetadataContext::common
CBSBSFContext common
Definition: h264_metadata.c:47
H264MetadataContext::transfer_characteristics
int transfer_characteristics
Definition: h264_metadata.c:61
SEIRawUserDataUnregistered::data_length
size_t data_length
Definition: cbs_sei.h:43
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
ctx
AVFormatContext * ctx
Definition: movenc.c:49
H264RawSEIDisplayOrientation::display_orientation_repetition_period
uint16_t display_orientation_repetition_period
Definition: cbs_h264.h:301
h2645data.h
NAN
#define NAN
Definition: mathematics.h:115
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
BSF_ELEMENT_REMOVE
@ BSF_ELEMENT_REMOVE
Definition: cbs_bsf.h:106
framerate
float framerate
Definition: av1_levels.c:29
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
FLAGS
#define FLAGS
Definition: h264_metadata.c:593
FFBitStreamFilter
Definition: bsf_internal.h:27
cbs_sei.h
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
sei.h
H264MetadataContext::delete_filler
int delete_filler
Definition: h264_metadata.c:78
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
h264_metadata_codec_ids
static enum AVCodecID h264_metadata_codec_ids[]
Definition: h264_metadata.c:712
H264MetadataContext::crop_bottom
int crop_bottom
Definition: h264_metadata.c:73
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
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
h264_metadata_handle_display_orientation
static int h264_metadata_handle_display_orientation(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au, int seek_point)
Definition: h264_metadata.c:326
FFBitStreamFilter::p
AVBitStreamFilter p
The public AVBitStreamFilter.
Definition: bsf_internal.h:31
aud
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Definition: cbs_h264_syntax_template.c:841
H264MetadataContext::flip
int flip
Definition: h264_metadata.c:82
H264RawSEIDisplayOrientation::hor_flip
uint8_t hor_flip
Definition: cbs_h264.h:298
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
h264_metadata_class
static const AVClass h264_metadata_class
Definition: h264_metadata.c:705
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
ff_cbs_bsf_generic_close
void ff_cbs_bsf_generic_close(AVBSFContext *bsf)
Close a generic CBS BSF instance.
Definition: cbs_bsf.c:155
transfer_characteristics
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
Definition: vf_colorspace.c:166
h264_metadata_init
static int h264_metadata_init(AVBSFContext *bsf)
Definition: h264_metadata.c:552
H264RawSEIDisplayOrientation
Definition: cbs_h264.h:296
height
#define height
H264MetadataContext::aud
int aud
Definition: h264_metadata.c:51
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
BSF_ELEMENT_PASS
@ BSF_ELEMENT_PASS
Definition: cbs_bsf.h:99
H264MetadataContext::colour_primaries
int colour_primaries
Definition: h264_metadata.c:60
M_PI
#define M_PI
Definition: mathematics.h:67
H264MetadataContext
Definition: h264_metadata.c:46
H264RawSlice::header
H264RawSliceHeader header
Definition: cbs_h264.h:389
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
h264_metadata_type
static const CBSBSFType h264_metadata_type
Definition: h264_metadata.c:545
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: packet.c:252
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:316
display.h
common.h
SEI_TYPE_DISPLAY_ORIENTATION
@ SEI_TYPE_DISPLAY_ORIENTATION
Definition: sei.h:77
ff_h2645_pixel_aspect
const AVRational ff_h2645_pixel_aspect[]
Definition: h2645data.c:21
LEVEL_UNSET
@ LEVEL_UNSET
Definition: h264_metadata.c:42
AVBSFContext::priv_data
void * priv_data
Opaque filter-specific private data.
Definition: bsf.h:83
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
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
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.c:58
LEVEL_AUTO
@ LEVEL_AUTO
Definition: h264_metadata.c:43
H264MetadataContext::display_orientation_payload
H264RawSEIDisplayOrientation display_orientation_payload
Definition: h264_metadata.c:83
H264RawAUD
Definition: cbs_h264.h:218
SEI_TYPE_USER_DATA_UNREGISTERED
@ SEI_TYPE_USER_DATA_UNREGISTERED
Definition: sei.h:35
H264MetadataContext::matrix_coefficients
int matrix_coefficients
Definition: h264_metadata.c:62
H264MetadataContext::done_first_au
int done_first_au
Definition: h264_metadata.c:49
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
LEVEL
#define LEVEL(name, value)
H264MetadataContext::tick_rate
AVRational tick_rate
Definition: h264_metadata.c:66
desc
const char * desc
Definition: libsvtav1.c:75
mem.h
H264MetadataContext::zero_new_constraint_set_flags
int zero_new_constraint_set_flags
Definition: h264_metadata.c:68
message
static int FUNC() message(CodedBitstreamContext *ctx, RWContext *rw, SEIRawMessage *current)
Definition: cbs_sei_syntax_template.c:165
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
BSF_ELEMENT_INSERT
@ BSF_ELEMENT_INSERT
Definition: cbs_bsf.h:104
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
H264MetadataContext::level
int level
Definition: h264_metadata.c:85
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:234
int32_t
int32_t
Definition: audioconvert.c:56
h264.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
H264MetadataContext::sample_aspect_ratio
AVRational sample_aspect_ratio
Definition: h264_metadata.c:54
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:41
H264_MAX_WIDTH
@ H264_MAX_WIDTH
Definition: h264.h:108
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:239
H264_NAL_AUD
@ H264_NAL_AUD
Definition: h264.h:43
H264MetadataContext::crop_left
int crop_left
Definition: h264_metadata.c:70
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
av_tolower
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:237
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:153
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:860
H264RawSlice
Definition: cbs_h264.h:388
FLIP_VERTICAL
@ FLIP_VERTICAL
Definition: h264_metadata.c:38
OFFSET
#define OFFSET(x)
Definition: h264_metadata.c:592
H264RawSPS
Definition: cbs_h264.h:102
H264_NAL_SLICE
@ H264_NAL_SLICE
Definition: h264.h:35