virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

vaapi_encode: Refactor initialisation

Browse Source 
This allows better checking of capabilities and will make it easier
to add more functionality later.

It also commonises some duplicated code around rate control setup
and adds more comments explaining the internals.

(cherry picked from commit 80a5d05108)
This commit is contained in:
Mark Thompson 2016-09-18 14:55:26 +01:00
parent 06d73d002e
commit c8241e730f
5 changed files with 422 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

263
libavcodec/vaapi_encode.c
View File

@ -922,7 +922,7 @@ fail:
return err; return err;
} }
static av_cold int vaapi_encode_check_config(AVCodecContext *avctx) static av_cold int vaapi_encode_config_attributes(AVCodecContext *avctx)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAStatus vas; VAStatus vas;
@ -930,6 +930,7 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
VAProfile *profiles = NULL; VAProfile *profiles = NULL;
VAEntrypoint *entrypoints = NULL; VAEntrypoint *entrypoints = NULL;
VAConfigAttrib attr[] = { VAConfigAttrib attr[] = {
{ VAConfigAttribRTFormat },
{ VAConfigAttribRateControl }, { VAConfigAttribRateControl },
{ VAConfigAttribEncMaxRefFrames }, { VAConfigAttribEncMaxRefFrames },
}; };
@ -1001,13 +1002,33 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
continue; continue;
} }
switch (attr[i].type) { switch (attr[i].type) {
case VAConfigAttribRateControl: case VAConfigAttribRTFormat:
if (!(ctx->va_rc_mode & attr[i].value)) { if (!(ctx->va_rt_format & attr[i].value)) {
av_log(avctx, AV_LOG_ERROR, "Rate control mode is not " av_log(avctx, AV_LOG_ERROR, "Surface RT format %#x "
"supported: %x\n", attr[i].value); "is not supported (mask %#x).\n",
ctx->va_rt_format, attr[i].value);
err = AVERROR(EINVAL); err = AVERROR(EINVAL);
goto fail; goto fail;
} }
ctx->config_attributes[ctx->nb_config_attributes++] =
(VAConfigAttrib) {
.type = VAConfigAttribRTFormat,
.value = ctx->va_rt_format,
};
break;
case VAConfigAttribRateControl:
if (!(ctx->va_rc_mode & attr[i].value)) {
av_log(avctx, AV_LOG_ERROR, "Rate control mode %#x "
"is not supported (mask: %#x).\n",
ctx->va_rc_mode, attr[i].value);
err = AVERROR(EINVAL);
goto fail;
}
ctx->config_attributes[ctx->nb_config_attributes++] =
(VAConfigAttrib) {
.type = VAConfigAttribRateControl,
.value = ctx->va_rc_mode,
};
break; break;
case VAConfigAttribEncMaxRefFrames: case VAConfigAttribEncMaxRefFrames:
{ {
@ -1016,18 +1037,20 @@ static av_cold int vaapi_encode_check_config(AVCodecContext *avctx)
if (avctx->gop_size > 1 && ref_l0 < 1) { if (avctx->gop_size > 1 && ref_l0 < 1) {
av_log(avctx, AV_LOG_ERROR, "P frames are not " av_log(avctx, AV_LOG_ERROR, "P frames are not "
"supported (%x).\n", attr[i].value); "supported (%#x).\n", attr[i].value);
err = AVERROR(EINVAL); err = AVERROR(EINVAL);
goto fail; goto fail;
} }
if (avctx->max_b_frames > 0 && ref_l1 < 1) { if (avctx->max_b_frames > 0 && ref_l1 < 1) {
av_log(avctx, AV_LOG_ERROR, "B frames are not " av_log(avctx, AV_LOG_ERROR, "B frames are not "
"supported (%x).\n", attr[i].value); "supported (%#x).\n", attr[i].value);
err = AVERROR(EINVAL); err = AVERROR(EINVAL);
goto fail; goto fail;
} }
} }
break; break;
default:
av_assert0(0 && "Unexpected config attribute.");
} }
} }
@ -1038,6 +1061,54 @@ fail:
return err; return err;
} }
static av_cold int vaapi_encode_init_rate_control(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
int hrd_buffer_size;
int hrd_initial_buffer_fullness;
if (avctx->bit_rate > INT32_MAX) {
av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
"higher is not supported.\n");
return AVERROR(EINVAL);
}
if (avctx->rc_buffer_size)
hrd_buffer_size = avctx->rc_buffer_size;
else
hrd_buffer_size = avctx->bit_rate;
if (avctx->rc_initial_buffer_occupancy)
hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
else
hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
ctx->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
ctx->rc_params.rc = (VAEncMiscParameterRateControl) {
.bits_per_second = avctx->bit_rate,
.target_percentage = 66,
.window_size = 1000,
.initial_qp = (avctx->qmax >= 0 ? avctx->qmax : 40),
.min_qp = (avctx->qmin >= 0 ? avctx->qmin : 18),
.basic_unit_size = 0,
};
ctx->global_params[ctx->nb_global_params] =
&ctx->rc_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(ctx->rc_params);
ctx->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
ctx->hrd_params.hrd = (VAEncMiscParameterHRD) {
.initial_buffer_fullness = hrd_initial_buffer_fullness,
.buffer_size = hrd_buffer_size,
};
ctx->global_params[ctx->nb_global_params] =
&ctx->hrd_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(ctx->hrd_params);
return 0;
}
static void vaapi_encode_free_output_buffer(void *opaque, static void vaapi_encode_free_output_buffer(void *opaque,
uint8_t *data) uint8_t *data)
{ {
@ -1067,7 +1138,7 @@ static AVBufferRef *vaapi_encode_alloc_output_buffer(void *opaque,
// bound on that. // bound on that.
vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context, vas = vaCreateBuffer(ctx->hwctx->display, ctx->va_context,
VAEncCodedBufferType, VAEncCodedBufferType,
3 * ctx->aligned_width * ctx->aligned_height + 3 * ctx->surface_width * ctx->surface_height +
(1 << 16), 1, 0, &buffer_id); (1 << 16), 1, 0, &buffer_id);
if (vas != VA_STATUS_SUCCESS) { if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create bitstream " av_log(avctx, AV_LOG_ERROR, "Failed to create bitstream "
@ -1089,69 +1160,14 @@ static AVBufferRef *vaapi_encode_alloc_output_buffer(void *opaque,
return ref; return ref;
} }
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx, static av_cold int vaapi_encode_create_recon_frames(AVCodecContext *avctx)
const VAAPIEncodeType *type)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
AVVAAPIFramesContext *recon_hwctx = NULL;
AVVAAPIHWConfig *hwconfig = NULL; AVVAAPIHWConfig *hwconfig = NULL;
AVHWFramesConstraints *constraints = NULL; AVHWFramesConstraints *constraints = NULL;
enum AVPixelFormat recon_format; enum AVPixelFormat recon_format;
VAStatus vas;
int err, i; int err, i;
if (!avctx->hw_frames_ctx) {
av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
"required to associate the encoding device.\n");
return AVERROR(EINVAL);
}
ctx->codec = type;
ctx->codec_options = ctx->codec_options_data;
ctx->va_config = VA_INVALID_ID;
ctx->va_context = VA_INVALID_ID;
ctx->priv_data = av_mallocz(type->priv_data_size);
if (!ctx->priv_data) {
err = AVERROR(ENOMEM);
goto fail;
}
ctx->input_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
if (!ctx->input_frames_ref) {
err = AVERROR(ENOMEM);
goto fail;
}
ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
if (!ctx->device_ref) {
err = AVERROR(ENOMEM);
goto fail;
}
ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
ctx->hwctx = ctx->device->hwctx;
err = ctx->codec->init(avctx);
if (err < 0)
goto fail;
err = vaapi_encode_check_config(avctx);
if (err < 0)
goto fail;
vas = vaCreateConfig(ctx->hwctx->display,
ctx->va_profile, ctx->va_entrypoint,
ctx->config_attributes, ctx->nb_config_attributes,
&ctx->va_config);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
"configuration: %d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref); hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
if (!hwconfig) { if (!hwconfig) {
err = AVERROR(ENOMEM); err = AVERROR(ENOMEM);
@ -1190,13 +1206,13 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
av_log(avctx, AV_LOG_DEBUG, "Using %s as format of " av_log(avctx, AV_LOG_DEBUG, "Using %s as format of "
"reconstructed frames.\n", av_get_pix_fmt_name(recon_format)); "reconstructed frames.\n", av_get_pix_fmt_name(recon_format));
if (ctx->aligned_width < constraints->min_width || if (ctx->surface_width < constraints->min_width ||
ctx->aligned_height < constraints->min_height || ctx->surface_height < constraints->min_height ||
ctx->aligned_width > constraints->max_width || ctx->surface_width > constraints->max_width ||
ctx->aligned_height > constraints->max_height) { ctx->surface_height > constraints->max_height) {
av_log(avctx, AV_LOG_ERROR, "Hardware does not support encoding at " av_log(avctx, AV_LOG_ERROR, "Hardware does not support encoding at "
"size %dx%d (constraints: width %d-%d height %d-%d).\n", "size %dx%d (constraints: width %d-%d height %d-%d).\n",
ctx->aligned_width, ctx->aligned_height, ctx->surface_width, ctx->surface_height,
constraints->min_width, constraints->max_width, constraints->min_width, constraints->max_width,
constraints->min_height, constraints->max_height); constraints->min_height, constraints->max_height);
err = AVERROR(EINVAL); err = AVERROR(EINVAL);
@ -1215,9 +1231,10 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
ctx->recon_frames->format = AV_PIX_FMT_VAAPI; ctx->recon_frames->format = AV_PIX_FMT_VAAPI;
ctx->recon_frames->sw_format = recon_format; ctx->recon_frames->sw_format = recon_format;
ctx->recon_frames->width = ctx->aligned_width; ctx->recon_frames->width = ctx->surface_width;
ctx->recon_frames->height = ctx->aligned_height; ctx->recon_frames->height = ctx->surface_height;
ctx->recon_frames->initial_pool_size = ctx->nb_recon_frames; ctx->recon_frames->initial_pool_size =
avctx->max_b_frames + 3;
err = av_hwframe_ctx_init(ctx->recon_frames_ref); err = av_hwframe_ctx_init(ctx->recon_frames_ref);
if (err < 0) { if (err < 0) {
@ -1225,10 +1242,75 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
"frame context: %d.\n", err); "frame context: %d.\n", err);
goto fail; goto fail;
} }
recon_hwctx = ctx->recon_frames->hwctx;
err = 0;
fail:
av_freep(&hwconfig);
av_hwframe_constraints_free(&constraints);
return err;
}
av_cold int ff_vaapi_encode_init(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
AVVAAPIFramesContext *recon_hwctx = NULL;
VAStatus vas;
int err;
if (!avctx->hw_frames_ctx) {
av_log(avctx, AV_LOG_ERROR, "A hardware frames reference is "
"required to associate the encoding device.\n");
return AVERROR(EINVAL);
}
ctx->codec_options = ctx->codec_options_data;
ctx->va_config = VA_INVALID_ID;
ctx->va_context = VA_INVALID_ID;
ctx->priv_data = av_mallocz(ctx->codec->priv_data_size);
if (!ctx->priv_data) {
err = AVERROR(ENOMEM);
goto fail;
}
ctx->input_frames_ref = av_buffer_ref(avctx->hw_frames_ctx);
if (!ctx->input_frames_ref) {
err = AVERROR(ENOMEM);
goto fail;
}
ctx->input_frames = (AVHWFramesContext*)ctx->input_frames_ref->data;
ctx->device_ref = av_buffer_ref(ctx->input_frames->device_ref);
if (!ctx->device_ref) {
err = AVERROR(ENOMEM);
goto fail;
}
ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
ctx->hwctx = ctx->device->hwctx;
err = vaapi_encode_config_attributes(avctx);
if (err < 0)
goto fail;
vas = vaCreateConfig(ctx->hwctx->display,
ctx->va_profile, ctx->va_entrypoint,
ctx->config_attributes, ctx->nb_config_attributes,
&ctx->va_config);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create encode pipeline "
"configuration: %d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
err = vaapi_encode_create_recon_frames(avctx);
if (err < 0)
goto fail;
recon_hwctx = ctx->recon_frames->hwctx;
vas = vaCreateContext(ctx->hwctx->display, ctx->va_config, vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
ctx->aligned_width, ctx->aligned_height, ctx->surface_width, ctx->surface_height,
VA_PROGRESSIVE, VA_PROGRESSIVE,
recon_hwctx->surface_ids, recon_hwctx->surface_ids,
recon_hwctx->nb_surfaces, recon_hwctx->nb_surfaces,
@ -1240,6 +1322,26 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
goto fail; goto fail;
} }
ctx->output_buffer_pool =
av_buffer_pool_init2(sizeof(VABufferID), avctx,
&vaapi_encode_alloc_output_buffer, NULL);
if (!ctx->output_buffer_pool) {
err = AVERROR(ENOMEM);
goto fail;
}
if (ctx->va_rc_mode & ~VA_RC_CQP) {
err = vaapi_encode_init_rate_control(avctx);
if (err < 0)
goto fail;
}
if (ctx->codec->configure) {
err = ctx->codec->configure(avctx);
if (err < 0)
goto fail;
}
ctx->input_order = 0; ctx->input_order = 0;
ctx->output_delay = avctx->max_b_frames; ctx->output_delay = avctx->max_b_frames;
ctx->decode_delay = 1; ctx->decode_delay = 1;
@ -1271,14 +1373,6 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
} }
} }
ctx->output_buffer_pool =
av_buffer_pool_init2(sizeof(VABufferID), avctx,
&vaapi_encode_alloc_output_buffer, NULL);
if (!ctx->output_buffer_pool) {
err = AVERROR(ENOMEM);
goto fail;
}
// All I are IDR for now. // All I are IDR for now.
ctx->i_per_idr = 0; ctx->i_per_idr = 0;
ctx->p_per_i = ((avctx->gop_size + avctx->max_b_frames) / ctx->p_per_i = ((avctx->gop_size + avctx->max_b_frames) /
@ -1292,8 +1386,6 @@ av_cold int ff_vaapi_encode_init(AVCodecContext *avctx,
return 0; return 0;
fail: fail:
av_freep(&hwconfig);
av_hwframe_constraints_free(&constraints);
ff_vaapi_encode_close(avctx); ff_vaapi_encode_close(avctx);
return err; return err;
} }
@ -1318,9 +1410,6 @@ av_cold int ff_vaapi_encode_close(AVCodecContext *avctx)
ctx->va_config = VA_INVALID_ID; ctx->va_config = VA_INVALID_ID;
} }
if (ctx->codec->close)
ctx->codec->close(avctx);
av_buffer_pool_uninit(&ctx->output_buffer_pool); av_buffer_pool_uninit(&ctx->output_buffer_pool);
av_freep(&ctx->codec_sequence_params); av_freep(&ctx->codec_sequence_params);

96
libavcodec/vaapi_encode.h
View File

@ -48,15 +48,6 @@ enum {
PICTURE_TYPE_B = 3, PICTURE_TYPE_B = 3,
}; };
enum {
// All encode operations are done independently.
ISSUE_MODE_SERIALISE_EVERYTHING = 0,
// Overlap as many operations as possible.
ISSUE_MODE_MAXIMISE_THROUGHPUT,
// Overlap operations only when satisfying parallel dependencies.
ISSUE_MODE_MINIMISE_LATENCY,
};
typedef struct VAAPIEncodeSlice { typedef struct VAAPIEncodeSlice {
void *priv_data; void *priv_data;
void *codec_slice_params; void *codec_slice_params;
@ -102,43 +93,65 @@ typedef struct VAAPIEncodeContext {
// Codec-specific hooks. // Codec-specific hooks.
const struct VAAPIEncodeType *codec; const struct VAAPIEncodeType *codec;
// Encoding profile (VAProfileXXX).
VAProfile va_profile;
// Encoding entrypoint (usually VAEntryointEncSlice).
VAEntrypoint va_entrypoint;
// Surface colour/sampling format (usually VA_RT_FORMAT_YUV420).
unsigned int va_rt_format;
// Rate control mode.
unsigned int va_rc_mode;
// The required size of surfaces. This is probably the input
// size (AVCodecContext.width|height) aligned up to whatever
// block size is required by the codec.
int surface_width;
int surface_height;
// Everything above this point must be set before calling
// ff_vaapi_encode_init().
// Codec-specific state. // Codec-specific state.
void *priv_data; void *priv_data;
VAProfile va_profile; // Configuration attributes to use when creating va_config.
VAEntrypoint va_entrypoint; VAConfigAttrib config_attributes[MAX_CONFIG_ATTRIBUTES];
int nb_config_attributes;
VAConfigID va_config; VAConfigID va_config;
VAContextID va_context; VAContextID va_context;
int va_rc_mode;
AVBufferRef *device_ref; AVBufferRef *device_ref;
AVHWDeviceContext *device; AVHWDeviceContext *device;
AVVAAPIDeviceContext *hwctx; AVVAAPIDeviceContext *hwctx;
// The hardware frame context containing the input frames.
AVBufferRef *input_frames_ref; AVBufferRef *input_frames_ref;
AVHWFramesContext *input_frames; AVHWFramesContext *input_frames;
// Input size, set from input frames. // The hardware frame context containing the reconstructed frames.
int input_width;
int input_height;
// Aligned size, set by codec init, becomes hwframe size.
int aligned_width;
int aligned_height;
int nb_recon_frames;
AVBufferRef *recon_frames_ref; AVBufferRef *recon_frames_ref;
AVHWFramesContext *recon_frames; AVHWFramesContext *recon_frames;
// Pool of (reusable) bitstream output buffers.
AVBufferPool *output_buffer_pool; AVBufferPool *output_buffer_pool;
VAConfigAttrib config_attributes[MAX_CONFIG_ATTRIBUTES]; // Global parameters which will be applied at the start of the
int nb_config_attributes; // sequence (includes rate control parameters below).
VAEncMiscParameterBuffer *global_params[MAX_GLOBAL_PARAMS]; VAEncMiscParameterBuffer *global_params[MAX_GLOBAL_PARAMS];
size_t global_params_size[MAX_GLOBAL_PARAMS]; size_t global_params_size[MAX_GLOBAL_PARAMS];
int nb_global_params; int nb_global_params;
// Rate control parameters.
struct {
VAEncMiscParameterBuffer misc;
VAEncMiscParameterRateControl rc;
} rc_params;
struct {
VAEncMiscParameterBuffer misc;
VAEncMiscParameterHRD hrd;
} hrd_params;
// Per-sequence parameter structure (VAEncSequenceParameterBuffer*). // Per-sequence parameter structure (VAEncSequenceParameterBuffer*).
void *codec_sequence_params; void *codec_sequence_params;
@ -158,7 +171,15 @@ typedef struct VAAPIEncodeContext {
// Next output order index (encode order). // Next output order index (encode order).
int64_t output_order; int64_t output_order;
int issue_mode; enum {
// All encode operations are done independently (synchronise
// immediately after every operation).
ISSUE_MODE_SERIALISE_EVERYTHING = 0,
// Overlap as many operations as possible.
ISSUE_MODE_MAXIMISE_THROUGHPUT,
// Overlap operations only when satisfying parallel dependencies.
ISSUE_MODE_MINIMISE_LATENCY,
} issue_mode;
// Timestamp handling. // Timestamp handling.
int64_t first_pts; int64_t first_pts;
@ -183,15 +204,20 @@ typedef struct VAAPIEncodeContext {
typedef struct VAAPIEncodeType { typedef struct VAAPIEncodeType {
size_t priv_data_size; size_t priv_data_size;
int (*init)(AVCodecContext *avctx); // Perform any extra codec-specific configuration after the
int (*close)(AVCodecContext *avctx); // codec context is initialised (set up the private data and
// add any necessary global parameters).
int (*configure)(AVCodecContext *avctx);
// The size of the parameter structures:
// sizeof(VAEnc{type}ParameterBuffer{codec}).
size_t sequence_params_size; size_t sequence_params_size;
size_t picture_params_size; size_t picture_params_size;
size_t slice_params_size; size_t slice_params_size;
// Fill the parameter structures.
int (*init_sequence_params)(AVCodecContext *avctx); int (*init_sequence_params)(AVCodecContext *avctx);
int (*init_picture_params)(AVCodecContext *avctx, int (*init_picture_params)(AVCodecContext *avctx,
VAAPIEncodePicture *pic); VAAPIEncodePicture *pic);
@ -199,10 +225,13 @@ typedef struct VAAPIEncodeType {
VAAPIEncodePicture *pic, VAAPIEncodePicture *pic,
VAAPIEncodeSlice *slice); VAAPIEncodeSlice *slice);
// The type used by the packed header: this should look like
// VAEncPackedHeader{something}.
int sequence_header_type; int sequence_header_type;
int picture_header_type; int picture_header_type;
int slice_header_type; int slice_header_type;
// Write the packed header data to the provided buffer.
int (*write_sequence_header)(AVCodecContext *avctx, int (*write_sequence_header)(AVCodecContext *avctx,
char *data, size_t *data_len); char *data, size_t *data_len);
int (*write_picture_header)(AVCodecContext *avctx, int (*write_picture_header)(AVCodecContext *avctx,
@ -213,10 +242,18 @@ typedef struct VAAPIEncodeType {
VAAPIEncodeSlice *slice, VAAPIEncodeSlice *slice,
char *data, size_t *data_len); char *data, size_t *data_len);
// Fill an extra parameter structure, which will then be
// passed to vaRenderPicture(). Will be called repeatedly
// with increasing index argument until AVERROR_EOF is
// returned.
int (*write_extra_buffer)(AVCodecContext *avctx, int (*write_extra_buffer)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, VAAPIEncodePicture *pic,
int index, int *type, int index, int *type,
char *data, size_t *data_len); char *data, size_t *data_len);
// Write an extra packed header. Will be called repeatedly
// with increasing index argument until AVERROR_EOF is
// returned.
int (*write_extra_header)(AVCodecContext *avctx, int (*write_extra_header)(AVCodecContext *avctx,
VAAPIEncodePicture *pic, VAAPIEncodePicture *pic,
int index, int *type, int index, int *type,
@ -227,8 +264,7 @@ typedef struct VAAPIEncodeType {
int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt, int ff_vaapi_encode2(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *input_image, int *got_packet); const AVFrame *input_image, int *got_packet);
int ff_vaapi_encode_init(AVCodecContext *avctx, int ff_vaapi_encode_init(AVCodecContext *avctx);
const VAAPIEncodeType *type);
int ff_vaapi_encode_close(AVCodecContext *avctx); int ff_vaapi_encode_close(AVCodecContext *avctx);
#endif /* AVCODEC_VAAPI_ENCODE_H */ #endif /* AVCODEC_VAAPI_ENCODE_H */

257
libavcodec/vaapi_encode_h264.c
View File

@ -148,14 +148,6 @@ typedef struct VAAPIEncodeH264Context {
// Rate control configuration. // Rate control configuration.
int send_timing_sei; int send_timing_sei;
struct {
VAEncMiscParameterBuffer misc;
VAEncMiscParameterRateControl rc;
} rc_params;
struct {
VAEncMiscParameterBuffer misc;
VAEncMiscParameterHRD hrd;
} hrd_params;
#if VA_CHECK_VERSION(0, 36, 0) #if VA_CHECK_VERSION(0, 36, 0)
// Speed-quality tradeoff setting. // Speed-quality tradeoff setting.
@ -797,16 +789,16 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
vseq->seq_fields.bits.log2_max_frame_num_minus4 = 4; vseq->seq_fields.bits.log2_max_frame_num_minus4 = 4;
vseq->seq_fields.bits.pic_order_cnt_type = 0; vseq->seq_fields.bits.pic_order_cnt_type = 0;
if (ctx->input_width != ctx->aligned_width || if (avctx->width != ctx->surface_width ||
ctx->input_height != ctx->aligned_height) { avctx->height != ctx->surface_height) {
vseq->frame_cropping_flag = 1; vseq->frame_cropping_flag = 1;
vseq->frame_crop_left_offset = 0; vseq->frame_crop_left_offset = 0;
vseq->frame_crop_right_offset = vseq->frame_crop_right_offset =
(ctx->aligned_width - ctx->input_width) / 2; (ctx->surface_width - avctx->width) / 2;
vseq->frame_crop_top_offset = 0; vseq->frame_crop_top_offset = 0;
vseq->frame_crop_bottom_offset = vseq->frame_crop_bottom_offset =
(ctx->aligned_height - ctx->input_height) / 2; (ctx->surface_height - avctx->height) / 2;
} else { } else {
vseq->frame_cropping_flag = 0; vseq->frame_cropping_flag = 0;
} }
@ -866,9 +858,9 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
(avctx->bit_rate >> mseq->bit_rate_scale + 6) - 1; (avctx->bit_rate >> mseq->bit_rate_scale + 6) - 1;
mseq->cpb_size_scale = mseq->cpb_size_scale =
av_clip_uintp2(av_log2(priv->hrd_params.hrd.buffer_size) - 15 - 4, 4); av_clip_uintp2(av_log2(ctx->hrd_params.hrd.buffer_size) - 15 - 4, 4);
mseq->cpb_size_value_minus1[0] = mseq->cpb_size_value_minus1[0] =
(priv->hrd_params.hrd.buffer_size >> mseq->cpb_size_scale + 4) - 1; (ctx->hrd_params.hrd.buffer_size >> mseq->cpb_size_scale + 4) - 1;
// CBR mode isn't actually available here, despite naming. // CBR mode isn't actually available here, despite naming.
mseq->cbr_flag[0] = 0; mseq->cbr_flag[0] = 0;
@ -880,8 +872,8 @@ static int vaapi_encode_h264_init_sequence_params(AVCodecContext *avctx)
// This calculation can easily overflow 32 bits. // This calculation can easily overflow 32 bits.
mseq->initial_cpb_removal_delay = 90000 * mseq->initial_cpb_removal_delay = 90000 *
(uint64_t)priv->hrd_params.hrd.initial_buffer_fullness / (uint64_t)ctx->hrd_params.hrd.initial_buffer_fullness /
priv->hrd_params.hrd.buffer_size; ctx->hrd_params.hrd.buffer_size;
mseq->initial_cpb_removal_delay_offset = 0; mseq->initial_cpb_removal_delay_offset = 0;
} else { } else {
@ -1083,100 +1075,94 @@ static int vaapi_encode_h264_init_slice_params(AVCodecContext *avctx,
return 0; return 0;
} }
static av_cold int vaapi_encode_h264_init_constant_bitrate(AVCodecContext *avctx) static av_cold int vaapi_encode_h264_configure(AVCodecContext *avctx)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH264Context *priv = ctx->priv_data; VAAPIEncodeH264Context *priv = ctx->priv_data;
int hrd_buffer_size; VAAPIEncodeH264Options *opt = ctx->codec_options;
int hrd_initial_buffer_fullness;
if (avctx->bit_rate > INT32_MAX) { priv->mb_width = FFALIGN(avctx->width, 16) / 16;
av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or " priv->mb_height = FFALIGN(avctx->height, 16) / 16;
"higher is not supported.\n");
return AVERROR(EINVAL); if (ctx->va_rc_mode == VA_RC_CQP) {
priv->fixed_qp_p = opt->qp;
if (avctx->i_quant_factor > 0.0)
priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
avctx->i_quant_offset) + 0.5);
else
priv->fixed_qp_idr = priv->fixed_qp_p;
if (avctx->b_quant_factor > 0.0)
priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
avctx->b_quant_offset) + 0.5);
else
priv->fixed_qp_b = priv->fixed_qp_p;
av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
"%d / %d / %d for IDR- / P- / B-frames.\n",
priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
} else if (ctx->va_rc_mode == VA_RC_CBR) {
// These still need to be set for pic_init_qp/slice_qp_delta.
priv->fixed_qp_idr = 26;
priv->fixed_qp_p = 26;
priv->fixed_qp_b = 26;
av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %d bps.\n",
avctx->bit_rate);
} else {
av_assert0(0 && "Invalid RC mode.");
} }
if (avctx->rc_buffer_size) if (opt->quality > 0) {
hrd_buffer_size = avctx->rc_buffer_size; #if VA_CHECK_VERSION(0, 36, 0)
else priv->quality_params.misc.type =
hrd_buffer_size = avctx->bit_rate; VAEncMiscParameterTypeQualityLevel;
if (avctx->rc_initial_buffer_occupancy) priv->quality_params.quality.quality_level = opt->quality;
hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
else
hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl; ctx->global_params[ctx->nb_global_params] =
priv->rc_params.rc = (VAEncMiscParameterRateControl) { &priv->quality_params.misc;
.bits_per_second = avctx->bit_rate, ctx->global_params_size[ctx->nb_global_params++] =
.target_percentage = 66, sizeof(priv->quality_params);
.window_size = 1000, #else
.initial_qp = (avctx->qmax >= 0 ? avctx->qmax : 40), av_log(avctx, AV_LOG_WARNING, "The encode quality option is not "
.min_qp = (avctx->qmin >= 0 ? avctx->qmin : 18), "supported with this VAAPI version.\n");
.basic_unit_size = 0, #endif
}; }
ctx->global_params[ctx->nb_global_params] =
&priv->rc_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->rc_params);
priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
.initial_buffer_fullness = hrd_initial_buffer_fullness,
.buffer_size = hrd_buffer_size,
};
ctx->global_params[ctx->nb_global_params] =
&priv->hrd_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->hrd_params);
// These still need to be set for pic_init_qp/slice_qp_delta.
priv->fixed_qp_idr = 26;
priv->fixed_qp_p = 26;
priv->fixed_qp_b = 26;
av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
avctx->bit_rate);
return 0; return 0;
} }
static av_cold int vaapi_encode_h264_init_fixed_qp(AVCodecContext *avctx) static const VAAPIEncodeType vaapi_encode_type_h264 = {
.priv_data_size = sizeof(VAAPIEncodeH264Context),
.configure = &vaapi_encode_h264_configure,
.sequence_params_size = sizeof(VAEncSequenceParameterBufferH264),
.init_sequence_params = &vaapi_encode_h264_init_sequence_params,
.picture_params_size = sizeof(VAEncPictureParameterBufferH264),
.init_picture_params = &vaapi_encode_h264_init_picture_params,
.slice_params_size = sizeof(VAEncSliceParameterBufferH264),
.init_slice_params = &vaapi_encode_h264_init_slice_params,
.sequence_header_type = VAEncPackedHeaderSequence,
.write_sequence_header = &vaapi_encode_h264_write_sequence_header,
.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)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH264Context *priv = ctx->priv_data; VAAPIEncodeH264Options *opt =
VAAPIEncodeH264Options *opt = ctx->codec_options; (VAAPIEncodeH264Options*)ctx->codec_options_data;
priv->fixed_qp_p = opt->qp; ctx->codec = &vaapi_encode_type_h264;
if (avctx->i_quant_factor > 0.0)
priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
avctx->i_quant_offset) + 0.5);
else
priv->fixed_qp_idr = priv->fixed_qp_p;
if (avctx->b_quant_factor > 0.0)
priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
avctx->b_quant_offset) + 0.5);
else
priv->fixed_qp_b = priv->fixed_qp_p;
av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
"%d / %d / %d for IDR- / P- / B-frames.\n",
priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
return 0;
}
static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx)
{
static const VAConfigAttrib default_config_attributes[] = {
{ .type = VAConfigAttribRTFormat,
.value = VA_RT_FORMAT_YUV420 },
{ .type = VAConfigAttribEncPackedHeaders,
.value = (VA_ENC_PACKED_HEADER_SEQUENCE |
VA_ENC_PACKED_HEADER_SLICE) },
};
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH264Context *priv = ctx->priv_data;
VAAPIEncodeH264Options *opt = ctx->codec_options;
int i, err;
switch (avctx->profile) { switch (avctx->profile) {
case FF_PROFILE_H264_CONSTRAINED_BASELINE: case FF_PROFILE_H264_CONSTRAINED_BASELINE:
@ -1216,7 +1202,7 @@ static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (opt->low_power) { if (opt->low_power) {
#if VA_CHECK_VERSION(0, 39, 1) #if VA_CHECK_VERSION(0, 39, 2)
ctx->va_entrypoint = VAEntrypointEncSliceLP; ctx->va_entrypoint = VAEntrypointEncSliceLP;
#else #else
av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not " av_log(avctx, AV_LOG_ERROR, "Low-power encoding is not "
@ -1227,80 +1213,19 @@ static av_cold int vaapi_encode_h264_init_internal(AVCodecContext *avctx)
ctx->va_entrypoint = VAEntrypointEncSlice; ctx->va_entrypoint = VAEntrypointEncSlice;
} }
ctx->input_width = avctx->width; // Only 8-bit encode is supported.
ctx->input_height = avctx->height; ctx->va_rt_format = VA_RT_FORMAT_YUV420;
ctx->aligned_width = FFALIGN(ctx->input_width, 16);
ctx->aligned_height = FFALIGN(ctx->input_height, 16);
priv->mb_width = ctx->aligned_width / 16;
priv->mb_height = ctx->aligned_height / 16;
for (i = 0; i < FF_ARRAY_ELEMS(default_config_attributes); i++) { if (avctx->bit_rate > 0)
ctx->config_attributes[ctx->nb_config_attributes++] =
default_config_attributes[i];
}
if (avctx->bit_rate > 0) {
ctx->va_rc_mode = VA_RC_CBR; ctx->va_rc_mode = VA_RC_CBR;
err = vaapi_encode_h264_init_constant_bitrate(avctx); else
} else {
ctx->va_rc_mode = VA_RC_CQP; ctx->va_rc_mode = VA_RC_CQP;
err = vaapi_encode_h264_init_fixed_qp(avctx);
}
if (err < 0)
return err;
ctx->config_attributes[ctx->nb_config_attributes++] = (VAConfigAttrib) {
.type = VAConfigAttribRateControl,
.value = ctx->va_rc_mode,
};
if (opt->quality > 0) { ctx->surface_width = FFALIGN(avctx->width, 16);
#if VA_CHECK_VERSION(0, 36, 0) ctx->surface_height = FFALIGN(avctx->height, 16);
priv->quality_params.misc.type =
VAEncMiscParameterTypeQualityLevel;
priv->quality_params.quality.quality_level = opt->quality;
ctx->global_params[ctx->nb_global_params] = return ff_vaapi_encode_init(avctx);
&priv->quality_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->quality_params);
#else
av_log(avctx, AV_LOG_WARNING, "The encode quality option is not "
"supported with this VAAPI version.\n");
#endif
}
ctx->nb_recon_frames = 20;
return 0;
}
static VAAPIEncodeType vaapi_encode_type_h264 = {
.priv_data_size = sizeof(VAAPIEncodeH264Context),
.init = &vaapi_encode_h264_init_internal,
.sequence_params_size = sizeof(VAEncSequenceParameterBufferH264),
.init_sequence_params = &vaapi_encode_h264_init_sequence_params,
.picture_params_size = sizeof(VAEncPictureParameterBufferH264),
.init_picture_params = &vaapi_encode_h264_init_picture_params,
.slice_params_size = sizeof(VAEncSliceParameterBufferH264),
.init_slice_params = &vaapi_encode_h264_init_slice_params,
.sequence_header_type = VAEncPackedHeaderSequence,
.write_sequence_header = &vaapi_encode_h264_write_sequence_header,
.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)
{
return ff_vaapi_encode_init(avctx, &vaapi_encode_type_h264);
} }
#define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \ #define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \

208
libavcodec/vaapi_encode_h265.c
View File

@ -798,8 +798,8 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
vseq->intra_idr_period = 0; vseq->intra_idr_period = 0;
vseq->ip_period = 0; vseq->ip_period = 0;
vseq->pic_width_in_luma_samples = ctx->aligned_width; vseq->pic_width_in_luma_samples = ctx->surface_width;
vseq->pic_height_in_luma_samples = ctx->aligned_height; vseq->pic_height_in_luma_samples = ctx->surface_height;
vseq->seq_fields.bits.chroma_format_idc = 1; // 4:2:0. vseq->seq_fields.bits.chroma_format_idc = 1; // 4:2:0.
vseq->seq_fields.bits.separate_colour_plane_flag = 0; vseq->seq_fields.bits.separate_colour_plane_flag = 0;
@ -911,15 +911,15 @@ static int vaapi_encode_h265_init_sequence_params(AVCodecContext *avctx)
mseq->vps_poc_proportional_to_timing_flag = 1; mseq->vps_poc_proportional_to_timing_flag = 1;
mseq->vps_num_ticks_poc_diff_minus1 = 0; mseq->vps_num_ticks_poc_diff_minus1 = 0;
if (ctx->input_width != ctx->aligned_width || if (avctx->width != ctx->surface_width ||
ctx->input_height != ctx->aligned_height) { avctx->height != ctx->surface_height) {
mseq->conformance_window_flag = 1; mseq->conformance_window_flag = 1;
mseq->conf_win_left_offset = 0; mseq->conf_win_left_offset = 0;
mseq->conf_win_right_offset = mseq->conf_win_right_offset =
(ctx->aligned_width - ctx->input_width) / 2; (ctx->surface_width - avctx->width) / 2;
mseq->conf_win_top_offset = 0; mseq->conf_win_top_offset = 0;
mseq->conf_win_bottom_offset = mseq->conf_win_bottom_offset =
(ctx->aligned_height - ctx->input_height) / 2; (ctx->surface_height - avctx->height) / 2;
} else { } else {
mseq->conformance_window_flag = 0; mseq->conformance_window_flag = 0;
} }
@ -1154,156 +1154,56 @@ static int vaapi_encode_h265_init_slice_params(AVCodecContext *avctx,
return 0; return 0;
} }
static av_cold int vaapi_encode_h265_init_constant_bitrate(AVCodecContext *avctx) static av_cold int vaapi_encode_h265_configure(AVCodecContext *avctx)
{
VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = ctx->priv_data;
int hrd_buffer_size;
int hrd_initial_buffer_fullness;
if (avctx->bit_rate > INT32_MAX) {
av_log(avctx, AV_LOG_ERROR, "Target bitrate of 2^31 bps or "
"higher is not supported.\n");
return AVERROR(EINVAL);
}
if (avctx->rc_buffer_size)
hrd_buffer_size = avctx->rc_buffer_size;
else
hrd_buffer_size = avctx->bit_rate;
if (avctx->rc_initial_buffer_occupancy)
hrd_initial_buffer_fullness = avctx->rc_initial_buffer_occupancy;
else
hrd_initial_buffer_fullness = hrd_buffer_size * 3 / 4;
priv->rc_params.misc.type = VAEncMiscParameterTypeRateControl;
priv->rc_params.rc = (VAEncMiscParameterRateControl) {
.bits_per_second = avctx->bit_rate,
.target_percentage = 66,
.window_size = 1000,
.initial_qp = (avctx->qmax >= 0 ? avctx->qmax : 40),
.min_qp = (avctx->qmin >= 0 ? avctx->qmin : 20),
.basic_unit_size = 0,
};
ctx->global_params[ctx->nb_global_params] =
&priv->rc_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->rc_params);
priv->hrd_params.misc.type = VAEncMiscParameterTypeHRD;
priv->hrd_params.hrd = (VAEncMiscParameterHRD) {
.initial_buffer_fullness = hrd_initial_buffer_fullness,
.buffer_size = hrd_buffer_size,
};
ctx->global_params[ctx->nb_global_params] =
&priv->hrd_params.misc;
ctx->global_params_size[ctx->nb_global_params++] =
sizeof(priv->hrd_params);
// These still need to be set for pic_init_qp/slice_qp_delta.
priv->fixed_qp_idr = 30;
priv->fixed_qp_p = 30;
priv->fixed_qp_b = 30;
av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %"PRId64" bps.\n",
avctx->bit_rate);
return 0;
}
static av_cold int vaapi_encode_h265_init_fixed_qp(AVCodecContext *avctx)
{ {
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeH265Context *priv = ctx->priv_data; VAAPIEncodeH265Context *priv = ctx->priv_data;
VAAPIEncodeH265Options *opt = ctx->codec_options; VAAPIEncodeH265Options *opt = ctx->codec_options;
priv->fixed_qp_p = opt->qp; priv->ctu_width = FFALIGN(ctx->surface_width, 32) / 32;
if (avctx->i_quant_factor > 0.0) priv->ctu_height = FFALIGN(ctx->surface_height, 32) / 32;
priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
avctx->i_quant_offset) + 0.5);
else
priv->fixed_qp_idr = priv->fixed_qp_p;
if (avctx->b_quant_factor > 0.0)
priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
avctx->b_quant_offset) + 0.5);
else
priv->fixed_qp_b = priv->fixed_qp_p;
av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = " av_log(avctx, AV_LOG_VERBOSE, "Input %ux%u -> Surface %ux%u -> CTU %ux%u.\n",
"%d / %d / %d for IDR- / P- / B-frames.\n", avctx->width, avctx->height, ctx->surface_width,
priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b); ctx->surface_height, priv->ctu_width, priv->ctu_height);
return 0;
}
static av_cold int vaapi_encode_h265_init_internal(AVCodecContext *avctx) if (ctx->va_rc_mode == VA_RC_CQP) {
{ priv->fixed_qp_p = opt->qp;
static const VAConfigAttrib default_config_attributes[] = { if (avctx->i_quant_factor > 0.0)
{ .type = VAConfigAttribRTFormat, priv->fixed_qp_idr = (int)((priv->fixed_qp_p * avctx->i_quant_factor +
.value = VA_RT_FORMAT_YUV420 }, avctx->i_quant_offset) + 0.5);
{ .type = VAConfigAttribEncPackedHeaders, else
.value = (VA_ENC_PACKED_HEADER_SEQUENCE | priv->fixed_qp_idr = priv->fixed_qp_p;
VA_ENC_PACKED_HEADER_SLICE) }, if (avctx->b_quant_factor > 0.0)
}; priv->fixed_qp_b = (int)((priv->fixed_qp_p * avctx->b_quant_factor +
avctx->b_quant_offset) + 0.5);
else
priv->fixed_qp_b = priv->fixed_qp_p;
VAAPIEncodeContext *ctx = avctx->priv_data; av_log(avctx, AV_LOG_DEBUG, "Using fixed QP = "
VAAPIEncodeH265Context *priv = ctx->priv_data; "%d / %d / %d for IDR- / P- / B-frames.\n",
int i, err; priv->fixed_qp_idr, priv->fixed_qp_p, priv->fixed_qp_b);
switch (avctx->profile) { } else if (ctx->va_rc_mode == VA_RC_CBR) {
case FF_PROFILE_HEVC_MAIN: // These still need to be set for pic_init_qp/slice_qp_delta.
case FF_PROFILE_UNKNOWN: priv->fixed_qp_idr = 30;
ctx->va_profile = VAProfileHEVCMain; priv->fixed_qp_p = 30;
break; priv->fixed_qp_b = 30;
case FF_PROFILE_HEVC_MAIN_10:
av_log(avctx, AV_LOG_ERROR, "H.265 main 10-bit profile "
"is not supported.\n");
return AVERROR_PATCHWELCOME;
default:
av_log(avctx, AV_LOG_ERROR, "Unknown H.265 profile %d.\n",
avctx->profile);
return AVERROR(EINVAL);
}
ctx->va_entrypoint = VAEntrypointEncSlice;
ctx->input_width = avctx->width; av_log(avctx, AV_LOG_DEBUG, "Using constant-bitrate = %d bps.\n",
ctx->input_height = avctx->height; avctx->bit_rate);
ctx->aligned_width = FFALIGN(ctx->input_width, 16);
ctx->aligned_height = FFALIGN(ctx->input_height, 16);
priv->ctu_width = FFALIGN(ctx->aligned_width, 32) / 32;
priv->ctu_height = FFALIGN(ctx->aligned_height, 32) / 32;
av_log(avctx, AV_LOG_VERBOSE, "Input %ux%u -> Aligned %ux%u -> CTU %ux%u.\n",
ctx->input_width, ctx->input_height, ctx->aligned_width,
ctx->aligned_height, priv->ctu_width, priv->ctu_height);
for (i = 0; i < FF_ARRAY_ELEMS(default_config_attributes); i++) {
ctx->config_attributes[ctx->nb_config_attributes++] =
default_config_attributes[i];
}
if (avctx->bit_rate > 0) {
ctx->va_rc_mode = VA_RC_CBR;
err = vaapi_encode_h265_init_constant_bitrate(avctx);
} else { } else {
ctx->va_rc_mode = VA_RC_CQP; av_assert0(0 && "Invalid RC mode.");
err = vaapi_encode_h265_init_fixed_qp(avctx);
} }
if (err < 0)
return err;
ctx->config_attributes[ctx->nb_config_attributes++] = (VAConfigAttrib) {
.type = VAConfigAttribRateControl,
.value = ctx->va_rc_mode,
};
ctx->nb_recon_frames = 20;
return 0; return 0;
} }
static VAAPIEncodeType vaapi_encode_type_h265 = { static const VAAPIEncodeType vaapi_encode_type_h265 = {
.priv_data_size = sizeof(VAAPIEncodeH265Context), .priv_data_size = sizeof(VAAPIEncodeH265Context),
.init = &vaapi_encode_h265_init_internal, .configure = &vaapi_encode_h265_configure,
.sequence_params_size = sizeof(VAEncSequenceParameterBufferHEVC), .sequence_params_size = sizeof(VAEncSequenceParameterBufferHEVC),
.init_sequence_params = &vaapi_encode_h265_init_sequence_params, .init_sequence_params = &vaapi_encode_h265_init_sequence_params,
@ -1323,7 +1223,39 @@ static VAAPIEncodeType vaapi_encode_type_h265 = {
static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx) static av_cold int vaapi_encode_h265_init(AVCodecContext *avctx)
{ {
return ff_vaapi_encode_init(avctx, &vaapi_encode_type_h265); VAAPIEncodeContext *ctx = avctx->priv_data;
ctx->codec = &vaapi_encode_type_h265;
switch (avctx->profile) {
case FF_PROFILE_HEVC_MAIN:
case FF_PROFILE_UNKNOWN:
ctx->va_profile = VAProfileHEVCMain;
break;
case FF_PROFILE_HEVC_MAIN_10:
av_log(avctx, AV_LOG_ERROR, "H.265 main 10-bit profile "
"is not supported.\n");
return AVERROR_PATCHWELCOME;
default:
av_log(avctx, AV_LOG_ERROR, "Unknown H.265 profile %d.\n",
avctx->profile);
return AVERROR(EINVAL);
}
ctx->va_entrypoint = VAEntrypointEncSlice;
// This will be dependent on profile when 10-bit is supported.
ctx->va_rt_format = VA_RT_FORMAT_YUV420;
if (avctx->bit_rate > 0)
ctx->va_rc_mode = VA_RC_CBR;
else
ctx->va_rc_mode = VA_RC_CQP;
ctx->surface_width = FFALIGN(avctx->width, 16);
ctx->surface_height = FFALIGN(avctx->height, 16);
return ff_vaapi_encode_init(avctx);
} }
#define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \ #define OFFSET(x) (offsetof(VAAPIEncodeContext, codec_options_data) + \

45
libavcodec/vaapi_encode_mjpeg.c
View File

@ -277,8 +277,8 @@ static int vaapi_encode_mjpeg_init_picture_params(AVCodecContext *avctx,
vpic->reconstructed_picture = pic->recon_surface; vpic->reconstructed_picture = pic->recon_surface;
vpic->coded_buf = pic->output_buffer; vpic->coded_buf = pic->output_buffer;
vpic->picture_width = ctx->input_width; vpic->picture_width = avctx->width;
vpic->picture_height = ctx->input_height; vpic->picture_height = avctx->height;
vpic->pic_flags.bits.profile = 0; vpic->pic_flags.bits.profile = 0;
vpic->pic_flags.bits.progressive = 0; vpic->pic_flags.bits.progressive = 0;
@ -333,31 +333,10 @@ static int vaapi_encode_mjpeg_init_slice_params(AVCodecContext *avctx,
return 0; return 0;
} }
static av_cold int vaapi_encode_mjpeg_init_internal(AVCodecContext *avctx) static av_cold int vaapi_encode_mjpeg_configure(AVCodecContext *avctx)
{ {
static const VAConfigAttrib default_config_attributes[] = {
{ .type = VAConfigAttribRTFormat,
.value = VA_RT_FORMAT_YUV420 },
{ .type = VAConfigAttribEncPackedHeaders,
.value = VA_ENC_PACKED_HEADER_SEQUENCE },
};
VAAPIEncodeContext *ctx = avctx->priv_data; VAAPIEncodeContext *ctx = avctx->priv_data;
VAAPIEncodeMJPEGContext *priv = ctx->priv_data; VAAPIEncodeMJPEGContext *priv = ctx->priv_data;
int i;
ctx->va_profile = VAProfileJPEGBaseline;
ctx->va_entrypoint = VAEntrypointEncPicture;
ctx->input_width = avctx->width;
ctx->input_height = avctx->height;
ctx->aligned_width = FFALIGN(ctx->input_width, 8);
ctx->aligned_height = FFALIGN(ctx->input_height, 8);
for (i = 0; i < FF_ARRAY_ELEMS(default_config_attributes); i++) {
ctx->config_attributes[ctx->nb_config_attributes++] =
default_config_attributes[i];
}
priv->quality = avctx->global_quality; priv->quality = avctx->global_quality;
if (priv->quality < 1 || priv->quality > 100) { if (priv->quality < 1 || priv->quality > 100) {
@ -374,7 +353,7 @@ static av_cold int vaapi_encode_mjpeg_init_internal(AVCodecContext *avctx)
static VAAPIEncodeType vaapi_encode_type_mjpeg = { static VAAPIEncodeType vaapi_encode_type_mjpeg = {
.priv_data_size = sizeof(VAAPIEncodeMJPEGContext), .priv_data_size = sizeof(VAAPIEncodeMJPEGContext),
.init = &vaapi_encode_mjpeg_init_internal, .configure = &vaapi_encode_mjpeg_configure,
.picture_params_size = sizeof(VAEncPictureParameterBufferJPEG), .picture_params_size = sizeof(VAEncPictureParameterBufferJPEG),
.init_picture_params = &vaapi_encode_mjpeg_init_picture_params, .init_picture_params = &vaapi_encode_mjpeg_init_picture_params,
@ -390,7 +369,21 @@ static VAAPIEncodeType vaapi_encode_type_mjpeg = {
static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx) static av_cold int vaapi_encode_mjpeg_init(AVCodecContext *avctx)
{ {
return ff_vaapi_encode_init(avctx, &vaapi_encode_type_mjpeg); VAAPIEncodeContext *ctx = avctx->priv_data;
ctx->codec = &vaapi_encode_type_mjpeg;
ctx->va_profile = VAProfileJPEGBaseline;
ctx->va_entrypoint = VAEntrypointEncPicture;
ctx->va_rt_format = VA_RT_FORMAT_YUV420;
ctx->va_rc_mode = VA_RC_CQP;
ctx->surface_width = FFALIGN(avctx->width, 8);
ctx->surface_height = FFALIGN(avctx->height, 8);
return ff_vaapi_encode_init(avctx);
} }
static const AVCodecDefault vaapi_encode_mjpeg_defaults[] = { static const AVCodecDefault vaapi_encode_mjpeg_defaults[] = {