FFmpeg  4.3.6
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 "bsf_internal.h"
26 #include "cbs.h"
27 #include "cbs_h264.h"
28 #include "h264.h"
29 #include "h264_levels.h"
30 #include "h264_sei.h"
31 
32 enum {
37 };
38 
39 enum {
42 };
43 
44 enum {
46  LEVEL_AUTO = -1,
47 };
48 
49 typedef struct H264MetadataContext {
50  const AVClass *class;
51 
54 
56 
57  int aud;
58 
60 
62 
68 
70 
73 
74  int crop_left;
76  int crop_top;
78 
79  const char *sei_user_data;
80 
82 
84  double rotate;
85  int flip;
86 
87  int level;
89 
90 
92  H264RawSPS *sps)
93 {
95  int need_vui = 0;
96  int crop_unit_x, crop_unit_y;
97 
99  // Table E-1.
100  static const AVRational sar_idc[] = {
101  { 0, 0 }, // Unspecified (never written here).
102  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
103  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
104  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
105  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
106  };
107  int num, den, i;
108 
109  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
110  ctx->sample_aspect_ratio.den, 65535);
111 
112  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
113  if (num == sar_idc[i].num &&
114  den == sar_idc[i].den)
115  break;
116  }
117  if (i == FF_ARRAY_ELEMS(sar_idc)) {
118  sps->vui.aspect_ratio_idc = 255;
119  sps->vui.sar_width = num;
120  sps->vui.sar_height = den;
121  } else {
122  sps->vui.aspect_ratio_idc = i;
123  }
125  need_vui = 1;
126  }
127 
128 #define SET_VUI_FIELD(field) do { \
129  if (ctx->field >= 0) { \
130  sps->vui.field = ctx->field; \
131  need_vui = 1; \
132  } \
133  } while (0)
134 
135  if (ctx->overscan_appropriate_flag >= 0) {
138  }
139 
140  if (ctx->video_format >= 0 ||
141  ctx->video_full_range_flag >= 0 ||
142  ctx->colour_primaries >= 0 ||
143  ctx->transfer_characteristics >= 0 ||
144  ctx->matrix_coefficients >= 0) {
145 
147 
149 
150  if (ctx->colour_primaries >= 0 ||
151  ctx->transfer_characteristics >= 0 ||
152  ctx->matrix_coefficients >= 0) {
153 
157 
159  }
161  }
162 
163  if (ctx->chroma_sample_loc_type >= 0) {
169  need_vui = 1;
170  }
171 
172  if (ctx->tick_rate.num && ctx->tick_rate.den) {
173  int num, den;
174 
175  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
176  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
177 
178  sps->vui.time_scale = num;
179  sps->vui.num_units_in_tick = den;
180 
181  sps->vui.timing_info_present_flag = 1;
182  need_vui = 1;
183  }
185 
186  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
187  crop_unit_x = 1;
188  crop_unit_y = 2 - sps->frame_mbs_only_flag;
189  } else {
190  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
191  crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
192  (2 - sps->frame_mbs_only_flag);
193  }
194 #define CROP(border, unit) do { \
195  if (ctx->crop_ ## border >= 0) { \
196  if (ctx->crop_ ## border % unit != 0) { \
197  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
198  "must be a multiple of %d.\n", #border, unit); \
199  return AVERROR(EINVAL); \
200  } \
201  sps->frame_crop_ ## border ## _offset = \
202  ctx->crop_ ## border / unit; \
203  sps->frame_cropping_flag = 1; \
204  } \
205  } while (0)
206  CROP(left, crop_unit_x);
207  CROP(right, crop_unit_x);
208  CROP(top, crop_unit_y);
209  CROP(bottom, crop_unit_y);
210 #undef CROP
211 
212  if (ctx->level != LEVEL_UNSET) {
213  int level_idc;
214 
215  if (ctx->level == LEVEL_AUTO) {
216  const H264LevelDescriptor *desc;
217  int64_t bit_rate;
218  int width, height, dpb_frames;
219  int framerate;
220 
222  bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
223  (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
224  } else if (sps->vui.vcl_hrd_parameters_present_flag) {
225  bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
226  (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
227  // Adjust for VCL vs. NAL limits.
228  bit_rate = bit_rate * 6 / 5;
229  } else {
230  bit_rate = 0;
231  }
232 
233  // Don't use max_dec_frame_buffering if it is only inferred.
234  dpb_frames = sps->vui.bitstream_restriction_flag ?
236 
237  width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
238  height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
239  (2 - sps->frame_mbs_only_flag);
240 
241  if (sps->vui.timing_info_present_flag)
242  framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;
243  else
244  framerate = 0;
245 
246  desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,
247  width, height, dpb_frames);
248  if (desc) {
249  level_idc = desc->level_idc;
250  } else {
251  av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
252  "conform to any level: using level 6.2.\n");
253  level_idc = 62;
254  }
255  } else {
256  level_idc = ctx->level;
257  }
258 
259  if (level_idc == 9) {
260  if (sps->profile_idc == 66 ||
261  sps->profile_idc == 77 ||
262  sps->profile_idc == 88) {
263  sps->level_idc = 11;
264  sps->constraint_set3_flag = 1;
265  } else {
266  sps->level_idc = 9;
267  }
268  } else {
269  sps->level_idc = level_idc;
270  }
271  }
272 
273  if (need_vui)
275 
276  return 0;
277 }
278 
280 {
283  uint8_t *side_data;
284  int side_data_size;
285  int err, i;
286 
288  &side_data_size);
289  if (!side_data_size)
290  return 0;
291 
292  err = ff_cbs_read(ctx->cbc, au, side_data, side_data_size);
293  if (err < 0) {
294  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata from packet side data.\n");
295  return err;
296  }
297 
298  for (i = 0; i < au->nb_units; i++) {
299  if (au->units[i].type == H264_NAL_SPS) {
300  err = h264_metadata_update_sps(bsf, au->units[i].content);
301  if (err < 0)
302  return err;
303  }
304  }
305 
306  err = ff_cbs_write_fragment_data(ctx->cbc, au);
307  if (err < 0) {
308  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata into packet side data.\n");
309  return err;
310  }
311 
313  if (!side_data)
314  return AVERROR(ENOMEM);
315  memcpy(side_data, au->data, au->data_size);
316 
317  ff_cbs_fragment_reset(ctx->cbc, au);
318 
319  return 0;
320 }
321 
323 {
326  int err, i, j, has_sps;
327  H264RawAUD aud;
328 
329  err = ff_bsf_get_packet_ref(bsf, pkt);
330  if (err < 0)
331  return err;
332 
333  err = h264_metadata_update_side_data(bsf, pkt);
334  if (err < 0)
335  goto fail;
336 
337  err = ff_cbs_read_packet(ctx->cbc, au, pkt);
338  if (err < 0) {
339  av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
340  goto fail;
341  }
342 
343  if (au->nb_units == 0) {
344  av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
345  err = AVERROR_INVALIDDATA;
346  goto fail;
347  }
348 
349  // If an AUD is present, it must be the first NAL unit.
350  if (au->units[0].type == H264_NAL_AUD) {
351  if (ctx->aud == REMOVE)
352  ff_cbs_delete_unit(ctx->cbc, au, 0);
353  } else {
354  if (ctx->aud == INSERT) {
355  static const int primary_pic_type_table[] = {
356  0x084, // 2, 7
357  0x0a5, // 0, 2, 5, 7
358  0x0e7, // 0, 1, 2, 5, 6, 7
359  0x210, // 4, 9
360  0x318, // 3, 4, 8, 9
361  0x294, // 2, 4, 7, 9
362  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
363  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
364  };
365  int primary_pic_type_mask = 0xff;
366 
367  for (i = 0; i < au->nb_units; i++) {
368  if (au->units[i].type == H264_NAL_SLICE ||
369  au->units[i].type == H264_NAL_IDR_SLICE) {
370  H264RawSlice *slice = au->units[i].content;
371  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
372  if (!(primary_pic_type_table[j] &
373  (1 << slice->header.slice_type)))
374  primary_pic_type_mask &= ~(1 << j);
375  }
376  }
377  }
378  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
379  if (primary_pic_type_mask & (1 << j))
380  break;
381  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
382  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
383  "invalid slice types?\n");
384  err = AVERROR_INVALIDDATA;
385  goto fail;
386  }
387 
388  aud = (H264RawAUD) {
390  .primary_pic_type = j,
391  };
392 
393  err = ff_cbs_insert_unit_content(ctx->cbc, au,
394  0, H264_NAL_AUD, &aud, NULL);
395  if (err < 0) {
396  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
397  goto fail;
398  }
399  }
400  }
401 
402  has_sps = 0;
403  for (i = 0; i < au->nb_units; i++) {
404  if (au->units[i].type == H264_NAL_SPS) {
405  err = h264_metadata_update_sps(bsf, au->units[i].content);
406  if (err < 0)
407  goto fail;
408  has_sps = 1;
409  }
410  }
411 
412  // Only insert the SEI in access units containing SPSs, and also
413  // unconditionally in the first access unit we ever see.
414  if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
415  H264RawSEIPayload payload = {
417  };
420 
421  for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
422  int c, v;
423  c = ctx->sei_user_data[i];
424  if (c == '-') {
425  continue;
426  } else if (av_isxdigit(c)) {
427  c = av_tolower(c);
428  v = (c <= '9' ? c - '0' : c - 'a' + 10);
429  } else {
430  goto invalid_user_data;
431  }
432  if (j & 1)
433  udu->uuid_iso_iec_11578[j / 2] |= v;
434  else
435  udu->uuid_iso_iec_11578[j / 2] = v << 4;
436  ++j;
437  }
438  if (j == 32 && ctx->sei_user_data[i] == '+') {
439  size_t len = strlen(ctx->sei_user_data + i + 1);
440 
441  udu->data_ref = av_buffer_alloc(len + 1);
442  if (!udu->data_ref) {
443  err = AVERROR(ENOMEM);
444  goto fail;
445  }
446 
447  udu->data = udu->data_ref->data;
448  udu->data_length = len + 1;
449  memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
450 
451  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
452  if (err < 0) {
453  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
454  "message to access unit.\n");
455  goto fail;
456  }
457 
458  } else {
459  invalid_user_data:
460  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
461  "must be \"UUID+string\".\n");
462  err = AVERROR(EINVAL);
463  goto fail;
464  }
465  }
466 
467  if (ctx->delete_filler) {
468  for (i = au->nb_units - 1; i >= 0; i--) {
469  if (au->units[i].type == H264_NAL_FILLER_DATA) {
470  ff_cbs_delete_unit(ctx->cbc, au, i);
471  continue;
472  }
473 
474  if (au->units[i].type == H264_NAL_SEI) {
475  // Filler SEI messages.
476  H264RawSEI *sei = au->units[i].content;
477 
478  for (j = sei->payload_count - 1; j >= 0; j--) {
479  if (sei->payload[j].payload_type ==
482  &au->units[i], j);
483  }
484  }
485  }
486  }
487 
488  if (ctx->display_orientation != PASS) {
489  for (i = au->nb_units - 1; i >= 0; i--) {
490  H264RawSEI *sei;
491  if (au->units[i].type != H264_NAL_SEI)
492  continue;
493  sei = au->units[i].content;
494 
495  for (j = sei->payload_count - 1; j >= 0; j--) {
497  int32_t *matrix;
498 
499  if (sei->payload[j].payload_type !=
501  continue;
502  disp = &sei->payload[j].payload.display_orientation;
503 
504  if (ctx->display_orientation == REMOVE ||
505  ctx->display_orientation == INSERT) {
507  &au->units[i], j);
508  continue;
509  }
510 
511  matrix = av_malloc(9 * sizeof(int32_t));
512  if (!matrix) {
513  err = AVERROR(ENOMEM);
514  goto fail;
515  }
516 
518  disp->anticlockwise_rotation *
519  180.0 / 65536.0);
520  av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
521 
522  // If there are multiple display orientation messages in an
523  // access unit, then the last one added to the packet (i.e.
524  // the first one in the access unit) will prevail.
526  (uint8_t*)matrix,
527  9 * sizeof(int32_t));
528  if (err < 0) {
529  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
530  "displaymatrix side data to packet.\n");
531  av_free(matrix);
532  goto fail;
533  }
534  }
535  }
536  }
537  if (ctx->display_orientation == INSERT) {
538  H264RawSEIPayload payload = {
540  };
542  &payload.payload.display_orientation;
543  uint8_t *data;
544  int size;
545  int write = 0;
546 
548  if (data && size >= 9 * sizeof(int32_t)) {
549  int32_t matrix[9];
550  int hflip, vflip;
551  double angle;
552 
553  memcpy(matrix, data, sizeof(matrix));
554 
555  hflip = vflip = 0;
556  if (matrix[0] < 0 && matrix[4] > 0)
557  hflip = 1;
558  else if (matrix[0] > 0 && matrix[4] < 0)
559  vflip = 1;
560  av_display_matrix_flip(matrix, hflip, vflip);
561 
562  angle = av_display_rotation_get(matrix);
563 
564  if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
565  matrix[2] != 0 || matrix[5] != 0 ||
566  matrix[6] != 0 || matrix[7] != 0) {
567  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
568  "representable in H.264 parameters.\n");
569  } else {
570  disp->hor_flip = hflip;
571  disp->ver_flip = vflip;
572  disp->anticlockwise_rotation =
573  (uint16_t)rint((angle >= 0.0 ? angle
574  : angle + 360.0) *
575  65536.0 / 360.0);
576  write = 1;
577  }
578  }
579 
580  if (has_sps || !ctx->done_first_au) {
581  if (!isnan(ctx->rotate)) {
582  disp->anticlockwise_rotation =
583  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
584  : ctx->rotate + 360.0) *
585  65536.0 / 360.0);
586  write = 1;
587  }
588  if (ctx->flip) {
589  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
590  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
591  write = 1;
592  }
593  }
594 
595  if (write) {
597 
598  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
599  if (err < 0) {
600  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
601  "SEI message to access unit.\n");
602  goto fail;
603  }
604  }
605  }
606 
607  err = ff_cbs_write_packet(ctx->cbc, pkt, au);
608  if (err < 0) {
609  av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
610  goto fail;
611  }
612 
613  ctx->done_first_au = 1;
614 
615  err = 0;
616 fail:
617  ff_cbs_fragment_reset(ctx->cbc, au);
618 
619  if (err < 0)
620  av_packet_unref(pkt);
621 
622  return err;
623 }
624 
626 {
629  int err, i;
630 
631  err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
632  if (err < 0)
633  return err;
634 
635  if (bsf->par_in->extradata) {
636  err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
637  if (err < 0) {
638  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
639  goto fail;
640  }
641 
642  for (i = 0; i < au->nb_units; i++) {
643  if (au->units[i].type == H264_NAL_SPS) {
644  err = h264_metadata_update_sps(bsf, au->units[i].content);
645  if (err < 0)
646  goto fail;
647  }
648  }
649 
650  err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
651  if (err < 0) {
652  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
653  goto fail;
654  }
655  }
656 
657  err = 0;
658 fail:
659  ff_cbs_fragment_reset(ctx->cbc, au);
660  return err;
661 }
662 
664 {
666 
667  ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
668  ff_cbs_close(&ctx->cbc);
669 }
670 
671 #define OFFSET(x) offsetof(H264MetadataContext, x)
672 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
673 static const AVOption h264_metadata_options[] = {
674  { "aud", "Access Unit Delimiter NAL units",
676  { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
677  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
678  { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
679  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
680  { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
681  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
682  { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
683 
684  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
686  { .dbl = 0.0 }, 0, 65535, FLAGS },
687 
688  { "overscan_appropriate_flag", "Set VUI overscan appropriate flag",
690  { .i64 = -1 }, -1, 1, FLAGS },
691 
692  { "video_format", "Set video format (table E-2)",
694  { .i64 = -1 }, -1, 7, FLAGS},
695  { "video_full_range_flag", "Set video full range flag",
697  { .i64 = -1 }, -1, 1, FLAGS },
698  { "colour_primaries", "Set colour primaries (table E-3)",
700  { .i64 = -1 }, -1, 255, FLAGS },
701  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
703  { .i64 = -1 }, -1, 255, FLAGS },
704  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
706  { .i64 = -1 }, -1, 255, FLAGS },
707 
708  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
710  { .i64 = -1 }, -1, 6, FLAGS },
711 
712  { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
714  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
715  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
717  { .i64 = -1 }, -1, 1, FLAGS },
718 
719  { "crop_left", "Set left border crop offset",
721  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
722  { "crop_right", "Set right border crop offset",
724  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
725  { "crop_top", "Set top border crop offset",
727  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
728  { "crop_bottom", "Set bottom border crop offset",
730  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
731 
732  { "sei_user_data", "Insert SEI user data (UUID+string)",
733  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
734 
735  { "delete_filler", "Delete all filler (both NAL and SEI)",
736  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
737 
738  { "display_orientation", "Display orientation SEI",
740  { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
741  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
742  { .i64 = PASS }, .flags = FLAGS, .unit = "disp_or" },
743  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
744  { .i64 = INSERT }, .flags = FLAGS, .unit = "disp_or" },
745  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
746  { .i64 = REMOVE }, .flags = FLAGS, .unit = "disp_or" },
747  { "extract", NULL, 0, AV_OPT_TYPE_CONST,
748  { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
749 
750  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
752  { .dbl = NAN }, -360.0, +360.0, FLAGS },
753  { "flip", "Set flip in display orientation SEI",
755  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
756  { "horizontal", "Set hor_flip",
758  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
759  { "vertical", "Set ver_flip",
761  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
762 
763  { "level", "Set level (table A-1)",
765  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
766  { "auto", "Attempt to guess level from stream properties",
768  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
769 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
770  { .i64 = value }, .flags = FLAGS, .unit = "level"
771  { LEVEL("1", 10) },
772  { LEVEL("1b", 9) },
773  { LEVEL("1.1", 11) },
774  { LEVEL("1.2", 12) },
775  { LEVEL("1.3", 13) },
776  { LEVEL("2", 20) },
777  { LEVEL("2.1", 21) },
778  { LEVEL("2.2", 22) },
779  { LEVEL("3", 30) },
780  { LEVEL("3.1", 31) },
781  { LEVEL("3.2", 32) },
782  { LEVEL("4", 40) },
783  { LEVEL("4.1", 41) },
784  { LEVEL("4.2", 42) },
785  { LEVEL("5", 50) },
786  { LEVEL("5.1", 51) },
787  { LEVEL("5.2", 52) },
788  { LEVEL("6", 60) },
789  { LEVEL("6.1", 61) },
790  { LEVEL("6.2", 62) },
791 #undef LEVEL
792 
793  { NULL }
794 };
795 
796 static const AVClass h264_metadata_class = {
797  .class_name = "h264_metadata_bsf",
798  .item_name = av_default_item_name,
799  .option = h264_metadata_options,
800  .version = LIBAVUTIL_VERSION_INT,
801 };
802 
803 static const enum AVCodecID h264_metadata_codec_ids[] = {
805 };
806 
808  .name = "h264_metadata",
809  .priv_data_size = sizeof(H264MetadataContext),
810  .priv_class = &h264_metadata_class,
812  .close = &h264_metadata_close,
815 };
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: bsf.h:83
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:69
int size
static const AVOption h264_metadata_options[]
AVOption.
Definition: opt.h:246
union H264RawSEIPayload::@28 payload
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:79
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:799
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: bsf.h:49
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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: bsf.h:70
uint8_t max_dec_frame_buffering
Definition: cbs_h264.h:108
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:196
uint8_t
#define av_malloc(s)
AVOptions.
uint8_t overscan_info_present_flag
Definition: cbs_h264.h:73
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: packet.h:108
uint32_t num_units_in_tick
Definition: cbs_h264.h:89
unregistered user data
Definition: h264_sei.h:34
display orientation
Definition: h264_sei.h:37
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: bsf.h:99
#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
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
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:269
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
#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:353
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:1596
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:123
uint8_t timing_info_present_flag
Definition: cbs_h264.h:88
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:330
#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
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define FF_ARRAY_ELEMS(a)
uint8_t profile_idc
Definition: cbs_h264.h:114
#define rint
Definition: tablegen.h:41
int ff_cbs_write_fragment_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Write the content of the fragment to its own internal buffer.
Definition: cbs.c:340
uint32_t bit_rate_value_minus1[H264_MAX_CPB_CNT]
Definition: cbs_h264.h:57
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
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:605
uint8_t * data
The data buffer.
Definition: buffer.h:89
#define SET_VUI_FIELD(field)
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
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define isnan(x)
Definition: libm.h:340
FF_ENABLE_DEPRECATION_WARNINGS 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:298
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)
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
#define av_free(p)
H264RawSliceHeader header
Definition: cbs_h264.h:430
int len
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
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
static int h264_metadata_update_side_data(AVBSFContext *bsf, AVPacket *pkt)
uint16_t pic_height_in_map_units_minus1
Definition: cbs_h264.h:150
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:332
int ff_cbs_read(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Read a bitstream from a memory region into a fragment, then split into units and decompose.
Definition: cbs.c:269
uint8_t nal_unit_type
Definition: cbs_h264.h:42
This structure stores compressed data.
Definition: packet.h:332
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:249
int ff_cbs_h264_add_sei_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *access_unit, H264RawSEIPayload *payload)
Add an SEI message to an access unit.
Definition: cbs_h2645.c:1534
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