FFmpeg
h264_metadata_bsf.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/avstring.h"
20 #include "libavutil/display.h"
21 #include "libavutil/common.h"
22 #include "libavutil/opt.h"
23 
24 #include "bsf.h"
25 #include "cbs.h"
26 #include "cbs_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:5793
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:69
uint8_t video_format
Definition: cbs_h264.h:77
static const AVOption h264_metadata_options[]
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
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:345
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:740
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:5759
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:666
static AVPacket pkt
const AVBitStreamFilter ff_h264_metadata_bsf
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5780
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)
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
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
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
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:239
const char * name
Definition: avcodec.h:5809
#define height
ptrdiff_t size
Definition: opengl_enc.c:100
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:154
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
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
static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *pkt)
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:1646
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:320
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
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:206
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:139
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:113
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:221
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:1584
common internal and external API header
static const AVClass h264_metadata_class
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:3967
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
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
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:5787
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:238
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