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