FFmpeg  4.2.2
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_h264.h"
27 #include "h264.h"
28 #include "h264_levels.h"
29 #include "h264_sei.h"
30 
31 enum {
36 };
37 
38 enum {
41 };
42 
43 enum {
45  LEVEL_AUTO = -1,
46 };
47 
48 typedef struct H264MetadataContext {
49  const AVClass *class;
50 
53 
55 
56  int aud;
57 
59 
65 
67 
70 
71  int crop_left;
73  int crop_top;
75 
76  const char *sei_user_data;
77 
79 
81  double rotate;
82  int flip;
83 
84  int level;
86 
87 
89  H264RawSPS *sps)
90 {
92  int need_vui = 0;
93  int crop_unit_x, crop_unit_y;
94 
96  // Table E-1.
97  static const AVRational sar_idc[] = {
98  { 0, 0 }, // Unspecified (never written here).
99  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
100  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
101  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
102  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
103  };
104  int num, den, i;
105 
106  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
107  ctx->sample_aspect_ratio.den, 65535);
108 
109  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
110  if (num == sar_idc[i].num &&
111  den == sar_idc[i].den)
112  break;
113  }
114  if (i == FF_ARRAY_ELEMS(sar_idc)) {
115  sps->vui.aspect_ratio_idc = 255;
116  sps->vui.sar_width = num;
117  sps->vui.sar_height = den;
118  } else {
119  sps->vui.aspect_ratio_idc = i;
120  }
122  need_vui = 1;
123  }
124 
125 #define SET_OR_INFER(field, value, present_flag, infer) do { \
126  if (value >= 0) { \
127  field = value; \
128  need_vui = 1; \
129  } else if (!present_flag) \
130  field = infer; \
131  } while (0)
132 
133  if (ctx->video_format >= 0 ||
134  ctx->video_full_range_flag >= 0 ||
135  ctx->colour_primaries >= 0 ||
136  ctx->transfer_characteristics >= 0 ||
137  ctx->matrix_coefficients >= 0) {
138 
141 
145 
146  if (ctx->colour_primaries >= 0 ||
147  ctx->transfer_characteristics >= 0 ||
148  ctx->matrix_coefficients >= 0) {
149 
151  ctx->colour_primaries,
153 
157 
159  ctx->matrix_coefficients,
161 
163  }
165  need_vui = 1;
166  }
167 
168  if (ctx->chroma_sample_loc_type >= 0) {
174  need_vui = 1;
175  }
176 
177  if (ctx->tick_rate.num && ctx->tick_rate.den) {
178  int num, den;
179 
180  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
181  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
182 
183  sps->vui.time_scale = num;
184  sps->vui.num_units_in_tick = den;
185 
186  sps->vui.timing_info_present_flag = 1;
187  need_vui = 1;
188  }
191  sps->vui.timing_info_present_flag, 0);
192 
193  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
194  crop_unit_x = 1;
195  crop_unit_y = 2 - sps->frame_mbs_only_flag;
196  } else {
197  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
198  crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
199  (2 - sps->frame_mbs_only_flag);
200  }
201 #define CROP(border, unit) do { \
202  if (ctx->crop_ ## border >= 0) { \
203  if (ctx->crop_ ## border % unit != 0) { \
204  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
205  "must be a multiple of %d.\n", #border, unit); \
206  return AVERROR(EINVAL); \
207  } \
208  sps->frame_crop_ ## border ## _offset = \
209  ctx->crop_ ## border / unit; \
210  sps->frame_cropping_flag = 1; \
211  } \
212  } while (0)
213  CROP(left, crop_unit_x);
214  CROP(right, crop_unit_x);
215  CROP(top, crop_unit_y);
216  CROP(bottom, crop_unit_y);
217 #undef CROP
218 
219  if (ctx->level != LEVEL_UNSET) {
220  int level_idc;
221 
222  if (ctx->level == LEVEL_AUTO) {
223  const H264LevelDescriptor *desc;
224  int64_t bit_rate;
225  int width, height, dpb_frames;
226  int framerate;
227 
229  bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
230  (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
231  } else if (sps->vui.vcl_hrd_parameters_present_flag) {
232  bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
233  (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
234  // Adjust for VCL vs. NAL limits.
235  bit_rate = bit_rate * 6 / 5;
236  } else {
237  bit_rate = 0;
238  }
239 
240  // Don't use max_dec_frame_buffering if it is only inferred.
241  dpb_frames = sps->vui.bitstream_restriction_flag ?
243 
244  width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
245  height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
246  (2 - sps->frame_mbs_only_flag);
247 
248  if (sps->vui.timing_info_present_flag)
249  framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;
250  else
251  framerate = 0;
252 
253  desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,
254  width, height, dpb_frames);
255  if (desc) {
256  level_idc = desc->level_idc;
257  } else {
258  av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
259  "conform to any level: using level 6.2.\n");
260  level_idc = 62;
261  }
262  } else {
263  level_idc = ctx->level;
264  }
265 
266  if (level_idc == 9) {
267  if (sps->profile_idc == 66 ||
268  sps->profile_idc == 77 ||
269  sps->profile_idc == 88) {
270  sps->level_idc = 11;
271  sps->constraint_set3_flag = 1;
272  } else {
273  sps->level_idc = 9;
274  }
275  } else {
276  sps->level_idc = level_idc;
277  }
278  }
279 
280  if (need_vui)
282 
283  return 0;
284 }
285 
287 {
290  int err, i, j, has_sps;
291  H264RawAUD aud;
292 
293  err = ff_bsf_get_packet_ref(bsf, pkt);
294  if (err < 0)
295  return err;
296 
297  err = ff_cbs_read_packet(ctx->cbc, au, pkt);
298  if (err < 0) {
299  av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
300  goto fail;
301  }
302 
303  if (au->nb_units == 0) {
304  av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
305  err = AVERROR_INVALIDDATA;
306  goto fail;
307  }
308 
309  // If an AUD is present, it must be the first NAL unit.
310  if (au->units[0].type == H264_NAL_AUD) {
311  if (ctx->aud == REMOVE)
312  ff_cbs_delete_unit(ctx->cbc, au, 0);
313  } else {
314  if (ctx->aud == INSERT) {
315  static const int primary_pic_type_table[] = {
316  0x084, // 2, 7
317  0x0a5, // 0, 2, 5, 7
318  0x0e7, // 0, 1, 2, 5, 6, 7
319  0x210, // 4, 9
320  0x318, // 3, 4, 8, 9
321  0x294, // 2, 4, 7, 9
322  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
323  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
324  };
325  int primary_pic_type_mask = 0xff;
326 
327  for (i = 0; i < au->nb_units; i++) {
328  if (au->units[i].type == H264_NAL_SLICE ||
329  au->units[i].type == H264_NAL_IDR_SLICE) {
330  H264RawSlice *slice = au->units[i].content;
331  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
332  if (!(primary_pic_type_table[j] &
333  (1 << slice->header.slice_type)))
334  primary_pic_type_mask &= ~(1 << j);
335  }
336  }
337  }
338  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
339  if (primary_pic_type_mask & (1 << j))
340  break;
341  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
342  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
343  "invalid slice types?\n");
344  err = AVERROR_INVALIDDATA;
345  goto fail;
346  }
347 
348  aud = (H264RawAUD) {
350  .primary_pic_type = j,
351  };
352 
353  err = ff_cbs_insert_unit_content(ctx->cbc, au,
354  0, H264_NAL_AUD, &aud, NULL);
355  if (err < 0) {
356  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
357  goto fail;
358  }
359  }
360  }
361 
362  has_sps = 0;
363  for (i = 0; i < au->nb_units; i++) {
364  if (au->units[i].type == H264_NAL_SPS) {
365  err = h264_metadata_update_sps(bsf, au->units[i].content);
366  if (err < 0)
367  goto fail;
368  has_sps = 1;
369  }
370  }
371 
372  // Only insert the SEI in access units containing SPSs, and also
373  // unconditionally in the first access unit we ever see.
374  if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
375  H264RawSEIPayload payload = {
377  };
380 
381  for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
382  int c, v;
383  c = ctx->sei_user_data[i];
384  if (c == '-') {
385  continue;
386  } else if (av_isxdigit(c)) {
387  c = av_tolower(c);
388  v = (c <= '9' ? c - '0' : c - 'a' + 10);
389  } else {
390  goto invalid_user_data;
391  }
392  if (i & 1)
393  udu->uuid_iso_iec_11578[j / 2] |= v;
394  else
395  udu->uuid_iso_iec_11578[j / 2] = v << 4;
396  ++j;
397  }
398  if (j == 32 && ctx->sei_user_data[i] == '+') {
399  size_t len = strlen(ctx->sei_user_data + i + 1);
400 
401  udu->data_ref = av_buffer_alloc(len + 1);
402  if (!udu->data_ref) {
403  err = AVERROR(ENOMEM);
404  goto fail;
405  }
406 
407  udu->data = udu->data_ref->data;
408  udu->data_length = len + 1;
409  memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
410 
411  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
412  if (err < 0) {
413  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
414  "message to access unit.\n");
415  goto fail;
416  }
417 
418  } else {
419  invalid_user_data:
420  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
421  "must be \"UUID+string\".\n");
422  err = AVERROR(EINVAL);
423  goto fail;
424  }
425  }
426 
427  if (ctx->delete_filler) {
428  for (i = au->nb_units - 1; i >= 0; i--) {
429  if (au->units[i].type == H264_NAL_FILLER_DATA) {
430  ff_cbs_delete_unit(ctx->cbc, au, i);
431  continue;
432  }
433 
434  if (au->units[i].type == H264_NAL_SEI) {
435  // Filler SEI messages.
436  H264RawSEI *sei = au->units[i].content;
437 
438  for (j = sei->payload_count - 1; j >= 0; j--) {
439  if (sei->payload[j].payload_type ==
442  &au->units[i], j);
443  }
444  }
445  }
446  }
447 
448  if (ctx->display_orientation != PASS) {
449  for (i = au->nb_units - 1; i >= 0; i--) {
450  H264RawSEI *sei;
451  if (au->units[i].type != H264_NAL_SEI)
452  continue;
453  sei = au->units[i].content;
454 
455  for (j = sei->payload_count - 1; j >= 0; j--) {
457  int32_t *matrix;
458 
459  if (sei->payload[j].payload_type !=
461  continue;
462  disp = &sei->payload[j].payload.display_orientation;
463 
464  if (ctx->display_orientation == REMOVE ||
465  ctx->display_orientation == INSERT) {
467  &au->units[i], j);
468  continue;
469  }
470 
471  matrix = av_malloc(9 * sizeof(int32_t));
472  if (!matrix) {
473  err = AVERROR(ENOMEM);
474  goto fail;
475  }
476 
478  disp->anticlockwise_rotation *
479  180.0 / 65536.0);
480  av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
481 
482  // If there are multiple display orientation messages in an
483  // access unit, then the last one added to the packet (i.e.
484  // the first one in the access unit) will prevail.
486  (uint8_t*)matrix,
487  9 * sizeof(int32_t));
488  if (err < 0) {
489  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
490  "displaymatrix side data to packet.\n");
491  av_freep(matrix);
492  goto fail;
493  }
494  }
495  }
496  }
497  if (ctx->display_orientation == INSERT) {
498  H264RawSEIPayload payload = {
500  };
502  &payload.payload.display_orientation;
503  uint8_t *data;
504  int size;
505  int write = 0;
506 
508  if (data && size >= 9 * sizeof(int32_t)) {
509  int32_t matrix[9];
510  int hflip, vflip;
511  double angle;
512 
513  memcpy(matrix, data, sizeof(matrix));
514 
515  hflip = vflip = 0;
516  if (matrix[0] < 0 && matrix[4] > 0)
517  hflip = 1;
518  else if (matrix[0] > 0 && matrix[4] < 0)
519  vflip = 1;
520  av_display_matrix_flip(matrix, hflip, vflip);
521 
522  angle = av_display_rotation_get(matrix);
523 
524  if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
525  matrix[2] != 0 || matrix[5] != 0 ||
526  matrix[6] != 0 || matrix[7] != 0) {
527  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
528  "representable in H.264 parameters.\n");
529  } else {
530  disp->hor_flip = hflip;
531  disp->ver_flip = vflip;
532  disp->anticlockwise_rotation =
533  (uint16_t)rint((angle >= 0.0 ? angle
534  : angle + 360.0) *
535  65536.0 / 360.0);
536  write = 1;
537  }
538  }
539 
540  if (has_sps || !ctx->done_first_au) {
541  if (!isnan(ctx->rotate)) {
542  disp->anticlockwise_rotation =
543  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
544  : ctx->rotate + 360.0) *
545  65536.0 / 360.0);
546  write = 1;
547  }
548  if (ctx->flip) {
549  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
550  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
551  write = 1;
552  }
553  }
554 
555  if (write) {
557 
558  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
559  if (err < 0) {
560  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
561  "SEI message to access unit.\n");
562  goto fail;
563  }
564  }
565  }
566 
567  err = ff_cbs_write_packet(ctx->cbc, pkt, au);
568  if (err < 0) {
569  av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
570  goto fail;
571  }
572 
573  ctx->done_first_au = 1;
574 
575  err = 0;
576 fail:
577  ff_cbs_fragment_reset(ctx->cbc, au);
578 
579  if (err < 0)
580  av_packet_unref(pkt);
581 
582  return err;
583 }
584 
586 {
589  int err, i;
590 
591  err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
592  if (err < 0)
593  return err;
594 
595  if (bsf->par_in->extradata) {
596  err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
597  if (err < 0) {
598  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
599  goto fail;
600  }
601 
602  for (i = 0; i < au->nb_units; i++) {
603  if (au->units[i].type == H264_NAL_SPS) {
604  err = h264_metadata_update_sps(bsf, au->units[i].content);
605  if (err < 0)
606  goto fail;
607  }
608  }
609 
610  err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
611  if (err < 0) {
612  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
613  goto fail;
614  }
615  }
616 
617  err = 0;
618 fail:
619  ff_cbs_fragment_reset(ctx->cbc, au);
620  return err;
621 }
622 
624 {
626 
627  ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
628  ff_cbs_close(&ctx->cbc);
629 }
630 
631 #define OFFSET(x) offsetof(H264MetadataContext, x)
632 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
633 static const AVOption h264_metadata_options[] = {
634  { "aud", "Access Unit Delimiter NAL units",
636  { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
637  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
638  { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
639  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
640  { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
641  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
642  { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
643 
644  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
646  { .dbl = 0.0 }, 0, 65535, FLAGS },
647 
648  { "video_format", "Set video format (table E-2)",
650  { .i64 = -1 }, -1, 7, FLAGS},
651  { "video_full_range_flag", "Set video full range flag",
653  { .i64 = -1 }, -1, 1, FLAGS },
654  { "colour_primaries", "Set colour primaries (table E-3)",
656  { .i64 = -1 }, -1, 255, FLAGS },
657  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
659  { .i64 = -1 }, -1, 255, FLAGS },
660  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
662  { .i64 = -1 }, -1, 255, FLAGS },
663 
664  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
666  { .i64 = -1 }, -1, 6, FLAGS },
667 
668  { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
670  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
671  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
673  { .i64 = -1 }, -1, 1, FLAGS },
674 
675  { "crop_left", "Set left border crop offset",
677  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
678  { "crop_right", "Set right border crop offset",
680  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
681  { "crop_top", "Set top border crop offset",
683  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
684  { "crop_bottom", "Set bottom border crop offset",
686  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
687 
688  { "sei_user_data", "Insert SEI user data (UUID+string)",
689  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
690 
691  { "delete_filler", "Delete all filler (both NAL and SEI)",
692  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
693 
694  { "display_orientation", "Display orientation SEI",
696  { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
697  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
698  { .i64 = PASS }, .flags = FLAGS, .unit = "disp_or" },
699  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
700  { .i64 = INSERT }, .flags = FLAGS, .unit = "disp_or" },
701  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
702  { .i64 = REMOVE }, .flags = FLAGS, .unit = "disp_or" },
703  { "extract", NULL, 0, AV_OPT_TYPE_CONST,
704  { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
705 
706  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
708  { .dbl = NAN }, -360.0, +360.0, FLAGS },
709  { "flip", "Set flip in display orientation SEI",
711  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
712  { "horizontal", "Set hor_flip",
714  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
715  { "vertical", "Set ver_flip",
717  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
718 
719  { "level", "Set level (table A-1)",
721  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
722  { "auto", "Attempt to guess level from stream properties",
724  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
725 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
726  { .i64 = value }, .flags = FLAGS, .unit = "level"
727  { LEVEL("1", 10) },
728  { LEVEL("1b", 9) },
729  { LEVEL("1.1", 11) },
730  { LEVEL("1.2", 12) },
731  { LEVEL("1.3", 13) },
732  { LEVEL("2", 20) },
733  { LEVEL("2.1", 21) },
734  { LEVEL("2.2", 22) },
735  { LEVEL("3", 30) },
736  { LEVEL("3.1", 31) },
737  { LEVEL("3.2", 32) },
738  { LEVEL("4", 40) },
739  { LEVEL("4.1", 41) },
740  { LEVEL("4.2", 42) },
741  { LEVEL("5", 50) },
742  { LEVEL("5.1", 51) },
743  { LEVEL("5.2", 52) },
744  { LEVEL("6", 60) },
745  { LEVEL("6.1", 61) },
746  { LEVEL("6.2", 62) },
747 #undef LEVEL
748 
749  { NULL }
750 };
751 
752 static const AVClass h264_metadata_class = {
753  .class_name = "h264_metadata_bsf",
754  .item_name = av_default_item_name,
755  .option = h264_metadata_options,
756  .version = LIBAVUTIL_VERSION_INT,
757 };
758 
759 static const enum AVCodecID h264_metadata_codec_ids[] = {
761 };
762 
764  .name = "h264_metadata",
765  .priv_data_size = sizeof(H264MetadataContext),
766  .priv_class = &h264_metadata_class,
768  .close = &h264_metadata_close,
771 };
static int h264_metadata_update_sps(AVBSFContext *bsf, H264RawSPS *sps)
uint32_t payload_type
Definition: cbs_h264.h:322
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
const char * sei_user_data
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5797
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:69
int size
uint8_t video_format
Definition: cbs_h264.h:77
static const AVOption h264_metadata_options[]
AVOption.
Definition: opt.h:246
uint8_t bit_rate_scale
Definition: cbs_h264.h:54
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
uint8_t chroma_sample_loc_type_bottom_field
Definition: cbs_h264.h:86
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:401
const char * desc
Definition: nvenc.c:68
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
void ff_cbs_delete_unit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position)
Delete a unit from a fragment and free all memory it uses.
Definition: cbs.c:796
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: avcodec.h:5763
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int ff_cbs_insert_unit_content(CodedBitstreamContext *ctx, 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:722
static AVPacket pkt
const AVBitStreamFilter ff_h264_metadata_bsf
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5784
uint8_t max_dec_frame_buffering
Definition: cbs_h264.h:108
uint8_t fixed_frame_rate_flag
Definition: cbs_h264.h:91
H264RawVUI vui
Definition: cbs_h264.h:163
int framerate
Definition: h264_levels.c:65
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
#define FLAGS
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
H264RawHRD nal_hrd_parameters
Definition: cbs_h264.h:94
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:72
#define LEVEL(name, value)
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:153
uint8_t
#define av_malloc(s)
AVOptions.
uint16_t pic_width_in_mbs_minus1
Definition: cbs_h264.h:149
int dpb_frames
Definition: h264_levels.c:159
uint16_t display_orientation_repetition_period
Definition: cbs_h264.h:304
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1252
uint32_t num_units_in_tick
Definition: cbs_h264.h:89
unregistered user data
Definition: h264_sei.h:33
display orientation
Definition: h264_sei.h:36
int level_idc
Definition: h264_levels.c:25
const char data[16]
Definition: mxf.c:91
int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)
Read the data bitstream from a packet into a fragment, then split into units and decompose.
Definition: cbs.c:242
const char * name
Definition: avcodec.h:5813
#define height
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
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:162
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:228
#define av_log(a,...)
uint8_t nal_hrd_parameters_present_flag
Definition: cbs_h264.h:93
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:157
H.264 common definitions.
static av_const int av_tolower(int c)
Locale-independent conversion of ASCII characters to lowercase.
Definition: avstring.h:241
uint8_t chroma_sample_loc_type_top_field
Definition: cbs_h264.h:85
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: avcodec.h:215
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
CodedBitstreamContext * cbc
uint8_t aspect_ratio_info_present_flag
Definition: cbs_h264.h:68
static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *pkt)
#define AVERROR(e)
Definition: error.h:43
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
Display matrix.
void ff_cbs_h264_delete_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *access_unit, CodedBitstreamUnit *nal_unit, int position)
Delete an SEI message from an access unit.
Definition: cbs_h2645.c:1586
uint8_t transfer_characteristics
Definition: cbs_h264.h:81
uint16_t sar_width
Definition: cbs_h264.h:70
uint8_t slice_type
Definition: cbs_h264.h:355
uint8_t frame_mbs_only_flag
Definition: cbs_h264.h:152
#define fail()
Definition: checkasm.h:120
uint8_t timing_info_present_flag
Definition: cbs_h264.h:88
uint8_t video_full_range_flag
Definition: cbs_h264.h:78
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:330
uint8_t colour_primaries
Definition: cbs_h264.h:80
#define NAN
Definition: mathematics.h:64
int ff_cbs_write_extradata(CodedBitstreamContext *ctx, AVCodecParameters *par, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to the extradata in codec parameters.
Definition: cbs.c:376
uint16_t sar_height
Definition: cbs_h264.h:71
#define width
uint8_t separate_colour_plane_flag
Definition: cbs_h264.h:127
CodedBitstreamFragment access_unit
uint8_t vui_parameters_present_flag
Definition: cbs_h264.h:162
#define CROP(border, unit)
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t colour_description_present_flag
Definition: cbs_h264.h:79
uint8_t video_signal_type_present_flag
Definition: cbs_h264.h:76
uint8_t chroma_format_idc
Definition: cbs_h264.h:126
#define FF_ARRAY_ELEMS(a)
uint8_t profile_idc
Definition: cbs_h264.h:114
#define rint
Definition: tablegen.h:41
uint32_t bit_rate_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:57
#define SET_OR_INFER(field, value, present_flag, infer)
uint8_t chroma_loc_info_present_flag
Definition: cbs_h264.h:84
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
Describe the class of an AVClass context structure.
Definition: log.h:67
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:142
Context structure for coded bitstream operations.
Definition: cbs.h:168
uint8_t matrix_coefficients
Definition: cbs_h264.h:82
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define isnan(x)
Definition: libm.h:340
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:295
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:115
static av_const int av_isxdigit(int c)
Locale-independent conversion of ASCII isxdigit.
Definition: avstring.h:251
H264RawSEIPayload payload[H264_MAX_SEI_PAYLOADS]
Definition: cbs_h264.h:347
int ff_cbs_read_extradata(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecParameters *par)
Read the extradata bitstream found in codec parameters into a fragment, then split into units and dec...
Definition: cbs.c:224
static enum AVCodecID h264_metadata_codec_ids[]
static int h264_metadata_init(AVBSFContext *bsf)
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *access_unit, const H264RawSEIPayload *payload)
Add an SEI message to an access unit.
Definition: cbs_h2645.c:1524
common internal and external API header
static const AVClass h264_metadata_class
static double c[64]
static void h264_metadata_close(AVBSFContext *bsf)
static enum AVCodecID codec_ids[]
#define OFFSET(x)
H264RawSEIDisplayOrientation display_orientation
Definition: cbs_h264.h:332
uint32_t time_scale
Definition: cbs_h264.h:90
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
uint8_t level_idc
Definition: cbs_h264.h:122
uint8_t bitstream_restriction_flag
Definition: cbs_h264.h:101
int den
Denominator.
Definition: rational.h:60
H264RawSliceHeader header
Definition: cbs_h264.h:430
int len
union H264RawSEIPayload::@51 payload
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3971
AVRational sample_aspect_ratio
double av_display_rotation_get(const int32_t matrix[9])
Extract the rotation component of the transformation matrix.
Definition: display.c:34
#define av_freep(p)
uint16_t pic_height_in_map_units_minus1
Definition: cbs_h264.h:150
uint8_t nal_unit_type
Definition: cbs_h264.h:42
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5791
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:239
uint8_t payload_count
Definition: cbs_h264.h:348
uint8_t vcl_hrd_parameters_present_flag
Definition: cbs_h264.h:95
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:90
H264RawHRD vcl_hrd_parameters
Definition: cbs_h264.h:96
uint8_t constraint_set3_flag
Definition: cbs_h264.h:118