FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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_sei.h"
29 
30 enum {
35 };
36 
37 enum {
40 };
41 
42 typedef struct H264MetadataContext {
43  const AVClass *class;
44 
47 
49 
50  int aud;
51 
53 
59 
61 
64 
65  int crop_left;
67  int crop_top;
69 
70  const char *sei_user_data;
71 
73 
75  double rotate;
76  int flip;
78 
79 
81  H264RawSPS *sps)
82 {
84  int need_vui = 0;
85  int crop_unit_x, crop_unit_y;
86 
88  // Table E-1.
89  static const AVRational sar_idc[] = {
90  { 0, 0 }, // Unspecified (never written here).
91  { 1, 1 }, { 12, 11 }, { 10, 11 }, { 16, 11 },
92  { 40, 33 }, { 24, 11 }, { 20, 11 }, { 32, 11 },
93  { 80, 33 }, { 18, 11 }, { 15, 11 }, { 64, 33 },
94  { 160, 99 }, { 4, 3 }, { 3, 2 }, { 2, 1 },
95  };
96  int num, den, i;
97 
98  av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
99  ctx->sample_aspect_ratio.den, 65535);
100 
101  for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
102  if (num == sar_idc[i].num &&
103  den == sar_idc[i].den)
104  break;
105  }
106  if (i == FF_ARRAY_ELEMS(sar_idc)) {
107  sps->vui.aspect_ratio_idc = 255;
108  sps->vui.sar_width = num;
109  sps->vui.sar_height = den;
110  } else {
111  sps->vui.aspect_ratio_idc = i;
112  }
114  need_vui = 1;
115  }
116 
117 #define SET_OR_INFER(field, value, present_flag, infer) do { \
118  if (value >= 0) { \
119  field = value; \
120  need_vui = 1; \
121  } else if (!present_flag) \
122  field = infer; \
123  } while (0)
124 
125  if (ctx->video_format >= 0 ||
126  ctx->video_full_range_flag >= 0 ||
127  ctx->colour_primaries >= 0 ||
128  ctx->transfer_characteristics >= 0 ||
129  ctx->matrix_coefficients >= 0) {
130 
133 
137 
138  if (ctx->colour_primaries >= 0 ||
139  ctx->transfer_characteristics >= 0 ||
140  ctx->matrix_coefficients >= 0) {
141 
143  ctx->colour_primaries,
145 
149 
151  ctx->matrix_coefficients,
153 
155  }
157  need_vui = 1;
158  }
159 
160  if (ctx->chroma_sample_loc_type >= 0) {
166  need_vui = 1;
167  }
168 
169  if (ctx->tick_rate.num && ctx->tick_rate.den) {
170  int num, den;
171 
172  av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
173  UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
174 
175  sps->vui.time_scale = num;
176  sps->vui.num_units_in_tick = den;
177 
178  sps->vui.timing_info_present_flag = 1;
179  need_vui = 1;
180  }
183  sps->vui.timing_info_present_flag, 0);
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 (need_vui)
213 
214  return 0;
215 }
216 
218 {
220  AVPacket *in = NULL;
222  int err, i, j, has_sps;
223  H264RawAUD aud;
224  uint8_t *displaymatrix_side_data = NULL;
225  size_t displaymatrix_side_data_size = 0;
226 
227  err = ff_bsf_get_packet(bsf, &in);
228  if (err < 0)
229  return err;
230 
231  err = ff_cbs_read_packet(ctx->cbc, au, in);
232  if (err < 0) {
233  av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
234  goto fail;
235  }
236 
237  if (au->nb_units == 0) {
238  av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
239  err = AVERROR_INVALIDDATA;
240  goto fail;
241  }
242 
243  // If an AUD is present, it must be the first NAL unit.
244  if (au->units[0].type == H264_NAL_AUD) {
245  if (ctx->aud == REMOVE)
246  ff_cbs_delete_unit(ctx->cbc, au, 0);
247  } else {
248  if (ctx->aud == INSERT) {
249  static const int primary_pic_type_table[] = {
250  0x084, // 2, 7
251  0x0a5, // 0, 2, 5, 7
252  0x0e7, // 0, 1, 2, 5, 6, 7
253  0x210, // 4, 9
254  0x318, // 3, 4, 8, 9
255  0x294, // 2, 4, 7, 9
256  0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
257  0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
258  };
259  int primary_pic_type_mask = 0xff;
260 
261  for (i = 0; i < au->nb_units; i++) {
262  if (au->units[i].type == H264_NAL_SLICE ||
263  au->units[i].type == H264_NAL_IDR_SLICE) {
264  H264RawSlice *slice = au->units[i].content;
265  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
266  if (!(primary_pic_type_table[j] &
267  (1 << slice->header.slice_type)))
268  primary_pic_type_mask &= ~(1 << j);
269  }
270  }
271  }
272  for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
273  if (primary_pic_type_mask & (1 << j))
274  break;
275  if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
276  av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
277  "invalid slice types?\n");
278  err = AVERROR_INVALIDDATA;
279  goto fail;
280  }
281 
282  aud = (H264RawAUD) {
284  .primary_pic_type = j,
285  };
286 
287  err = ff_cbs_insert_unit_content(ctx->cbc, au,
288  0, H264_NAL_AUD, &aud, NULL);
289  if (err < 0) {
290  av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
291  goto fail;
292  }
293  }
294  }
295 
296  has_sps = 0;
297  for (i = 0; i < au->nb_units; i++) {
298  if (au->units[i].type == H264_NAL_SPS) {
299  err = h264_metadata_update_sps(bsf, au->units[i].content);
300  if (err < 0)
301  goto fail;
302  has_sps = 1;
303  }
304  }
305 
306  // Only insert the SEI in access units containing SPSs, and also
307  // unconditionally in the first access unit we ever see.
308  if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
309  H264RawSEIPayload payload = {
311  };
314 
315  for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
316  int c, v;
317  c = ctx->sei_user_data[i];
318  if (c == '-') {
319  continue;
320  } else if (av_isxdigit(c)) {
321  c = av_tolower(c);
322  v = (c <= '9' ? c - '0' : c - 'a' + 10);
323  } else {
324  goto invalid_user_data;
325  }
326  if (i & 1)
327  udu->uuid_iso_iec_11578[j / 2] |= v;
328  else
329  udu->uuid_iso_iec_11578[j / 2] = v << 4;
330  ++j;
331  }
332  if (j == 32 && ctx->sei_user_data[i] == '+') {
333  size_t len = strlen(ctx->sei_user_data + i + 1);
334 
335  udu->data_ref = av_buffer_alloc(len + 1);
336  if (!udu->data_ref) {
337  err = AVERROR(ENOMEM);
338  goto fail;
339  }
340 
341  udu->data = udu->data_ref->data;
342  udu->data_length = len + 1;
343  memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
344 
345  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
346  if (err < 0) {
347  av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
348  "message to access unit.\n");
349  goto fail;
350  }
351 
352  } else {
353  invalid_user_data:
354  av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
355  "must be \"UUID+string\".\n");
356  err = AVERROR(EINVAL);
357  goto fail;
358  }
359  }
360 
361  if (ctx->delete_filler) {
362  for (i = 0; i < au->nb_units; i++) {
363  if (au->units[i].type == H264_NAL_FILLER_DATA) {
364  // Filler NAL units.
365  err = ff_cbs_delete_unit(ctx->cbc, au, i);
366  if (err < 0) {
367  av_log(bsf, AV_LOG_ERROR, "Failed to delete "
368  "filler NAL.\n");
369  goto fail;
370  }
371  --i;
372  continue;
373  }
374 
375  if (au->units[i].type == H264_NAL_SEI) {
376  // Filler SEI messages.
377  H264RawSEI *sei = au->units[i].content;
378 
379  for (j = 0; j < sei->payload_count; j++) {
380  if (sei->payload[j].payload_type ==
382  err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
383  &au->units[i], j);
384  if (err < 0) {
385  av_log(bsf, AV_LOG_ERROR, "Failed to delete "
386  "filler SEI message.\n");
387  goto fail;
388  }
389  // Renumbering might have happened, start again at
390  // the same NAL unit position.
391  --i;
392  break;
393  }
394  }
395  }
396  }
397  }
398 
399  if (ctx->display_orientation != PASS) {
400  for (i = 0; i < au->nb_units; i++) {
401  H264RawSEI *sei;
402  if (au->units[i].type != H264_NAL_SEI)
403  continue;
404  sei = au->units[i].content;
405 
406  for (j = 0; j < sei->payload_count; j++) {
408  int32_t *matrix;
409 
410  if (sei->payload[j].payload_type !=
412  continue;
413  disp = &sei->payload[j].payload.display_orientation;
414 
415  if (ctx->display_orientation == REMOVE ||
416  ctx->display_orientation == INSERT) {
417  err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
418  &au->units[i], j);
419  if (err < 0) {
420  av_log(bsf, AV_LOG_ERROR, "Failed to delete "
421  "display orientation SEI message.\n");
422  goto fail;
423  }
424  --i;
425  break;
426  }
427 
428  matrix = av_mallocz(9 * sizeof(int32_t));
429  if (!matrix) {
430  err = AVERROR(ENOMEM);
431  goto fail;
432  }
433 
435  disp->anticlockwise_rotation *
436  180.0 / 65536.0);
437  av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
438 
439  // If there are multiple display orientation messages in an
440  // access unit then ignore all but the last one.
441  av_freep(&displaymatrix_side_data);
442 
443  displaymatrix_side_data = (uint8_t*)matrix;
444  displaymatrix_side_data_size = 9 * sizeof(int32_t);
445  }
446  }
447  }
448  if (ctx->display_orientation == INSERT) {
449  H264RawSEIPayload payload = {
451  };
453  &payload.payload.display_orientation;
454  uint8_t *data;
455  int size;
456  int write = 0;
457 
459  if (data && size >= 9 * sizeof(int32_t)) {
460  int32_t matrix[9];
461  int hflip, vflip;
462  double angle;
463 
464  memcpy(matrix, data, sizeof(matrix));
465 
466  hflip = vflip = 0;
467  if (matrix[0] < 0 && matrix[4] > 0)
468  hflip = 1;
469  else if (matrix[0] > 0 && matrix[4] < 0)
470  vflip = 1;
471  av_display_matrix_flip(matrix, hflip, vflip);
472 
473  angle = av_display_rotation_get(matrix);
474 
475  if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
476  matrix[2] != 0 || matrix[5] != 0 ||
477  matrix[6] != 0 || matrix[7] != 0) {
478  av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
479  "representable in H.264 parameters.\n");
480  } else {
481  disp->hor_flip = hflip;
482  disp->ver_flip = vflip;
483  disp->anticlockwise_rotation =
484  (uint16_t)rint((angle >= 0.0 ? angle
485  : angle + 360.0) *
486  65536.0 / 360.0);
487  write = 1;
488  }
489  }
490 
491  if (has_sps || !ctx->done_first_au) {
492  if (!isnan(ctx->rotate)) {
493  disp->anticlockwise_rotation =
494  (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
495  : ctx->rotate + 360.0) *
496  65536.0 / 360.0);
497  write = 1;
498  }
499  if (ctx->flip) {
500  disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
501  disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
502  write = 1;
503  }
504  }
505 
506  if (write) {
508 
509  err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
510  if (err < 0) {
511  av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
512  "SEI message to access unit.\n");
513  goto fail;
514  }
515  }
516  }
517 
518  err = ff_cbs_write_packet(ctx->cbc, out, au);
519  if (err < 0) {
520  av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
521  goto fail;
522  }
523 
524  err = av_packet_copy_props(out, in);
525  if (err < 0)
526  goto fail;
527 
528  if (displaymatrix_side_data) {
530  displaymatrix_side_data,
531  displaymatrix_side_data_size);
532  if (err) {
533  av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
534  "displaymatrix side data to packet.\n");
535  goto fail;
536  }
537  displaymatrix_side_data = NULL;
538  }
539 
540  ctx->done_first_au = 1;
541 
542  err = 0;
543 fail:
544  ff_cbs_fragment_uninit(ctx->cbc, au);
545  av_freep(&displaymatrix_side_data);
546 
547  if (err < 0)
548  av_packet_unref(out);
549  av_packet_free(&in);
550 
551  return err;
552 }
553 
555 {
558  int err, i;
559 
560  err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
561  if (err < 0)
562  return err;
563 
564  if (bsf->par_in->extradata) {
565  err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
566  if (err < 0) {
567  av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
568  goto fail;
569  }
570 
571  for (i = 0; i < au->nb_units; i++) {
572  if (au->units[i].type == H264_NAL_SPS) {
573  err = h264_metadata_update_sps(bsf, au->units[i].content);
574  if (err < 0)
575  goto fail;
576  }
577  }
578 
579  err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
580  if (err < 0) {
581  av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
582  goto fail;
583  }
584  }
585 
586  err = 0;
587 fail:
588  ff_cbs_fragment_uninit(ctx->cbc, au);
589  return err;
590 }
591 
593 {
595  ff_cbs_close(&ctx->cbc);
596 }
597 
598 #define OFFSET(x) offsetof(H264MetadataContext, x)
599 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
600 static const AVOption h264_metadata_options[] = {
601  { "aud", "Access Unit Delimiter NAL units",
603  { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
604  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
605  { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
606  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
607  { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
608  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
609  { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
610 
611  { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
612  OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
613  { .dbl = 0.0 }, 0, 65535, FLAGS },
614 
615  { "video_format", "Set video format (table E-2)",
616  OFFSET(video_format), AV_OPT_TYPE_INT,
617  { .i64 = -1 }, -1, 7, FLAGS},
618  { "video_full_range_flag", "Set video full range flag",
619  OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
620  { .i64 = -1 }, -1, 1, FLAGS },
621  { "colour_primaries", "Set colour primaries (table E-3)",
622  OFFSET(colour_primaries), AV_OPT_TYPE_INT,
623  { .i64 = -1 }, -1, 255, FLAGS },
624  { "transfer_characteristics", "Set transfer characteristics (table E-4)",
626  { .i64 = -1 }, -1, 255, FLAGS },
627  { "matrix_coefficients", "Set matrix coefficients (table E-5)",
628  OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
629  { .i64 = -1 }, -1, 255, FLAGS },
630 
631  { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
632  OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
633  { .i64 = -1 }, -1, 6, FLAGS },
634 
635  { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
636  OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
637  { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
638  { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
639  OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
640  { .i64 = -1 }, -1, 1, FLAGS },
641 
642  { "crop_left", "Set left border crop offset",
643  OFFSET(crop_left), AV_OPT_TYPE_INT,
644  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
645  { "crop_right", "Set right border crop offset",
646  OFFSET(crop_right), AV_OPT_TYPE_INT,
647  { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
648  { "crop_top", "Set top border crop offset",
649  OFFSET(crop_top), AV_OPT_TYPE_INT,
650  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
651  { "crop_bottom", "Set bottom border crop offset",
652  OFFSET(crop_bottom), AV_OPT_TYPE_INT,
653  { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
654 
655  { "sei_user_data", "Insert SEI user data (UUID+string)",
656  OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
657 
658  { "delete_filler", "Delete all filler (both NAL and SEI)",
659  OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
660 
661  { "display_orientation", "Display orientation SEI",
662  OFFSET(display_orientation), AV_OPT_TYPE_INT,
663  { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
664  { "pass", NULL, 0, AV_OPT_TYPE_CONST,
665  { .i64 = PASS }, .flags = FLAGS, .unit = "disp_or" },
666  { "insert", NULL, 0, AV_OPT_TYPE_CONST,
667  { .i64 = INSERT }, .flags = FLAGS, .unit = "disp_or" },
668  { "remove", NULL, 0, AV_OPT_TYPE_CONST,
669  { .i64 = REMOVE }, .flags = FLAGS, .unit = "disp_or" },
670  { "extract", NULL, 0, AV_OPT_TYPE_CONST,
671  { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
672 
673  { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
674  OFFSET(rotate), AV_OPT_TYPE_DOUBLE,
675  { .dbl = NAN }, -360.0, +360.0, FLAGS },
676  { "flip", "Set flip in display orientation SEI",
678  { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
679  { "horizontal", "Set hor_flip",
681  { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
682  { "vertical", "Set ver_flip",
684  { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
685 
686  { NULL }
687 };
688 
689 static const AVClass h264_metadata_class = {
690  .class_name = "h264_metadata_bsf",
691  .item_name = av_default_item_name,
692  .option = h264_metadata_options,
693  .version = LIBAVUTIL_VERSION_INT,
694 };
695 
696 static const enum AVCodecID h264_metadata_codec_ids[] = {
698 };
699 
701  .name = "h264_metadata",
702  .priv_data_size = sizeof(H264MetadataContext),
703  .priv_class = &h264_metadata_class,
705  .close = &h264_metadata_close,
708 };
static int h264_metadata_update_sps(AVBSFContext *bsf, H264RawSPS *sps)
uint32_t payload_type
Definition: cbs_h264.h:319
#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:5721
uint8_t aspect_ratio_idc
Definition: cbs_h264.h:70
uint8_t video_format
Definition: cbs_h264.h:78
static const AVOption h264_metadata_options[]
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#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:87
int ff_cbs_write_packet(CodedBitstreamContext *ctx, AVPacket *pkt, CodedBitstreamFragment *frag)
Write the bitstream of a fragment to a packet.
Definition: cbs.c:331
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:62
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:5687
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:558
int 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:1552
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
const AVBitStreamFilter ff_h264_metadata_bsf
void * priv_data
Opaque filter-specific private data.
Definition: avcodec.h:5708
uint8_t fixed_frame_rate_flag
Definition: cbs_h264.h:92
H264RawVUI vui
Definition: cbs_h264.h:164
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
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
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:114
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:62
uint8_t
AVOptions.
uint16_t display_orientation_repetition_period
Definition: cbs_h264.h:305
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1211
uint32_t num_units_in_tick
Definition: cbs_h264.h:90
unregistered user data
Definition: h264_sei.h:33
display orientation
Definition: h264_sei.h:36
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:221
const char * name
Definition: avcodec.h:5737
ptrdiff_t size
Definition: opengl_enc.c:101
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.
Definition: cbs.h:153
H264RawNALUnitHeader nal_unit_header
Definition: cbs_h264.h:229
#define av_log(a,...)
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:86
union H264RawSEIPayload::@42 payload
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:69
void ff_cbs_fragment_uninit(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free all allocated memory in a fragment.
Definition: cbs.c:127
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:136
#define AVERROR(e)
Definition: error.h:43
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
Display matrix.
uint8_t transfer_characteristics
Definition: cbs_h264.h:82
uint16_t sar_width
Definition: cbs_h264.h:71
uint8_t slice_type
Definition: cbs_h264.h:350
uint8_t frame_mbs_only_flag
Definition: cbs_h264.h:153
#define fail()
Definition: checkasm.h:117
uint8_t timing_info_present_flag
Definition: cbs_h264.h:89
uint8_t video_full_range_flag
Definition: cbs_h264.h:79
H264RawSEIUserDataUnregistered user_data_unregistered
Definition: cbs_h264.h:327
static const struct TransferCharacteristics transfer_characteristics[AVCOL_TRC_NB]
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: avpacket.c:558
uint8_t colour_primaries
Definition: cbs_h264.h:81
#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:306
uint16_t sar_height
Definition: cbs_h264.h:72
uint8_t separate_colour_plane_flag
Definition: cbs_h264.h:128
CodedBitstreamFragment access_unit
uint8_t vui_parameters_present_flag
Definition: cbs_h264.h:163
#define CROP(border, unit)
int32_t
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t colour_description_present_flag
Definition: cbs_h264.h:80
uint8_t video_signal_type_present_flag
Definition: cbs_h264.h:77
int 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:632
uint8_t chroma_format_idc
Definition: cbs_h264.h:127
#define FF_ARRAY_ELEMS(a)
#define rint
Definition: tablegen.h:41
#define SET_OR_INFER(field, value, present_flag, infer)
uint8_t chroma_loc_info_present_flag
Definition: cbs_h264.h:85
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:592
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)
Describe the class of an AVClass context structure.
Definition: log.h:67
Context structure for coded bitstream operations.
Definition: cbs.h:159
uint8_t matrix_coefficients
Definition: cbs_h264.h:83
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:101
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:342
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:201
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:1490
common internal and external API header
static const AVClass h264_metadata_class
static double c[64]
static void h264_metadata_close(AVBSFContext *bsf)
static enum AVCodecID codec_ids[]
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
Called by the bitstream filters to get the next packet for filtering.
Definition: bsf.c:206
#define OFFSET(x)
H264RawSEIDisplayOrientation display_orientation
Definition: cbs_h264.h:329
uint32_t time_scale
Definition: cbs_h264.h:91
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
int den
Denominator.
Definition: rational.h:60
H264RawSliceHeader header
Definition: cbs_h264.h:425
int len
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: avcodec.h:3898
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
FILE * out
Definition: movenc.c:54
#define av_freep(p)
uint8_t nal_unit_type
Definition: cbs_h264.h:43
This structure stores compressed data.
Definition: avcodec.h:1407
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5715
uint8_t payload_count
Definition: cbs_h264.h:343
static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *out)