2 * This file is part of FFmpeg.
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.
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.
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
19 #include "libavutil/avstring.h"
20 #include "libavutil/display.h"
21 #include "libavutil/common.h"
22 #include "libavutil/opt.h"
42 typedef struct H264MetadataContext {
45 CodedBitstreamContext *cbc;
46 CodedBitstreamFragment access_unit;
52 AVRational sample_aspect_ratio;
55 int video_full_range_flag;
57 int transfer_characteristics;
58 int matrix_coefficients;
60 int chroma_sample_loc_type;
63 int fixed_frame_rate_flag;
70 const char *sei_user_data;
74 int display_orientation;
77 } H264MetadataContext;
80 static int h264_metadata_update_sps(AVBSFContext *bsf,
83 H264MetadataContext *ctx = bsf->priv_data;
85 int crop_unit_x, crop_unit_y;
87 if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
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 },
98 av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
99 ctx->sample_aspect_ratio.den, 65535);
101 for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
102 if (num == sar_idc[i].num &&
103 den == sar_idc[i].den)
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;
111 sps->vui.aspect_ratio_idc = i;
113 sps->vui.aspect_ratio_info_present_flag = 1;
117 #define SET_OR_INFER(field, value, present_flag, infer) do { \
121 } else if (!present_flag) \
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) {
131 SET_OR_INFER(sps->vui.video_format, ctx->video_format,
132 sps->vui.video_signal_type_present_flag, 5);
134 SET_OR_INFER(sps->vui.video_full_range_flag,
135 ctx->video_full_range_flag,
136 sps->vui.video_signal_type_present_flag, 0);
138 if (ctx->colour_primaries >= 0 ||
139 ctx->transfer_characteristics >= 0 ||
140 ctx->matrix_coefficients >= 0) {
142 SET_OR_INFER(sps->vui.colour_primaries,
143 ctx->colour_primaries,
144 sps->vui.colour_description_present_flag, 2);
146 SET_OR_INFER(sps->vui.transfer_characteristics,
147 ctx->transfer_characteristics,
148 sps->vui.colour_description_present_flag, 2);
150 SET_OR_INFER(sps->vui.matrix_coefficients,
151 ctx->matrix_coefficients,
152 sps->vui.colour_description_present_flag, 2);
154 sps->vui.colour_description_present_flag = 1;
156 sps->vui.video_signal_type_present_flag = 1;
160 if (ctx->chroma_sample_loc_type >= 0) {
161 sps->vui.chroma_sample_loc_type_top_field =
162 ctx->chroma_sample_loc_type;
163 sps->vui.chroma_sample_loc_type_bottom_field =
164 ctx->chroma_sample_loc_type;
165 sps->vui.chroma_loc_info_present_flag = 1;
169 if (ctx->tick_rate.num && ctx->tick_rate.den) {
172 av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
173 UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
175 sps->vui.time_scale = num;
176 sps->vui.num_units_in_tick = den;
178 sps->vui.timing_info_present_flag = 1;
181 SET_OR_INFER(sps->vui.fixed_frame_rate_flag,
182 ctx->fixed_frame_rate_flag,
183 sps->vui.timing_info_present_flag, 0);
185 if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
187 crop_unit_y = 2 - sps->frame_mbs_only_flag;
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);
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); \
200 sps->frame_crop_ ## border ## _offset = \
201 ctx->crop_ ## border / unit; \
202 sps->frame_cropping_flag = 1; \
205 CROP(left, crop_unit_x);
206 CROP(right, crop_unit_x);
207 CROP(top, crop_unit_y);
208 CROP(bottom, crop_unit_y);
212 sps->vui_parameters_present_flag = 1;
217 static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *out)
219 H264MetadataContext *ctx = bsf->priv_data;
221 CodedBitstreamFragment *au = &ctx->access_unit;
222 int err, i, j, has_sps;
224 uint8_t *displaymatrix_side_data = NULL;
225 size_t displaymatrix_side_data_size = 0;
227 err = ff_bsf_get_packet(bsf, &in);
231 err = ff_cbs_read_packet(ctx->cbc, au, in);
233 av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
237 if (au->nb_units == 0) {
238 av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
239 err = AVERROR_INVALIDDATA;
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);
248 if (ctx->aud == INSERT) {
249 static const int primary_pic_type_table[] = {
252 0x0e7, // 0, 1, 2, 5, 6, 7
256 0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
257 0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
259 int primary_pic_type_mask = 0xff;
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);
272 for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
273 if (primary_pic_type_mask & (1 << j))
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;
283 .nal_unit_header.nal_unit_type = H264_NAL_AUD,
284 .primary_pic_type = j,
287 err = ff_cbs_insert_unit_content(ctx->cbc, au,
288 0, H264_NAL_AUD, &aud, NULL);
290 av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
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);
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 = {
310 .payload_type = H264_SEI_TYPE_USER_DATA_UNREGISTERED,
312 H264RawSEIUserDataUnregistered *udu =
313 &payload.payload.user_data_unregistered;
315 for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
317 c = ctx->sei_user_data[i];
320 } else if (av_isxdigit(c)) {
322 v = (c <= '9' ? c - '0' : c - 'a' + 10);
324 goto invalid_user_data;
327 udu->uuid_iso_iec_11578[j / 2] |= v;
329 udu->uuid_iso_iec_11578[j / 2] = v << 4;
332 if (j == 32 && ctx->sei_user_data[i] == '+') {
333 size_t len = strlen(ctx->sei_user_data + i + 1);
335 udu->data_ref = av_buffer_alloc(len + 1);
336 if (!udu->data_ref) {
337 err = AVERROR(ENOMEM);
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);
345 err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
347 av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
348 "message to access unit.\n");
354 av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
355 "must be \"UUID+string\".\n");
356 err = AVERROR(EINVAL);
361 if (ctx->delete_filler) {
362 for (i = 0; i < au->nb_units; i++) {
363 if (au->units[i].type == H264_NAL_FILLER_DATA) {
365 err = ff_cbs_delete_unit(ctx->cbc, au, i);
367 av_log(bsf, AV_LOG_ERROR, "Failed to delete "
375 if (au->units[i].type == H264_NAL_SEI) {
376 // Filler SEI messages.
377 H264RawSEI *sei = au->units[i].content;
379 for (j = 0; j < sei->payload_count; j++) {
380 if (sei->payload[j].payload_type ==
381 H264_SEI_TYPE_FILLER_PAYLOAD) {
382 err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
385 av_log(bsf, AV_LOG_ERROR, "Failed to delete "
386 "filler SEI message.\n");
389 // Renumbering might have happened, start again at
390 // the same NAL unit position.
399 if (ctx->display_orientation != PASS) {
400 for (i = 0; i < au->nb_units; i++) {
402 if (au->units[i].type != H264_NAL_SEI)
404 sei = au->units[i].content;
406 for (j = 0; j < sei->payload_count; j++) {
407 H264RawSEIDisplayOrientation *disp;
410 if (sei->payload[j].payload_type !=
411 H264_SEI_TYPE_DISPLAY_ORIENTATION)
413 disp = &sei->payload[j].payload.display_orientation;
415 if (ctx->display_orientation == REMOVE ||
416 ctx->display_orientation == INSERT) {
417 err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
420 av_log(bsf, AV_LOG_ERROR, "Failed to delete "
421 "display orientation SEI message.\n");
428 matrix = av_mallocz(9 * sizeof(int32_t));
430 err = AVERROR(ENOMEM);
434 av_display_rotation_set(matrix,
435 disp->anticlockwise_rotation *
437 av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
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);
443 displaymatrix_side_data = (uint8_t*)matrix;
444 displaymatrix_side_data_size = 9 * sizeof(int32_t);
448 if (ctx->display_orientation == INSERT) {
449 H264RawSEIPayload payload = {
450 .payload_type = H264_SEI_TYPE_DISPLAY_ORIENTATION,
452 H264RawSEIDisplayOrientation *disp =
453 &payload.payload.display_orientation;
458 data = av_packet_get_side_data(in, AV_PKT_DATA_DISPLAYMATRIX, &size);
459 if (data && size >= 9 * sizeof(int32_t)) {
464 memcpy(matrix, data, sizeof(matrix));
467 if (matrix[0] < 0 && matrix[4] > 0)
469 else if (matrix[0] > 0 && matrix[4] < 0)
471 av_display_matrix_flip(matrix, hflip, vflip);
473 angle = av_display_rotation_get(matrix);
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");
481 disp->hor_flip = hflip;
482 disp->ver_flip = vflip;
483 disp->anticlockwise_rotation =
484 (uint16_t)rint((angle >= 0.0 ? angle
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) *
500 disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
501 disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
507 disp->display_orientation_repetition_period = 1;
509 err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
511 av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
512 "SEI message to access unit.\n");
518 err = ff_cbs_write_packet(ctx->cbc, out, au);
520 av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
524 err = av_packet_copy_props(out, in);
528 if (displaymatrix_side_data) {
529 err = av_packet_add_side_data(out, AV_PKT_DATA_DISPLAYMATRIX,
530 displaymatrix_side_data,
531 displaymatrix_side_data_size);
533 av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
534 "displaymatrix side data to packet.\n");
537 displaymatrix_side_data = NULL;
540 ctx->done_first_au = 1;
544 ff_cbs_fragment_uninit(ctx->cbc, au);
545 av_freep(&displaymatrix_side_data);
548 av_packet_unref(out);
554 static int h264_metadata_init(AVBSFContext *bsf)
556 H264MetadataContext *ctx = bsf->priv_data;
557 CodedBitstreamFragment *au = &ctx->access_unit;
560 err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
564 if (bsf->par_in->extradata) {
565 err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
567 av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
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);
579 err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
581 av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
588 ff_cbs_fragment_uninit(ctx->cbc, au);
592 static void h264_metadata_close(AVBSFContext *bsf)
594 H264MetadataContext *ctx = bsf->priv_data;
595 ff_cbs_close(&ctx->cbc);
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",
602 OFFSET(aud), AV_OPT_TYPE_INT,
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" },
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 },
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)",
625 OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,
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 },
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 },
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 },
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 },
655 { "sei_user_data", "Insert SEI user data (UUID+string)",
656 OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
658 { "delete_filler", "Delete all filler (both NAL and SEI)",
659 OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
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" },
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",
677 OFFSET(flip), AV_OPT_TYPE_FLAGS,
678 { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
679 { "horizontal", "Set hor_flip",
680 0, AV_OPT_TYPE_CONST,
681 { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
682 { "vertical", "Set ver_flip",
683 0, AV_OPT_TYPE_CONST,
684 { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
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,
696 static const enum AVCodecID h264_metadata_codec_ids[] = {
697 AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
700 const AVBitStreamFilter ff_h264_metadata_bsf = {
701 .name = "h264_metadata",
702 .priv_data_size = sizeof(H264MetadataContext),
703 .priv_class = &h264_metadata_class,
704 .init = &h264_metadata_init,
705 .close = &h264_metadata_close,
706 .filter = &h264_metadata_filter,
707 .codec_ids = h264_metadata_codec_ids,