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 
61 
67 
69 
72 
73  int crop_left;
75  int crop_top;
77 
78  const char *sei_user_data;
79 
81 
83  double rotate;
84  int flip;
85 
86  int level;
88 
89 
91  H264RawSPS *sps)
92 {
94  int need_vui = 0;
95  int crop_unit_x, crop_unit_y;
96 
98  // Table E-1.
99  static const AVRational sar_idc[] = {
100  { 0, 0 }, // Unspecified (never written here).
101  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
102  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
103  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
104  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
105  };
106  int num, den, i;
107 
108  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
109  ctx->sample_aspect_ratio.den, 65535);
110 
111  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
112  if (num == sar_idc[i].num &&
113  den == sar_idc[i].den)
114  break;
115  }
116  if (i == FF_ARRAY_ELEMS(sar_idc)) {
117  sps->vui.aspect_ratio_idc = 255;
118  sps->vui.sar_width = num;
119  sps->vui.sar_height = den;
120  } else {
121  sps->vui.aspect_ratio_idc = i;
122  }
124  need_vui = 1;
125  }
126 
127 #define SET_VUI_FIELD(field) do { \
128  if (ctx->field >= 0) { \
129  sps->vui.field = ctx->field; \
130  need_vui = 1; \
131  } \
132  } while (0)
133 
134  if (ctx->overscan_appropriate_flag >= 0) {
137  }
138 
139  if (ctx->video_format >= 0 ||
140  ctx->video_full_range_flag >= 0 ||
141  ctx->colour_primaries >= 0 ||
142  ctx->transfer_characteristics >= 0 ||
143  ctx->matrix_coefficients >= 0) {
144 
146 
148 
149  if (ctx->colour_primaries >= 0 ||
150  ctx->transfer_characteristics >= 0 ||
151  ctx->matrix_coefficients >= 0) {
152 
156 
158  }
160  }
161 
162  if (ctx->chroma_sample_loc_type >= 0) {
168  need_vui = 1;
169  }
170 
171  if (ctx->tick_rate.num && ctx->tick_rate.den) {
172  int num, den;
173 
174  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
175  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
176 
177  sps->vui.time_scale = num;
178  sps->vui.num_units_in_tick = den;
179 
180  sps->vui.timing_info_present_flag = 1;
181  need_vui = 1;
182  }
184 
185  if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
186  crop_unit_x = 1;
187  crop_unit_y = 2 - sps->frame_mbs_only_flag;
188  } else {
189  crop_unit_x = 1 + (sps->chroma_format_idc < 3);
190  crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
191  (2 - sps->frame_mbs_only_flag);
192  }
193 #define CROP(border, unit) do { \
194  if (ctx->crop_ ## border >= 0) { \
195  if (ctx->crop_ ## border % unit != 0) { \
196  av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
197  "must be a multiple of %d.\n", #border, unit); \
198  return AVERROR(EINVAL); \
199  } \
200  sps->frame_crop_ ## border ## _offset = \
201  ctx->crop_ ## border / unit; \
202  sps->frame_cropping_flag = 1; \
203  } \
204  } while (0)
205  CROP(left, crop_unit_x);
206  CROP(right, crop_unit_x);
207  CROP(top, crop_unit_y);
208  CROP(bottom, crop_unit_y);
209 #undef CROP
210 
211  if (ctx->level != LEVEL_UNSET) {
212  int level_idc;
213 
214  if (ctx->level == LEVEL_AUTO) {
215  const H264LevelDescriptor *desc;
216  int64_t bit_rate;
217  int width, height, dpb_frames;
218  int framerate;
219 
221  bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
222  (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
223  } else if (sps->vui.vcl_hrd_parameters_present_flag) {
224  bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
225  (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
226  // Adjust for VCL vs. NAL limits.
227  bit_rate = bit_rate * 6 / 5;
228  } else {
229  bit_rate = 0;
230  }
231 
232  // Don't use max_dec_frame_buffering if it is only inferred.
233  dpb_frames = sps->vui.bitstream_restriction_flag ?
235 
236  width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
237  height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
238  (2 - sps->frame_mbs_only_flag);
239 
240  if (sps->vui.timing_info_present_flag)
241  framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;
242  else
243  framerate = 0;
244 
245  desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,
246  width, height, dpb_frames);
247  if (desc) {
248  level_idc = desc->level_idc;
249  } else {
250  av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
251  "conform to any level: using level 6.2.\n");
252  level_idc = 62;
253  }
254  } else {
255  level_idc = ctx->level;
256  }
257 
258  if (level_idc == 9) {
259  if (sps->profile_idc == 66 ||
260  sps->profile_idc == 77 ||
261  sps->profile_idc == 88) {
262  sps->level_idc = 11;
263  sps->constraint_set3_flag = 1;
264  } else {
265  sps->level_idc = 9;
266  }
267  } else {
268  sps->level_idc = level_idc;
269  }
270  }
271 
272  if (need_vui)
274 
275  return 0;
276 }
277 
279 {
282  int err, i, j, has_sps;
283  H264RawAUD aud;
284 
285  err = ff_bsf_get_packet_ref(bsf, pkt);
286  if (err < 0)
287  return err;
288 
289  err = ff_cbs_read_packet(ctx->cbc, au, pkt);
290  if (err < 0) {
291  av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
292  goto fail;
293  }
294 
295  if (au->nb_units == 0) {
296  av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
297  err = AVERROR_INVALIDDATA;
298  goto fail;
299  }
300 
301  // If an AUD is present, it must be the first NAL unit.
302  if (au->units[0].type == H264_NAL_AUD) {
303  if (ctx->aud == REMOVE)
304  ff_cbs_delete_unit(ctx->cbc, au, 0);
305  } else {
306  if (ctx->aud == INSERT) {
307  static const int primary_pic_type_table[] = {
308  0x084, // 2, 7
309  0x0a5, // 0, 2, 5, 7
310  0x0e7, // 0, 1, 2, 5, 6, 7
311  0x210, // 4, 9
312  0x318, // 3, 4, 8, 9
313  0x294, // 2, 4, 7, 9
314  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
315  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
316  };
317  int primary_pic_type_mask = 0xff;
318 
319  for (i = 0; i < au->nb_units; i++) {
320  if (au->units[i].type == H264_NAL_SLICE ||
321  au->units[i].type == H264_NAL_IDR_SLICE) {
322  H264RawSlice *slice = au->units[i].content;
323  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
324  if (!(primary_pic_type_table[j] &
325  (1 << slice->header.slice_type)))
326  primary_pic_type_mask &= ~(1 << j);
327  }
328  }
329  }
330  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
331  if (primary_pic_type_mask & (1 << j))
332  break;
333  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
334  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
335  "invalid slice types?\n");
336  err = AVERROR_INVALIDDATA;
337  goto fail;
338  }
339 
340  aud = (H264RawAUD) {
342  .primary_pic_type = j,
343  };
344 
345  err = ff_cbs_insert_unit_content(ctx->cbc, au,
346  0, H264_NAL_AUD, &aud, NULL);
347  if (err < 0) {
348  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
349  goto fail;
350  }
351  }
352  }
353 
354  has_sps = 0;
355  for (i = 0; i < au->nb_units; i++) {
356  if (au->units[i].type == H264_NAL_SPS) {
357  err = h264_metadata_update_sps(bsf, au->units[i].content);
358  if (err < 0)
359  goto fail;
360  has_sps = 1;
361  }
362  }
363 
364  // Only insert the SEI in access units containing SPSs, and also
365  // unconditionally in the first access unit we ever see.
366  if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
367  H264RawSEIPayload payload = {
369  };
372 
373  for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
374  int c, v;
375  c = ctx->sei_user_data[i];
376  if (c == '-') {
377  continue;
378  } else if (av_isxdigit(c)) {
379  c = av_tolower(c);
380  v = (c <= '9' ? c - '0' : c - 'a' + 10);
381  } else {
382  goto invalid_user_data;
383  }
384  if (i & 1)
385  udu->uuid_iso_iec_11578[j / 2] |= v;
386  else
387  udu->uuid_iso_iec_11578[j / 2] = v << 4;
388  ++j;
389  }
390  if (j == 32 && ctx->sei_user_data[i] == '+') {
391  size_t len = strlen(ctx->sei_user_data + i + 1);
392 
393  udu->data_ref = av_buffer_alloc(len + 1);
394  if (!udu->data_ref) {
395  err = AVERROR(ENOMEM);
396  goto fail;
397  }
398 
399  udu->data = udu->data_ref->data;
400  udu->data_length = len + 1;
401  memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
402 
403  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
404  if (err < 0) {
405  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
406  "message to access unit.\n");
407  goto fail;
408  }
409 
410  } else {
411  invalid_user_data:
412  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
413  "must be \"UUID+string\".\n");
414  err = AVERROR(EINVAL);
415  goto fail;
416  }
417  }
418 
419  if (ctx->delete_filler) {
420  for (i = au->nb_units - 1; i >= 0; i--) {
421  if (au->units[i].type == H264_NAL_FILLER_DATA) {
422  ff_cbs_delete_unit(ctx->cbc, au, i);
423  continue;
424  }
425 
426  if (au->units[i].type == H264_NAL_SEI) {
427  // Filler SEI messages.
428  H264RawSEI *sei = au->units[i].content;
429 
430  for (j = sei->payload_count - 1; j >= 0; j--) {
431  if (sei->payload[j].payload_type ==
434  &au->units[i], j);
435  }
436  }
437  }
438  }
439 
440  if (ctx->display_orientation != PASS) {
441  for (i = au->nb_units - 1; i >= 0; i--) {
442  H264RawSEI *sei;
443  if (au->units[i].type != H264_NAL_SEI)
444  continue;
445  sei = au->units[i].content;
446 
447  for (j = sei->payload_count - 1; j >= 0; j--) {
449  int32_t *matrix;
450 
451  if (sei->payload[j].payload_type !=
453  continue;
454  disp = &sei->payload[j].payload.display_orientation;
455 
456  if (ctx->display_orientation == REMOVE ||
457  ctx->display_orientation == INSERT) {
459  &au->units[i], j);
460  continue;
461  }
462 
463  matrix = av_malloc(9 * sizeof(int32_t));
464  if (!matrix) {
465  err = AVERROR(ENOMEM);
466  goto fail;
467  }
468 
470  disp->anticlockwise_rotation *
471  180.0 / 65536.0);
472  av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
473 
474  // If there are multiple display orientation messages in an
475  // access unit, then the last one added to the packet (i.e.
476  // the first one in the access unit) will prevail.
478  (uint8_t*)matrix,
479  9 * sizeof(int32_t));
480  if (err < 0) {
481  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
482  "displaymatrix side data to packet.\n");
483  av_freep(matrix);
484  goto fail;
485  }
486  }
487  }
488  }
489  if (ctx->display_orientation == INSERT) {
490  H264RawSEIPayload payload = {
492  };
494  &payload.payload.display_orientation;
495  uint8_t *data;
496  int size;
497  int write = 0;
498 
500  if (data && size >= 9 * sizeof(int32_t)) {
501  int32_t matrix[9];
502  int hflip, vflip;
503  double angle;
504 
505  memcpy(matrix, data, sizeof(matrix));
506 
507  hflip = vflip = 0;
508  if (matrix[0] < 0 && matrix[4] > 0)
509  hflip = 1;
510  else if (matrix[0] > 0 && matrix[4] < 0)
511  vflip = 1;
512  av_display_matrix_flip(matrix, hflip, vflip);
513 
514  angle = av_display_rotation_get(matrix);
515 
516  if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
517  matrix[2] != 0 || matrix[5] != 0 ||
518  matrix[6] != 0 || matrix[7] != 0) {
519  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
520  "representable in H.264 parameters.\n");
521  } else {
522  disp->hor_flip = hflip;
523  disp->ver_flip = vflip;
524  disp->anticlockwise_rotation =
525  (uint16_t)rint((angle >= 0.0 ? angle
526  : angle + 360.0) *
527  65536.0 / 360.0);
528  write = 1;
529  }
530  }
531 
532  if (has_sps || !ctx->done_first_au) {
533  if (!isnan(ctx->rotate)) {
534  disp->anticlockwise_rotation =
535  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
536  : ctx->rotate + 360.0) *
537  65536.0 / 360.0);
538  write = 1;
539  }
540  if (ctx->flip) {
541  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
542  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
543  write = 1;
544  }
545  }
546 
547  if (write) {
549 
550  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
551  if (err < 0) {
552  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
553  "SEI message to access unit.\n");
554  goto fail;
555  }
556  }
557  }
558 
559  err = ff_cbs_write_packet(ctx->cbc, pkt, au);
560  if (err < 0) {
561  av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
562  goto fail;
563  }
564 
565  ctx->done_first_au = 1;
566 
567  err = 0;
568 fail:
569  ff_cbs_fragment_reset(ctx->cbc, au);
570 
571  if (err < 0)
572  av_packet_unref(pkt);
573 
574  return err;
575 }
576 
578 {
581  int err, i;
582 
583  err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
584  if (err < 0)
585  return err;
586 
587  if (bsf->par_in->extradata) {
588  err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
589  if (err < 0) {
590  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
591  goto fail;
592  }
593 
594  for (i = 0; i < au->nb_units; i++) {
595  if (au->units[i].type == H264_NAL_SPS) {
596  err = h264_metadata_update_sps(bsf, au->units[i].content);
597  if (err < 0)
598  goto fail;
599  }
600  }
601 
602  err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
603  if (err < 0) {
604  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
605  goto fail;
606  }
607  }
608 
609  err = 0;
610 fail:
611  ff_cbs_fragment_reset(ctx->cbc, au);
612  return err;
613 }
614 
616 {
618 
619  ff_cbs_fragment_free(ctx->cbc, &ctx->access_unit);
620  ff_cbs_close(&ctx->cbc);
621 }
622 
623 #define OFFSET(x) offsetof(H264MetadataContext, x)
624 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
625 static const AVOption h264_metadata_options[] = {
626  { "aud", "Access Unit Delimiter NAL units",
628  { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
629  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
630  { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
631  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
632  { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
633  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
634  { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
635 
636  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
638  { .dbl = 0.0 }, 0, 65535, FLAGS },
639 
640  { "overscan_appropriate_flag", "Set VUI overscan appropriate flag",
642  { .i64 = -1 }, -1, 1, FLAGS },
643 
644  { "video_format", "Set video format (table E-2)",
646  { .i64 = -1 }, -1, 7, FLAGS},
647  { "video_full_range_flag", "Set video full range flag",
649  { .i64 = -1 }, -1, 1, FLAGS },
650  { "colour_primaries", "Set colour primaries (table E-3)",
652  { .i64 = -1 }, -1, 255, FLAGS },
653  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
655  { .i64 = -1 }, -1, 255, FLAGS },
656  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
658  { .i64 = -1 }, -1, 255, FLAGS },
659 
660  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
662  { .i64 = -1 }, -1, 6, FLAGS },
663 
664  { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
666  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
667  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
669  { .i64 = -1 }, -1, 1, FLAGS },
670 
671  { "crop_left", "Set left border crop offset",
673  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
674  { "crop_right", "Set right border crop offset",
676  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
677  { "crop_top", "Set top border crop offset",
679  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
680  { "crop_bottom", "Set bottom border crop offset",
682  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
683 
684  { "sei_user_data", "Insert SEI user data (UUID+string)",
685  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
686 
687  { "delete_filler", "Delete all filler (both NAL and SEI)",
688  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
689 
690  { "display_orientation", "Display orientation SEI",
692  { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
693  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
694  { .i64 = PASS }, .flags = FLAGS, .unit = "disp_or" },
695  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
696  { .i64 = INSERT }, .flags = FLAGS, .unit = "disp_or" },
697  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
698  { .i64 = REMOVE }, .flags = FLAGS, .unit = "disp_or" },
699  { "extract", NULL, 0, AV_OPT_TYPE_CONST,
700  { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
701 
702  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
704  { .dbl = NAN }, -360.0, +360.0, FLAGS },
705  { "flip", "Set flip in display orientation SEI",
707  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
708  { "horizontal", "Set hor_flip",
710  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
711  { "vertical", "Set ver_flip",
713  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
714 
715  { "level", "Set level (table A-1)",
717  { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
718  { "auto", "Attempt to guess level from stream properties",
720  { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
721 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
722  { .i64 = value }, .flags = FLAGS, .unit = "level"
723  { LEVEL("1", 10) },
724  { LEVEL("1b", 9) },
725  { LEVEL("1.1", 11) },
726  { LEVEL("1.2", 12) },
727  { LEVEL("1.3", 13) },
728  { LEVEL("2", 20) },
729  { LEVEL("2.1", 21) },
730  { LEVEL("2.2", 22) },
731  { LEVEL("3", 30) },
732  { LEVEL("3.1", 31) },
733  { LEVEL("3.2", 32) },
734  { LEVEL("4", 40) },
735  { LEVEL("4.1", 41) },
736  { LEVEL("4.2", 42) },
737  { LEVEL("5", 50) },
738  { LEVEL("5.1", 51) },
739  { LEVEL("5.2", 52) },
740  { LEVEL("6", 60) },
741  { LEVEL("6.1", 61) },
742  { LEVEL("6.2", 62) },
743 #undef LEVEL
744 
745  { NULL }
746 };
747 
748 static const AVClass h264_metadata_class = {
749  .class_name = "h264_metadata_bsf",
750  .item_name = av_default_item_name,
751  .option = h264_metadata_options,
752  .version = LIBAVUTIL_VERSION_INT,
753 };
754 
755 static const enum AVCodecID h264_metadata_codec_ids[] = {
757 };
758 
760  .name = "h264_metadata",
761  .priv_data_size = sizeof(H264MetadataContext),
762  .priv_class = &h264_metadata_class,
764  .close = &h264_metadata_close,
767 };
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:5808
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:69
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:5774
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:5795
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)
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
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:1255
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:5824
#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:1649
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:122
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: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
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
#define SET_VUI_FIELD(field)
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
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)
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:3982
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:1457
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5802
int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
Called by bitstream filters to get packet for filtering.
Definition: bsf.c:239
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:1587
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