#include "qsv_common.h"
#include "qsv_memory.h"
#include "h264_common.h"
+#include "h265_common.h"
/*
* The frame info struct remembers information about each frame across calls to
hb_work_object_t hb_encqsv =
{
WORK_ENCQSV,
- "H.264/AVC encoder (Intel QSV)",
+ "Quick Sync Video encoder (Intel Media SDK)",
encqsvInit,
encqsvWork,
encqsvClose
/* We need 2 consecutive B-frames for B-pyramid (GopRefDist >= 3) */
goto unsupported;
}
- else if (pv->qsv_info->codec_id == MFX_CODEC_AVC)
+ else if (pv->param.videoParam->mfx.CodecId == MFX_CODEC_AVC)
{
switch (pv->param.videoParam->mfx.CodecProfile)
{
break;
}
}
+ else if (pv->param.videoParam->mfx.CodecId == MFX_CODEC_HEVC)
+ {
+ switch (pv->param.videoParam->mfx.CodecProfile)
+ {
+ case MFX_PROFILE_HEVC_MAINSP:
+ goto unsupported; // B-frames not allowed by profile
+ default:
+ break;
+ }
+ }
/* Handle B-pyramid auto (on for CQP, off otherwise) */
if (pv->param.gop.b_pyramid < 0)
pv->param.codingOption2.BRefType = MFX_B_REF_OFF;
}
+static int qsv_hevc_make_header(hb_work_object_t *w, mfxSession session)
+{
+ size_t len;
+ int ret = 0;
+ uint8_t *buf, *end;
+ mfxBitstream bitstream;
+ hb_buffer_t *bitstream_buf;
+ mfxStatus status;
+ mfxSyncPoint syncPoint;
+ mfxFrameSurface1 frameSurface1;
+ hb_work_private_t *pv = w->private_data;
+
+ memset(&bitstream, 0, sizeof(mfxBitstream));
+ memset(&syncPoint, 0, sizeof(mfxSyncPoint));
+ memset(&frameSurface1, 0, sizeof(mfxFrameSurface1));
+
+ /* The bitstream buffer should be able to hold any encoded frame */
+ bitstream_buf = hb_video_buffer_init(pv->job->width, pv->job->height);
+ if (bitstream_buf == NULL)
+ {
+ hb_log("qsv_hevc_make_header: hb_buffer_init failed");
+ ret = -1;
+ goto end;
+ }
+ bitstream.Data = bitstream_buf->data;
+ bitstream.MaxLength = bitstream_buf->size;
+
+ /* We only need to encode one frame, so we only need one surface */
+ mfxU16 Height = pv->param.videoParam->mfx.FrameInfo.Height;
+ mfxU16 Width = pv->param.videoParam->mfx.FrameInfo.Width;
+ frameSurface1.Info = pv->param.videoParam->mfx.FrameInfo;
+ frameSurface1.Data.VU = av_mallocz(Width * Height / 2);
+ frameSurface1.Data.Y = av_mallocz(Width * Height);
+ frameSurface1.Data.Pitch = Width;
+
+ /* Encode a single blank frame */
+ do
+ {
+ status = MFXVideoENCODE_EncodeFrameAsync(session, NULL,
+ &frameSurface1,
+ &bitstream,
+ &syncPoint);
+
+ if (status == MFX_ERR_MORE_DATA)
+ {
+ break; // more input needed, but we don't have any
+ }
+ if (status < MFX_ERR_NONE)
+ {
+ hb_log("qsv_hevc_make_header: MFXVideoENCODE_EncodeFrameAsync failed (%d)", status);
+ ret = -1;
+ goto end;
+ }
+ if (syncPoint)
+ {
+ break; // we have output
+ }
+ if (status == MFX_WRN_DEVICE_BUSY)
+ {
+ av_qsv_sleep(1);
+ }
+ }
+ while (status >= MFX_ERR_NONE);
+
+ /* If we don't have any output yet, flush the encoder */
+ if (!syncPoint)
+ {
+ do
+ {
+ status = MFXVideoENCODE_EncodeFrameAsync(session, NULL, NULL,
+ &bitstream,
+ &syncPoint);
+
+ if (status == MFX_ERR_MORE_DATA)
+ {
+ break; // done flushing
+ }
+ if (status < MFX_ERR_NONE)
+ {
+ hb_log("qsv_hevc_make_header: MFXVideoENCODE_EncodeFrameAsync failed (%d)", status);
+ ret = -1;
+ goto end;
+ }
+ if (syncPoint)
+ {
+ break; // we have output
+ }
+ if (status == MFX_WRN_DEVICE_BUSY)
+ {
+ av_qsv_sleep(1);
+ }
+ }
+ while (status >= MFX_ERR_NONE);
+ }
+
+ /* Still no data at this point, we can't proceed */
+ if (!syncPoint)
+ {
+ hb_log("qsv_hevc_make_header: no sync point");
+ ret = -1;
+ goto end;
+ }
+
+ do
+ {
+ status = MFXVideoCORE_SyncOperation(session, syncPoint, 100);
+ }
+ while (status == MFX_WRN_IN_EXECUTION);
+
+ if (status != MFX_ERR_NONE)
+ {
+ hb_log("qsv_hevc_make_header: MFXVideoCORE_SyncOperation failed (%d)", status);
+ ret = -1;
+ goto end;
+ }
+
+ if (!bitstream.DataLength)
+ {
+ hb_log("qsv_hevc_make_header: no bitstream data");
+ ret = -1;
+ goto end;
+ }
+
+ /* Include any parameter sets and SEI NAL units in the headers. */
+ len = bitstream.DataLength;
+ buf = bitstream.Data + bitstream.DataOffset;
+ end = bitstream.Data + bitstream.DataOffset + bitstream.DataLength;
+ w->config->h265.headers_length = 0;
+
+ while ((buf = hb_annexb_find_next_nalu(buf, &len)) != NULL)
+ {
+ switch ((buf[0] >> 1) & 0x3f)
+ {
+ case 32: // VPS_NUT
+ case 33: // SPS_NUT
+ case 34: // PPS_NUT
+ case 39: // PREFIX_SEI_NUT
+ case 40: // SUFFIX_SEI_NUT
+ break;
+ default:
+ len = end - buf;
+ continue;
+ }
+
+ size_t size = hb_nal_unit_write_annexb(NULL, buf, len) + w->config->h265.headers_length;
+ if (sizeof(w->config->h265.headers) < size)
+ {
+ /* Will never happen in practice */
+ hb_log("qsv_hevc_make_header: header too large (size: %lu, max: %lu)",
+ size, sizeof(w->config->h265.headers));
+ }
+
+ w->config->h265.headers_length += hb_nal_unit_write_annexb(w->config->h265.headers +
+ w->config->h265.headers_length, buf, len);
+ len = end - buf;
+ }
+
+end:
+ hb_buffer_close(&bitstream_buf);
+ av_free(frameSurface1.Data.VU);
+ av_free(frameSurface1.Data.Y);
+ return ret;
+}
+
int qsv_enc_init(hb_work_private_t *pv)
{
av_qsv_context *qsv = pv->job->qsv.ctx;
av_qsv_list_add(qsv_encode->tasks, task);
}
+ // plugins should be loaded before querying for surface allocation
+ if (pv->loaded_plugins == NULL)
+ {
+ if (MFXQueryVersion(qsv->mfx_session, &version) != MFX_ERR_NONE)
+ {
+ hb_error("qsv_enc_init: MFXQueryVersion failed");
+ *job->done_error = HB_ERROR_INIT;
+ *job->die = 1;
+ return -1;
+ }
+ pv->loaded_plugins = hb_qsv_load_plugins(pv->qsv_info, qsv->mfx_session, version);
+ if (pv->loaded_plugins == NULL)
+ {
+ hb_error("qsv_enc_init: hb_qsv_load_plugins failed");
+ *job->done_error = HB_ERROR_INIT;
+ *job->die = 1;
+ return -1;
+ }
+ }
+
// setup surface allocation
pv->param.videoParam->IOPattern = (pv->is_sys_mem ?
MFX_IOPATTERN_IN_SYSTEM_MEMORY :
AV_QSV_CHECK_POINTER(qsv_encode->p_syncp[i]->p_sync, MFX_ERR_MEMORY_ALLOC);
}
- // log actual implementation details now that we know them
- if ((MFXQueryIMPL (qsv->mfx_session, &impl) == MFX_ERR_NONE) &&
- (MFXQueryVersion(qsv->mfx_session, &version) == MFX_ERR_NONE))
- {
- hb_log("qsv_enc_init: using '%s' implementation, API: %"PRIu16".%"PRIu16"",
- hb_qsv_impl_get_name(impl), version.Major, version.Minor);
- }
- else
- {
- hb_log("qsv_enc_init: MFXQueryIMPL/MFXQueryVersion failure");
- }
-
- // if not re-using encqsvInit's MFX session, load required plug-ins here
- if (pv->loaded_plugins == NULL)
- {
- pv->loaded_plugins = hb_qsv_load_plugins(pv->qsv_info, qsv->mfx_session, version);
- if (pv->loaded_plugins == NULL)
- {
- hb_error("qsv_enc_init: hb_qsv_load_plugins failed");
- *job->done_error = HB_ERROR_INIT;
- *job->die = 1;
- return -1;
- }
- }
-
// initialize the encoder
sts = MFXVideoENCODE_Init(qsv->mfx_session, pv->param.videoParam);
if (sts < MFX_ERR_NONE) // ignore warnings
}
qsv_encode->is_init_done = 1;
+ // query and log actual implementation details
+ if ((MFXQueryIMPL (qsv->mfx_session, &impl) == MFX_ERR_NONE) &&
+ (MFXQueryVersion(qsv->mfx_session, &version) == MFX_ERR_NONE))
+ {
+ hb_log("qsv_enc_init: using '%s' implementation, API: %"PRIu16".%"PRIu16"",
+ hb_qsv_impl_get_name(impl), version.Major, version.Minor);
+ }
+ else
+ {
+ hb_log("qsv_enc_init: MFXQueryIMPL/MFXQueryVersion failure");
+ }
+
pv->init_done = 1;
return 0;
}
// set AsyncDepth to match that of decode and VPP
pv->param.videoParam->AsyncDepth = job->qsv.async_depth;
- // enable and set colorimetry (video signal information)
- pv->param.videoSignalInfo.ColourDescriptionPresent = 1;
+ // set and enable colorimetry (video signal information)
switch (job->color_matrix_code)
{
case 4:
pv->param.videoSignalInfo.MatrixCoefficients = job->title->color_matrix;
break;
}
+ pv->param.videoSignalInfo.ColourDescriptionPresent = 1;
// parse user-specified encoder options, if present
if (job->encoder_options != NULL && *job->encoder_options)
job->par.num, job->par.den, UINT16_MAX);
// some encoding parameters are used by filters to configure their output
- if (pv->param.videoParam->mfx.FrameInfo.PicStruct != MFX_PICSTRUCT_PROGRESSIVE)
+ switch (pv->qsv_info->codec_id)
{
- job->qsv.enc_info.align_height = AV_QSV_ALIGN32(job->height);
+ case MFX_CODEC_HEVC:
+ job->qsv.enc_info.align_width = AV_QSV_ALIGN32(job->width);
+ job->qsv.enc_info.align_height = AV_QSV_ALIGN32(job->height);
+ break;
+
+ case MFX_CODEC_AVC:
+ default:
+ job->qsv.enc_info.align_width = AV_QSV_ALIGN16(job->width);
+ job->qsv.enc_info.align_height = AV_QSV_ALIGN16(job->height);
+ break;
}
- else
+ if (pv->param.videoParam->mfx.FrameInfo.PicStruct != MFX_PICSTRUCT_PROGRESSIVE)
{
- job->qsv.enc_info.align_height = AV_QSV_ALIGN16(job->height);
+ // additional alignment may be required
+ switch (pv->qsv_info->codec_id)
+ {
+ case MFX_CODEC_AVC:
+ job->qsv.enc_info.align_height = AV_QSV_ALIGN32(job->qsv.enc_info.align_height);
+ break;
+
+ default:
+ break;
+ }
}
- job->qsv.enc_info.align_width = AV_QSV_ALIGN16(job->width);
job->qsv.enc_info.pic_struct = pv->param.videoParam->mfx.FrameInfo.PicStruct;
job->qsv.enc_info.is_init_done = 1;
- // encode to H.264 and set FrameInfo
- pv->param.videoParam->mfx.CodecId = MFX_CODEC_AVC;
+ // set codec, profile/level and FrameInfo
+ pv->param.videoParam->mfx.CodecId = pv->qsv_info->codec_id;
pv->param.videoParam->mfx.CodecLevel = MFX_LEVEL_UNKNOWN;
pv->param.videoParam->mfx.CodecProfile = MFX_PROFILE_UNKNOWN;
pv->param.videoParam->mfx.FrameInfo.FourCC = MFX_FOURCC_NV12;
* init a dummy encode-only session to get the SPS/PPS
* and the final output settings sanitized by Media SDK
* this is fine since the actual encode will use the same
- * values for all parameters relevant to the H.264 bitstream
+ * values for all parameters relevant to the output bitstream
*/
mfxStatus err;
mfxVersion version;
sps_pps->PPSId = 0;
sps_pps->PPSBuffer = w->config->h264.pps;
sps_pps->PPSBufSize = sizeof(w->config->h264.pps);
- videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)sps_pps;
+ if (pv->param.videoParam->mfx.CodecId == MFX_CODEC_AVC)
+ {
+ videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)sps_pps;
+ }
// introduced in API 1.0
memset(option1, 0, sizeof(mfxExtCodingOption));
option1->Header.BufferId = MFX_EXTBUFF_CODING_OPTION;
videoParam.ExtParam[videoParam.NumExtParam++] = (mfxExtBuffer*)option2;
}
err = MFXVideoENCODE_GetVideoParam(session, &videoParam);
- MFXVideoENCODE_Close(session);
- if (err == MFX_ERR_NONE)
+ if (err != MFX_ERR_NONE)
{
- // remove 32-bit NAL prefix (0x00 0x00 0x00 0x01)
+ hb_error("encqsvInit: MFXVideoENCODE_GetVideoParam failed (%d)", err);
+ hb_qsv_unload_plugins(&pv->loaded_plugins, session, version);
+ MFXClose(session);
+ return -1;
+ }
+
+ /* We have the final encoding parameters, now get the headers for muxing */
+ if (videoParam.mfx.CodecId == MFX_CODEC_AVC)
+ {
+ // remove 4-byte Annex B NAL unit prefix (0x00 0x00 0x00 0x01)
w->config->h264.sps_length = sps_pps->SPSBufSize - 4;
memmove(w->config->h264.sps, w->config->h264.sps + 4,
w->config->h264.sps_length);
memmove(w->config->h264.pps, w->config->h264.pps + 4,
w->config->h264.pps_length);
}
- else
+ else if (videoParam.mfx.CodecId == MFX_CODEC_HEVC)
{
- hb_error("encqsvInit: MFXVideoENCODE_GetVideoParam failed (%d)", err);
- hb_qsv_unload_plugins(&pv->loaded_plugins, session, version);
- MFXClose(session);
- return -1;
+ if (qsv_hevc_make_header(w, session) < 0)
+ {
+ hb_error("encqsvInit: qsv_hevc_make_header failed");
+ hb_qsv_unload_plugins(&pv->loaded_plugins, session, version);
+ MFXVideoENCODE_Close(session);
+ MFXClose(session);
+ return -1;
+ }
}
+ /* We don't need this encode session once we have the header */
+ MFXVideoENCODE_Close(session);
+
#ifdef HB_DRIVER_FIX_33
if (la_workaround)
{
if (videoParam.mfx.GopRefDist > 1)
{
/* the muxer needs to know to the init_delay */
- switch (pv->qsv_info->codec_id)
+ switch (videoParam.mfx.CodecId)
{
case MFX_CODEC_AVC:
+ case MFX_CODEC_HEVC:
pv->init_delay = &w->config->h264.init_delay;
break;
default: // unreachable
static void qsv_bitstream_slurp(hb_work_private_t *pv, mfxBitstream *bs)
{
- /*
- * we need to convert the encoder's Annex B output
- * to an MP4-compatible format (ISO/IEC 14496-15).
- */
- hb_buffer_t *buf = hb_nal_bitstream_annexb_to_mp4(bs->Data + bs->DataOffset,
- bs->DataLength);
- if (buf == NULL)
+ hb_buffer_t *buf;
+
+ if (pv->param.videoParam->mfx.CodecId == MFX_CODEC_AVC)
{
- hb_error("encqsv: hb_nal_bitstream_annexb_to_mp4 failed");
- goto fail;
+ /*
+ * We provided the muxer with the parameter sets in an MP4-compatible
+ * format (ISO/IEC 14496-15). We need to convert the bitstream to the
+ * same format to match the extradata.
+ */
+ if ((buf = hb_nal_bitstream_annexb_to_mp4(bs->Data + bs->DataOffset,
+ bs->DataLength)) == NULL)
+ {
+ hb_error("encqsv: hb_nal_bitstream_annexb_to_mp4 failed");
+ goto fail;
+ }
+ }
+ else
+ {
+ /* Both extradata and bitstream are in Annex B format. */
+ if ((buf = hb_buffer_init(bs->DataLength)) == NULL)
+ {
+ hb_error("encqsv: hb_buffer_init failed");
+ goto fail;
+ }
+ memcpy(buf->data, bs->Data + bs->DataOffset, bs->DataLength);
}
bs->DataLength = bs->DataOffset = 0;
bs->MaxLength = pv->job->qsv.ctx->enc_space->p_buf_max_size;
#include "hb_dict.h"
#include "qsv_common.h"
#include "h264_common.h"
+#include "h265_common.h"
// QSV info for each codec
static hb_qsv_info_t *hb_qsv_info_avc = NULL;
{ "Progressive High", "high|set4", MFX_PROFILE_AVC_PROGRESSIVE_HIGH, },
{ NULL, },
};
+static hb_triplet_t hb_qsv_h265_profiles[] =
+{
+ { "Main", "main", MFX_PROFILE_HEVC_MAIN, },
+ { "Main 10", "main10", MFX_PROFILE_HEVC_MAIN10, },
+ { "Main Still Picture", "mainstillpicture", MFX_PROFILE_HEVC_MAINSP, },
+ { NULL, },
+};
static hb_triplet_t hb_qsv_h264_levels[] =
{
{ "1.0", "1.0", MFX_LEVEL_AVC_1, },
{ "5.2", "5.2", MFX_LEVEL_AVC_52, },
{ NULL, },
};
+static hb_triplet_t hb_qsv_h265_levels[] =
+{
+ { "1.0", "1.0", MFX_LEVEL_HEVC_1, },
+ { "2.0", "2.0", MFX_LEVEL_HEVC_2, },
+ { "2.1", "2.1", MFX_LEVEL_HEVC_21, },
+ { "3.0", "3.0", MFX_LEVEL_HEVC_3, },
+ { "3.1", "3.1", MFX_LEVEL_HEVC_31, },
+ { "4.0", "4.0", MFX_LEVEL_HEVC_4, },
+ { "4.1", "4.1", MFX_LEVEL_HEVC_41, },
+ { "5.0", "5.0", MFX_LEVEL_HEVC_5, },
+ { "5.1", "5.1", MFX_LEVEL_HEVC_51, },
+ { "5.2", "5.2", MFX_LEVEL_HEVC_52, },
+ { "6.0", "6.0", MFX_LEVEL_HEVC_6, },
+ { "6.1", "6.1", MFX_LEVEL_HEVC_61, },
+ { "6.2", "6.2", MFX_LEVEL_HEVC_62, },
+ { NULL, },
+};
// check available Intel Media SDK version against a minimum
#define HB_CHECK_MFX_VERSION(MFX_VERSION, MAJOR, MINOR) \
int hb_qsv_available()
{
- return hb_qsv_video_encoder_is_enabled(HB_VCODEC_QSV_H264);
+ return (hb_qsv_video_encoder_is_enabled(HB_VCODEC_QSV_H264) ||
+ hb_qsv_video_encoder_is_enabled(HB_VCODEC_QSV_H265));
}
int hb_qsv_video_encoder_is_enabled(int encoder)
{
case HB_VCODEC_QSV_H264:
return hb_qsv_info_avc != NULL && hb_qsv_info_avc->available;
+ case HB_VCODEC_QSV_H265:
+ return hb_qsv_info_hevc != NULL && hb_qsv_info_hevc->available;
default:
return 0;
}
}
if (hb_qsv_info_hevc != NULL && hb_qsv_info_hevc->available)
{
- hb_deep_log(2, " - H.265 encoder: yes (unsupported)");
- hb_deep_log(2, " - preferred implementation: %s",
- hb_qsv_impl_get_name(hb_qsv_info_hevc->implementation));
+ hb_log(" - H.265 encoder: yes");
+ hb_log(" - preferred implementation: %s",
+ hb_qsv_impl_get_name(hb_qsv_info_hevc->implementation));
if (qsv_hardware_info_hevc.available)
{
- log_capabilities(2, qsv_hardware_info_hevc.capabilities,
+ log_capabilities(1, qsv_hardware_info_hevc.capabilities,
" - capabilities (hardware): ");
}
if (qsv_software_info_hevc.available)
{
- log_capabilities(2, qsv_software_info_hevc.capabilities,
+ log_capabilities(1, qsv_software_info_hevc.capabilities,
" - capabilities (software): ");
}
}
else
{
- hb_deep_log(2, " - H.265 encoder: no");
+ hb_log(" - H.265 encoder: no");
}
}
}
{
case HB_VCODEC_QSV_H264:
return hb_qsv_info_avc;
+ case HB_VCODEC_QSV_H265:
+ return hb_qsv_info_hevc;
default:
return NULL;
}
case MFX_CODEC_AVC:
ivalue = hb_qsv_atoindex(hb_h264_vidformat_names, value, &error);
break;
+ case MFX_CODEC_HEVC:
+ ivalue = hb_qsv_atoindex(hb_h265_vidformat_names, value, &error);
+ break;
default:
return HB_QSV_PARAM_UNSUPPORTED;
}
case MFX_CODEC_AVC:
ivalue = hb_qsv_atoindex(hb_h264_fullrange_names, value, &error);
break;
+ case MFX_CODEC_HEVC:
+ ivalue = hb_qsv_atoindex(hb_h265_fullrange_names, value, &error);
+ break;
default:
return HB_QSV_PARAM_UNSUPPORTED;
}
case MFX_CODEC_AVC:
ivalue = hb_qsv_atoindex(hb_h264_colorprim_names, value, &error);
break;
+ case MFX_CODEC_HEVC:
+ ivalue = hb_qsv_atoindex(hb_h265_colorprim_names, value, &error);
+ break;
default:
return HB_QSV_PARAM_UNSUPPORTED;
}
case MFX_CODEC_AVC:
ivalue = hb_qsv_atoindex(hb_h264_transfer_names, value, &error);
break;
+ case MFX_CODEC_HEVC:
+ ivalue = hb_qsv_atoindex(hb_h265_transfer_names, value, &error);
+ break;
default:
return HB_QSV_PARAM_UNSUPPORTED;
}
case MFX_CODEC_AVC:
ivalue = hb_qsv_atoindex(hb_h264_colmatrix_names, value, &error);
break;
+ case MFX_CODEC_HEVC:
+ ivalue = hb_qsv_atoindex(hb_h265_colmatrix_names, value, &error);
+ break;
default:
return HB_QSV_PARAM_UNSUPPORTED;
}
case MFX_CODEC_AVC:
profile = hb_triplet4key(hb_qsv_h264_profiles, profile_key);
break;
+
+ case MFX_CODEC_HEVC:
+ profile = hb_triplet4key(hb_qsv_h265_profiles, profile_key);
+ break;
+
default:
break;
}
case MFX_CODEC_AVC:
level = hb_triplet4key(hb_qsv_h264_levels, level_key);
break;
+
+ case MFX_CODEC_HEVC:
+ level = hb_triplet4key(hb_qsv_h265_levels, level_key);
+ break;
+
default:
break;
}
{
case HB_VCODEC_QSV_H264:
return hb_h264_profile_names;
+ case HB_VCODEC_QSV_H265:
+ return hb_h265_profile_names;
default:
return NULL;
}
{
case HB_VCODEC_QSV_H264:
return hb_h264_level_names;
+ case HB_VCODEC_QSV_H265:
+ return hb_h265_level_names;
default:
return NULL;
}
const char* hb_qsv_video_quality_get_name(uint32_t codec)
{
- uint64_t caps;
+ uint64_t caps = 0;
switch (codec)
{
case HB_VCODEC_QSV_H264:
- caps = hb_qsv_info_avc != NULL ? hb_qsv_info_avc->capabilities : 0;
- return (caps & HB_QSV_CAP_RATECONTROL_ICQ) ? "ICQ" : "QP";
+ if (hb_qsv_info_avc != NULL) caps = hb_qsv_info_avc->capabilities;
+ break;
+
+ case HB_VCODEC_QSV_H265:
+ if (hb_qsv_info_hevc != NULL) caps = hb_qsv_info_hevc->capabilities;
+ break;
default:
- return "QP";
+ break;
}
+ return (caps & HB_QSV_CAP_RATECONTROL_ICQ) ? "ICQ" : "QP";
}
void hb_qsv_video_quality_get_limits(uint32_t codec, float *low, float *high,
float *granularity, int *direction)
{
- uint64_t caps;
+ uint64_t caps = 0;
switch (codec)
{
- case HB_VCODEC_QSV_H264:
- caps = hb_qsv_info_avc != NULL ? hb_qsv_info_avc->capabilities : 0;
+ case HB_VCODEC_QSV_H265:
+ if (hb_qsv_info_hevc != NULL) caps = hb_qsv_info_hevc->capabilities;
*direction = 1;
*granularity = 1.;
*low = (caps & HB_QSV_CAP_RATECONTROL_ICQ) ? 1. : 0.;
*high = 51.;
break;
+ case HB_VCODEC_QSV_H264:
default:
+ if (hb_qsv_info_avc != NULL) caps = hb_qsv_info_avc->capabilities;
*direction = 1;
*granularity = 1.;
- *low = 0.;
+ *low = (caps & HB_QSV_CAP_RATECONTROL_ICQ) ? 1. : 0.;
*high = 51.;
break;
}
case MFX_CODEC_AVC:
return "H.264/AVC";
+ case MFX_CODEC_HEVC:
+ return "H.265/HEVC";
+
default:
return NULL;
}
profile = hb_triplet4value(hb_qsv_h264_profiles, profile_id);
break;
+ case MFX_CODEC_HEVC:
+ profile = hb_triplet4value(hb_qsv_h265_profiles, profile_id);
+ break;
+
default:
break;
}
level = hb_triplet4value(hb_qsv_h264_levels, level_id);
break;
+ case MFX_CODEC_HEVC:
+ level = hb_triplet4value(hb_qsv_h265_levels, level_id);
+ break;
+
default:
break;
}
projects / handbrake / commitdiff