Skip to content

Commit

Permalink
qsv: enable QSV encoder via FFmpeg API
Browse files Browse the repository at this point in the history
Co-authored-by: Kesy, Anton <[email protected]>
  • Loading branch information
galinart and antonkesy committed Nov 28, 2024
1 parent 7b65852 commit fc5186b
Show file tree
Hide file tree
Showing 30 changed files with 979 additions and 4,206 deletions.
Original file line number Diff line number Diff line change
@@ -0,0 +1,31 @@
From 95676fcc5c7141124a10bab0498110aed88680ce Mon Sep 17 00:00:00 2001
From: galinart <[email protected]>
Date: Thu, 17 Oct 2024 16:17:36 +0100
Subject: [PATCH] libavcodec/qsvenc.c: update has_b_frames value after
initialization of encoder

---
libavcodec/qsvenc.c | 7 +++++++
1 file changed, 7 insertions(+)

diff --git a/libavcodec/qsvenc.c b/libavcodec/qsvenc.c
index 8200a14..c2bb5e5 100644
--- a/libavcodec/qsvenc.c
+++ b/libavcodec/qsvenc.c
@@ -1842,6 +1842,13 @@ int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q)
return ret;
}

+ // Update AVCodecContext with actual encoding parameters
+ mfxInfoMFX *info = &q->param.mfx;
+ avctx->has_b_frames = 0;
+ if (info->GopRefDist > 1) {
+ avctx->has_b_frames = info->GopRefDist - 1;
+ }
+
q->avctx = avctx;

return 0;
--
2.25.1

144 changes: 144 additions & 0 deletions contrib/ffmpeg/A19-libavcodec-qsv-enable-av1-scc.patch
Original file line number Diff line number Diff line change
@@ -0,0 +1,144 @@
From 71b77865d4955440106015bd08172b876abed1f5 Mon Sep 17 00:00:00 2001
From: galinart <[email protected]>
Date: Tue, 12 Nov 2024 15:50:06 +0000
Subject: [PATCH] qsv: enable av1 scc

---
libavcodec/qsvenc.c | 42 +++++++++++++++++++++++++++++++++++++++++
libavcodec/qsvenc.h | 8 +++++++-
libavcodec/qsvenc_av1.c | 4 ++++
3 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/libavcodec/qsvenc.c b/libavcodec/qsvenc.c
index c2bb5e5..284b608 100644
--- a/libavcodec/qsvenc.c
+++ b/libavcodec/qsvenc.c
@@ -494,6 +494,9 @@ static void dump_video_av1_param(AVCodecContext *avctx, QSVEncContext *q,
mfxExtAV1BitstreamParam *av1_bs_param = (mfxExtAV1BitstreamParam *)coding_opts[1];
mfxExtCodingOption2 *co2 = (mfxExtCodingOption2*)coding_opts[2];
mfxExtCodingOption3 *co3 = (mfxExtCodingOption3*)coding_opts[3];
+#if QSV_HAVE_EXT_AV1_SCC
+ mfxExtAV1ScreenContentTools *scc = (mfxExtAV1ScreenContentTools*)coding_opts[4];
+#endif

av_log(avctx, AV_LOG_VERBOSE, "profile: %s; level: %"PRIu16"\n",
print_profile(avctx->codec_id, info->CodecProfile), info->CodecLevel);
@@ -566,6 +569,13 @@ static void dump_video_av1_param(AVCodecContext *avctx, QSVEncContext *q,
print_threestate(av1_bs_param->WriteIVFHeaders));
av_log(avctx, AV_LOG_VERBOSE, "LowDelayBRC: %s\n", print_threestate(co3->LowDelayBRC));
av_log(avctx, AV_LOG_VERBOSE, "MaxFrameSize: %d;\n", co2->MaxFrameSize);
+#if QSV_HAVE_EXT_AV1_SCC
+ if (scc) {
+ av_log(avctx, AV_LOG_VERBOSE,
+ "Palette: %s; IntraBlockCopy: %s\n",
+ print_threestate(scc->Palette), print_threestate(scc->IntraBlockCopy));
+ }
+#endif
}
#endif

@@ -1282,6 +1292,28 @@ static int init_video_param(AVCodecContext *avctx, QSVEncContext *q)
}
#endif

+#if QSV_HAVE_EXT_AV1_SCC
+ if (q->palette_mode || q->intrabc) {
+ if (QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 13)) {
+ if (q->param.mfx.CodecId != MFX_CODEC_AV1) {
+ av_log(avctx, AV_LOG_ERROR, "Not supported encoder for Screen Content Tool Encode. "
+ "Supported: av1_qsv \n");
+ return AVERROR_UNKNOWN;
+ }
+
+ q->extsccparam.Header.BufferId = MFX_EXTBUFF_AV1_SCREEN_CONTENT_TOOLS;
+ q->extsccparam.Header.BufferSz = sizeof(q->extsccparam);
+ q->extsccparam.Palette = q->palette_mode ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ q->extsccparam.IntraBlockCopy = q->intrabc ? MFX_CODINGOPTION_ON : MFX_CODINGOPTION_OFF;
+ q->extparam_internal[q->nb_extparam_internal++] = (mfxExtBuffer *)&q->extsccparam;
+ } else {
+ av_log(avctx, AV_LOG_ERROR,
+ "This version of runtime doesn't support Screen Content Tool Encode\n");
+ return AVERROR_UNKNOWN;
+ }
+ }
+#endif
+
if (!check_enc_param(avctx,q)) {
av_log(avctx, AV_LOG_ERROR,
"some encoding parameters are not supported by the QSV "
@@ -1389,11 +1421,21 @@ static int qsv_retrieve_enc_av1_params(AVCodecContext *avctx, QSVEncContext *q)
.Header.BufferSz = sizeof(co3),
};

+#if QSV_HAVE_EXT_AV1_SCC
+ mfxExtAV1ScreenContentTools scc_buf = {
+ .Header.BufferId = MFX_EXTBUFF_AV1_SCREEN_CONTENT_TOOLS,
+ .Header.BufferSz = sizeof(scc_buf),
+ };
+#endif
+
mfxExtBuffer *ext_buffers[] = {
(mfxExtBuffer*)&av1_extend_tile_buf,
(mfxExtBuffer*)&av1_bs_param,
(mfxExtBuffer*)&co2,
(mfxExtBuffer*)&co3,
+#if QSV_HAVE_EXT_AV1_SCC
+ (mfxExtBuffer*)&scc_buf,
+#endif
};

if (!QSV_RUNTIME_VERSION_ATLEAST(q->ver, 2, 5)) {
diff --git a/libavcodec/qsvenc.h b/libavcodec/qsvenc.h
index 4bc77f2..2e0a19b 100644
--- a/libavcodec/qsvenc.h
+++ b/libavcodec/qsvenc.h
@@ -38,6 +38,7 @@

#define QSV_HAVE_EXT_VP9_TILES QSV_VERSION_ATLEAST(1, 29)
#define QSV_HAVE_EXT_AV1_PARAM QSV_VERSION_ATLEAST(2, 5)
+#define QSV_HAVE_EXT_AV1_SCC QSV_VERSION_ATLEAST(2, 13)

#if defined(_WIN32) || defined(__CYGWIN__)
#define QSV_HAVE_AVBR 1
@@ -188,10 +189,13 @@ typedef struct QSVEncContext {
mfxFrameSurface1 **opaque_surfaces;
AVBufferRef *opaque_alloc_buf;
#endif
+#if QSV_HAVE_EXT_AV1_SCC
+ mfxExtAV1ScreenContentTools extsccparam;
+#endif

mfxExtVideoSignalInfo extvsi;

- mfxExtBuffer *extparam_internal[5 + (QSV_HAVE_MF * 2) + (QSV_HAVE_EXT_AV1_PARAM * 2) + QSV_HAVE_HE];
+ mfxExtBuffer *extparam_internal[5 + (QSV_HAVE_MF * 2) + (QSV_HAVE_EXT_AV1_PARAM * 2) + QSV_HAVE_HE + QSV_HAVE_EXT_AV1_SCC];
int nb_extparam_internal;

mfxExtBuffer **extparam_str;
@@ -319,6 +323,8 @@ typedef struct QSVEncContext {
int dual_gfx;

AVDictionary *qsv_params;
+ int palette_mode;
+ int intrabc;
} QSVEncContext;

int ff_qsv_enc_init(AVCodecContext *avctx, QSVEncContext *q);
diff --git a/libavcodec/qsvenc_av1.c b/libavcodec/qsvenc_av1.c
index a86b409..4f035f3 100644
--- a/libavcodec/qsvenc_av1.c
+++ b/libavcodec/qsvenc_av1.c
@@ -189,6 +189,10 @@ static const AVOption options[] = {
{ "tile_cols", "Number of columns for tiled encoding", OFFSET(qsv.tile_cols), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
{ "tile_rows", "Number of rows for tiled encoding", OFFSET(qsv.tile_rows), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, UINT16_MAX, VE },
{ "look_ahead_depth", "Depth of look ahead in number frames, available when extbrc option is enabled", OFFSET(qsv.look_ahead_depth), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 100, VE },
+#if QSV_HAVE_EXT_AV1_SCC
+ { "palette_mode", "Enable palette mode of Screen Content Tool for encoding", OFFSET(qsv.palette_mode), AV_OPT_TYPE_BOOL, { .i64 = 0}, 0, 1, VE},
+ { "intrabc", "Enable intra block copy of Screen Content Tool for encoding", OFFSET(qsv.intrabc), AV_OPT_TYPE_BOOL, { .i64 = 0}, 0, 1, VE},
+#endif
{ NULL },
};

--
2.25.1

3 changes: 3 additions & 0 deletions contrib/ffmpeg/module.defs
Original file line number Diff line number Diff line change
Expand Up @@ -167,6 +167,9 @@ endif
ifeq (1,$(FEATURE.qsv))
FFMPEG.CONFIGURE.extra += --enable-libvpl
FFMPEG.CONFIGURE.extra += --enable-filter=vpp_qsv
FFMPEG.CONFIGURE.extra += --enable-encoder=hevc_qsv
FFMPEG.CONFIGURE.extra += --enable-encoder=h264_qsv
FFMPEG.CONFIGURE.extra += --enable-encoder=av1_qsv
endif

ifeq (1,$(FEATURE.vce))
Expand Down
22 changes: 0 additions & 22 deletions libhb/avfilter.c
Original file line number Diff line number Diff line change
Expand Up @@ -238,22 +238,6 @@ static hb_buffer_t* filterFrame( hb_filter_private_t * pv, hb_buffer_t ** buf_in
hb_buffer_list_t list;
hb_buffer_t * buf = NULL, * next = NULL;

#if HB_PROJECT_FEATURE_QSV && (defined( _WIN32 ) || defined( __MINGW32__ ))
mfxFrameSurface1 *surface = NULL;
HBQSVFramesContext *frames_ctx = NULL;
if (hb_qsv_hw_filters_via_video_memory_are_enabled(pv->input.job) && buf_in != NULL)
{
hb_buffer_t *in = *buf_in;
AVFrame *frame = (AVFrame *)in->storage;
if (frame)
{
// We need to keep surface pointer because hb_avfilter_add_buf set it to 0 after in ffmpeg call
surface = (mfxFrameSurface1 *)frame->data[3];
frames_ctx = in->qsv_details.qsv_frames_ctx;
}
}
#endif

hb_avfilter_add_buf(pv->graph, buf_in);
buf = hb_avfilter_get_buf(pv->graph);

Expand All @@ -262,12 +246,6 @@ static hb_buffer_t* filterFrame( hb_filter_private_t * pv, hb_buffer_t ** buf_in
hb_buffer_list_append(&pv->list, buf);
buf = hb_avfilter_get_buf(pv->graph);
}
#if HB_PROJECT_FEATURE_QSV && (defined( _WIN32 ) || defined( __MINGW32__ ))
if (hb_qsv_hw_filters_via_video_memory_are_enabled(pv->input.job) && surface)
{
hb_qsv_release_surface_from_pool_by_surface_pointer(frames_ctx, surface);
}
#endif
// Delay one frame so we can set the stop time of the output buffer
hb_buffer_list_clear(&list);
while (hb_buffer_list_count(&pv->list) > 1)
Expand Down
44 changes: 13 additions & 31 deletions libhb/common.c
Original file line number Diff line number Diff line change
Expand Up @@ -285,16 +285,16 @@ hb_encoder_internal_t hb_video_encoders[] =
// actual encoders
{ { "AV1 (SVT)", "svt_av1", "AV1 (SVT)", HB_VCODEC_SVT_AV1, HB_MUX_MASK_MP4|HB_MUX_MASK_WEBM|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_SVT, },
{ { "AV1 10-bit (SVT)", "svt_av1_10bit", "AV1 10-bit (SVT)", HB_VCODEC_SVT_AV1_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_WEBM|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_SVT, },
{ { "AV1 (Intel QSV)", "qsv_av1", "AV1 (Intel Media SDK)", HB_VCODEC_QSV_AV1, HB_MUX_MASK_MP4|HB_MUX_MASK_WEBM|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_QSV, },
{ { "AV1 10-bit (Intel QSV)", "qsv_av1_10bit", "AV1 10-bit (Intel Media SDK)", HB_VCODEC_QSV_AV1_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_WEBM|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_QSV, },
{ { "AV1 (Intel QSV)", "qsv_av1", "AV1 (Intel Media SDK)", HB_VCODEC_FFMPEG_QSV_AV1, HB_MUX_MASK_MP4|HB_MUX_MASK_WEBM|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_QSV, },
{ { "AV1 10-bit (Intel QSV)", "qsv_av1_10bit", "AV1 10-bit (Intel Media SDK)", HB_VCODEC_FFMPEG_QSV_AV1_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_WEBM|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_QSV, },
{ { "AV1 (NVEnc)", "nvenc_av1", "AV1 (NVEnc)", HB_VCODEC_FFMPEG_NVENC_AV1, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_NVENC, },
{ { "AV1 10-bit (NVEnc)", "nvenc_av1_10bit", "AV1 10-bit (NVEnc)", HB_VCODEC_FFMPEG_NVENC_AV1_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_NVENC, },
{ { "AV1 (AMD VCE)", "vce_av1", "AV1 (AMD VCE)", HB_VCODEC_FFMPEG_VCE_AV1, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_VCE, },
{ { "AV1 (MediaFoundation)", "mf_av1", "AV1 (MediaFoundation)", HB_VCODEC_FFMPEG_MF_AV1, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_AV1_MF, },
{ { "FFV1", "ffv1", "FFV1 (libavcodec)", HB_VCODEC_FFMPEG_FFV1, HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_FFV1, },
{ { "H.264 (x264)", "x264", "H.264 (libx264)", HB_VCODEC_X264_8BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_X264, },
{ { "H.264 10-bit (x264)", "x264_10bit", "H.264 10-bit (libx264)", HB_VCODEC_X264_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_X264, },
{ { "H.264 (Intel QSV)", "qsv_h264", "H.264 (Intel Media SDK)", HB_VCODEC_QSV_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_QSV, },
{ { "H.264 (Intel QSV)", "qsv_h264", "H.264 (Intel Media SDK)", HB_VCODEC_FFMPEG_QSV_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_QSV, },
{ { "H.264 (AMD VCE)", "vce_h264", "H.264 (AMD VCE)", HB_VCODEC_FFMPEG_VCE_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_VCE, },
{ { "H.264 (NVEnc)", "nvenc_h264", "H.264 (NVEnc)", HB_VCODEC_FFMPEG_NVENC_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_NVENC, },
{ { "H.264 (MediaFoundation)", "mf_h264", "H.264 (MediaFoundation)", HB_VCODEC_FFMPEG_MF_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H264_MF, },
Expand All @@ -303,8 +303,8 @@ hb_encoder_internal_t hb_video_encoders[] =
{ { "H.265 10-bit (x265)", "x265_10bit", "H.265 10-bit (libx265)", HB_VCODEC_X265_10BIT, HB_MUX_AV_MP4|HB_MUX_AV_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_X265, },
{ { "H.265 12-bit (x265)", "x265_12bit", "H.265 12-bit (libx265)", HB_VCODEC_X265_12BIT, HB_MUX_AV_MP4|HB_MUX_AV_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_X265, },
{ { "H.265 16-bit (x265)", "x265_16bit", "H.265 16-bit (libx265)", HB_VCODEC_X265_16BIT, HB_MUX_AV_MP4|HB_MUX_AV_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_X265, },
{ { "H.265 (Intel QSV)", "qsv_h265", "H.265 (Intel Media SDK)", HB_VCODEC_QSV_H265, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_QSV, },
{ { "H.265 10-bit (Intel QSV)", "qsv_h265_10bit", "H.265 10-bit (Intel Media SDK)", HB_VCODEC_QSV_H265_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_QSV, },
{ { "H.265 (Intel QSV)", "qsv_h265", "H.265 (Intel Media SDK)", HB_VCODEC_FFMPEG_QSV_H265, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_QSV, },
{ { "H.265 10-bit (Intel QSV)", "qsv_h265_10bit", "H.265 10-bit (Intel Media SDK)", HB_VCODEC_FFMPEG_QSV_H265_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_QSV, },
{ { "H.265 (AMD VCE)", "vce_h265", "H.265 (AMD VCE)", HB_VCODEC_FFMPEG_VCE_H265, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_VCE, },
{ { "H.265 10-bit (AMD VCE)", "vce_h265_10bit", "H.265 10-bit (AMD VCE)", HB_VCODEC_FFMPEG_VCE_H265_10BIT, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_VCE, },
{ { "H.265 (NVEnc)", "nvenc_h265", "H.265 (NVEnc)", HB_VCODEC_FFMPEG_NVENC_H265, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 0, 1, HB_GID_VCODEC_H265_NVENC, },
Expand Down Expand Up @@ -1690,11 +1690,11 @@ int hb_video_multipass_is_supported(uint32_t codec, int constant_quality)
case HB_VCODEC_FFMPEG_NVENC_H265_10BIT:
case HB_VCODEC_FFMPEG_NVENC_AV1:
case HB_VCODEC_FFMPEG_NVENC_AV1_10BIT:
case HB_VCODEC_QSV_H264:
case HB_VCODEC_QSV_H265:
case HB_VCODEC_QSV_H265_10BIT:
case HB_VCODEC_QSV_AV1:
case HB_VCODEC_QSV_AV1_10BIT:
case HB_VCODEC_FFMPEG_QSV_H264:
case HB_VCODEC_FFMPEG_QSV_H265:
case HB_VCODEC_FFMPEG_QSV_H265_10BIT:
case HB_VCODEC_FFMPEG_QSV_AV1:
case HB_VCODEC_FFMPEG_QSV_AV1_10BIT:
return 0;

case HB_VCODEC_FFMPEG_VP9:
Expand Down Expand Up @@ -1748,8 +1748,8 @@ int hb_video_encoder_get_depth(int encoder)
switch (encoder)
{
#if HB_PROJECT_FEATURE_QSV
case HB_VCODEC_QSV_H265_10BIT:
case HB_VCODEC_QSV_AV1_10BIT:
case HB_VCODEC_FFMPEG_QSV_H265_10BIT:
case HB_VCODEC_FFMPEG_QSV_AV1_10BIT:
#endif
#ifdef __APPLE__
case HB_VCODEC_VT_H265_10BIT:
Expand All @@ -1773,13 +1773,6 @@ int hb_video_encoder_get_depth(int encoder)

const char* const* hb_video_encoder_get_presets(int encoder)
{
#if HB_PROJECT_FEATURE_QSV
if (encoder & HB_VCODEC_QSV_MASK)
{
return hb_qsv_preset_get_names();
}
#endif

if (encoder & HB_VCODEC_FFMPEG_MASK)
{
return hb_av_preset_get_names(encoder);
Expand Down Expand Up @@ -2001,13 +1994,6 @@ static const enum AVPixelFormat standard_444_12bit_pix_fmts[] =

const int* hb_video_encoder_get_pix_fmts(int encoder, const char *profile)
{
#if HB_PROJECT_FEATURE_QSV
if (encoder & HB_VCODEC_QSV_MASK)
{
return hb_qsv_get_pix_fmts(encoder);
}
#endif

if (encoder & HB_VCODEC_FFMPEG_MASK)
{
return hb_av_get_pix_fmts(encoder);
Expand Down Expand Up @@ -6735,11 +6721,7 @@ static int pix_fmt_is_supported(hb_job_t *job, int pix_fmt)

if (planes_count == 2)
{
if (hb_hwaccel_decode_is_enabled(job) == 0
#if HB_PROJECT_FEATURE_QSV
&& hb_qsv_full_path_is_enabled(job) == 0
#endif
)
if (hb_hwaccel_decode_is_enabled(job) == 0)
{
return 0;
}
Expand Down
14 changes: 1 addition & 13 deletions libhb/cropscale.c
Original file line number Diff line number Diff line change
Expand Up @@ -12,8 +12,6 @@
#include "handbrake/hbffmpeg.h"
#if HB_PROJECT_FEATURE_QSV && (defined( _WIN32 ) || defined( __MINGW32__ ))
#include "handbrake/qsv_common.h"
#include "libavutil/hwcontext_qsv.h"
#include "libavutil/hwcontext.h"
#endif

static int crop_scale_init(hb_filter_object_t * filter,
Expand Down Expand Up @@ -99,18 +97,8 @@ static int crop_scale_init(hb_filter_object_t * filter, hb_filter_init_t * init)
hb_dict_t * avsettings = hb_dict_init();

#if HB_PROJECT_FEATURE_QSV && (defined( _WIN32 ) || defined( __MINGW32__ ))
if (hb_qsv_hw_filters_via_video_memory_are_enabled(init->job) || hb_qsv_hw_filters_via_system_memory_are_enabled(init->job))
if(init->hw_pix_fmt == AV_PIX_FMT_QSV)
{
if (hb_qsv_hw_filters_via_video_memory_are_enabled(init->job))
{
int result = hb_qsv_create_ffmpeg_vpp_pool(init, width, height);
if (result < 0)
{
hb_error("hb_create_ffmpeg_pool vpp allocation failed");
return result;
}
}

if (top > 0 || bottom > 0 || left > 0 || right > 0)
{
hb_dict_set_int(avsettings, "cx", left);
Expand Down
Loading

0 comments on commit fc5186b

Please sign in to comment.