// Copyright (c) 2009-2025 Intel Corporation // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in all // copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. #include "mfx_common_int.h" #include "mfx_ext_buffers.h" #include "mfx_utils.h" #include #include #include #include mfxExtBuffer* GetExtendedBuffer(mfxExtBuffer** extBuf, mfxU32 numExtBuf, mfxU32 id) { if (extBuf != 0) { for (mfxU16 i = 0; i < numExtBuf; i++) { if (extBuf[i] != 0 && extBuf[i]->BufferId == id) // assuming aligned buffers return (extBuf[i]); } } return 0; } mfxExtBuffer* GetExtendedBufferInternal(mfxExtBuffer** extBuf, mfxU32 numExtBuf, mfxU32 id) { mfxExtBuffer* result = GetExtendedBuffer(extBuf, numExtBuf, id); if (!result) throw std::logic_error(": no external buffer found"); return result; } mfxStatus CheckFrameInfoCommon(mfxFrameInfo *info, mfxU32 codecId) { MFX_AUTO_LTRACE(MFX_TRACE_LEVEL_INTERNAL, "CheckFrameInfoCommon"); MFX_CHECK_NULL_PTR1(info); MFX_CHECK(info->Width && info->Width % 16 == 0, MFX_ERR_INVALID_VIDEO_PARAM); if (codecId == MFX_CODEC_JPEG) { MFX_CHECK(info->Height && info->Height % 8 == 0, MFX_ERR_INVALID_VIDEO_PARAM); } else { MFX_CHECK(info->Height && info->Height % 16 == 0, MFX_ERR_INVALID_VIDEO_PARAM); } switch (info->FourCC) { case MFX_FOURCC_NV12: case MFX_FOURCC_YV12: case MFX_FOURCC_YUY2: case MFX_FOURCC_RGB3: case MFX_FOURCC_RGB4: #ifdef MFX_ENABLE_RGBP case MFX_FOURCC_RGBP: #endif case MFX_FOURCC_BGRP: case MFX_FOURCC_P010: case MFX_FOURCC_NV16: case MFX_FOURCC_P210: case MFX_FOURCC_AYUV: case MFX_FOURCC_Y210: case MFX_FOURCC_Y410: case MFX_FOURCC_P016: case MFX_FOURCC_Y216: case MFX_FOURCC_Y416: case MFX_FOURCC_ABGR16F: break; case MFX_FOURCC_YUV444: case MFX_FOURCC_YUV411: case MFX_FOURCC_YUV400: case MFX_FOURCC_YUV422H: case MFX_FOURCC_YUV422V: case MFX_FOURCC_UYVY: case MFX_FOURCC_IMC3: if (codecId != MFX_CODEC_JPEG) { MFX_LTRACE_MSG(MFX_TRACE_LEVEL_CRITICAL_INFO, "MFX_ERR_INVALID_VIDEO_PARAM"); MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); } break; default: { MFX_LTRACE_MSG(MFX_TRACE_LEVEL_CRITICAL_INFO, "MFX_ERR_INVALID_VIDEO_PARAM"); MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); } } MFX_CHECK((!info->BitDepthLuma || (info->BitDepthLuma >= 8)) && (!info->BitDepthChroma || (info->BitDepthChroma >= 8)) , MFX_ERR_INVALID_VIDEO_PARAM); if (info->BitDepthLuma > 8 || info->BitDepthChroma > 8) { switch (info->FourCC) { case MFX_FOURCC_P010: case MFX_FOURCC_P210: case MFX_FOURCC_Y210: case MFX_FOURCC_Y410: case MFX_FOURCC_P016: case MFX_FOURCC_Y216: case MFX_FOURCC_Y416: break; default: { MFX_LTRACE_MSG(MFX_TRACE_LEVEL_CRITICAL_INFO, "MFX_ERR_INVALID_VIDEO_PARAM"); MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); } } } if (info->Shift) { if ( info->FourCC != MFX_FOURCC_P010 && info->FourCC != MFX_FOURCC_P210 && info->FourCC != MFX_FOURCC_Y210 && info->FourCC != MFX_FOURCC_P016 && info->FourCC != MFX_FOURCC_Y216 && info->FourCC != MFX_FOURCC_Y416 && info->FourCC != MFX_FOURCC_R16 ) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); } if (codecId != MFX_CODEC_JPEG) { MFX_CHECK(info->ChromaFormat <= MFX_CHROMAFORMAT_YUV444, MFX_ERR_INVALID_VIDEO_PARAM); } else { MFX_CHECK(info->ChromaFormat < MFX_CHROMAFORMAT_RESERVED1, MFX_ERR_INVALID_VIDEO_PARAM); } MFX_CHECK(!(info->FrameRateExtN != 0 && info->FrameRateExtD == 0), MFX_ERR_INVALID_VIDEO_PARAM); MFX_CHECK((!info->AspectRatioW && !info->AspectRatioH) || (info->AspectRatioW && info->AspectRatioH), MFX_ERR_INVALID_VIDEO_PARAM); return MFX_ERR_NONE; } mfxStatus CheckFrameInfoEncoders(mfxFrameInfo *info) { if (info->CropX > info->Width) return MFX_ERR_INVALID_VIDEO_PARAM; if (info->CropY > info->Height) return MFX_ERR_INVALID_VIDEO_PARAM; if (info->CropX + info->CropW > info->Width) return MFX_ERR_INVALID_VIDEO_PARAM; if (info->CropY + info->CropH > info->Height) return MFX_ERR_INVALID_VIDEO_PARAM; switch (info->PicStruct) { case MFX_PICSTRUCT_UNKNOWN: case MFX_PICSTRUCT_PROGRESSIVE: case MFX_PICSTRUCT_FIELD_TFF: case MFX_PICSTRUCT_FIELD_BFF: break; default: case MFX_PICSTRUCT_FIELD_REPEATED: case MFX_PICSTRUCT_FRAME_DOUBLING: case MFX_PICSTRUCT_FRAME_TRIPLING: return MFX_ERR_INVALID_VIDEO_PARAM; } // both zero or not zero if ((info->AspectRatioW || info->AspectRatioH) && !(info->AspectRatioW && info->AspectRatioH)) return MFX_ERR_INVALID_VIDEO_PARAM; if ((info->FrameRateExtN || info->FrameRateExtD) && !(info->FrameRateExtN && info->FrameRateExtD)) return MFX_ERR_INVALID_VIDEO_PARAM; return MFX_ERR_NONE; } mfxStatus CheckFrameInfoDecVideoProcCsc(mfxFrameInfo *info, mfxU32 codecId) { mfxStatus sts = CheckFrameInfoCommon(info, codecId); MFX_CHECK_STS(sts); switch(info->FourCC) { case MFX_FOURCC_NV12: case MFX_FOURCC_P010: case MFX_FOURCC_P016: if (info->ChromaFormat == MFX_CHROMAFORMAT_YUV420) return MFX_ERR_NONE; MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); case MFX_FOURCC_YUY2: case MFX_FOURCC_Y210: case MFX_FOURCC_Y216: if (info->ChromaFormat == MFX_CHROMAFORMAT_YUV422) return MFX_ERR_NONE; MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); case MFX_FOURCC_AYUV: case MFX_FOURCC_Y410: case MFX_FOURCC_Y416: case MFX_FOURCC_RGB4: case MFX_FOURCC_RGBP: if (info->ChromaFormat == MFX_CHROMAFORMAT_YUV444) return MFX_ERR_NONE; MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); default: MFX_RETURN(MFX_ERR_UNSUPPORTED); } } mfxStatus CheckFrameInfoCodecs(mfxFrameInfo *info, mfxU32 codecId) { MFX_AUTO_LTRACE(MFX_TRACE_LEVEL_INTERNAL, "CheckFrameInfoCodecs"); mfxStatus sts = CheckFrameInfoCommon(info, codecId); MFX_CHECK_STS(sts); switch (codecId) { case MFX_CODEC_JPEG: if (info->FourCC != MFX_FOURCC_NV12 && info->FourCC != MFX_FOURCC_RGB4 && info->FourCC != MFX_FOURCC_YUY2 && info->FourCC != MFX_FOURCC_UYVY && info->FourCC != MFX_FOURCC_BGRP && info->FourCC != MFX_FOURCC_IMC3 && info->FourCC != MFX_FOURCC_YUV444 && info->FourCC != MFX_FOURCC_YUV411 && info->FourCC != MFX_FOURCC_YUV400 && info->FourCC != MFX_FOURCC_YUV422H && info->FourCC != MFX_FOURCC_YUV422V && info->FourCC != MFX_FOURCC_RGBP) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_VP8: MFX_CHECK(info->FourCC == MFX_FOURCC_NV12 || info->FourCC == MFX_FOURCC_YV12, MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_VP9: if (info->FourCC != MFX_FOURCC_NV12 && info->FourCC != MFX_FOURCC_AYUV && info->FourCC != MFX_FOURCC_P010 && info->FourCC != MFX_FOURCC_Y410 && info->FourCC != MFX_FOURCC_P016 && info->FourCC != MFX_FOURCC_Y416) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_AVC: if (info->FourCC != MFX_FOURCC_NV12 && info->FourCC != MFX_FOURCC_P010 && info->FourCC != MFX_FOURCC_NV16 && info->FourCC != MFX_FOURCC_P210) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_HEVC: if (info->FourCC != MFX_FOURCC_NV12 && info->FourCC != MFX_FOURCC_YUY2 && info->FourCC != MFX_FOURCC_P010 && info->FourCC != MFX_FOURCC_NV16 && info->FourCC != MFX_FOURCC_P210 && info->FourCC != MFX_FOURCC_AYUV && info->FourCC != MFX_FOURCC_Y210 && info->FourCC != MFX_FOURCC_Y410 && info->FourCC != MFX_FOURCC_P016 && info->FourCC != MFX_FOURCC_Y216 && info->FourCC != MFX_FOURCC_Y416 ) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); break; #if defined(MFX_ENABLE_VVC_VIDEO_DECODE) case MFX_CODEC_VVC: if (info->FourCC != MFX_FOURCC_NV12 && info->FourCC != MFX_FOURCC_P010) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); break; #endif #if defined(MFX_ENABLE_AV1_VIDEO_CODEC) case MFX_CODEC_AV1: if ( info->FourCC != MFX_FOURCC_NV12 && info->FourCC != MFX_FOURCC_YV12 && info->FourCC != MFX_FOURCC_P010 && info->FourCC != MFX_FOURCC_AYUV && info->FourCC != MFX_FOURCC_Y410) MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); break; #endif default: MFX_CHECK(info->FourCC == MFX_FOURCC_NV12, MFX_ERR_INVALID_VIDEO_PARAM); break; } switch (codecId) { case MFX_CODEC_JPEG: MFX_CHECK( info->ChromaFormat == MFX_CHROMAFORMAT_YUV420 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV444 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV411 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV400 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV422H || info->ChromaFormat == MFX_CHROMAFORMAT_YUV422V , MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_AVC: MFX_CHECK( info->ChromaFormat == MFX_CHROMAFORMAT_YUV420 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV422 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV400 , MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_HEVC: case MFX_CODEC_VP9: MFX_CHECK( info->ChromaFormat == MFX_CHROMAFORMAT_YUV420 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV400 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV422 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV444 , MFX_ERR_INVALID_VIDEO_PARAM); break; case MFX_CODEC_AV1: MFX_CHECK(info->ChromaFormat == MFX_CHROMAFORMAT_YUV420 , MFX_ERR_INVALID_VIDEO_PARAM); break; default: MFX_CHECK(info->ChromaFormat == MFX_CHROMAFORMAT_YUV420 || info->ChromaFormat == MFX_CHROMAFORMAT_YUV400, MFX_ERR_INVALID_VIDEO_PARAM); break; } switch (codecId) { #if defined(MFX_ENABLE_VVC_VIDEO_DECODE) case MFX_CODEC_VVC: if (info->FourCC == MFX_FOURCC_P210 || info->FourCC == MFX_FOURCC_Y210 || info->FourCC == MFX_FOURCC_P016 || info->FourCC == MFX_FOURCC_Y216 || info->FourCC == MFX_FOURCC_Y416) { MFX_CHECK(info->Shift == 1, MFX_ERR_INVALID_VIDEO_PARAM); } #endif case MFX_CODEC_HEVC: case MFX_CODEC_AVC: break; default: if (info->FourCC == MFX_FOURCC_P010 || info->FourCC == MFX_FOURCC_P210 || info->FourCC == MFX_FOURCC_Y210 || info->FourCC == MFX_FOURCC_P016 || info->FourCC == MFX_FOURCC_Y216 || info->FourCC == MFX_FOURCC_Y416) { MFX_CHECK(info->Shift == 1, MFX_ERR_INVALID_VIDEO_PARAM); } break; } return MFX_ERR_NONE; } mfxStatus UpdateCscOutputFormat(mfxVideoParam *par, mfxFrameAllocRequest *request) { #ifdef MFX_DEC_VIDEO_POSTPROCESS_DISABLE (void)par; (void)request; #else mfxExtDecVideoProcessing * videoProcessing = (mfxExtDecVideoProcessing *)GetExtendedBuffer(par->ExtParam, par->NumExtParam, MFX_EXTBUFF_DEC_VIDEO_PROCESSING); if (videoProcessing && videoProcessing->Out.FourCC != par->mfx.FrameInfo.FourCC) { request->Info.ChromaFormat = videoProcessing->Out.ChromaFormat; request->Info.FourCC = videoProcessing->Out.FourCC; switch (videoProcessing->Out.FourCC) { // if is 8 bit, shift value has to be 0 case MFX_FOURCC_NV12: case MFX_FOURCC_YUY2: case MFX_FOURCC_AYUV: request->Info.BitDepthLuma = 8; request->Info.Shift = 0; break; // 10 bit case MFX_FOURCC_P010: case MFX_FOURCC_Y210: request->Info.BitDepthLuma = 10; request->Info.Shift = 1; break; case MFX_FOURCC_Y410: request->Info.BitDepthLuma = 10; request->Info.Shift = 0; break; // 12 bit case MFX_FOURCC_P016: case MFX_FOURCC_Y416: case MFX_FOURCC_Y216: request->Info.BitDepthLuma = 12; request->Info.Shift = 1; break; case MFX_FOURCC_RGBP: case MFX_FOURCC_RGB4: request->Info.BitDepthLuma = 0; request->Info.Shift = 0; break; default: MFX_RETURN(MFX_ERR_UNSUPPORTED); } request->Info.BitDepthChroma = request->Info.BitDepthLuma; } #endif // !MFX_DEC_VIDEO_POSTPROCESS_DISABLE return MFX_ERR_NONE; } static mfxStatus CheckVideoParamCommon(mfxVideoParam *in, eMFXHWType type) { MFX_AUTO_LTRACE(MFX_TRACE_LEVEL_INTERNAL, "CheckVideoParamCommon"); MFX_CHECK_NULL_PTR1(in); mfxStatus sts = CheckFrameInfoCodecs(&in->mfx.FrameInfo, in->mfx.CodecId); MFX_CHECK_STS(sts); if (in->Protected) { MFX_CHECK(type != MFX_HW_UNKNOWN && IS_PROTECTION_ANY(in->Protected), MFX_ERR_INVALID_VIDEO_PARAM); } switch (in->mfx.CodecId) { case MFX_CODEC_AVC: case MFX_CODEC_HEVC: case MFX_CODEC_MPEG2: case MFX_CODEC_VC1: case MFX_CODEC_JPEG: case MFX_CODEC_VP8: case MFX_CODEC_VP9: #if defined(MFX_ENABLE_AV1_VIDEO_CODEC) case MFX_CODEC_AV1: #endif #if defined(MFX_ENABLE_VVC_VIDEO_DECODE) case MFX_CODEC_VVC: #endif break; default: MFX_RETURN(MFX_ERR_INVALID_VIDEO_PARAM); } MFX_CHECK(in->IOPattern, MFX_ERR_INVALID_VIDEO_PARAM); if ( in->mfx.FrameInfo.FourCC == MFX_FOURCC_P010 || in->mfx.FrameInfo.FourCC == MFX_FOURCC_P210 || in->mfx.FrameInfo.FourCC == MFX_FOURCC_Y210 || in->mfx.FrameInfo.FourCC == MFX_FOURCC_P016 || in->mfx.FrameInfo.FourCC == MFX_FOURCC_Y216 || in->mfx.FrameInfo.FourCC == MFX_FOURCC_Y416 ) { if (type == MFX_HW_UNKNOWN) { MFX_CHECK(in->mfx.FrameInfo.Shift == 0, MFX_ERR_INVALID_VIDEO_PARAM); } else { MFX_CHECK(!(in->IOPattern & MFX_IOPATTERN_OUT_VIDEO_MEMORY) || in->mfx.FrameInfo.Shift == 1, MFX_ERR_INVALID_VIDEO_PARAM); } } return MFX_ERR_NONE; } mfxStatus CheckVideoParamDecoders(mfxVideoParam *in, eMFXHWType type) { mfxStatus sts = CheckVideoParamCommon(in, type); MFX_CHECK(sts >= MFX_ERR_NONE, sts); auto const supportedMemoryType = (in->IOPattern & MFX_IOPATTERN_OUT_VIDEO_MEMORY) || (in->IOPattern & MFX_IOPATTERN_OUT_SYSTEM_MEMORY); MFX_CHECK(supportedMemoryType, MFX_ERR_INVALID_VIDEO_PARAM); MFX_CHECK(!(in->IOPattern & MFX_IOPATTERN_OUT_VIDEO_MEMORY) || !(in->IOPattern & MFX_IOPATTERN_OUT_SYSTEM_MEMORY) , MFX_ERR_INVALID_VIDEO_PARAM); sts = CheckDecodersExtendedBuffers(in); MFX_CHECK(sts >= MFX_ERR_NONE, sts); return MFX_ERR_NONE; } mfxStatus CheckVideoParamEncoders(mfxVideoParam *in, eMFXHWType type) { mfxStatus sts = CheckFrameInfoEncoders(&in->mfx.FrameInfo); MFX_CHECK(sts >= MFX_ERR_NONE, sts); sts = CheckVideoParamCommon(in, type); MFX_CHECK(sts >= MFX_ERR_NONE, sts); MFX_CHECK(!in->Protected || (in->IOPattern & MFX_IOPATTERN_IN_VIDEO_MEMORY), MFX_ERR_INVALID_VIDEO_PARAM); return MFX_ERR_NONE; } mfxStatus CheckBitstream(const mfxBitstream *bs) { if (!bs || !bs->Data) MFX_RETURN(MFX_ERR_NULL_PTR); if (bs->DataOffset + bs->DataLength > bs->MaxLength) MFX_RETURN(MFX_ERR_UNDEFINED_BEHAVIOR); return MFX_ERR_NONE; } /* Check if pointers required for given FOURCC is NOT null */ mfxStatus CheckFramePointers(mfxFrameInfo const& info, mfxFrameData const& data) { switch (info.FourCC) { case MFX_FOURCC_A2RGB10: MFX_CHECK(data.B, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_Y410: MFX_CHECK(data.Y410, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_Y210: MFX_CHECK(data.Y16 && data.U16 && data.V16, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_P8: case MFX_FOURCC_P8_TEXTURE: case MFX_FOURCC_R16: MFX_CHECK(data.Y, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_NV12: case MFX_FOURCC_NV16: case MFX_FOURCC_P010: case MFX_FOURCC_P016: case MFX_FOURCC_P210: MFX_CHECK(data.Y && data.UV, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_Y216: MFX_CHECK(data.Y16 && data.U16 && data.V16, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_Y416: MFX_CHECK(data.Y16 && data.U16 && data.V16 && data.A , MFX_ERR_UNDEFINED_BEHAVIOR); break; #if defined (MFX_ENABLE_FOURCC_RGB565) case MFX_FOURCC_RGB565: MFX_CHECK(data.R && data.G && data.B, MFX_ERR_UNDEFINED_BEHAVIOR); break; #endif // MFX_ENABLE_FOURCC_RGB565 #ifdef MFX_ENABLE_RGBP case MFX_FOURCC_RGBP: #endif case MFX_FOURCC_BGRP: case MFX_FOURCC_RGB3: MFX_CHECK(data.R && data.G && data.B, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_AYUV: case MFX_FOURCC_AYUV_RGB4: case MFX_FOURCC_RGB4: case MFX_FOURCC_BGR4: case MFX_FOURCC_ABGR16F: case MFX_FOURCC_ARGB16: case MFX_FOURCC_ABGR16: MFX_CHECK(data.R && data.G && data.B && data.A, MFX_ERR_UNDEFINED_BEHAVIOR); break; case MFX_FOURCC_YV12: case MFX_FOURCC_YUY2: case MFX_FOURCC_I420: default: MFX_CHECK(data.Y && data.U && data.V, MFX_ERR_UNDEFINED_BEHAVIOR); break; } return MFX_ERR_NONE; } mfxStatus CheckFrameData(const mfxFrameSurface1 *surface) { if (!surface) return MFX_ERR_NULL_PTR; if (surface->Data.MemId) return MFX_ERR_NONE; MFX_RETURN(CheckFramePointers(surface->Info, surface->Data)); } mfxStatus CheckDecodersExtendedBuffers(mfxVideoParam const* par) { static const mfxU32 g_commonSupportedExtBuffers[] = { #ifndef MFX_ADAPTIVE_PLAYBACK_DISABLE MFX_EXTBUFF_DEC_ADAPTIVE_PLAYBACK, #endif MFX_EXTBUFF_ALLOCATION_HINTS }; static const mfxU32 g_decoderSupportedExtBuffersAVC[] = { MFX_EXTBUFF_MVC_SEQ_DESC, MFX_EXTBUFF_MVC_TARGET_VIEWS, #ifndef MFX_DEC_VIDEO_POSTPROCESS_DISABLE MFX_EXTBUFF_DEC_VIDEO_PROCESSING, #endif }; static const mfxU32 g_decoderSupportedExtBuffersHEVC[] = { MFX_EXTBUFF_HEVC_PARAM #ifdef MFX_EXTBUFF_FORCE_PRIVATE_DDI_ENABLE , MFX_EXTBUFF_FORCE_PRIVATE_DDI #endif #ifndef MFX_DEC_VIDEO_POSTPROCESS_DISABLE ,MFX_EXTBUFF_DEC_VIDEO_PROCESSING #endif }; static const mfxU32 g_decoderSupportedExtBuffersVC1[] = { 0 //Fallback }; static const mfxU32 g_decoderSupportedExtBuffersVP9[] = { #ifndef MFX_ADAPTIVE_PLAYBACK_DISABLE MFX_EXTBUFF_DEC_ADAPTIVE_PLAYBACK, #endif #ifndef MFX_DEC_VIDEO_POSTPROCESS_DISABLE MFX_EXTBUFF_DEC_VIDEO_PROCESSING, #endif 0 //Fallback }; static const mfxU32 g_decoderSupportedExtBuffersMJPEG[] = {MFX_EXTBUFF_JPEG_HUFFMAN, MFX_EXTBUFF_DEC_VIDEO_PROCESSING, MFX_EXTBUFF_JPEG_QT}; static const mfxU32 g_decoderSupportedExtBuffersAV1[] = { #ifndef MFX_DEC_VIDEO_POSTPROCESS_DISABLE MFX_EXTBUFF_DEC_VIDEO_PROCESSING, #endif MFX_EXTBUFF_AV1_FILM_GRAIN_PARAM, 0 //Fallback }; const mfxU32 *supported_buffers = 0; mfxU32 numberOfSupported = 0; if (par->mfx.CodecId == MFX_CODEC_AVC) { supported_buffers = g_decoderSupportedExtBuffersAVC; numberOfSupported = sizeof(g_decoderSupportedExtBuffersAVC) / sizeof(g_decoderSupportedExtBuffersAVC[0]); } else if (par->mfx.CodecId == MFX_CODEC_VC1 || par->mfx.CodecId == MFX_CODEC_MPEG2) { supported_buffers = g_decoderSupportedExtBuffersVC1; numberOfSupported = sizeof(g_decoderSupportedExtBuffersVC1) / sizeof(g_decoderSupportedExtBuffersVC1[0]); } else if (par->mfx.CodecId == MFX_CODEC_HEVC) { supported_buffers = g_decoderSupportedExtBuffersHEVC; numberOfSupported = sizeof(g_decoderSupportedExtBuffersHEVC) / sizeof(g_decoderSupportedExtBuffersHEVC[0]); } else if (par->mfx.CodecId == MFX_CODEC_JPEG) { supported_buffers = g_decoderSupportedExtBuffersMJPEG; numberOfSupported = sizeof(g_decoderSupportedExtBuffersMJPEG) / sizeof(g_decoderSupportedExtBuffersMJPEG[0]); } else if (par->mfx.CodecId == MFX_CODEC_VP9) { supported_buffers = g_decoderSupportedExtBuffersVP9; numberOfSupported = sizeof(g_decoderSupportedExtBuffersVP9) / sizeof(g_decoderSupportedExtBuffersVP9[0]); } else if (par->mfx.CodecId == MFX_CODEC_AV1) { supported_buffers = g_decoderSupportedExtBuffersAV1; numberOfSupported = sizeof(g_decoderSupportedExtBuffersAV1) / sizeof(g_decoderSupportedExtBuffersAV1[0]); } else { supported_buffers = g_commonSupportedExtBuffers; numberOfSupported = sizeof(g_commonSupportedExtBuffers) / sizeof(g_commonSupportedExtBuffers[0]); } const mfxU32 *common_supported_buffers = g_commonSupportedExtBuffers; mfxU32 common_numberOfSupported = sizeof(g_commonSupportedExtBuffers) / sizeof(g_commonSupportedExtBuffers[0]); for (mfxU32 i = 0; i < par->NumExtParam; i++) { MFX_CHECK_NULL_PTR1(par->ExtParam[i]); bool is_known = false; for (mfxU32 j = 0; j < numberOfSupported; ++j) { if (supported_buffers[j] && par->ExtParam[i]->BufferId == supported_buffers[j]) { is_known = true; break; } } for (mfxU32 j = 0; j < common_numberOfSupported; ++j) { if (par->ExtParam[i]->BufferId == common_supported_buffers[j]) { is_known = true; break; } } MFX_CHECK(is_known, MFX_ERR_UNSUPPORTED); if (par->ExtParam[i]->BufferId == MFX_EXTBUFF_ALLOCATION_HINTS) { MFX_SAFE_CALL(CheckAllocationHintsBuffer(*reinterpret_cast(par->ExtParam[i]))); } } return MFX_ERR_NONE; } // converts u32 nom and denom to packed u16+u16, used in va mfxStatus PackMfxFrameRate(mfxU32 nom, mfxU32 den, mfxU32& packed) { mfxStatus sts = MFX_ERR_NONE; if (!nom) { packed = 0; return sts; } if (!den) // denominator assumed 1 if is 0 den = 1; if ((nom | den) >> 16) // don't fit to u16 { mfxU32 gcd = nom; // will be greatest common divisor mfxU32 rem = den; while (rem > 0) { mfxU32 oldrem = rem; rem = gcd % rem; gcd = oldrem; } if (gcd > 1) { nom /= gcd; den /= gcd; } if ((nom | den) >> 16) // still don't fit to u16 - lose precision { if (nom > den) // make nom 0xffff for max precision { den = (mfxU32)((mfxF64)den * 0xffff / nom + .5); if (!den) den = 1; nom = 0xffff; } else { nom = (mfxU32)((mfxF64)nom * 0xffff / den + .5); den = 0xffff; } sts = MFX_WRN_VIDEO_PARAM_CHANGED; } } packed = (den << 16) | nom; MFX_RETURN(sts); } ////////////////////////////////////////////////////////////////////////////////////////////////////////// // Extended Buffer class ////////////////////////////////////////////////////////////////////////////////////////////////////////// ExtendedBuffer::ExtendedBuffer() { } ExtendedBuffer::~ExtendedBuffer() { Release(); } void ExtendedBuffer::Release() { if(m_buffers.empty()) return; BuffersList::iterator iter = m_buffers.begin(); BuffersList::iterator iter_end = m_buffers.end(); for( ; iter != iter_end; ++iter) { mfxU8 * buffer = (mfxU8 *)*iter; delete[] buffer; } m_buffers.clear(); } size_t ExtendedBuffer::GetCount() const { return m_buffers.size(); } void ExtendedBuffer::AddBuffer(mfxExtBuffer * in) { if (GetBufferByIdInternal(in->BufferId)) return; mfxExtBuffer * buffer = (mfxExtBuffer *)(new mfxU8[in->BufferSz]); memset(buffer, 0, in->BufferSz); buffer->BufferSz = in->BufferSz; buffer->BufferId = in->BufferId; AddBufferInternal(buffer); } void ExtendedBuffer::AddBufferInternal(mfxExtBuffer * buffer) { m_buffers.push_back(buffer); } mfxExtBuffer ** ExtendedBuffer::GetBuffers() { return &m_buffers[0]; } mfxExtBuffer * ExtendedBuffer::GetBufferByIdInternal(mfxU32 id) { BuffersList::iterator iter = m_buffers.begin(); BuffersList::iterator iter_end = m_buffers.end(); for( ; iter != iter_end; ++iter) { mfxExtBuffer * buffer = *iter; if (buffer->BufferId == id) return buffer; } return 0; } mfxExtBuffer * ExtendedBuffer::GetBufferByPositionInternal(mfxU32 pos) { if (pos >= m_buffers.size()) return 0; return m_buffers[pos]; } //////////////////////////////////////////////////////////////////////////////////////////////////////////// // mfxVideoParamWrapper implementation //////////////////////////////////////////////////////////////////////////////////////////////////////////// mfxVideoParamWrapper::mfxVideoParamWrapper() : m_mvcSequenceBuffer(0) { } mfxVideoParamWrapper::mfxVideoParamWrapper(const mfxVideoParam & par) : m_mvcSequenceBuffer(0) { CopyVideoParam(par); } mfxVideoParamWrapper::~mfxVideoParamWrapper() { delete[] m_mvcSequenceBuffer; } mfxVideoParamWrapper & mfxVideoParamWrapper::operator = (const mfxVideoParam & par) { CopyVideoParam(par); return *this; } mfxVideoParamWrapper & mfxVideoParamWrapper::operator = (const mfxVideoParamWrapper & par) { return mfxVideoParamWrapper::operator = ( *((const mfxVideoParam *)&par)); } bool mfxVideoParamWrapper::CreateExtendedBuffer(mfxU32 bufferId) { if (m_buffers.GetBufferById(bufferId)) return true; switch(bufferId) { case MFX_EXTBUFF_VIDEO_SIGNAL_INFO: m_buffers.AddTypedBuffer(bufferId); break; case MFX_EXTBUFF_CODING_OPTION_SPSPPS: m_buffers.AddTypedBuffer(bufferId); break; case MFX_EXTBUFF_HEVC_PARAM: m_buffers.AddTypedBuffer(bufferId); break; case MFX_EXTBUFF_CODING_OPTION: m_buffers.AddTypedBuffer(bufferId); break; case MFX_EXTBUFF_CHROMA_LOC_INFO: m_buffers.AddTypedBuffer(bufferId); break; default: assert(false); return false; } NumExtParam = (mfxU16)m_buffers.GetCount(); ExtParam = NumExtParam ? m_buffers.GetBuffers() : 0; return true; } void mfxVideoParamWrapper::CopyVideoParam(const mfxVideoParam & par) { mfxVideoParam * temp = this; *temp = par; this->NumExtParam = 0; this->ExtParam = 0; for (mfxU32 i = 0; i < par.NumExtParam; i++) { switch(par.ExtParam[i]->BufferId) { case MFX_EXTBUFF_MVC_SEQ_DESC: { mfxExtMVCSeqDesc * mvcPoints = (mfxExtMVCSeqDesc *)GetExtendedBufferInternal(par.ExtParam, par.NumExtParam, MFX_EXTBUFF_MVC_SEQ_DESC); m_buffers.AddTypedBuffer(MFX_EXTBUFF_MVC_SEQ_DESC); mfxExtMVCSeqDesc * points = m_buffers.GetBufferById(MFX_EXTBUFF_MVC_SEQ_DESC); size_t size = mvcPoints->NumView * sizeof(mfxMVCViewDependency) + mvcPoints->NumOP * sizeof(mfxMVCOperationPoint) + mvcPoints->NumViewId * sizeof(mfxU16); if (!m_mvcSequenceBuffer) m_mvcSequenceBuffer = new mfxU8[size]; else { delete[] m_mvcSequenceBuffer; m_mvcSequenceBuffer = new mfxU8[size]; } mfxU8 * ptr = m_mvcSequenceBuffer; if (points) { points->NumView = points->NumViewAlloc = mvcPoints->NumView; points->View = (mfxMVCViewDependency * )ptr; std::copy(mvcPoints->View, mvcPoints->View + mvcPoints->NumView, points->View); ptr += mvcPoints->NumView * sizeof(mfxMVCViewDependency); points->NumView = points->NumViewAlloc = mvcPoints->NumView; points->ViewId = (mfxU16 *)ptr; std::copy(mvcPoints->ViewId, mvcPoints->ViewId + mvcPoints->NumViewId, points->ViewId); ptr += mvcPoints->NumViewId * sizeof(mfxU16); points->NumOP = points->NumOPAlloc = mvcPoints->NumOP; points->OP = (mfxMVCOperationPoint *)ptr; std::copy(mvcPoints->OP, mvcPoints->OP + mvcPoints->NumOP, points->OP); mfxU16 * targetView = points->ViewId; for (mfxU32 j = 0; j < points->NumOP; j++) { points->OP[j].TargetViewId = targetView; targetView += points->OP[j].NumTargetViews; } } } break; #ifdef MFX_EXTBUFF_FORCE_PRIVATE_DDI_ENABLE case MFX_EXTBUFF_FORCE_PRIVATE_DDI: #endif #ifndef MFX_DEC_VIDEO_POSTPROCESS_DISABLE case MFX_EXTBUFF_DEC_VIDEO_PROCESSING: #endif case MFX_EXTBUFF_MVC_TARGET_VIEWS: case MFX_EXTBUFF_VIDEO_SIGNAL_INFO: #if defined(MFX_ENABLE_SVC_VIDEO_DECODE) case MFX_EXTBUFF_SVC_SEQ_DESC: case MFX_EXTBUFF_SVC_TARGET_LAYER: #endif #ifndef MFX_ADAPTIVE_PLAYBACK_DISABLE case MFX_EXTBUFF_DEC_ADAPTIVE_PLAYBACK: #endif case MFX_EXTBUFF_JPEG_QT: case MFX_EXTBUFF_JPEG_HUFFMAN: case MFX_EXTBUFF_HEVC_PARAM: default: { void * in = GetExtendedBufferInternal(par.ExtParam, par.NumExtParam, par.ExtParam[i]->BufferId); m_buffers.AddBuffer(par.ExtParam[i]); mfxExtBuffer * out = m_buffers.GetBufferById(par.ExtParam[i]->BufferId); if (NULL == out) { assert(false); throw UMC::UMC_ERR_FAILED; } mfxU8 *src = reinterpret_cast(in), *dst = reinterpret_cast(out); std::copy(src, src + par.ExtParam[i]->BufferSz, dst); } break; }; } NumExtParam = (mfxU16)m_buffers.GetCount(); ExtParam = NumExtParam ? m_buffers.GetBuffers() : 0; } mfxU32 GetMinPitch(mfxU32 fourcc, mfxU16 width) { switch (fourcc) { case MFX_FOURCC_P8: case MFX_FOURCC_P8_TEXTURE: case MFX_FOURCC_NV12: case MFX_FOURCC_YV12: case MFX_FOURCC_I420: #ifdef MFX_ENABLE_RGBP case MFX_FOURCC_RGBP: #endif case MFX_FOURCC_BGRP: case MFX_FOURCC_NV16: return width * 1; #if defined (MFX_ENABLE_FOURCC_RGB565) case MFX_FOURCC_RGB565: return width * 2; #endif // MFX_ENABLE_FOURCC_RGB565 case MFX_FOURCC_R16: return width * 2; case MFX_FOURCC_RGB3: return width * 3; case MFX_FOURCC_AYUV: case MFX_FOURCC_AYUV_RGB4: case MFX_FOURCC_RGB4: case MFX_FOURCC_BGR4: case MFX_FOURCC_A2RGB10: return width * 4; case MFX_FOURCC_ARGB16: case MFX_FOURCC_ABGR16: case MFX_FOURCC_ABGR16F: return width * 8; case MFX_FOURCC_YUY2: case MFX_FOURCC_UYVY: return width * 2; case MFX_FOURCC_P010: case MFX_FOURCC_P016: case MFX_FOURCC_P210: return width * 2; case MFX_FOURCC_Y210: case MFX_FOURCC_Y410: return width * 4; case MFX_FOURCC_Y216: return width * 4; case MFX_FOURCC_Y416: return width * 8; } return 0; } mfxU8* GetFramePointer(mfxU32 fourcc, mfxFrameData const& data) { switch (fourcc) { case MFX_FOURCC_RGB3: case MFX_FOURCC_RGB4: case MFX_FOURCC_BGR4: #ifdef MFX_ENABLE_RGBP case MFX_FOURCC_RGBP: #endif case MFX_FOURCC_BGRP: case MFX_FOURCC_ARGB16: case MFX_FOURCC_ABGR16: return std::min({data.R, data.G, data.B}); break; #if defined (MFX_ENABLE_FOURCC_RGB565) case MFX_FOURCC_RGB565: return data.R; break; #endif // MFX_ENABLE_FOURCC_RGB565 case MFX_FOURCC_R16: return reinterpret_cast(data.Y16); break; case MFX_FOURCC_AYUV: return data.V; break; case MFX_FOURCC_UYVY: return data.U; break; case MFX_FOURCC_A2RGB10: return data.B; break; case MFX_FOURCC_Y410: return reinterpret_cast(data.Y410); break; case MFX_FOURCC_Y416: return reinterpret_cast(data.U16); break; case MFX_FOURCC_ABGR16F: return reinterpret_cast(data.ABGRFP16); break; default: return data.Y; } } mfxU8* GetFramePointer(const mfxFrameSurface1& surf) { return GetFramePointer(surf.Info.FourCC, surf.Data); } mfxStatus GetFramePointerChecked(mfxFrameInfo const& info, mfxFrameData const& data, mfxU8** ptr) { MFX_CHECK(ptr, MFX_ERR_UNDEFINED_BEHAVIOR); *ptr = GetFramePointer(info.FourCC, data); if (!*ptr) return MFX_ERR_NONE; mfxStatus sts = CheckFramePointers(info, data); MFX_CHECK_STS(sts); mfxU32 const pitch = (data.PitchHigh << 16) | data.PitchLow; mfxU32 const min_pitch = GetMinPitch(info.FourCC, info.Width); MFX_CHECK(min_pitch, MFX_ERR_UNDEFINED_BEHAVIOR); MFX_CHECK(pitch >= min_pitch, MFX_ERR_UNDEFINED_BEHAVIOR); return MFX_ERR_NONE; } bool IsSurfaceEmpty(const mfxFrameSurface1 & surface) { return !(surface.Data.MemId || surface.Data.Y || surface.Data.U || surface.Data.V || surface.Data.A); } mfxFrameSurface1 MakeSurface(mfxFrameInfo const& fi, const mfxFrameSurface1& surface) { mfxFrameSurface1 tmpSrf{}; tmpSrf.Info = fi; tmpSrf.Data = surface.Data; tmpSrf.FrameInterface = surface.FrameInterface; tmpSrf.Version = surface.Version; return tmpSrf; } mfxFrameSurface1 MakeSurface(mfxFrameInfo const& fi, mfxMemId mid) { mfxFrameSurface1 surface{}; surface.Info = fi; surface.Data.MemId = mid; return surface; } mfxU16 BitDepthFromFourcc(mfxU32 fourcc) { switch (fourcc) { case MFX_FOURCC_NV12: case MFX_FOURCC_NV16: case MFX_FOURCC_YV12: case MFX_FOURCC_YUY2: case MFX_FOURCC_AYUV: case MFX_FOURCC_UYVY: return 8; case MFX_FOURCC_P010: case MFX_FOURCC_P210: case MFX_FOURCC_Y210: case MFX_FOURCC_Y410: return 10; case MFX_FOURCC_P016: case MFX_FOURCC_Y216: case MFX_FOURCC_Y416: return 12; case MFX_FOURCC_ABGR16F: return 16; // RGB formats #if defined (MFX_ENABLE_FOURCC_RGB565) case MFX_FOURCC_RGB565: #endif case MFX_FOURCC_RGB3: #ifdef MFX_ENABLE_RGBP case MFX_FOURCC_RGBP: #endif case MFX_FOURCC_BGRP: case MFX_FOURCC_RGB4: case MFX_FOURCC_BGR4: case MFX_FOURCC_A2RGB10: case MFX_FOURCC_ARGB16: case MFX_FOURCC_ABGR16: case MFX_FOURCC_AYUV_RGB4: case MFX_FOURCC_R16: // Plain data formats case MFX_FOURCC_P8: case MFX_FOURCC_P8_TEXTURE: default: return 0; } } mfxU16 ChromaFormatFromFourcc(mfxU32 fourcc) { switch (fourcc) { case MFX_FOURCC_NV12: case MFX_FOURCC_YV12: case MFX_FOURCC_P010: case MFX_FOURCC_P016: return MFX_CHROMAFORMAT_YUV420; case MFX_FOURCC_Y210: case MFX_FOURCC_Y216: case MFX_FOURCC_YUY2: case MFX_FOURCC_UYVY: case MFX_FOURCC_NV16: case MFX_FOURCC_P210: return MFX_CHROMAFORMAT_YUV422H; case MFX_FOURCC_AYUV: case MFX_FOURCC_Y410: case MFX_FOURCC_Y416: return MFX_CHROMAFORMAT_YUV444; // RGB formats #if defined (MFX_ENABLE_FOURCC_RGB565) case MFX_FOURCC_RGB565: #endif case MFX_FOURCC_RGB3: #ifdef MFX_ENABLE_RGBP case MFX_FOURCC_RGBP: #endif case MFX_FOURCC_BGRP: case MFX_FOURCC_RGB4: case MFX_FOURCC_BGR4: case MFX_FOURCC_A2RGB10: case MFX_FOURCC_ARGB16: case MFX_FOURCC_ABGR16: case MFX_FOURCC_AYUV_RGB4: case MFX_FOURCC_R16: // Plain data formats case MFX_FOURCC_P8: case MFX_FOURCC_P8_TEXTURE: default: return 0; } } mfxPlatform MakePlatform(eMFXHWType type, mfxU16 device_id) { mfxPlatform platform = {}; platform.MediaAdapterType = MFX_MEDIA_INTEGRATED; switch (type) { case MFX_HW_SNB : platform.CodeName = MFX_PLATFORM_SANDYBRIDGE; break; case MFX_HW_IVB : platform.CodeName = MFX_PLATFORM_IVYBRIDGE; break; case MFX_HW_HSW: case MFX_HW_HSW_ULT: platform.CodeName = MFX_PLATFORM_HASWELL; break; case MFX_HW_VLV : platform.CodeName = MFX_PLATFORM_BAYTRAIL; break; case MFX_HW_BDW : platform.CodeName = MFX_PLATFORM_BROADWELL; break; case MFX_HW_CHT : platform.CodeName = MFX_PLATFORM_CHERRYTRAIL; break; case MFX_HW_SCL : platform.CodeName = MFX_PLATFORM_SKYLAKE; break; case MFX_HW_APL : platform.CodeName = MFX_PLATFORM_APOLLOLAKE; break; case MFX_HW_KBL : platform.CodeName = MFX_PLATFORM_KABYLAKE; break; case MFX_HW_GLK : platform.CodeName = MFX_PLATFORM_GEMINILAKE; break; case MFX_HW_CFL : platform.CodeName = MFX_PLATFORM_COFFEELAKE; break; case MFX_HW_CNL : platform.CodeName = MFX_PLATFORM_CANNONLAKE; break; case MFX_HW_ICL : case MFX_HW_ICL_LP : platform.CodeName = MFX_PLATFORM_ICELAKE; break; case MFX_HW_EHL : platform.CodeName = MFX_PLATFORM_ELKHARTLAKE; break; case MFX_HW_JSL : platform.CodeName = MFX_PLATFORM_JASPERLAKE; break; case MFX_HW_RKL : case MFX_HW_TGL_LP : platform.CodeName = MFX_PLATFORM_TIGERLAKE; break; case MFX_HW_DG1 : platform.MediaAdapterType = MFX_MEDIA_DISCRETE; platform.CodeName = MFX_PLATFORM_TIGERLAKE; break; case MFX_HW_ADL_S : platform.CodeName = MFX_PLATFORM_ALDERLAKE_S; break; case MFX_HW_ADL_P : platform.CodeName = MFX_PLATFORM_ALDERLAKE_P; break; case MFX_HW_ADL_N : platform.CodeName = MFX_PLATFORM_ALDERLAKE_N; break; case MFX_HW_DG2 : platform.MediaAdapterType = MFX_MEDIA_DISCRETE; platform.CodeName = MFX_PLATFORM_DG2; break; case MFX_HW_MTL : platform.CodeName = MFX_PLATFORM_METEORLAKE; break; case MFX_HW_ARL : platform.CodeName = MFX_PLATFORM_ARROWLAKE; break; case MFX_HW_LNL : platform.CodeName = MFX_PLATFORM_LUNARLAKE; break; case MFX_HW_BMG : platform.MediaAdapterType = MFX_MEDIA_DISCRETE; platform.CodeName = MFX_PLATFORM_BATTLEMAGE; break; // From Pantherlake platform.CodeName will be filled with MFX_PLATFORM_MAXIMUM. NOT to create any new CodeName values. case MFX_HW_PTL : platform.CodeName = MFX_PLATFORM_MAXIMUM; break; case MFX_HW_NVL_XE3G : platform.CodeName = MFX_PLATFORM_MAXIMUM; break; default: platform.MediaAdapterType = MFX_MEDIA_UNKNOWN; platform.CodeName = MFX_PLATFORM_UNKNOWN; break; } platform.DeviceId = device_id; return platform; }