diff options
| -rw-r--r-- | libhb/common.c | 1 | ||||
| -rw-r--r-- | libhb/common.h | 2 | ||||
| -rw-r--r-- | libhb/enc_qsv.c | 345 | ||||
| -rw-r--r-- | libhb/muxavformat.c | 2 | ||||
| -rw-r--r-- | libhb/qsv_common.c | 107 | ||||
| -rw-r--r-- | libhb/work.c | 4 |
6 files changed, 390 insertions, 71 deletions
diff --git a/libhb/common.c b/libhb/common.c index b6d36d203..6877e31a6 100644 --- a/libhb/common.c +++ b/libhb/common.c @@ -226,6 +226,7 @@ hb_encoder_internal_t hb_video_encoders[] = { { "H.264 (x264)", "x264", "H.264 (libx264)", HB_VCODEC_X264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_H264, }, { { "H.264 (Intel QSV)", "qsv_h264", "H.264 (Intel Media SDK)", HB_VCODEC_QSV_H264, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_H264, }, { { "H.265 (x265)", "x265", "H.265 (libx265)", HB_VCODEC_X265, HB_MUX_AV_MP4|HB_MUX_AV_MKV, }, NULL, 1, HB_GID_VCODEC_H265, }, + { { "H.265 (Intel QSV)", "qsv_h265", "H.265 (Intel Media SDK)", HB_VCODEC_QSV_H265, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_H265, }, { { "MPEG-4", "mpeg4", "MPEG-4 (libavcodec)", HB_VCODEC_FFMPEG_MPEG4, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_MPEG4, }, { { "MPEG-2", "mpeg2", "MPEG-2 (libavcodec)", HB_VCODEC_FFMPEG_MPEG2, HB_MUX_MASK_MP4|HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_MPEG2, }, { { "VP8", "VP8", "VP8 (libvpx)", HB_VCODEC_FFMPEG_VP8, HB_MUX_MASK_MKV, }, NULL, 1, HB_GID_VCODEC_VP8, }, diff --git a/libhb/common.h b/libhb/common.h index 9cf51b3e2..a928eb484 100644 --- a/libhb/common.h +++ b/libhb/common.h @@ -498,8 +498,10 @@ struct hb_job_s #define HB_VCODEC_FFMPEG_VP8 0x0000040 #define HB_VCODEC_FFMPEG_MASK 0x00000F0 #define HB_VCODEC_QSV_H264 0x0000100 +#define HB_VCODEC_QSV_H265 0x0000200 #define HB_VCODEC_QSV_MASK 0x0000F00 #define HB_VCODEC_H264_MASK (HB_VCODEC_X264|HB_VCODEC_QSV_H264) +#define HB_VCODEC_H265_MASK (HB_VCODEC_X265|HB_VCODEC_QSV_H265) int vcodec; double vquality; diff --git a/libhb/enc_qsv.c b/libhb/enc_qsv.c index 2f19b36f0..39ed16bef 100644 --- a/libhb/enc_qsv.c +++ b/libhb/enc_qsv.c @@ -33,6 +33,7 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #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 @@ -58,7 +59,7 @@ void encqsvClose(hb_work_object_t*); hb_work_object_t hb_encqsv = { WORK_ENCQSV, - "H.264/AVC encoder (Intel QSV)", + "Quick Sync Video encoder (Intel Media SDK)", encqsvInit, encqsvWork, encqsvClose @@ -177,7 +178,7 @@ static void qsv_handle_breftype(hb_work_private_t *pv) /* 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) { @@ -189,6 +190,16 @@ static void qsv_handle_breftype(hb_work_private_t *pv) 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) @@ -275,6 +286,170 @@ unsupported: 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; @@ -377,6 +552,26 @@ int qsv_enc_init(hb_work_private_t *pv) 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 : @@ -444,31 +639,6 @@ int qsv_enc_init(hb_work_private_t *pv) 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 @@ -480,6 +650,18 @@ int qsv_enc_init(hb_work_private_t *pv) } 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; } @@ -515,8 +697,7 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) // 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: @@ -550,6 +731,7 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) 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) @@ -615,20 +797,37 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) 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; @@ -871,7 +1070,7 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) * 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; @@ -941,7 +1140,10 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) 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; @@ -959,10 +1161,18 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) 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); @@ -970,14 +1180,21 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) 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) { @@ -1003,9 +1220,10 @@ int encqsvInit(hb_work_object_t *w, hb_job_t *job) 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 @@ -1473,16 +1691,31 @@ static int qsv_frame_is_key(mfxU16 FrameType) 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; diff --git a/libhb/muxavformat.c b/libhb/muxavformat.c index e6ad4ae23..bfa377089 100644 --- a/libhb/muxavformat.c +++ b/libhb/muxavformat.c @@ -324,6 +324,7 @@ static int avformatInit( hb_mux_object_t * m ) } break; case HB_VCODEC_X265: + case HB_VCODEC_QSV_H265: track->st->codec->codec_id = AV_CODEC_ID_HEVC; if (job->config.h265.headers_length > 0) @@ -1069,6 +1070,7 @@ static int avformatMux(hb_mux_object_t *m, hb_mux_data_t *track, hb_buffer_t *bu pkt.duration = duration; if (track->type == MUX_TYPE_VIDEO && ((job->vcodec & HB_VCODEC_H264_MASK) || + (job->vcodec & HB_VCODEC_H265_MASK) || (job->vcodec & HB_VCODEC_FFMPEG_MASK))) { if (buf->s.frametype == HB_FRAME_IDR) diff --git a/libhb/qsv_common.c b/libhb/qsv_common.c index e383b806e..60d371f82 100644 --- a/libhb/qsv_common.c +++ b/libhb/qsv_common.c @@ -18,6 +18,7 @@ #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; @@ -45,6 +46,13 @@ static hb_triplet_t hb_qsv_h264_profiles[] = { "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, }, @@ -66,6 +74,23 @@ static hb_triplet_t hb_qsv_h264_levels[] = { "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) \ @@ -114,7 +139,8 @@ static int qsv_implementation_is_hardware(mfxIMPL implementation) 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) @@ -123,6 +149,8 @@ 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; } @@ -773,23 +801,23 @@ void hb_qsv_info_print() } 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"); } } } @@ -800,6 +828,8 @@ hb_qsv_info_t* hb_qsv_info_get(int encoder) { case HB_VCODEC_QSV_H264: return hb_qsv_info_avc; + case HB_VCODEC_QSV_H265: + return hb_qsv_info_hevc; default: return NULL; } @@ -1220,6 +1250,9 @@ int hb_qsv_param_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, 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; } @@ -1242,6 +1275,9 @@ int hb_qsv_param_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, 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; } @@ -1264,6 +1300,9 @@ int hb_qsv_param_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, 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; } @@ -1287,6 +1326,9 @@ int hb_qsv_param_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, 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; } @@ -1310,6 +1352,9 @@ int hb_qsv_param_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, 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; } @@ -1479,6 +1524,11 @@ int hb_qsv_profile_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, const char 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; } @@ -1501,6 +1551,11 @@ int hb_qsv_level_parse(hb_qsv_param_t *param, hb_qsv_info_t *info, const char *l 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; } @@ -1546,6 +1601,8 @@ const char* const* hb_qsv_profile_get_names(int encoder) { case HB_VCODEC_QSV_H264: return hb_h264_profile_names; + case HB_VCODEC_QSV_H265: + return hb_h265_profile_names; default: return NULL; } @@ -1557,6 +1614,8 @@ const char* const* hb_qsv_level_get_names(int encoder) { case HB_VCODEC_QSV_H264: return hb_h264_level_names; + case HB_VCODEC_QSV_H265: + return hb_h265_level_names; default: return NULL; } @@ -1564,36 +1623,43 @@ const char* const* hb_qsv_level_get_names(int encoder) 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; } @@ -1893,6 +1959,9 @@ const char* hb_qsv_codec_name(uint32_t codec_id) case MFX_CODEC_AVC: return "H.264/AVC"; + case MFX_CODEC_HEVC: + return "H.265/HEVC"; + default: return NULL; } @@ -1907,6 +1976,10 @@ const char* hb_qsv_profile_name(uint32_t codec_id, uint16_t profile_id) 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; } @@ -1922,6 +1995,10 @@ const char* hb_qsv_level_name(uint32_t codec_id, uint16_t level_id) 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; } diff --git a/libhb/work.c b/libhb/work.c index 8a58519ee..11c8d2919 100644 --- a/libhb/work.c +++ b/libhb/work.c @@ -363,6 +363,7 @@ void hb_display_job_info(hb_job_t *job) case HB_VCODEC_X264: case HB_VCODEC_X265: case HB_VCODEC_QSV_H264: + case HB_VCODEC_QSV_H265: hb_log(" + preset: %s", job->encoder_preset); default: break; @@ -391,6 +392,7 @@ void hb_display_job_info(hb_job_t *job) case HB_VCODEC_X264: case HB_VCODEC_X265: case HB_VCODEC_QSV_H264: + case HB_VCODEC_QSV_H265: hb_log(" + profile: %s", job->encoder_profile); default: break; @@ -402,6 +404,7 @@ void hb_display_job_info(hb_job_t *job) { case HB_VCODEC_X264: case HB_VCODEC_QSV_H264: + case HB_VCODEC_QSV_H265: hb_log(" + level: %s", job->encoder_level); default: break; @@ -1359,6 +1362,7 @@ static void do_job(hb_job_t *job) w = hb_get_work( job->h, WORK_ENCX264 ); break; case HB_VCODEC_QSV_H264: + case HB_VCODEC_QSV_H265: w = hb_get_work( job->h, WORK_ENCQSV ); break; case HB_VCODEC_THEORA: |