X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=libavcodec%2Fvaapi_encode_h264.c;h=5bd56057cdb3a1ee8749bbcf7945ac4748f49d9d;hb=f450cc7bc595155bacdb9f5d2414a076ccf81b4a;hp=7819788cf7b2915a92c8777aa1a5723cdb747401;hpb=b51c7c6b8a5b35cfd06cb9655f9ec4c9f0ddd81b;p=ffmpeg diff --git a/libavcodec/vaapi_encode_h264.c b/libavcodec/vaapi_encode_h264.c index 7819788cf7b..5bd56057cdb 100644 --- a/libavcodec/vaapi_encode_h264.c +++ b/libavcodec/vaapi_encode_h264.c @@ -26,6 +26,7 @@ #include "avcodec.h" #include "h264.h" +#include "h264_sei.h" #include "internal.h" #include "vaapi_encode.h" #include "vaapi_encode_h26x.h" @@ -61,7 +62,45 @@ typedef struct VAAPIEncodeH264MiscSequenceParams { int pic_init_qs_minus26; - char vui_parameters_present_flag; + char overscan_info_present_flag; + char overscan_appropriate_flag; + + char video_signal_type_present_flag; + unsigned int video_format; + char video_full_range_flag; + char colour_description_present_flag; + unsigned int colour_primaries; + unsigned int transfer_characteristics; + unsigned int matrix_coefficients; + + char chroma_loc_info_present_flag; + unsigned int chroma_sample_loc_type_top_field; + unsigned int chroma_sample_loc_type_bottom_field; + + // Some timing elements are in VAEncSequenceParameterBufferH264. + char fixed_frame_rate_flag; + + char nal_hrd_parameters_present_flag; + char vcl_hrd_parameters_present_flag; + char low_delay_hrd_flag; + char pic_struct_present_flag; + char bitstream_restriction_flag; + + unsigned int cpb_cnt_minus1; + unsigned int bit_rate_scale; + unsigned int cpb_size_scale; + unsigned int bit_rate_value_minus1[32]; + unsigned int cpb_size_value_minus1[32]; + char cbr_flag[32]; + unsigned int initial_cpb_removal_delay_length_minus1; + unsigned int cpb_removal_delay_length_minus1; + unsigned int dpb_output_delay_length_minus1; + unsigned int time_offset_length; + + unsigned int initial_cpb_removal_delay; + unsigned int initial_cpb_removal_delay_offset; + + unsigned int pic_struct; } VAAPIEncodeH264MiscSequenceParams; // This structure contains all possibly-useful per-slice syntax elements @@ -104,7 +143,11 @@ typedef struct VAAPIEncodeH264Context { int next_frame_num; int64_t idr_pic_count; + int cpb_delay; + int dpb_delay; + // Rate control configuration. + int send_timing_sei; struct { VAEncMiscParameterBuffer misc; VAEncMiscParameterRateControl rc; @@ -126,11 +169,13 @@ typedef struct VAAPIEncodeH264Context { typedef struct VAAPIEncodeH264Options { int qp; int quality; + int low_power; } VAAPIEncodeH264Options; #define vseq_var(name) vseq->name, name #define vseq_field(name) vseq->seq_fields.bits.name, name +#define vvui_field(name) vseq->vui_fields.bits.name, name #define vpic_var(name) vpic->name, name #define vpic_field(name) vpic->pic_fields.bits.name, name #define vslice_var(name) vslice->name, name @@ -153,6 +198,83 @@ static void vaapi_encode_h264_write_trailing_rbsp(PutBitContext *pbc) u(1, 0, rbsp_alignment_zero_bit); } +static void vaapi_encode_h264_write_vui(PutBitContext *pbc, + VAAPIEncodeContext *ctx) +{ + VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params; + VAAPIEncodeH264Context *priv = ctx->priv_data; + VAAPIEncodeH264MiscSequenceParams *mseq = &priv->misc_sequence_params; + int i; + + u(1, vvui_field(aspect_ratio_info_present_flag)); + if (vseq->vui_fields.bits.aspect_ratio_info_present_flag) { + u(8, vseq_var(aspect_ratio_idc)); + if (vseq->aspect_ratio_idc == 255) { + u(16, vseq_var(sar_width)); + u(16, vseq_var(sar_height)); + } + } + + u(1, mseq_var(overscan_info_present_flag)); + if (mseq->overscan_info_present_flag) + u(1, mseq_var(overscan_appropriate_flag)); + + u(1, mseq_var(video_signal_type_present_flag)); + if (mseq->video_signal_type_present_flag) { + u(3, mseq_var(video_format)); + u(1, mseq_var(video_full_range_flag)); + u(1, mseq_var(colour_description_present_flag)); + if (mseq->colour_description_present_flag) { + u(8, mseq_var(colour_primaries)); + u(8, mseq_var(transfer_characteristics)); + u(8, mseq_var(matrix_coefficients)); + } + } + + u(1, mseq_var(chroma_loc_info_present_flag)); + if (mseq->chroma_loc_info_present_flag) { + ue(mseq_var(chroma_sample_loc_type_top_field)); + ue(mseq_var(chroma_sample_loc_type_bottom_field)); + } + + u(1, vvui_field(timing_info_present_flag)); + if (vseq->vui_fields.bits.timing_info_present_flag) { + u(32, vseq_var(num_units_in_tick)); + u(32, vseq_var(time_scale)); + u(1, mseq_var(fixed_frame_rate_flag)); + } + + u(1, mseq_var(nal_hrd_parameters_present_flag)); + if (mseq->nal_hrd_parameters_present_flag) { + ue(mseq_var(cpb_cnt_minus1)); + u(4, mseq_var(bit_rate_scale)); + u(4, mseq_var(cpb_size_scale)); + for (i = 0; i <= mseq->cpb_cnt_minus1; i++) { + ue(mseq_var(bit_rate_value_minus1[i])); + ue(mseq_var(cpb_size_value_minus1[i])); + u(1, mseq_var(cbr_flag[i])); + } + u(5, mseq_var(initial_cpb_removal_delay_length_minus1)); + u(5, mseq_var(cpb_removal_delay_length_minus1)); + u(5, mseq_var(dpb_output_delay_length_minus1)); + u(5, mseq_var(time_offset_length)); + } + u(1, mseq_var(vcl_hrd_parameters_present_flag)); + if (mseq->vcl_hrd_parameters_present_flag) { + av_assert0(0 && "vcl hrd parameters not supported"); + } + + if (mseq->nal_hrd_parameters_present_flag || + mseq->vcl_hrd_parameters_present_flag) + u(1, mseq_var(low_delay_hrd_flag)); + u(1, mseq_var(pic_struct_present_flag)); + + u(1, vvui_field(bitstream_restriction_flag)); + if (vseq->vui_fields.bits.bitstream_restriction_flag) { + av_assert0(0 && "bitstream restrictions not supported"); + } +} + static void vaapi_encode_h264_write_sps(PutBitContext *pbc, VAAPIEncodeContext *ctx) { @@ -161,7 +283,7 @@ static void vaapi_encode_h264_write_sps(PutBitContext *pbc, VAAPIEncodeH264MiscSequenceParams *mseq = &priv->misc_sequence_params; int i; - vaapi_encode_h264_write_nal_header(pbc, NAL_SPS, 3); + vaapi_encode_h264_write_nal_header(pbc, H264_NAL_SPS, 3); u(8, mseq_var(profile_idc)); u(1, mseq_var(constraint_set0_flag)); @@ -232,7 +354,9 @@ static void vaapi_encode_h264_write_sps(PutBitContext *pbc, ue(vseq_var(frame_crop_bottom_offset)); } - u(1, mseq_var(vui_parameters_present_flag)); + u(1, vseq_var(vui_parameters_present_flag)); + if (vseq->vui_parameters_present_flag) + vaapi_encode_h264_write_vui(pbc, ctx); vaapi_encode_h264_write_trailing_rbsp(pbc); } @@ -244,7 +368,7 @@ static void vaapi_encode_h264_write_pps(PutBitContext *pbc, VAAPIEncodeH264Context *priv = ctx->priv_data; VAAPIEncodeH264MiscSequenceParams *mseq = &priv->misc_sequence_params; - vaapi_encode_h264_write_nal_header(pbc, NAL_PPS, 3); + vaapi_encode_h264_write_nal_header(pbc, H264_NAL_PPS, 3); ue(vpic_var(pic_parameter_set_id)); ue(vpic_var(seq_parameter_set_id)); @@ -428,6 +552,139 @@ static void vaapi_encode_h264_write_slice_header2(PutBitContext *pbc, // No alignment - this need not be a byte boundary. } +static void vaapi_encode_h264_write_buffering_period(PutBitContext *pbc, + VAAPIEncodeContext *ctx, + VAAPIEncodePicture *pic) +{ + VAAPIEncodeH264Context *priv = ctx->priv_data; + VAAPIEncodeH264MiscSequenceParams *mseq = &priv->misc_sequence_params; + VAEncPictureParameterBufferH264 *vpic = pic->codec_picture_params; + int i; + + ue(vpic_var(seq_parameter_set_id)); + + if (mseq->nal_hrd_parameters_present_flag) { + for (i = 0; i <= mseq->cpb_cnt_minus1; i++) { + u(mseq->initial_cpb_removal_delay_length_minus1 + 1, + mseq_var(initial_cpb_removal_delay)); + u(mseq->initial_cpb_removal_delay_length_minus1 + 1, + mseq_var(initial_cpb_removal_delay_offset)); + } + } + if (mseq->vcl_hrd_parameters_present_flag) { + av_assert0(0 && "vcl hrd parameters not supported"); + } +} + +static void vaapi_encode_h264_write_pic_timing(PutBitContext *pbc, + VAAPIEncodeContext *ctx, + VAAPIEncodePicture *pic) +{ + VAEncSequenceParameterBufferH264 *vseq = ctx->codec_sequence_params; + VAAPIEncodeH264Context *priv = ctx->priv_data; + VAAPIEncodeH264MiscSequenceParams *mseq = &priv->misc_sequence_params; + int i, num_clock_ts; + + if (mseq->nal_hrd_parameters_present_flag || + mseq->vcl_hrd_parameters_present_flag) { + u(mseq->cpb_removal_delay_length_minus1 + 1, + 2 * vseq->num_units_in_tick * priv->cpb_delay, + cpb_removal_delay); + u(mseq->dpb_output_delay_length_minus1 + 1, + 2 * vseq->num_units_in_tick * priv->dpb_delay, + dpb_output_delay); + } + if (mseq->pic_struct_present_flag) { + u(4, mseq_var(pic_struct)); + num_clock_ts = (mseq->pic_struct <= 2 ? 1 : + mseq->pic_struct <= 4 ? 2 : + mseq->pic_struct <= 8 ? 3 : 0); + for (i = 0; i < num_clock_ts; i++) { + u(1, 0, clock_timestamp_flag[i]); + // No full timestamp information. + } + } +} + +static void vaapi_encode_h264_write_identifier(PutBitContext *pbc, + VAAPIEncodeContext *ctx, + VAAPIEncodePicture *pic) +{ + const char *lavc = LIBAVCODEC_IDENT; + const char *vaapi = VA_VERSION_S; + const char *driver = vaQueryVendorString(ctx->hwctx->display); + char tmp[256]; + int i; + + // Random (version 4) ISO 11578 UUID. + uint8_t uuid[16] = { + 0x59, 0x94, 0x8b, 0x28, 0x11, 0xec, 0x45, 0xaf, + 0x96, 0x75, 0x19, 0xd4, 0x1f, 0xea, 0xa9, 0x4d, + }; + + for (i = 0; i < 16; i++) + u(8, uuid[i], uuid_iso_iec_11578); + + snprintf(tmp, sizeof(tmp), "%s / VAAPI %s / %s", lavc, vaapi, driver); + for (i = 0; i < sizeof(tmp) && tmp[i]; i++) + u(8, tmp[i], user_data_payload_byte); +} + +static void vaapi_encode_h264_write_sei(PutBitContext *pbc, + VAAPIEncodeContext *ctx, + VAAPIEncodePicture *pic) +{ + VAAPIEncodeH264Context *priv = ctx->priv_data; + PutBitContext payload_bits; + char payload[256]; + int payload_type, payload_size, i; + void (*write_payload)(PutBitContext *pbc, + VAAPIEncodeContext *ctx, + VAAPIEncodePicture *pic) = NULL; + + vaapi_encode_h264_write_nal_header(pbc, H264_NAL_SEI, 0); + + for (payload_type = 0; payload_type < 64; payload_type++) { + switch (payload_type) { + case SEI_TYPE_BUFFERING_PERIOD: + if (!priv->send_timing_sei || + pic->type != PICTURE_TYPE_IDR) + continue; + write_payload = &vaapi_encode_h264_write_buffering_period; + break; + case SEI_TYPE_PIC_TIMING: + if (!priv->send_timing_sei) + continue; + write_payload = &vaapi_encode_h264_write_pic_timing; + break; + case SEI_TYPE_USER_DATA_UNREGISTERED: + if (pic->encode_order != 0) + continue; + write_payload = &vaapi_encode_h264_write_identifier; + break; + default: + continue; + } + + init_put_bits(&payload_bits, payload, sizeof(payload)); + write_payload(&payload_bits, ctx, pic); + if (put_bits_count(&payload_bits) & 7) { + write_u(&payload_bits, 1, 1, bit_equal_to_one); + while (put_bits_count(&payload_bits) & 7) + write_u(&payload_bits, 1, 0, bit_equal_to_zero); + } + payload_size = put_bits_count(&payload_bits) / 8; + flush_put_bits(&payload_bits); + + u(8, payload_type, last_payload_type_byte); + u(8, payload_size, last_payload_size_byte); + for (i = 0; i < payload_size; i++) + u(8, payload[i] & 0xff, sei_payload); + } + + vaapi_encode_h264_write_trailing_rbsp(pbc); +} + static int vaapi_encode_h264_write_sequence_header(AVCodecContext *avctx, char *data, size_t *data_len) { @@ -489,6 +746,32 @@ static int vaapi_encode_h264_write_slice_header(AVCodecContext *avctx, tmp, header_len); } +static int vaapi_encode_h264_write_extra_header(AVCodecContext *avctx, + VAAPIEncodePicture *pic, + int index, int *type, + char *data, size_t *data_len) +{ + VAAPIEncodeContext *ctx = avctx->priv_data; + PutBitContext pbc; + char tmp[256]; + size_t header_len; + + if (index == 0 && ctx->va_rc_mode == VA_RC_CBR) { + *type = VAEncPackedHeaderH264_SEI; + + init_put_bits(&pbc, tmp, sizeof(tmp)); + vaapi_encode_h264_write_sei(&pbc, ctx, pic); + header_len = put_bits_count(&pbc); + flush_put_bits(&pbc); + + return ff_vaapi_encode_h26x_nal_unit_to_byte_stream(data, data_len, + tmp, header_len); + + } else { + return AVERROR_EOF; + } +} + static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) { VAAPIEncodeContext *ctx = avctx->priv_data; @@ -528,13 +811,82 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx) vseq->frame_cropping_flag = 0; } + vseq->vui_parameters_present_flag = 1; + if (avctx->sample_aspect_ratio.num != 0) { + vseq->vui_fields.bits.aspect_ratio_info_present_flag = 1; + // There is a large enum of these which we could support + // individually rather than using the generic X/Y form? + if (avctx->sample_aspect_ratio.num == + avctx->sample_aspect_ratio.den) { + vseq->aspect_ratio_idc = 1; + } else { + vseq->aspect_ratio_idc = 255; // Extended SAR. + vseq->sar_width = avctx->sample_aspect_ratio.num; + vseq->sar_height = avctx->sample_aspect_ratio.den; + } + } + if (avctx->color_primaries != AVCOL_PRI_UNSPECIFIED || + avctx->color_trc != AVCOL_TRC_UNSPECIFIED || + avctx->colorspace != AVCOL_SPC_UNSPECIFIED) { + mseq->video_signal_type_present_flag = 1; + mseq->video_format = 5; // Unspecified. + mseq->video_full_range_flag = 0; + mseq->colour_description_present_flag = 1; + // These enums are derived from the standard and hence + // we can just use the values directly. + mseq->colour_primaries = avctx->color_primaries; + mseq->transfer_characteristics = avctx->color_trc; + mseq->matrix_coefficients = avctx->colorspace; + } + vseq->bits_per_second = avctx->bit_rate; + + vseq->vui_fields.bits.timing_info_present_flag = 1; if (avctx->framerate.num > 0 && avctx->framerate.den > 0) { vseq->num_units_in_tick = avctx->framerate.num; vseq->time_scale = 2 * avctx->framerate.den; + mseq->fixed_frame_rate_flag = 1; } else { vseq->num_units_in_tick = avctx->time_base.num; vseq->time_scale = 2 * avctx->time_base.den; + mseq->fixed_frame_rate_flag = 0; + } + + if (ctx->va_rc_mode == VA_RC_CBR) { + priv->send_timing_sei = 1; + mseq->nal_hrd_parameters_present_flag = 1; + + mseq->cpb_cnt_minus1 = 0; + + // Try to scale these to a sensible range so that the + // golomb encode of the value is not overlong. + mseq->bit_rate_scale = + av_clip(av_log2(avctx->bit_rate) - 15, 0, 15); + mseq->bit_rate_value_minus1[0] = + (avctx->bit_rate >> mseq->bit_rate_scale) - 1; + + mseq->cpb_size_scale = + av_clip(av_log2(priv->hrd_params.hrd.buffer_size) - 15, 0, 15); + mseq->cpb_size_value_minus1[0] = + (priv->hrd_params.hrd.buffer_size >> mseq->cpb_size_scale) - 1; + + // CBR mode isn't actually available here, despite naming. + mseq->cbr_flag[0] = 0; + + mseq->initial_cpb_removal_delay_length_minus1 = 23; + mseq->cpb_removal_delay_length_minus1 = 23; + mseq->dpb_output_delay_length_minus1 = 7; + mseq->time_offset_length = 0; + + // This calculation can easily overflow 32 bits. + mseq->initial_cpb_removal_delay = 90000 * + (uint64_t)priv->hrd_params.hrd.initial_buffer_fullness / + priv->hrd_params.hrd.buffer_size; + + mseq->initial_cpb_removal_delay_offset = 0; + } else { + priv->send_timing_sei = 0; + mseq->nal_hrd_parameters_present_flag = 0; } vseq->intra_period = ctx->p_per_i * (ctx->b_per_p + 1); @@ -594,13 +946,16 @@ static int vaapi_encode_h264_init_picture_params(AVCodecContext *avctx, av_assert0(pic->display_order == pic->encode_order); vpic->frame_num = 0; priv->next_frame_num = 1; + priv->cpb_delay = 0; } else { vpic->frame_num = priv->next_frame_num; if (pic->type != PICTURE_TYPE_B) { // nal_ref_idc != 0 ++priv->next_frame_num; } + ++priv->cpb_delay; } + priv->dpb_delay = pic->display_order - pic->encode_order + 1; vpic->frame_num = vpic->frame_num & ((1 << (4 + vseq->seq_fields.bits.log2_max_frame_num_minus4)) - 1); @@ -655,9 +1010,9 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx, mslice = &pslice->misc_slice_params; if (pic->type == PICTURE_TYPE_IDR) - mslice->nal_unit_type = NAL_IDR_SLICE; + mslice->nal_unit_type = H264_NAL_IDR_SLICE; else - mslice->nal_unit_type = NAL_SLICE; + mslice->nal_unit_type = H264_NAL_SLICE; switch (pic->type) { case PICTURE_TYPE_IDR: @@ -854,7 +1209,17 @@ static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx) avctx->profile); return AVERROR(EINVAL); } - ctx->va_entrypoint = VAEntrypointEncSlice; + if (opt->low_power) { +#if VA_CHECK_VERSION(0, 39, 1) + ctx->va_entrypoint = VAEntrypointEncSliceLP; +#else + av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not " + "supported with this VAAPI version.\n"); + return AVERROR(EINVAL); +#endif + } else { + ctx->va_entrypoint = VAEntrypointEncSlice; + } ctx->input_width = avctx->width; ctx->input_height = avctx->height; @@ -923,6 +1288,8 @@ static VAAPIEncodeType vaapi_encode_type_h264 = { .slice_header_type = VAEncPackedHeaderH264_Slice, .write_slice_header = &vaapi_encode_h264_write_slice_header, + + .write_extra_header = &vaapi_encode_h264_write_extra_header, }; static av_cold int vaapi_encode_h264_init(AVCodecContext *avctx) @@ -937,7 +1304,10 @@ static const AVOption vaapi_encode_h264_options[] = { { "qp", "Constant QP (for P-frames; scaled by qfactor/qoffset for I/B)", OFFSET(qp), AV_OPT_TYPE_INT, { .i64 = 20 }, 0, 52, FLAGS }, { "quality", "Set encode quality (trades off against speed, higher is faster)", - OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, FLAGS }, + OFFSET(quality), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8, FLAGS }, + { "low_power", "Use low-power encoding mode (experimental: only supported " + "on some platforms, does not support all features)", + OFFSET(low_power), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS }, { NULL }, };