*/
#include "libavutil/avstring.h"
+#include "libavutil/display.h"
#include "libavutil/common.h"
#include "libavutil/opt.h"
#include "cbs.h"
#include "cbs_h264.h"
#include "h264.h"
+#include "h264_levels.h"
#include "h264_sei.h"
enum {
PASS,
INSERT,
REMOVE,
+ EXTRACT,
+};
+
+enum {
+ FLIP_HORIZONTAL = 1,
+ FLIP_VERTICAL = 2,
+};
+
+enum {
+ LEVEL_UNSET = -2,
+ LEVEL_AUTO = -1,
};
typedef struct H264MetadataContext {
CodedBitstreamContext *cbc;
CodedBitstreamFragment access_unit;
- H264RawAUD aud_nal;
- H264RawSEI sei_nal;
+ int done_first_au;
int aud;
int crop_bottom;
const char *sei_user_data;
- int sei_first_au;
int delete_filler;
+
+ int display_orientation;
+ double rotate;
+ int flip;
+
+ int level;
} H264MetadataContext;
CROP(bottom, crop_unit_y);
#undef CROP
+ if (ctx->level != LEVEL_UNSET) {
+ int level_idc;
+
+ if (ctx->level == LEVEL_AUTO) {
+ const H264LevelDescriptor *desc;
+ int64_t bit_rate;
+ int width, height, dpb_frames;
+
+ if (sps->vui.nal_hrd_parameters_present_flag) {
+ bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *
+ (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));
+ } else if (sps->vui.vcl_hrd_parameters_present_flag) {
+ bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *
+ (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));
+ // Adjust for VCL vs. NAL limits.
+ bit_rate = bit_rate * 6 / 5;
+ } else {
+ bit_rate = 0;
+ }
+
+ // Don't use max_dec_frame_buffering if it is only inferred.
+ dpb_frames = sps->vui.bitstream_restriction_flag ?
+ sps->vui.max_dec_frame_buffering : H264_MAX_DPB_FRAMES;
+
+ width = 16 * (sps->pic_width_in_mbs_minus1 + 1);
+ height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *
+ (2 - sps->frame_mbs_only_flag);
+
+ desc = ff_h264_guess_level(sps->profile_idc, bit_rate,
+ width, height, dpb_frames);
+ if (desc) {
+ level_idc = desc->level_idc;
+ } else {
+ av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "
+ "conform to any level: using level 6.2.\n");
+ level_idc = 62;
+ }
+ } else {
+ level_idc = ctx->level;
+ }
+
+ if (level_idc == 9) {
+ if (sps->profile_idc == 66 ||
+ sps->profile_idc == 77 ||
+ sps->profile_idc == 88) {
+ sps->level_idc = 11;
+ sps->constraint_set3_flag = 1;
+ } else {
+ sps->level_idc = 9;
+ }
+ } else {
+ sps->level_idc = level_idc;
+ }
+ }
+
if (need_vui)
sps->vui_parameters_present_flag = 1;
AVPacket *in = NULL;
CodedBitstreamFragment *au = &ctx->access_unit;
int err, i, j, has_sps;
+ H264RawAUD aud;
+ uint8_t *displaymatrix_side_data = NULL;
+ size_t displaymatrix_side_data_size = 0;
err = ff_bsf_get_packet(bsf, &in);
if (err < 0)
- goto fail;
+ return err;
err = ff_cbs_read_packet(ctx->cbc, au, in);
if (err < 0) {
0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
};
int primary_pic_type_mask = 0xff;
- H264RawAUD *aud = &ctx->aud_nal;
for (i = 0; i < au->nb_units; i++) {
if (au->units[i].type == H264_NAL_SLICE ||
goto fail;
}
- aud->nal_unit_header.nal_unit_type = H264_NAL_AUD;
- aud->primary_pic_type = j;
+ aud = (H264RawAUD) {
+ .nal_unit_header.nal_unit_type = H264_NAL_AUD,
+ .primary_pic_type = j,
+ };
err = ff_cbs_insert_unit_content(ctx->cbc, au,
- 0, H264_NAL_AUD, aud, NULL);
+ 0, H264_NAL_AUD, &aud, NULL);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
goto fail;
// Only insert the SEI in access units containing SPSs, and also
// unconditionally in the first access unit we ever see.
- if (ctx->sei_user_data && (has_sps || !ctx->sei_first_au)) {
+ if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
H264RawSEIPayload payload = {
.payload_type = H264_SEI_TYPE_USER_DATA_UNREGISTERED,
};
H264RawSEIUserDataUnregistered *udu =
&payload.payload.user_data_unregistered;
- ctx->sei_first_au = 1;
-
for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
int c, v;
c = ctx->sei_user_data[i];
udu->data_length = len + 1;
memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
- payload.payload_size = 16 + udu->data_length;
-
err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
"must be \"UUID+string\".\n");
err = AVERROR(EINVAL);
+ goto fail;
}
}
}
}
+ if (ctx->display_orientation != PASS) {
+ for (i = 0; i < au->nb_units; i++) {
+ H264RawSEI *sei;
+ if (au->units[i].type != H264_NAL_SEI)
+ continue;
+ sei = au->units[i].content;
+
+ for (j = 0; j < sei->payload_count; j++) {
+ H264RawSEIDisplayOrientation *disp;
+ int32_t *matrix;
+
+ if (sei->payload[j].payload_type !=
+ H264_SEI_TYPE_DISPLAY_ORIENTATION)
+ continue;
+ disp = &sei->payload[j].payload.display_orientation;
+
+ if (ctx->display_orientation == REMOVE ||
+ ctx->display_orientation == INSERT) {
+ err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
+ &au->units[i], j);
+ if (err < 0) {
+ av_log(bsf, AV_LOG_ERROR, "Failed to delete "
+ "display orientation SEI message.\n");
+ goto fail;
+ }
+ --i;
+ break;
+ }
+
+ matrix = av_mallocz(9 * sizeof(int32_t));
+ if (!matrix) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ av_display_rotation_set(matrix,
+ disp->anticlockwise_rotation *
+ 180.0 / 65536.0);
+ av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
+
+ // If there are multiple display orientation messages in an
+ // access unit then ignore all but the last one.
+ av_freep(&displaymatrix_side_data);
+
+ displaymatrix_side_data = (uint8_t*)matrix;
+ displaymatrix_side_data_size = 9 * sizeof(int32_t);
+ }
+ }
+ }
+ if (ctx->display_orientation == INSERT) {
+ H264RawSEIPayload payload = {
+ .payload_type = H264_SEI_TYPE_DISPLAY_ORIENTATION,
+ };
+ H264RawSEIDisplayOrientation *disp =
+ &payload.payload.display_orientation;
+ uint8_t *data;
+ int size;
+ int write = 0;
+
+ data = av_packet_get_side_data(in, AV_PKT_DATA_DISPLAYMATRIX, &size);
+ if (data && size >= 9 * sizeof(int32_t)) {
+ int32_t matrix[9];
+ int hflip, vflip;
+ double angle;
+
+ memcpy(matrix, data, sizeof(matrix));
+
+ hflip = vflip = 0;
+ if (matrix[0] < 0 && matrix[4] > 0)
+ hflip = 1;
+ else if (matrix[0] > 0 && matrix[4] < 0)
+ vflip = 1;
+ av_display_matrix_flip(matrix, hflip, vflip);
+
+ angle = av_display_rotation_get(matrix);
+
+ if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
+ matrix[2] != 0 || matrix[5] != 0 ||
+ matrix[6] != 0 || matrix[7] != 0) {
+ av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
+ "representable in H.264 parameters.\n");
+ } else {
+ disp->hor_flip = hflip;
+ disp->ver_flip = vflip;
+ disp->anticlockwise_rotation =
+ (uint16_t)rint((angle >= 0.0 ? angle
+ : angle + 360.0) *
+ 65536.0 / 360.0);
+ write = 1;
+ }
+ }
+
+ if (has_sps || !ctx->done_first_au) {
+ if (!isnan(ctx->rotate)) {
+ disp->anticlockwise_rotation =
+ (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
+ : ctx->rotate + 360.0) *
+ 65536.0 / 360.0);
+ write = 1;
+ }
+ if (ctx->flip) {
+ disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
+ disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
+ write = 1;
+ }
+ }
+
+ if (write) {
+ disp->display_orientation_repetition_period = 1;
+
+ err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
+ if (err < 0) {
+ av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
+ "SEI message to access unit.\n");
+ goto fail;
+ }
+ }
+ }
+
err = ff_cbs_write_packet(ctx->cbc, out, au);
if (err < 0) {
av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
if (err < 0)
goto fail;
+ if (displaymatrix_side_data) {
+ err = av_packet_add_side_data(out, AV_PKT_DATA_DISPLAYMATRIX,
+ displaymatrix_side_data,
+ displaymatrix_side_data_size);
+ if (err) {
+ av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
+ "displaymatrix side data to packet.\n");
+ goto fail;
+ }
+ displaymatrix_side_data = NULL;
+ }
+
+ ctx->done_first_au = 1;
+
err = 0;
fail:
ff_cbs_fragment_uninit(ctx->cbc, au);
+ av_freep(&displaymatrix_side_data);
+ if (err < 0)
+ av_packet_unref(out);
av_packet_free(&in);
return err;
}
#define OFFSET(x) offsetof(H264MetadataContext, x)
+#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
static const AVOption h264_metadata_options[] = {
{ "aud", "Access Unit Delimiter NAL units",
OFFSET(aud), AV_OPT_TYPE_INT,
- { .i64 = PASS }, PASS, REMOVE, 0, "aud" },
- { "pass", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PASS }, .unit = "aud" },
- { "insert", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = INSERT }, .unit = "aud" },
- { "remove", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = REMOVE }, .unit = "aud" },
+ { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
+ { "pass", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = PASS }, .flags = FLAGS, .unit = "aud" },
+ { "insert", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
+ { "remove", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
{ "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
- { .dbl = 0.0 }, 0, 65535 },
+ { .dbl = 0.0 }, 0, 65535, FLAGS },
{ "video_format", "Set video format (table E-2)",
OFFSET(video_format), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 7 },
+ { .i64 = -1 }, -1, 7, FLAGS},
{ "video_full_range_flag", "Set video full range flag",
OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 1 },
+ { .i64 = -1 }, -1, 1, FLAGS },
{ "colour_primaries", "Set colour primaries (table E-3)",
OFFSET(colour_primaries), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 255 },
+ { .i64 = -1 }, -1, 255, FLAGS },
{ "transfer_characteristics", "Set transfer characteristics (table E-4)",
OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 255 },
+ { .i64 = -1 }, -1, 255, FLAGS },
{ "matrix_coefficients", "Set matrix coefficients (table E-5)",
OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 255 },
+ { .i64 = -1 }, -1, 255, FLAGS },
{ "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 6 },
+ { .i64 = -1 }, -1, 6, FLAGS },
{ "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
- { .dbl = 0.0 }, 0, UINT_MAX },
+ { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
{ "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, 1 },
+ { .i64 = -1 }, -1, 1, FLAGS },
{ "crop_left", "Set left border crop offset",
OFFSET(crop_left), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, H264_MAX_WIDTH },
+ { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
{ "crop_right", "Set right border crop offset",
OFFSET(crop_right), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, H264_MAX_WIDTH },
+ { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
{ "crop_top", "Set top border crop offset",
OFFSET(crop_top), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, H264_MAX_HEIGHT },
+ { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
{ "crop_bottom", "Set bottom border crop offset",
OFFSET(crop_bottom), AV_OPT_TYPE_INT,
- { .i64 = -1 }, -1, H264_MAX_HEIGHT },
+ { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
{ "sei_user_data", "Insert SEI user data (UUID+string)",
- OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL } },
+ OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
{ "delete_filler", "Delete all filler (both NAL and SEI)",
- OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1 },
+ OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
+
+ { "display_orientation", "Display orientation SEI",
+ OFFSET(display_orientation), AV_OPT_TYPE_INT,
+ { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
+ { "pass", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = PASS }, .flags = FLAGS, .unit = "disp_or" },
+ { "insert", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = INSERT }, .flags = FLAGS, .unit = "disp_or" },
+ { "remove", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = REMOVE }, .flags = FLAGS, .unit = "disp_or" },
+ { "extract", NULL, 0, AV_OPT_TYPE_CONST,
+ { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
+
+ { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
+ OFFSET(rotate), AV_OPT_TYPE_DOUBLE,
+ { .dbl = NAN }, -360.0, +360.0, FLAGS },
+ { "flip", "Set flip in display orientation SEI",
+ OFFSET(flip), AV_OPT_TYPE_FLAGS,
+ { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
+ { "horizontal", "Set hor_flip",
+ 0, AV_OPT_TYPE_CONST,
+ { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
+ { "vertical", "Set ver_flip",
+ 0, AV_OPT_TYPE_CONST,
+ { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },
+
+ { "level", "Set level (table A-1)",
+ OFFSET(level), AV_OPT_TYPE_INT,
+ { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, "level" },
+ { "auto", "Attempt to guess level from stream properties",
+ 0, AV_OPT_TYPE_CONST,
+ { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },
+#define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \
+ { .i64 = value }, .flags = FLAGS, .unit = "level"
+ { LEVEL("1", 10) },
+ { LEVEL("1b", 9) },
+ { LEVEL("1.1", 11) },
+ { LEVEL("1.2", 12) },
+ { LEVEL("1.3", 13) },
+ { LEVEL("2", 20) },
+ { LEVEL("2.1", 21) },
+ { LEVEL("2.2", 22) },
+ { LEVEL("3", 30) },
+ { LEVEL("3.1", 31) },
+ { LEVEL("3.2", 32) },
+ { LEVEL("4", 40) },
+ { LEVEL("4.1", 41) },
+ { LEVEL("4.2", 42) },
+ { LEVEL("5", 50) },
+ { LEVEL("5.1", 51) },
+ { LEVEL("5.2", 52) },
+ { LEVEL("6", 60) },
+ { LEVEL("6.1", 61) },
+ { LEVEL("6.2", 62) },
+#undef LEVEL
{ NULL }
};
projects / ffmpeg / blobdiff