voukoder/voukoder-ffmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 15 Wiki Activity

add mfx again

Browse Source
This commit is contained in:
Daniel Stankewitz 2022-09-25 14:07:09 +02:00
parent 5857c8f7b3
commit 66bd1fb20d
30 changed files with 6776 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
.github/actions/libmfx/include/mfx/mfxadapter.h vendored Normal file
View File

@ -0,0 +1,40 @@
// Copyright (c) 2019-2020 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 "mfxdefs.h"
#if (MFX_VERSION >= 1031)
#ifndef __MFXADAPTER_H__
#define __MFXADAPTER_H__
#include "mfxstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif
mfxStatus MFX_CDECL MFXQueryAdapters(mfxComponentInfo* input_info, mfxAdaptersInfo* adapters);
mfxStatus MFX_CDECL MFXQueryAdaptersDecode(mfxBitstream* bitstream, mfxU32 codec_id, mfxAdaptersInfo* adapters);
mfxStatus MFX_CDECL MFXQueryAdaptersNumber(mfxU32* num_adapters);
#ifdef __cplusplus
} // extern "C"
#endif
#endif // __MFXADAPTER_H__
#endif

170
.github/actions/libmfx/include/mfx/mfxastructures.h vendored Normal file
View File

@ -0,0 +1,170 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXASTRUCTURES_H__
#define __MFXASTRUCTURES_H__
#include "mfxcommon.h"
#if !defined (__GNUC__)
#pragma warning(disable: 4201)
#endif
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* CodecId */
enum {
MFX_CODEC_AAC =MFX_MAKEFOURCC('A','A','C',' '),
MFX_CODEC_MP3 =MFX_MAKEFOURCC('M','P','3',' ')
};
enum {
/* AAC Profiles & Levels */
MFX_PROFILE_AAC_LC =2,
MFX_PROFILE_AAC_LTP =4,
MFX_PROFILE_AAC_MAIN =1,
MFX_PROFILE_AAC_SSR =3,
MFX_PROFILE_AAC_HE =5,
MFX_PROFILE_AAC_ALS =0x20,
MFX_PROFILE_AAC_BSAC =22,
MFX_PROFILE_AAC_PS =29,
/*MPEG AUDIO*/
MFX_AUDIO_MPEG1_LAYER1 =0x00000110,
MFX_AUDIO_MPEG1_LAYER2 =0x00000120,
MFX_AUDIO_MPEG1_LAYER3 =0x00000140,
MFX_AUDIO_MPEG2_LAYER1 =0x00000210,
MFX_AUDIO_MPEG2_LAYER2 =0x00000220,
MFX_AUDIO_MPEG2_LAYER3 =0x00000240
};
/*AAC HE decoder down sampling*/
enum {
MFX_AUDIO_AAC_HE_DWNSMPL_OFF=0,
MFX_AUDIO_AAC_HE_DWNSMPL_ON= 1
};
/* AAC decoder support of PS */
enum {
MFX_AUDIO_AAC_PS_DISABLE= 0,
MFX_AUDIO_AAC_PS_PARSER= 1,
MFX_AUDIO_AAC_PS_ENABLE_BL= 111,
MFX_AUDIO_AAC_PS_ENABLE_UR= 411
};
/*AAC decoder SBR support*/
enum {
MFX_AUDIO_AAC_SBR_DISABLE = 0,
MFX_AUDIO_AAC_SBR_ENABLE= 1,
MFX_AUDIO_AAC_SBR_UNDEF= 2
};
/*AAC header type*/
enum{
MFX_AUDIO_AAC_ADTS= 1,
MFX_AUDIO_AAC_ADIF= 2,
MFX_AUDIO_AAC_RAW= 3,
};
/*AAC encoder stereo mode*/
enum
{
MFX_AUDIO_AAC_MONO= 0,
MFX_AUDIO_AAC_LR_STEREO= 1,
MFX_AUDIO_AAC_MS_STEREO= 2,
MFX_AUDIO_AAC_JOINT_STEREO= 3
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU32 CodecId;
mfxU16 CodecProfile;
mfxU16 CodecLevel;
mfxU32 Bitrate;
mfxU32 SampleFrequency;
mfxU16 NumChannel;
mfxU16 BitPerSample;
mfxU16 reserved1[22];
union {
struct { /* AAC Decoding Options */
mfxU16 FlagPSSupportLev;
mfxU16 Layer;
mfxU16 AACHeaderDataSize;
mfxU8 AACHeaderData[64];
};
struct { /* AAC Encoding Options */
mfxU16 OutputFormat;
mfxU16 StereoMode;
mfxU16 reserved2[61];
};
};
} mfxAudioInfoMFX;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU16 AsyncDepth;
mfxU16 Protected;
mfxU16 reserved[14];
mfxAudioInfoMFX mfx;
mfxExtBuffer** ExtParam;
mfxU16 NumExtParam;
} mfxAudioParam;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU32 SuggestedInputSize;
mfxU32 SuggestedOutputSize;
mfxU32 reserved[6];
} mfxAudioAllocRequest;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
mfxU64 TimeStamp; /* 1/90KHz */
mfxU16 Locked;
mfxU16 NumChannels;
mfxU32 SampleFrequency;
mfxU16 BitPerSample;
mfxU16 reserved1[7];
mfxU8* Data;
mfxU32 reserved2;
mfxU32 DataLength;
mfxU32 MaxLength;
mfxU32 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxAudioFrame;
MFX_PACK_END()
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

101
.github/actions/libmfx/include/mfx/mfxaudio++.h vendored Normal file
View File

@ -0,0 +1,101 @@
// Copyright (c) 2017 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.
#ifndef __MFXAUDIOPLUSPLUS_H
#define __MFXAUDIOPLUSPLUS_H
#include "mfxaudio.h"
class MFXAudioSession
{
public:
MFXAudioSession(void) { m_session = (mfxSession) 0; }
virtual ~MFXAudioSession(void) { Close(); }
virtual mfxStatus Init(mfxIMPL impl, mfxVersion *ver) { return MFXInit(impl, ver, &m_session); }
virtual mfxStatus Close(void)
{
mfxStatus mfxRes;
mfxRes = MFXClose(m_session); m_session = (mfxSession) 0;
return mfxRes;
}
virtual mfxStatus QueryIMPL(mfxIMPL *impl) { return MFXQueryIMPL(m_session, impl); }
virtual mfxStatus QueryVersion(mfxVersion *version) { return MFXQueryVersion(m_session, version); }
virtual mfxStatus JoinSession(mfxSession child_session) { return MFXJoinSession(m_session, child_session);}
virtual mfxStatus DisjoinSession( ) { return MFXDisjoinSession(m_session);}
virtual mfxStatus CloneSession( mfxSession *clone) { return MFXCloneSession(m_session, clone);}
virtual mfxStatus SetPriority( mfxPriority priority) { return MFXSetPriority(m_session, priority);}
virtual mfxStatus GetPriority( mfxPriority *priority) { return MFXGetPriority(m_session, priority);}
virtual mfxStatus SyncOperation(mfxSyncPoint syncp, mfxU32 wait) { return MFXAudioCORE_SyncOperation(m_session, syncp, wait); }
virtual operator mfxSession (void) { return m_session; }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXAudioDECODE
{
public:
MFXAudioDECODE(mfxSession session) { m_session = session; }
virtual ~MFXAudioDECODE(void) { Close(); }
virtual mfxStatus Query(mfxAudioParam *in, mfxAudioParam *out) { return MFXAudioDECODE_Query(m_session, in, out); }
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxAudioParam *par) { return MFXAudioDECODE_DecodeHeader(m_session, bs, par); }
virtual mfxStatus QueryIOSize(mfxAudioParam *par, mfxAudioAllocRequest *request) { return MFXAudioDECODE_QueryIOSize(m_session, par, request); }
virtual mfxStatus Init(mfxAudioParam *par) { return MFXAudioDECODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxAudioParam *par) { return MFXAudioDECODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXAudioDECODE_Close(m_session); }
virtual mfxStatus GetAudioParam(mfxAudioParam *par) { return MFXAudioDECODE_GetAudioParam(m_session, par); }
virtual mfxStatus DecodeFrameAsync(mfxBitstream *bs, mfxAudioFrame *frame, mfxSyncPoint *syncp) { return MFXAudioDECODE_DecodeFrameAsync(m_session, bs, frame, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXAudioENCODE
{
public:
MFXAudioENCODE(mfxSession session) { m_session = session; }
virtual ~MFXAudioENCODE(void) { Close(); }
virtual mfxStatus Query(mfxAudioParam *in, mfxAudioParam *out) { return MFXAudioENCODE_Query(m_session, in, out); }
virtual mfxStatus QueryIOSize(mfxAudioParam *par, mfxAudioAllocRequest *request) { return MFXAudioENCODE_QueryIOSize(m_session, par, request); }
virtual mfxStatus Init(mfxAudioParam *par) { return MFXAudioENCODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxAudioParam *par) { return MFXAudioENCODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXAudioENCODE_Close(m_session); }
virtual mfxStatus GetAudioParam(mfxAudioParam *par) { return MFXAudioENCODE_GetAudioParam(m_session, par); }
virtual mfxStatus EncodeFrameAsync(mfxAudioFrame *frame, mfxBitstream *buffer_out, mfxSyncPoint *syncp) { return MFXAudioENCODE_EncodeFrameAsync(m_session, frame, buffer_out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
#endif

60
.github/actions/libmfx/include/mfx/mfxaudio.h vendored Normal file
View File

@ -0,0 +1,60 @@
// Copyright (c) 2017 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.
#ifndef __MFXAUDIO_H__
#define __MFXAUDIO_H__
#include "mfxsession.h"
#include "mfxastructures.h"
#define MFX_AUDIO_VERSION_MAJOR 1
#define MFX_AUDIO_VERSION_MINOR 15
#ifdef __cplusplus
extern "C"
{
#endif
/* AudioCORE */
mfxStatus MFX_CDECL MFXAudioCORE_SyncOperation(mfxSession session, mfxSyncPoint syncp, mfxU32 wait);
/* AudioENCODE */
mfxStatus MFX_CDECL MFXAudioENCODE_Query(mfxSession session, mfxAudioParam *in, mfxAudioParam *out);
mfxStatus MFX_CDECL MFXAudioENCODE_QueryIOSize(mfxSession session, mfxAudioParam *par, mfxAudioAllocRequest *request);
mfxStatus MFX_CDECL MFXAudioENCODE_Init(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioENCODE_Reset(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioENCODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXAudioENCODE_GetAudioParam(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioENCODE_EncodeFrameAsync(mfxSession session, mfxAudioFrame *frame, mfxBitstream *bs, mfxSyncPoint *syncp);
/* AudioDECODE */
mfxStatus MFX_CDECL MFXAudioDECODE_Query(mfxSession session, mfxAudioParam *in, mfxAudioParam *out);
mfxStatus MFX_CDECL MFXAudioDECODE_DecodeHeader(mfxSession session, mfxBitstream *bs, mfxAudioParam* par);
mfxStatus MFX_CDECL MFXAudioDECODE_Init(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioDECODE_Reset(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioDECODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXAudioDECODE_QueryIOSize(mfxSession session, mfxAudioParam *par, mfxAudioAllocRequest *request);
mfxStatus MFX_CDECL MFXAudioDECODE_GetAudioParam(mfxSession session, mfxAudioParam *par);
mfxStatus MFX_CDECL MFXAudioDECODE_DecodeFrameAsync(mfxSession session, mfxBitstream *bs, mfxAudioFrame *frame, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif
#endif

129
.github/actions/libmfx/include/mfx/mfxbrc.h vendored Normal file
View File

@ -0,0 +1,129 @@
// Copyright (c) 2019-2020 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.
#ifndef __MFXBRC_H__
#define __MFXBRC_H__
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_BRC = MFX_MAKEFOURCC('E','B','R','C')
};
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
#if (MFX_VERSION >= 1026)
mfxU32 reserved[23];
mfxU16 SceneChange; // Frame is Scene Chg frame
mfxU16 LongTerm; // Frame is long term refrence
mfxU32 FrameCmplx; // Frame Complexity
#else
mfxU32 reserved[25];
#endif
mfxU32 EncodedOrder; // Frame number in a sequence of reordered frames starting from encoder Init()
mfxU32 DisplayOrder; // Frame number in a sequence of frames in display order starting from last IDR
mfxU32 CodedFrameSize; // Size of frame in bytes after encoding
mfxU16 FrameType; // See FrameType enumerator
mfxU16 PyramidLayer; // B-pyramid or P-pyramid layer, frame belongs to
mfxU16 NumRecode; // Number of recodings performed for this frame
mfxU16 NumExtParam;
mfxExtBuffer** ExtParam;
} mfxBRCFrameParam;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxI32 QpY; // Frame-level Luma QP
#if (MFX_VERSION >= 1029)
mfxU32 InitialCpbRemovalDelay;
mfxU32 InitialCpbRemovalOffset;
mfxU32 reserved1[7];
mfxU32 MaxFrameSize; // Max frame size in bytes (used for rePak)
mfxU8 DeltaQP[8]; // deltaQP[i] is adding to QP value while i-rePak
mfxU16 MaxNumRepak; // Max number of rePak to provide MaxFrameSize (from 0 to 8)
mfxU16 NumExtParam;
mfxExtBuffer** ExtParam; // extension buffer list
#else
mfxU32 reserved1[13];
mfxHDL reserved2;
#endif
} mfxBRCFrameCtrl;
MFX_PACK_END()
/* BRCStatus */
enum {
MFX_BRC_OK = 0, // CodedFrameSize is acceptable, no further recoding/padding/skip required
MFX_BRC_BIG_FRAME = 1, // Coded frame is too big, recoding required
MFX_BRC_SMALL_FRAME = 2, // Coded frame is too small, recoding required
MFX_BRC_PANIC_BIG_FRAME = 3, // Coded frame is too big, no further recoding possible - skip frame
MFX_BRC_PANIC_SMALL_FRAME = 4 // Coded frame is too small, no further recoding possible - required padding to MinFrameSize
};
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU32 MinFrameSize; // Size in bytes, coded frame must be padded to when Status = MFX_BRC_PANIC_SMALL_FRAME
mfxU16 BRCStatus; // See BRCStatus enumerator
mfxU16 reserved[25];
mfxHDL reserved1;
} mfxBRCFrameStatus;
MFX_PACK_END()
/* Structure contains set of callbacks to perform external bit-rate control.
Can be attached to mfxVideoParam structure during encoder initialization.
Turn mfxExtCodingOption2::ExtBRC option ON to make encoder use external BRC instead of native one. */
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved[14];
mfxHDL pthis; // Pointer to user-defined BRC instance. Will be passed to each mfxExtBRC callback.
// Initialize BRC. Will be invoked during encoder Init(). In - pthis, par.
mfxStatus (MFX_CDECL *Init) (mfxHDL pthis, mfxVideoParam* par);
// Reset BRC. Will be invoked during encoder Reset(). In - pthis, par.
mfxStatus (MFX_CDECL *Reset) (mfxHDL pthis, mfxVideoParam* par);
// Close BRC. Will be invoked during encoder Close(). In - pthis.
mfxStatus (MFX_CDECL *Close) (mfxHDL pthis);
// Obtain from BRC controls required for frame encoding.
// Will be invoked BEFORE encoding of each frame. In - pthis, par; Out - ctrl.
mfxStatus (MFX_CDECL *GetFrameCtrl) (mfxHDL pthis, mfxBRCFrameParam* par, mfxBRCFrameCtrl* ctrl);
// Update BRC state and return command to continue/recode frame/do padding/skip frame.
// Will be invoked AFTER encoding of each frame. In - pthis, par, ctrl; Out - status.
mfxStatus (MFX_CDECL *Update) (mfxHDL pthis, mfxBRCFrameParam* par, mfxBRCFrameCtrl* ctrl, mfxBRCFrameStatus* status);
mfxHDL reserved1[10];
} mfxExtBRC;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

271
.github/actions/libmfx/include/mfx/mfxcamera.h vendored Normal file
View File

@ -0,0 +1,271 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXCAMERA_H__
#define __MFXCAMERA_H__
#include "mfxcommon.h"
#if !defined (__GNUC__)
#pragma warning(disable: 4201)
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Camera Extended Buffer Ids */
enum {
MFX_EXTBUF_CAM_GAMMA_CORRECTION = MFX_MAKEFOURCC('C','G','A','M'),
MFX_EXTBUF_CAM_WHITE_BALANCE = MFX_MAKEFOURCC('C','W','B','L'),
MFX_EXTBUF_CAM_HOT_PIXEL_REMOVAL = MFX_MAKEFOURCC('C','H','P','R'),
MFX_EXTBUF_CAM_BLACK_LEVEL_CORRECTION = MFX_MAKEFOURCC('C','B','L','C'),
MFX_EXTBUF_CAM_VIGNETTE_CORRECTION = MFX_MAKEFOURCC('C','V','G','T'),
MFX_EXTBUF_CAM_BAYER_DENOISE = MFX_MAKEFOURCC('C','D','N','S'),
MFX_EXTBUF_CAM_COLOR_CORRECTION_3X3 = MFX_MAKEFOURCC('C','C','3','3'),
MFX_EXTBUF_CAM_PADDING = MFX_MAKEFOURCC('C','P','A','D'),
MFX_EXTBUF_CAM_PIPECONTROL = MFX_MAKEFOURCC('C','P','P','C'),
MFX_EXTBUF_CAM_FORWARD_GAMMA_CORRECTION = MFX_MAKEFOURCC('C','F','G','C'),
MFX_EXTBUF_CAM_LENS_GEOM_DIST_CORRECTION = MFX_MAKEFOURCC('C','L','G','D'),
MFX_EXTBUF_CAM_3DLUT = MFX_MAKEFOURCC('C','L','U','T'),
MFX_EXTBUF_CAM_TOTAL_COLOR_CONTROL = MFX_MAKEFOURCC('C','T','C','C'),
MFX_EXTBUF_CAM_CSC_YUV_RGB = MFX_MAKEFOURCC('C','C','Y','R')
};
typedef enum {
MFX_CAM_GAMMA_VALUE = 0x0001,
MFX_CAM_GAMMA_LUT = 0x0002,
} mfxCamGammaParam;
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
mfxExtBuffer Header;
mfxU16 Mode;
mfxU16 reserved1;
mfxF64 GammaValue;
mfxU16 reserved2[3];
mfxU16 NumPoints;
mfxU16 GammaPoint[1024];
mfxU16 GammaCorrected[1024];
mfxU32 reserved3[4];
} mfxExtCamGammaCorrection;
MFX_PACK_END()
typedef enum {
MFX_CAM_WHITE_BALANCE_MANUAL = 0x0001,
MFX_CAM_WHITE_BALANCE_AUTO = 0x0002
} mfxCamWhiteBalanceMode;
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
mfxExtBuffer Header;
mfxU32 Mode;
mfxF64 R;
mfxF64 G0;
mfxF64 B;
mfxF64 G1;
mfxU32 reserved[8];
} mfxExtCamWhiteBalance;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 R;
mfxU16 G;
mfxU16 B;
mfxU16 C;
mfxU16 M;
mfxU16 Y;
mfxU16 reserved[6];
} mfxExtCamTotalColorControl;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxF32 PreOffset[3];
mfxF32 Matrix[3][3];
mfxF32 PostOffset[3];
mfxU16 reserved[30];
} mfxExtCamCscYuvRgb;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 PixelThresholdDifference;
mfxU16 PixelCountThreshold;
} mfxExtCamHotPixelRemoval;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 R;
mfxU16 G0;
mfxU16 B;
mfxU16 G1;
mfxU32 reserved[4];
} mfxExtCamBlackLevelCorrection;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU8 integer;
mfxU8 mantissa;
} mfxCamVignetteCorrectionElement;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxCamVignetteCorrectionElement R;
mfxCamVignetteCorrectionElement G0;
mfxCamVignetteCorrectionElement B;
mfxCamVignetteCorrectionElement G1;
} mfxCamVignetteCorrectionParam;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 Width;
mfxU32 Height;
mfxU32 Pitch;
mfxU32 reserved[7];
mfxCamVignetteCorrectionParam *CorrectionMap;
} mfxExtCamVignetteCorrection;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 Threshold;
mfxU16 reserved[27];
} mfxExtCamBayerDenoise;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
mfxExtBuffer Header;
mfxF64 CCM[3][3];
mfxU32 reserved[4];
} mfxExtCamColorCorrection3x3;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 Top;
mfxU16 Bottom;
mfxU16 Left;
mfxU16 Right;
mfxU32 reserved[4];
} mfxExtCamPadding;
MFX_PACK_END()
typedef enum {
MFX_CAM_BAYER_BGGR = 0x0000,
MFX_CAM_BAYER_RGGB = 0x0001,
MFX_CAM_BAYER_GBRG = 0x0002,
MFX_CAM_BAYER_GRBG = 0x0003
} mfxCamBayerFormat;
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 RawFormat;
mfxU16 reserved1;
mfxU32 reserved[5];
} mfxExtCamPipeControl;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct{
mfxU16 Pixel;
mfxU16 Red;
mfxU16 Green;
mfxU16 Blue;
} mfxCamFwdGammaSegment;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[19];
mfxU16 NumSegments;
union {
mfxCamFwdGammaSegment* Segment;
mfxU64 reserved1;
};
} mfxExtCamFwdGamma;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxF32 a[3]; // [R, G, B]
mfxF32 b[3]; // [R, G, B]
mfxF32 c[3]; // [R, G, B]
mfxF32 d[3]; // [R, G, B]
mfxU16 reserved[36];
} mfxExtCamLensGeomDistCorrection;
MFX_PACK_END()
/* LUTSize */
enum {
MFX_CAM_3DLUT17_SIZE = (17 * 17 * 17),
MFX_CAM_3DLUT33_SIZE = (33 * 33 * 33),
MFX_CAM_3DLUT65_SIZE = (65 * 65 * 65)
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU16 R;
mfxU16 G;
mfxU16 B;
mfxU16 Reserved;
} mfxCam3DLutEntry;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[10];
mfxU32 Size;
union
{
mfxCam3DLutEntry* Table;
mfxU64 reserved1;
};
} mfxExtCam3DLut;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif
#endif // __MFXCAMERA_H__

212
.github/actions/libmfx/include/mfx/mfxcommon.h vendored Normal file
View File

@ -0,0 +1,212 @@
// Copyright (c) 2018-2020 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.
#ifndef __MFXCOMMON_H__
#define __MFXCOMMON_H__
#include "mfxdefs.h"
#if !defined (__GNUC__)
#pragma warning(disable: 4201)
#endif
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#define MFX_MAKEFOURCC(A,B,C,D) ((((int)A))+(((int)B)<<8)+(((int)C)<<16)+(((int)D)<<24))
/* Extended Configuration Header Structure */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU32 BufferId;
mfxU32 BufferSz;
} mfxExtBuffer;
MFX_PACK_END()
/* Library initialization and deinitialization */
typedef mfxI32 mfxIMPL;
#define MFX_IMPL_BASETYPE(x) (0x00ff & (x))
enum {
MFX_IMPL_AUTO = 0x0000, /* Auto Selection/In or Not Supported/Out */
MFX_IMPL_SOFTWARE = 0x0001, /* Pure Software Implementation */
MFX_IMPL_HARDWARE = 0x0002, /* Hardware Accelerated Implementation (default device) */
MFX_IMPL_AUTO_ANY = 0x0003, /* Auto selection of any hardware/software implementation */
MFX_IMPL_HARDWARE_ANY = 0x0004, /* Auto selection of any hardware implementation */
MFX_IMPL_HARDWARE2 = 0x0005, /* Hardware accelerated implementation (2nd device) */
MFX_IMPL_HARDWARE3 = 0x0006, /* Hardware accelerated implementation (3rd device) */
MFX_IMPL_HARDWARE4 = 0x0007, /* Hardware accelerated implementation (4th device) */
MFX_IMPL_RUNTIME = 0x0008,
#if (MFX_VERSION >= MFX_VERSION_NEXT)
MFX_IMPL_SINGLE_THREAD= 0x0009,
#endif
MFX_IMPL_VIA_ANY = 0x0100,
MFX_IMPL_VIA_D3D9 = 0x0200,
MFX_IMPL_VIA_D3D11 = 0x0300,
MFX_IMPL_VIA_VAAPI = 0x0400,
MFX_IMPL_AUDIO = 0x8000,
#if (MFX_VERSION >= MFX_VERSION_NEXT)
MFX_IMPL_EXTERNAL_THREADING = 0x10000,
#endif
MFX_IMPL_UNSUPPORTED = 0x0000 /* One of the MFXQueryIMPL returns */
};
/* Version Info */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef union {
struct {
mfxU16 Minor;
mfxU16 Major;
};
mfxU32 Version;
} mfxVersion;
MFX_PACK_END()
/* session priority */
typedef enum
{
MFX_PRIORITY_LOW = 0,
MFX_PRIORITY_NORMAL = 1,
MFX_PRIORITY_HIGH = 2
} mfxPriority;
typedef struct _mfxEncryptedData mfxEncryptedData;
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct {
union {
struct {
mfxEncryptedData* EncryptedData;
mfxExtBuffer **ExtParam;
mfxU16 NumExtParam;
};
mfxU32 reserved[6];
};
mfxI64 DecodeTimeStamp;
mfxU64 TimeStamp;
mfxU8* Data;
mfxU32 DataOffset;
mfxU32 DataLength;
mfxU32 MaxLength;
mfxU16 PicStruct;
mfxU16 FrameType;
mfxU16 DataFlag;
mfxU16 reserved2;
} mfxBitstream;
MFX_PACK_END()
typedef struct _mfxSyncPoint *mfxSyncPoint;
/* GPUCopy */
enum {
MFX_GPUCOPY_DEFAULT = 0,
MFX_GPUCOPY_ON = 1,
MFX_GPUCOPY_OFF = 2
};
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxIMPL Implementation;
mfxVersion Version;
mfxU16 ExternalThreads;
union {
struct {
mfxExtBuffer **ExtParam;
mfxU16 NumExtParam;
};
mfxU16 reserved2[5];
};
mfxU16 GPUCopy;
mfxU16 reserved[21];
} mfxInitParam;
MFX_PACK_END()
enum {
MFX_EXTBUFF_THREADS_PARAM = MFX_MAKEFOURCC('T','H','D','P')
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 NumThread;
mfxI32 SchedulingType;
mfxI32 Priority;
mfxU16 reserved[55];
} mfxExtThreadsParam;
MFX_PACK_END()
/* PlatformCodeName */
enum {
MFX_PLATFORM_UNKNOWN = 0,
MFX_PLATFORM_SANDYBRIDGE = 1,
MFX_PLATFORM_IVYBRIDGE = 2,
MFX_PLATFORM_HASWELL = 3,
MFX_PLATFORM_BAYTRAIL = 4,
MFX_PLATFORM_BROADWELL = 5,
MFX_PLATFORM_CHERRYTRAIL = 6,
MFX_PLATFORM_SKYLAKE = 7,
MFX_PLATFORM_APOLLOLAKE = 8,
MFX_PLATFORM_KABYLAKE = 9,
#if (MFX_VERSION >= 1025)
MFX_PLATFORM_GEMINILAKE = 10,
MFX_PLATFORM_COFFEELAKE = 11,
MFX_PLATFORM_CANNONLAKE = 20,
#endif
#if (MFX_VERSION >= 1027)
MFX_PLATFORM_ICELAKE = 30,
#endif
MFX_PLATFORM_JASPERLAKE = 32,
MFX_PLATFORM_ELKHARTLAKE = 33,
MFX_PLATFORM_TIGERLAKE = 40,
MFX_PLATFORM_KEEMBAY = 50,
};
#if (MFX_VERSION >= 1031)
typedef enum
{
MFX_MEDIA_UNKNOWN = 0xffff,
MFX_MEDIA_INTEGRATED = 0,
MFX_MEDIA_DISCRETE = 1
} mfxMediaAdapterType;
#endif
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU16 CodeName;
mfxU16 DeviceId;
#if (MFX_VERSION >= 1031)
mfxU16 MediaAdapterType;
mfxU16 reserved[13];
#else
mfxU16 reserved[14];
#endif
} mfxPlatform;
MFX_PACK_END()
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

212
.github/actions/libmfx/include/mfx/mfxdefs.h vendored Normal file
View File

@ -0,0 +1,212 @@
// Copyright (c) 2019-2020 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.
#ifndef __MFXDEFS_H__
#define __MFXDEFS_H__
#define MFX_VERSION_MAJOR 1
#define MFX_VERSION_MINOR 34
// MFX_VERSION_NEXT is always +1 from last public release
// may be enforced by MFX_VERSION_USE_LATEST define
// if MFX_VERSION_USE_LATEST is defined MFX_VERSION is ignored
#define MFX_VERSION_NEXT (MFX_VERSION_MAJOR * 1000 + MFX_VERSION_MINOR + 1)
// MFX_VERSION - version of API that 'assumed' by build may be provided externally
// if it omitted then latest stable API derived from Major.Minor is assumed
#if !defined(MFX_VERSION)
#if defined(MFX_VERSION_USE_LATEST)
#define MFX_VERSION MFX_VERSION_NEXT
#else
#define MFX_VERSION (MFX_VERSION_MAJOR * 1000 + MFX_VERSION_MINOR)
#endif
#else
#undef MFX_VERSION_MINOR
#define MFX_VERSION_MINOR ((MFX_VERSION) % 1000)
#endif
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* In preprocessor syntax # symbol has stringize meaning,
so to expand some macro to preprocessor pragma we need to use
special compiler dependent construction */
#if defined(_MSC_VER)
#define MFX_PRAGMA_IMPL(x) __pragma(x)
#else
#define MFX_PRAGMA_IMPL(x) _Pragma(#x)
#endif
#define MFX_PACK_BEGIN_X(x) MFX_PRAGMA_IMPL(pack(push, x))
#define MFX_PACK_END() MFX_PRAGMA_IMPL(pack(pop))
/* The general rule for alignment is following:
- structures with pointers have 4/8 bytes alignment on 32/64 bit systems
- structures with fields of type mfxU64/mfxF64 (unsigned long long / double)
have alignment 8 bytes on 64 bit and 32 bit Windows, on Linux alignment is 4 bytes
- all the rest structures are 4 bytes aligned
- there are several exceptions: some structs which had 4-byte alignment were extended
with pointer / long type fields; such structs have 4-byte alignment to keep binary
compatibility with previously release API */
#define MFX_PACK_BEGIN_USUAL_STRUCT() MFX_PACK_BEGIN_X(4)
/* 64-bit LP64 data model */
#if defined(_WIN64) || defined(__LP64__)
#define MFX_PACK_BEGIN_STRUCT_W_PTR() MFX_PACK_BEGIN_X(8)
#define MFX_PACK_BEGIN_STRUCT_W_L_TYPE() MFX_PACK_BEGIN_X(8)
/* 32-bit ILP32 data model Windows (Intel architecture) */
#elif defined(_WIN32) || defined(_M_IX86) && !defined(__linux__)
#define MFX_PACK_BEGIN_STRUCT_W_PTR() MFX_PACK_BEGIN_X(4)
#define MFX_PACK_BEGIN_STRUCT_W_L_TYPE() MFX_PACK_BEGIN_X(8)
/* 32-bit ILP32 data model Linux */
#elif defined(__ILP32__)
#define MFX_PACK_BEGIN_STRUCT_W_PTR() MFX_PACK_BEGIN_X(4)
#define MFX_PACK_BEGIN_STRUCT_W_L_TYPE() MFX_PACK_BEGIN_X(4)
#else
#error Unknown packing
#endif
#define __INT64 long long
#define __UINT64 unsigned long long
#ifdef _WIN32
#define MFX_CDECL __cdecl
#define MFX_STDCALL __stdcall
#else
#define MFX_CDECL
#define MFX_STDCALL
#endif /* _WIN32 */
#define MFX_INFINITE 0xFFFFFFFF
typedef unsigned char mfxU8;
typedef char mfxI8;
typedef short mfxI16;
typedef unsigned short mfxU16;
typedef unsigned int mfxU32;
typedef int mfxI32;
#if defined( _WIN32 ) || defined ( _WIN64 )
typedef unsigned long mfxUL32;
typedef long mfxL32;
#else
typedef unsigned int mfxUL32;
typedef int mfxL32;
#endif
typedef float mfxF32;
typedef double mfxF64;
typedef __UINT64 mfxU64;
typedef __INT64 mfxI64;
typedef void* mfxHDL;
typedef mfxHDL mfxMemId;
typedef void* mfxThreadTask;
typedef char mfxChar;
typedef struct {
mfxI16 x;
mfxI16 y;
} mfxI16Pair;
typedef struct {
mfxHDL first;
mfxHDL second;
} mfxHDLPair;
/*********************************************************************************\
Error message
\*********************************************************************************/
typedef enum
{
/* no error */
MFX_ERR_NONE = 0, /* no error */
/* reserved for unexpected errors */
MFX_ERR_UNKNOWN = -1, /* unknown error. */
/* error codes <0 */
MFX_ERR_NULL_PTR = -2, /* null pointer */
MFX_ERR_UNSUPPORTED = -3, /* undeveloped feature */
MFX_ERR_MEMORY_ALLOC = -4, /* failed to allocate memory */
MFX_ERR_NOT_ENOUGH_BUFFER = -5, /* insufficient buffer at input/output */
MFX_ERR_INVALID_HANDLE = -6, /* invalid handle */
MFX_ERR_LOCK_MEMORY = -7, /* failed to lock the memory block */
MFX_ERR_NOT_INITIALIZED = -8, /* member function called before initialization */
MFX_ERR_NOT_FOUND = -9, /* the specified object is not found */
MFX_ERR_MORE_DATA = -10, /* expect more data at input */
MFX_ERR_MORE_SURFACE = -11, /* expect more surface at output */
MFX_ERR_ABORTED = -12, /* operation aborted */
MFX_ERR_DEVICE_LOST = -13, /* lose the HW acceleration device */
MFX_ERR_INCOMPATIBLE_VIDEO_PARAM = -14, /* incompatible video parameters */
MFX_ERR_INVALID_VIDEO_PARAM = -15, /* invalid video parameters */
MFX_ERR_UNDEFINED_BEHAVIOR = -16, /* undefined behavior */
MFX_ERR_DEVICE_FAILED = -17, /* device operation failure */
MFX_ERR_MORE_BITSTREAM = -18, /* expect more bitstream buffers at output */
MFX_ERR_INCOMPATIBLE_AUDIO_PARAM = -19, /* incompatible audio parameters */
MFX_ERR_INVALID_AUDIO_PARAM = -20, /* invalid audio parameters */
MFX_ERR_GPU_HANG = -21, /* device operation failure caused by GPU hang */
MFX_ERR_REALLOC_SURFACE = -22, /* bigger output surface required */
/* warnings >0 */
MFX_WRN_IN_EXECUTION = 1, /* the previous asynchronous operation is in execution */
MFX_WRN_DEVICE_BUSY = 2, /* the HW acceleration device is busy */
MFX_WRN_VIDEO_PARAM_CHANGED = 3, /* the video parameters are changed during decoding */
MFX_WRN_PARTIAL_ACCELERATION = 4, /* SW is used */
MFX_WRN_INCOMPATIBLE_VIDEO_PARAM = 5, /* incompatible video parameters */
MFX_WRN_VALUE_NOT_CHANGED = 6, /* the value is saturated based on its valid range */
MFX_WRN_OUT_OF_RANGE = 7, /* the value is out of valid range */
MFX_WRN_FILTER_SKIPPED = 10, /* one of requested filters has been skipped */
MFX_WRN_INCOMPATIBLE_AUDIO_PARAM = 11, /* incompatible audio parameters */
#if MFX_VERSION >= 1031
/* low-delay partial output */
MFX_ERR_NONE_PARTIAL_OUTPUT = 12, /* frame is not ready, but bitstream contains partial output */
#endif
/* threading statuses */
MFX_TASK_DONE = MFX_ERR_NONE, /* task has been completed */
MFX_TASK_WORKING = 8, /* there is some more work to do */
MFX_TASK_BUSY = 9, /* task is waiting for resources */
/* plug-in statuses */
MFX_ERR_MORE_DATA_SUBMIT_TASK = -10000, /* return MFX_ERR_MORE_DATA but submit internal asynchronous task */
} mfxStatus;
// Application
#if defined(MFX_DISPATCHER_EXPOSED_PREFIX)
#include "mfxdispatcherprefixedfunctions.h"
#endif // MFX_DISPATCHER_EXPOSED_PREFIX
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __MFXDEFS_H__ */

145
.github/actions/libmfx/include/mfx/mfxdispatcherprefixedfunctions.h vendored Normal file
View File

@ -0,0 +1,145 @@
// Copyright (c) 2017 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.
#ifndef __MFXDISPATCHERPREFIXEDFUNCTIONS_H__
#define __MFXDISPATCHERPREFIXEDFUNCTIONS_H__
// API 1.0 functions
#define MFXInit disp_MFXInit
#define MFXClose disp_MFXClose
#define MFXQueryIMPL disp_MFXQueryIMPL
#define MFXQueryVersion disp_MFXQueryVersion
#define MFXJoinSession disp_MFXJoinSession
#define MFXDisjoinSession disp_MFXDisjoinSession
#define MFXCloneSession disp_MFXCloneSession
#define MFXSetPriority disp_MFXSetPriority
#define MFXGetPriority disp_MFXGetPriority
#define MFXVideoCORE_SetBufferAllocator disp_MFXVideoCORE_SetBufferAllocator
#define MFXVideoCORE_SetFrameAllocator disp_MFXVideoCORE_SetFrameAllocator
#define MFXVideoCORE_SetHandle disp_MFXVideoCORE_SetHandle
#define MFXVideoCORE_GetHandle disp_MFXVideoCORE_GetHandle
#define MFXVideoCORE_SyncOperation disp_MFXVideoCORE_SyncOperation
#define MFXVideoENCODE_Query disp_MFXVideoENCODE_Query
#define MFXVideoENCODE_QueryIOSurf disp_MFXVideoENCODE_QueryIOSurf
#define MFXVideoENCODE_Init disp_MFXVideoENCODE_Init
#define MFXVideoENCODE_Reset disp_MFXVideoENCODE_Reset
#define MFXVideoENCODE_Close disp_MFXVideoENCODE_Close
#define MFXVideoENCODE_GetVideoParam disp_MFXVideoENCODE_GetVideoParam
#define MFXVideoENCODE_GetEncodeStat disp_MFXVideoENCODE_GetEncodeStat
#define MFXVideoENCODE_EncodeFrameAsync disp_MFXVideoENCODE_EncodeFrameAsync
#define MFXVideoDECODE_Query disp_MFXVideoDECODE_Query
#define MFXVideoDECODE_DecodeHeader disp_MFXVideoDECODE_DecodeHeader
#define MFXVideoDECODE_QueryIOSurf disp_MFXVideoDECODE_QueryIOSurf
#define MFXVideoDECODE_Init disp_MFXVideoDECODE_Init
#define MFXVideoDECODE_Reset disp_MFXVideoDECODE_Reset
#define MFXVideoDECODE_Close disp_MFXVideoDECODE_Close
#define MFXVideoDECODE_GetVideoParam disp_MFXVideoDECODE_GetVideoParam
#define MFXVideoDECODE_GetDecodeStat disp_MFXVideoDECODE_GetDecodeStat
#define MFXVideoDECODE_SetSkipMode disp_MFXVideoDECODE_SetSkipMode
#define MFXVideoDECODE_GetPayload disp_MFXVideoDECODE_GetPayload
#define MFXVideoDECODE_DecodeFrameAsync disp_MFXVideoDECODE_DecodeFrameAsync
#define MFXVideoVPP_Query disp_MFXVideoVPP_Query
#define MFXVideoVPP_QueryIOSurf disp_MFXVideoVPP_QueryIOSurf
#define MFXVideoVPP_Init disp_MFXVideoVPP_Init
#define MFXVideoVPP_Reset disp_MFXVideoVPP_Reset
#define MFXVideoVPP_Close disp_MFXVideoVPP_Close
#define MFXVideoVPP_GetVideoParam disp_MFXVideoVPP_GetVideoParam
#define MFXVideoVPP_GetVPPStat disp_MFXVideoVPP_GetVPPStat
#define MFXVideoVPP_RunFrameVPPAsync disp_MFXVideoVPP_RunFrameVPPAsync
// API 1.1 functions
#define MFXVideoUSER_Register disp_MFXVideoUSER_Register
#define MFXVideoUSER_Unregister disp_MFXVideoUSER_Unregister
#define MFXVideoUSER_ProcessFrameAsync disp_MFXVideoUSER_ProcessFrameAsync
// API 1.10 functions
#define MFXVideoENC_Query disp_MFXVideoENC_Query
#define MFXVideoENC_QueryIOSurf disp_MFXVideoENC_QueryIOSurf
#define MFXVideoENC_Init disp_MFXVideoENC_Init
#define MFXVideoENC_Reset disp_MFXVideoENC_Reset
#define MFXVideoENC_Close disp_MFXVideoENC_Close
#define MFXVideoENC_ProcessFrameAsync disp_MFXVideoENC_ProcessFrameAsync
#define MFXVideoVPP_RunFrameVPPAsyncEx disp_MFXVideoVPP_RunFrameVPPAsyncEx
#define MFXVideoUSER_Load disp_MFXVideoUSER_Load
#define MFXVideoUSER_UnLoad disp_MFXVideoUSER_UnLoad
// API 1.11 functions
#define MFXVideoPAK_Query disp_MFXVideoPAK_Query
#define MFXVideoPAK_QueryIOSurf disp_MFXVideoPAK_QueryIOSurf
#define MFXVideoPAK_Init disp_MFXVideoPAK_Init
#define MFXVideoPAK_Reset disp_MFXVideoPAK_Reset
#define MFXVideoPAK_Close disp_MFXVideoPAK_Close
#define MFXVideoPAK_ProcessFrameAsync disp_MFXVideoPAK_ProcessFrameAsync
// API 1.13 functions
#define MFXVideoUSER_LoadByPath disp_MFXVideoUSER_LoadByPath
// API 1.14 functions
#define MFXInitEx disp_MFXInitEx
#define MFXDoWork disp_MFXDoWork
// Audio library functions
// API 1.8 functions
#define MFXAudioCORE_SyncOperation disp_MFXAudioCORE_SyncOperation
#define MFXAudioENCODE_Query disp_MFXAudioENCODE_Query
#define MFXAudioENCODE_QueryIOSize disp_MFXAudioENCODE_QueryIOSize
#define MFXAudioENCODE_Init disp_MFXAudioENCODE_Init
#define MFXAudioENCODE_Reset disp_MFXAudioENCODE_Reset
#define MFXAudioENCODE_Close disp_MFXAudioENCODE_Close
#define MFXAudioENCODE_GetAudioParam disp_MFXAudioENCODE_GetAudioParam
#define MFXAudioENCODE_EncodeFrameAsync disp_MFXAudioENCODE_EncodeFrameAsync
#define MFXAudioDECODE_Query disp_MFXAudioDECODE_Query
#define MFXAudioDECODE_DecodeHeader disp_MFXAudioDECODE_DecodeHeader
#define MFXAudioDECODE_Init disp_MFXAudioDECODE_Init
#define MFXAudioDECODE_Reset disp_MFXAudioDECODE_Reset
#define MFXAudioDECODE_Close disp_MFXAudioDECODE_Close
#define MFXAudioDECODE_QueryIOSize disp_MFXAudioDECODE_QueryIOSize
#define MFXAudioDECODE_GetAudioParam disp_MFXAudioDECODE_GetAudioParam
#define MFXAudioDECODE_DecodeFrameAsync disp_MFXAudioDECODE_DecodeFrameAsync
// API 1.9 functions
#define MFXAudioUSER_Register disp_MFXAudioUSER_Register
#define MFXAudioUSER_Unregister disp_MFXAudioUSER_Unregister
#define MFXAudioUSER_ProcessFrameAsync disp_MFXAudioUSER_ProcessFrameAsync
#define MFXAudioUSER_Load disp_MFXAudioUSER_Load
#define MFXAudioUSER_UnLoad disp_MFXAudioUSER_UnLoad
// API 1.19 functions
#define MFXVideoENC_GetVideoParam disp_MFXVideoENC_GetVideoParam
#define MFXVideoPAK_GetVideoParam disp_MFXVideoPAK_GetVideoParam
#define MFXVideoCORE_QueryPlatform disp_MFXVideoCORE_QueryPlatform
#define MFXVideoUSER_GetPlugin disp_MFXVideoUSER_GetPlugin
#endif

74
.github/actions/libmfx/include/mfx/mfxenc.h vendored Normal file
View File

@ -0,0 +1,74 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXENC_H__
#define __MFXENC_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct _mfxENCInput{
mfxU32 reserved[32];
mfxFrameSurface1 *InSurface;
mfxU16 NumFrameL0;
mfxFrameSurface1 **L0Surface;
mfxU16 NumFrameL1;
mfxFrameSurface1 **L1Surface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxENCInput;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct _mfxENCOutput{
mfxU32 reserved[32];
mfxFrameSurface1 *OutSurface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxENCOutput;
MFX_PACK_END()
mfxStatus MFX_CDECL MFXVideoENC_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoENC_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoENC_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENC_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENC_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoENC_ProcessFrameAsync(mfxSession session, mfxENCInput *in, mfxENCOutput *out, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXVideoENC_GetVideoParam(mfxSession session, mfxVideoParam *par);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

583
.github/actions/libmfx/include/mfx/mfxfei.h vendored Normal file
View File

@ -0,0 +1,583 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXFEI_H__
#define __MFXFEI_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#include "mfxpak.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU16 Qp;
mfxU16 LenSP;
mfxU16 SearchPath;
mfxU16 SubMBPartMask;
mfxU16 SubPelMode;
mfxU16 InterSAD;
mfxU16 IntraSAD;
mfxU16 AdaptiveSearch;
mfxU16 MVPredictor;
mfxU16 MBQp;
mfxU16 FTEnable;
mfxU16 IntraPartMask;
mfxU16 RefWidth;
mfxU16 RefHeight;
mfxU16 SearchWindow;
mfxU16 DisableMVOutput;
mfxU16 DisableStatisticsOutput;
mfxU16 Enable8x8Stat;
mfxU16 PictureType; /* Input picture type*/
mfxU16 DownsampleInput;
mfxU16 RefPictureType[2]; /* reference picture type, 0 -L0, 1 - L1 */
mfxU16 DownsampleReference[2];
mfxFrameSurface1 *RefFrame[2];
mfxU16 reserved[28];
} mfxExtFeiPreEncCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc; /* size of allocated memory in number of macroblocks */
mfxU16 reserved2[20];
struct mfxExtFeiPreEncMVPredictorsMB {
mfxI16Pair MV[2]; /* 0 for L0 and 1 for L1 */
} *MB;
} mfxExtFeiPreEncMVPredictors;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
mfxU8 *MB;
} mfxExtFeiEncQP;
MFX_PACK_END()
/* PreENC output */
/* Layout is exactly the same as mfxExtFeiEncMVs, this buffer may be removed in future */
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
struct mfxExtFeiPreEncMVMB {
mfxI16Pair MV[16][2];
} *MB;
} mfxExtFeiPreEncMV;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
struct mfxExtFeiPreEncMBStatMB {
struct mfxExtFeiPreEncMBStatMBInter {
mfxU16 BestDistortion;
mfxU16 Mode ;
} Inter[2]; /*0 -L0, 1 - L1*/
mfxU16 BestIntraDistortion;
mfxU16 IntraMode ;
mfxU16 NumOfNonZeroCoef;
mfxU16 reserved1;
mfxU32 SumOfCoef;
mfxU32 reserved2;
mfxU32 Variance16x16;
mfxU32 Variance8x8[4];
mfxU32 PixelAverage16x16;
mfxU32 PixelAverage8x8[4];
} *MB;
} mfxExtFeiPreEncMBStat;
MFX_PACK_END()
/* 1 ENC_PAK input */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 SearchPath;
mfxU16 LenSP;
mfxU16 SubMBPartMask;
mfxU16 IntraPartMask;
mfxU16 MultiPredL0;
mfxU16 MultiPredL1;
mfxU16 SubPelMode;
mfxU16 InterSAD;
mfxU16 IntraSAD;
mfxU16 DistortionType;
mfxU16 RepartitionCheckEnable;
mfxU16 AdaptiveSearch;
mfxU16 MVPredictor;
mfxU16 NumMVPredictors[2];
mfxU16 PerMBQp;
mfxU16 PerMBInput;
mfxU16 MBSizeCtrl;
mfxU16 RefWidth;
mfxU16 RefHeight;
mfxU16 SearchWindow;
mfxU16 ColocatedMbDistortion;
mfxU16 reserved[38];
} mfxExtFeiEncFrameCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
struct mfxExtFeiEncMVPredictorsMB {
struct mfxExtFeiEncMVPredictorsMBRefIdx{
mfxU8 RefL0: 4;
mfxU8 RefL1: 4;
} RefIdx[4]; /* index is predictor number */
mfxU32 reserved;
mfxI16Pair MV[4][2]; /* first index is predictor number, second is 0 for L0 and 1 for L1 */
} *MB;
} mfxExtFeiEncMVPredictors;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
struct mfxExtFeiEncMBCtrlMB {
mfxU32 ForceToIntra : 1;
mfxU32 ForceToSkip : 1;
mfxU32 ForceToNoneSkip : 1;
#if (MFX_VERSION >= 1025)
mfxU32 DirectBiasAdjustment : 1;
mfxU32 GlobalMotionBiasAdjustment : 1;
mfxU32 MVCostScalingFactor : 3;
mfxU32 reserved1 : 24;
#else
mfxU32 reserved1 : 29;
#endif
mfxU32 reserved2;
mfxU32 reserved3;
mfxU32 reserved4 : 16;
mfxU32 TargetSizeInWord : 8;
mfxU32 MaxSizeInWord : 8;
} *MB;
} mfxExtFeiEncMBCtrl;
MFX_PACK_END()
/* 1 ENC_PAK output */
/* Buffer holds 32 MVs per MB. MVs are located in zigzag scan order.
Number in diagram below shows location of MV in memory.
For example, MV for right top 4x4 sub block is stored in 5-th element of the array.
========================
|| 00 | 01 || 04 | 05 ||
------------------------
|| 02 | 03 || 06 | 07 ||
========================
|| 08 | 09 || 12 | 13 ||
------------------------
|| 10 | 11 || 14 | 15 ||
========================
*/
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
struct mfxExtFeiEncMVMB {
mfxI16Pair MV[16][2]; /* first index is block (4x4 pixels) number, second is 0 for L0 and 1 for L1 */
} *MB;
} mfxExtFeiEncMV;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
struct mfxExtFeiEncMBStatMB {
mfxU16 InterDistortion[16];
mfxU16 BestInterDistortion;
mfxU16 BestIntraDistortion;
mfxU16 ColocatedMbDistortion;
mfxU16 reserved;
mfxU32 reserved1[2];
} *MB;
} mfxExtFeiEncMBStat;
MFX_PACK_END()
enum {
MFX_PAK_OBJECT_HEADER = 0x7149000A
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
/* dword 0-2 */
mfxU32 Header; /* MFX_PAK_OBJECT_HEADER */
mfxU32 MVDataLength;
mfxU32 MVDataOffset;
/* dword 3 */
mfxU32 InterMbMode : 2;
mfxU32 MBSkipFlag : 1;
mfxU32 Reserved00 : 1;
mfxU32 IntraMbMode : 2;
mfxU32 Reserved01 : 1;
mfxU32 FieldMbPolarityFlag : 1;
mfxU32 MbType : 5;
mfxU32 IntraMbFlag : 1;
mfxU32 FieldMbFlag : 1;
mfxU32 Transform8x8Flag : 1;
mfxU32 Reserved02 : 1;
mfxU32 DcBlockCodedCrFlag : 1;
mfxU32 DcBlockCodedCbFlag : 1;
mfxU32 DcBlockCodedYFlag : 1;
mfxU32 MVFormat : 3; /* layout and number of MVs, 0 - no MVs, 6 - 32 MVs, the rest are reserved */
mfxU32 Reserved03 : 8;
mfxU32 ExtendedFormat : 1; /* should be 1, specifies that LumaIntraPredModes and RefIdx are replicated for 8x8 and 4x4 block/subblock */
/* dword 4 */
mfxU8 HorzOrigin;
mfxU8 VertOrigin;
mfxU16 CbpY;
/* dword 5 */
mfxU16 CbpCb;
mfxU16 CbpCr;
/* dword 6 */
mfxU32 QpPrimeY : 8;
mfxU32 Reserved30 :17;
mfxU32 MbSkipConvDisable : 1;
mfxU32 IsLastMB : 1;
mfxU32 EnableCoefficientClamp : 1;
mfxU32 Direct8x8Pattern : 4;
union {
struct {/* Intra MBs */
/* dword 7-8 */
mfxU16 LumaIntraPredModes[4];
/* dword 9 */
mfxU32 ChromaIntraPredMode : 2;
mfxU32 IntraPredAvailFlags : 6;
mfxU32 Reserved60 : 24;
} IntraMB;
struct {/* Inter MBs */
/*dword 7 */
mfxU8 SubMbShapes;
mfxU8 SubMbPredModes;
mfxU16 Reserved40;
/* dword 8-9 */
mfxU8 RefIdx[2][4]; /* first index is 0 for L0 and 1 for L1 */
} InterMB;
};
/* dword 10 */
mfxU16 Reserved70;
mfxU8 TargetSizeInWord;
mfxU8 MaxSizeInWord;
mfxU32 reserved2[5];
}mfxFeiPakMBCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 reserved2[20];
mfxFeiPakMBCtrl *MB;
} mfxExtFeiPakMBCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU32 MaxFrameSize; /* in bytes */
mfxU32 NumPasses; /* up to 8 */
mfxU16 reserved[8];
mfxU8 DeltaQP[8]; /* list of delta QPs, only positive values */
} mfxExtFeiRepackCtrl;
MFX_PACK_END()
#if (MFX_VERSION >= 1025)
/* FEI repack status */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU32 NumPasses;
mfxU16 reserved[58];
} mfxExtFeiRepackStat;
MFX_PACK_END()
#endif
/* 1 decode stream out */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
/* dword 0 */
mfxU32 InterMbMode : 2;
mfxU32 MBSkipFlag : 1;
mfxU32 Reserved00 : 1;
mfxU32 IntraMbMode : 2;
mfxU32 Reserved01 : 1;
mfxU32 FieldMbPolarityFlag : 1;
mfxU32 MbType : 5;
mfxU32 IntraMbFlag : 1;
mfxU32 FieldMbFlag : 1;
mfxU32 Transform8x8Flag : 1;
mfxU32 Reserved02 : 1;
mfxU32 DcBlockCodedCrFlag : 1;
mfxU32 DcBlockCodedCbFlag : 1;
mfxU32 DcBlockCodedYFlag : 1;
mfxU32 Reserved03 :12;
/* dword 1 */
mfxU16 HorzOrigin;
mfxU16 VertOrigin;
/* dword 2 */
mfxU32 CbpY :16;
mfxU32 CbpCb : 4;
mfxU32 CbpCr : 4;
mfxU32 Reserved20 : 6;
mfxU32 IsLastMB : 1;
mfxU32 ConcealMB : 1;
/* dword 3 */
mfxU32 QpPrimeY : 7;
mfxU32 Reserved30 : 1;
mfxU32 Reserved31 : 8;
mfxU32 NzCoeffCount : 9;
mfxU32 Reserved32 : 3;
mfxU32 Direct8x8Pattern : 4;
/* dword 4-6 */
union {
struct {/* Intra MBs */
/* dword 4-5 */
mfxU16 LumaIntraPredModes[4];
/* dword 6 */
mfxU32 ChromaIntraPredMode : 2;
mfxU32 IntraPredAvailFlags : 6;
mfxU32 Reserved60 : 24;
} IntraMB;
struct {/* Inter MBs */
/* dword 4 */
mfxU8 SubMbShapes;
mfxU8 SubMbPredModes;
mfxU16 Reserved40;
/* dword 5-6 */
mfxU8 RefIdx[2][4]; /* first index is 0 for L0 and 1 for L1 */
} InterMB;
};
/* dword 7 */
mfxU32 Reserved70;
/* dword 8-15 */
mfxI16Pair MV[4][2]; /* L0 - 0, L1 - 1 */
}mfxFeiDecStreamOutMBCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[3];
mfxU32 NumMBAlloc;
mfxU16 RemapRefIdx; /* tri-state option, default is OFF */
mfxU16 PicStruct;
mfxU16 reserved2[18];
mfxFeiDecStreamOutMBCtrl *MB;
} mfxExtFeiDecStreamOut;
MFX_PACK_END()
/* SPS, PPS, Slice Header */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 SPSId;
mfxU16 PicOrderCntType;
mfxU16 Log2MaxPicOrderCntLsb;
mfxU16 reserved[121];
} mfxExtFeiSPS;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 SPSId;
mfxU16 PPSId;
mfxU16 PictureType;
mfxU16 FrameType;
mfxU16 PicInitQP;
mfxU16 NumRefIdxL0Active;
mfxU16 NumRefIdxL1Active;
mfxI16 ChromaQPIndexOffset;
mfxI16 SecondChromaQPIndexOffset;
mfxU16 Transform8x8ModeFlag;
mfxU16 reserved[114];
struct mfxExtFeiPpsDPB {
mfxU16 Index; /* index in mfxPAKInput::L0Surface array */
mfxU16 PicType;
mfxI32 FrameNumWrap;
mfxU16 LongTermFrameIdx;
mfxU16 reserved[3];
} DpbBefore[16], DpbAfter[16];
} mfxExtFeiPPS;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU16 NumSlice; /* actual number of slices in the picture */
mfxU16 reserved[11];
struct mfxSlice{
mfxU16 MBAddress;
mfxU16 NumMBs;
mfxU16 SliceType;
mfxU16 PPSId;
mfxU16 IdrPicId;
mfxU16 CabacInitIdc;
mfxU16 NumRefIdxL0Active;
mfxU16 NumRefIdxL1Active;
mfxI16 SliceQPDelta;
mfxU16 DisableDeblockingFilterIdc;
mfxI16 SliceAlphaC0OffsetDiv2;
mfxI16 SliceBetaOffsetDiv2;
mfxU16 reserved[20];
struct mfxSliceRef{
mfxU16 PictureType;
mfxU16 Index;
mfxU16 reserved[2];
} RefL0[32], RefL1[32]; /* index in mfxPAKInput::L0Surface array */
} *Slice;
}mfxExtFeiSliceHeader;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 DisableHME; /* 0 - enable, any other value means disable */
mfxU16 DisableSuperHME;
mfxU16 DisableUltraHME;
mfxU16 reserved[57];
} mfxExtFeiCodingOption;
MFX_PACK_END()
/* 1 functions */
typedef enum {
MFX_FEI_FUNCTION_PREENC =1,
MFX_FEI_FUNCTION_ENCODE =2,
MFX_FEI_FUNCTION_ENC =3,
MFX_FEI_FUNCTION_PAK =4,
MFX_FEI_FUNCTION_DEC =5,
} mfxFeiFunction;
enum {
MFX_EXTBUFF_FEI_PARAM = MFX_MAKEFOURCC('F','E','P','R'),
MFX_EXTBUFF_FEI_PREENC_CTRL = MFX_MAKEFOURCC('F','P','C','T'),
MFX_EXTBUFF_FEI_PREENC_MV_PRED = MFX_MAKEFOURCC('F','P','M','P'),
MFX_EXTBUFF_FEI_PREENC_MV = MFX_MAKEFOURCC('F','P','M','V'),
MFX_EXTBUFF_FEI_PREENC_MB = MFX_MAKEFOURCC('F','P','M','B'),
MFX_EXTBUFF_FEI_ENC_CTRL = MFX_MAKEFOURCC('F','E','C','T'),
MFX_EXTBUFF_FEI_ENC_MV_PRED = MFX_MAKEFOURCC('F','E','M','P'),
MFX_EXTBUFF_FEI_ENC_QP = MFX_MAKEFOURCC('F','E','Q','P'),
MFX_EXTBUFF_FEI_ENC_MV = MFX_MAKEFOURCC('F','E','M','V'),
MFX_EXTBUFF_FEI_ENC_MB = MFX_MAKEFOURCC('F','E','M','B'),
MFX_EXTBUFF_FEI_ENC_MB_STAT = MFX_MAKEFOURCC('F','E','S','T'),
MFX_EXTBUFF_FEI_PAK_CTRL = MFX_MAKEFOURCC('F','K','C','T'),
MFX_EXTBUFF_FEI_SPS = MFX_MAKEFOURCC('F','S','P','S'),
MFX_EXTBUFF_FEI_PPS = MFX_MAKEFOURCC('F','P','P','S'),
MFX_EXTBUFF_FEI_SLICE = MFX_MAKEFOURCC('F','S','L','C'),
MFX_EXTBUFF_FEI_CODING_OPTION = MFX_MAKEFOURCC('F','C','D','O'),
MFX_EXTBUFF_FEI_DEC_STREAM_OUT = MFX_MAKEFOURCC('F','D','S','O'),
MFX_EXTBUFF_FEI_REPACK_CTRL = MFX_MAKEFOURCC('F','E','R','P'),
#if (MFX_VERSION >= 1025)
MFX_EXTBUFF_FEI_REPACK_STAT = MFX_MAKEFOURCC('F','E','R','S')
#endif
};
/* should be attached to mfxVideoParam during initialization to indicate FEI function */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxFeiFunction Func;
mfxU16 SingleFieldProcessing;
mfxU16 reserved[57];
} mfxExtFeiParam;
MFX_PACK_END()
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif

290
.github/actions/libmfx/include/mfx/mfxfeihevc.h vendored Normal file
View File

@ -0,0 +1,290 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXFEIHEVC_H__
#define __MFXFEIHEVC_H__
#include "mfxcommon.h"
#ifdef __cplusplus
extern "C"
{
#endif
#if (MFX_VERSION >= 1027)
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 SearchPath;
mfxU16 LenSP;
mfxU16 RefWidth;
mfxU16 RefHeight;
mfxU16 SearchWindow;
mfxU16 NumMvPredictors[2]; /* 0 for L0 and 1 for L1 */
mfxU16 MultiPred[2]; /* 0 for L0 and 1 for L1 */
mfxU16 SubPelMode;
mfxU16 AdaptiveSearch;
mfxU16 MVPredictor;
mfxU16 PerCuQp;
mfxU16 PerCtuInput;
mfxU16 ForceCtuSplit;
mfxU16 NumFramePartitions;
mfxU16 FastIntraMode;
mfxU16 reserved0[107];
} mfxExtFeiHevcEncFrameCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
struct {
mfxU8 RefL0 : 4;
mfxU8 RefL1 : 4;
} RefIdx[4]; /* index is predictor number */
mfxU32 BlockSize : 2;
mfxU32 reserved0 : 30;
mfxI16Pair MV[4][2]; /* first index is predictor number, second is 0 for L0 and 1 for L1 */
} mfxFeiHevcEncMVPredictors;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 VaBufferID;
mfxU32 Pitch;
mfxU32 Height;
mfxU16 reserved0[54];
mfxFeiHevcEncMVPredictors *Data;
} mfxExtFeiHevcEncMVPredictors;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 VaBufferID;
mfxU32 Pitch;
mfxU32 Height;
mfxU16 reserved[6];
mfxU8 *Data;
} mfxExtFeiHevcEncQP;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU32 ForceToIntra : 1;
mfxU32 ForceToInter : 1;
mfxU32 reserved0 : 30;
mfxU32 reserved1[3];
} mfxFeiHevcEncCtuCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 VaBufferID;
mfxU32 Pitch;
mfxU32 Height;
mfxU16 reserved0[54];
mfxFeiHevcEncCtuCtrl *Data;
} mfxExtFeiHevcEncCtuCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU32 MaxFrameSize; /* in bytes */
mfxU32 NumPasses; /* up to 8 */
mfxU16 reserved[8];
mfxU8 DeltaQP[8]; /* list of delta QPs, only positive values */
} mfxExtFeiHevcRepackCtrl;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU32 NumPasses;
mfxU16 reserved[58];
} mfxExtFeiHevcRepackStat;
MFX_PACK_END()
#if MFX_VERSION >= MFX_VERSION_NEXT
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
/* DWORD 0 */
mfxU32 reserved0;
/* DWORD 1 */
mfxU32 SplitLevel2Part0 : 4;
mfxU32 SplitLevel2Part1 : 4;
mfxU32 SplitLevel2Part2 : 4;
mfxU32 SplitLevel2Part3 : 4;
mfxU32 SplitLevel1 : 4;
mfxU32 SplitLevel0 : 1;
mfxU32 reserved10 : 3;
mfxU32 CuCountMinus1 : 6;
mfxU32 LastCtuOfTileFlag : 1;
mfxU32 LastCtuOfSliceFlag : 1;
/* DWORD 2 */
mfxU32 CtuAddrX : 16;
mfxU32 CtuAddrY : 16;
/* DWORD 3 */
mfxU32 reserved3;
} mfxFeiHevcPakCtuRecordV0;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 VaBufferID;
mfxU32 Pitch;
mfxU32 Height;
mfxU16 reserved0[54];
mfxFeiHevcPakCtuRecordV0 *Data;
} mfxExtFeiHevcPakCtuRecordV0;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
/* DWORD 0 */
mfxU32 CuSize : 2;
mfxU32 PredMode : 1;
mfxU32 TransquantBypass : 1;
mfxU32 PartMode : 3;
mfxU32 IpcmEnable : 1;
mfxU32 IntraChromaMode : 3;
mfxU32 ZeroOutCoeffs : 1;
mfxU32 reserved00 : 4;
mfxU32 Qp : 7;
mfxU32 QpSign : 1;
mfxU32 InterpredIdc : 8;
/* DWORD 1 */
mfxU32 IntraMode0 : 6;
mfxU32 reserved10 : 2;
mfxU32 IntraMode1 : 6;
mfxU32 reserved11 : 2;
mfxU32 IntraMode2 : 6;
mfxU32 reserved12 : 2;
mfxU32 IntraMode3 : 6;
mfxU32 reserved13 : 2;
/* DWORD 2-9 */
struct {
mfxI16 x[4];
mfxI16 y[4];
} MVs[2]; /* 0-L0, 1-L1 */
/* DWORD 10 */
struct{
mfxU16 Ref0 : 4;
mfxU16 Ref1 : 4;
mfxU16 Ref2 : 4;
mfxU16 Ref3 : 4;
} RefIdx[2]; /* 0-L0, 1-L1 */
/* DWORD 11 */
mfxU32 TuSize;
/* DWORD 12 */
mfxU32 TransformSkipY : 16;
mfxU32 reserved120 : 12;
mfxU32 TuCountM1 : 4;
/* DWORD 13 */
mfxU32 TransformSkipU : 16;
mfxU32 TransformSkipV : 16;
} mfxFeiHevcPakCuRecordV0;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 VaBufferID;
mfxU32 Pitch;
mfxU32 Height;
mfxU16 reserved0[54];
mfxFeiHevcPakCuRecordV0 *Data;
} mfxExtFeiHevcPakCuRecordV0;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU32 BestDistortion;
mfxU32 ColocatedCtuDistortion;
} mfxFeiHevcDistortionCtu;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 VaBufferID;
mfxU32 Pitch;
mfxU32 Height;
mfxU16 reserved[6];
mfxFeiHevcDistortionCtu *Data;
} mfxExtFeiHevcDistortion;
MFX_PACK_END()
#endif
enum {
MFX_EXTBUFF_HEVCFEI_ENC_CTRL = MFX_MAKEFOURCC('F','H','C','T'),
MFX_EXTBUFF_HEVCFEI_ENC_MV_PRED = MFX_MAKEFOURCC('F','H','P','D'),
MFX_EXTBUFF_HEVCFEI_ENC_QP = MFX_MAKEFOURCC('F','H','Q','P'),
MFX_EXTBUFF_HEVCFEI_ENC_CTU_CTRL = MFX_MAKEFOURCC('F','H','E','C'),
MFX_EXTBUFF_HEVCFEI_REPACK_CTRL = MFX_MAKEFOURCC('F','H','R','P'),
MFX_EXTBUFF_HEVCFEI_REPACK_STAT = MFX_MAKEFOURCC('F','H','R','S'),
#if MFX_VERSION >= MFX_VERSION_NEXT
MFX_EXTBUFF_HEVCFEI_PAK_CTU_REC = MFX_MAKEFOURCC('F','H','T','B'),
MFX_EXTBUFF_HEVCFEI_PAK_CU_REC = MFX_MAKEFOURCC('F','H','C','U'),
MFX_EXTBUFF_HEVCFEI_ENC_DIST = MFX_MAKEFOURCC('F','H','D','S')
#endif
};
#endif // MFX_VERSION
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif // __MFXFEIHEVC_H__

105
.github/actions/libmfx/include/mfx/mfxjpeg.h vendored Normal file
View File

@ -0,0 +1,105 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFX_JPEG_H__
#define __MFX_JPEG_H__
#include "mfxdefs.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* CodecId */
enum {
MFX_CODEC_JPEG = MFX_MAKEFOURCC('J','P','E','G')
};
/* CodecProfile, CodecLevel */
enum
{
MFX_PROFILE_JPEG_BASELINE = 1
};
enum
{
MFX_ROTATION_0 = 0,
MFX_ROTATION_90 = 1,
MFX_ROTATION_180 = 2,
MFX_ROTATION_270 = 3
};
enum {
MFX_EXTBUFF_JPEG_QT = MFX_MAKEFOURCC('J','P','G','Q'),
MFX_EXTBUFF_JPEG_HUFFMAN = MFX_MAKEFOURCC('J','P','G','H')
};
enum {
MFX_JPEG_COLORFORMAT_UNKNOWN = 0,
MFX_JPEG_COLORFORMAT_YCbCr = 1,
MFX_JPEG_COLORFORMAT_RGB = 2
};
enum {
MFX_SCANTYPE_UNKNOWN = 0,
MFX_SCANTYPE_INTERLEAVED = 1,
MFX_SCANTYPE_NONINTERLEAVED = 2
};
enum {
MFX_CHROMAFORMAT_JPEG_SAMPLING = 6
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[7];
mfxU16 NumTable;
mfxU16 Qm[4][64];
} mfxExtJPEGQuantTables;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[2];
mfxU16 NumDCTable;
mfxU16 NumACTable;
struct {
mfxU8 Bits[16];
mfxU8 Values[12];
} DCTables[4];
struct {
mfxU8 Bits[16];
mfxU8 Values[162];
} ACTables[4];
} mfxExtJPEGHuffmanTables;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif // __MFX_JPEG_H__

99
.github/actions/libmfx/include/mfx/mfxla.h vendored Normal file
View File

@ -0,0 +1,99 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXLA_H__
#define __MFXLA_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
enum
{
MFX_EXTBUFF_LOOKAHEAD_CTRL = MFX_MAKEFOURCC('L','A','C','T'),
MFX_EXTBUFF_LOOKAHEAD_STAT = MFX_MAKEFOURCC('L','A','S','T'),
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct
{
mfxExtBuffer Header;
mfxU16 LookAheadDepth;
mfxU16 DependencyDepth;
mfxU16 DownScaleFactor;
mfxU16 BPyramid;
mfxU16 reserved1[23];
mfxU16 NumOutStream;
struct mfxStream{
mfxU16 Width;
mfxU16 Height;
mfxU16 reserved2[14];
} OutStream[16];
}mfxExtLAControl;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_L_TYPE()
typedef struct
{
mfxU16 Width;
mfxU16 Height;
mfxU32 FrameType;
mfxU32 FrameDisplayOrder;
mfxU32 FrameEncodeOrder;
mfxU32 IntraCost;
mfxU32 InterCost;
mfxU32 DependencyCost; //aggregated cost, how this frame influences subsequent frames
mfxU16 Layer;
mfxU16 reserved[23];
mfxU64 EstimatedRate[52];
}mfxLAFrameInfo;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved[20];
mfxU16 NumAlloc; //number of allocated mfxLAFrameInfo structures
mfxU16 NumStream; //number of resolutions
mfxU16 NumFrame; //number of frames for each resolution
mfxLAFrameInfo *FrameStat; //frame statistics
mfxFrameSurface1 *OutSurface; //reordered surface
} mfxExtLAFrameStatistics;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

106
.github/actions/libmfx/include/mfx/mfxmvc.h vendored Normal file
View File

@ -0,0 +1,106 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXMVC_H__
#define __MFXMVC_H__
#include "mfxdefs.h"
#ifdef __cplusplus
extern "C" {
#endif
/* CodecProfile, CodecLevel */
enum {
/* MVC profiles */
MFX_PROFILE_AVC_MULTIVIEW_HIGH =118,
MFX_PROFILE_AVC_STEREO_HIGH =128
};
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_MVC_SEQ_DESC = MFX_MAKEFOURCC('M','V','C','D'),
MFX_EXTBUFF_MVC_TARGET_VIEWS = MFX_MAKEFOURCC('M','V','C','T')
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU16 ViewId;
mfxU16 NumAnchorRefsL0;
mfxU16 NumAnchorRefsL1;
mfxU16 AnchorRefL0[16];
mfxU16 AnchorRefL1[16];
mfxU16 NumNonAnchorRefsL0;
mfxU16 NumNonAnchorRefsL1;
mfxU16 NonAnchorRefL0[16];
mfxU16 NonAnchorRefL1[16];
} mfxMVCViewDependency;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU16 TemporalId;
mfxU16 LevelIdc;
mfxU16 NumViews;
mfxU16 NumTargetViews;
mfxU16 *TargetViewId;
} mfxMVCOperationPoint;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxExtBuffer Header;
mfxU32 NumView;
mfxU32 NumViewAlloc;
mfxMVCViewDependency *View;
mfxU32 NumViewId;
mfxU32 NumViewIdAlloc;
mfxU16 *ViewId;
mfxU32 NumOP;
mfxU32 NumOPAlloc;
mfxMVCOperationPoint *OP;
mfxU16 NumRefsTotal;
mfxU32 Reserved[16];
} mfxExtMVCSeqDesc;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 TemporalId;
mfxU32 NumView;
mfxU16 ViewId[1024];
} mfxExtMVCTargetViews ;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif
#endif

78
.github/actions/libmfx/include/mfx/mfxpak.h vendored Normal file
View File

@ -0,0 +1,78 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXPAK_H__
#define __MFXPAK_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU16 reserved[32];
mfxFrameSurface1 *InSurface;
mfxU16 NumFrameL0;
mfxFrameSurface1 **L0Surface;
mfxU16 NumFrameL1;
mfxFrameSurface1 **L1Surface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
mfxU16 NumPayload;
mfxPayload **Payload;
} mfxPAKInput;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU16 reserved[32];
mfxBitstream *Bs;
mfxFrameSurface1 *OutSurface;
mfxU16 NumExtParam;
mfxExtBuffer **ExtParam;
} mfxPAKOutput;
MFX_PACK_END()
typedef struct _mfxSession *mfxSession;
mfxStatus MFX_CDECL MFXVideoPAK_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoPAK_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest request[2]);
mfxStatus MFX_CDECL MFXVideoPAK_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoPAK_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoPAK_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoPAK_ProcessFrameAsync(mfxSession session, mfxPAKInput *in, mfxPAKOutput *out, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXVideoPAK_GetVideoParam(mfxSession session, mfxVideoParam *par);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

56
.github/actions/libmfx/include/mfx/mfxpcp.h vendored Normal file
View File

@ -0,0 +1,56 @@
// Copyright (c) 2019 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.
#ifndef __MFXPCP_H__
#define __MFXPCP_H__
#include "mfxstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#if MFX_VERSION >= 1030
/* Protected in mfxVideoParam */
enum {
MFX_PROTECTION_CENC_WV_CLASSIC = 0x0004,
MFX_PROTECTION_CENC_WV_GOOGLE_DASH = 0x0005,
};
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_CENC_PARAM = MFX_MAKEFOURCC('C','E','N','P')
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct _mfxExtCencParam{
mfxExtBuffer Header;
mfxU32 StatusReportIndex;
mfxU32 reserved[15];
} mfxExtCencParam;
MFX_PACK_END()
#endif
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

717
.github/actions/libmfx/include/mfx/mfxplugin++.h vendored Normal file
View File

@ -0,0 +1,717 @@
// Copyright (c) 2017-2020 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.
#ifndef __MFXPLUGINPLUSPLUS_H
#define __MFXPLUGINPLUSPLUS_H
#include "mfxplugin.h"
// base class for MFXVideoUSER/MFXAudioUSER API
class MFXBaseUSER {
public:
explicit MFXBaseUSER(mfxSession session = NULL)
: m_session(session){}
virtual ~MFXBaseUSER() {}
virtual mfxStatus Register(mfxU32 type, const mfxPlugin *par) = 0;
virtual mfxStatus Unregister(mfxU32 type) = 0;
virtual mfxStatus ProcessFrameAsync(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp) = 0;
protected:
mfxSession m_session;
};
//c++ wrapper over only 3 exposed functions from MFXVideoUSER module
class MFXVideoUSER: public MFXBaseUSER {
public:
explicit MFXVideoUSER(mfxSession session = NULL)
: MFXBaseUSER(session){}
virtual mfxStatus Register(mfxU32 type, const mfxPlugin *par) {
return MFXVideoUSER_Register(m_session, type, par);
}
virtual mfxStatus Unregister(mfxU32 type) {
return MFXVideoUSER_Unregister(m_session, type);
}
virtual mfxStatus ProcessFrameAsync(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp) {
return MFXVideoUSER_ProcessFrameAsync(m_session, in, in_num, out, out_num, syncp);
}
};
//c++ wrapper over only 3 exposed functions from MFXAudioUSER module
class MFXAudioUSER: public MFXBaseUSER {
public:
explicit MFXAudioUSER(mfxSession session = NULL)
: MFXBaseUSER(session){}
virtual mfxStatus Register(mfxU32 type, const mfxPlugin *par) {
return MFXAudioUSER_Register(m_session, type, par);
}
virtual mfxStatus Unregister(mfxU32 type) {
return MFXAudioUSER_Unregister(m_session, type);
}
virtual mfxStatus ProcessFrameAsync(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp) {
return MFXAudioUSER_ProcessFrameAsync(m_session, in, in_num, out, out_num, syncp);
}
};
//initialize mfxPlugin struct
class MFXPluginParam {
mfxPluginParam m_param;
public:
MFXPluginParam(mfxU32 CodecId, mfxU32 Type, mfxPluginUID uid, mfxThreadPolicy ThreadPolicy = MFX_THREADPOLICY_SERIAL, mfxU32 MaxThreadNum = 1)
: m_param() {
m_param.PluginUID = uid;
m_param.Type = Type;
m_param.CodecId = CodecId;
m_param.MaxThreadNum = MaxThreadNum;
m_param.ThreadPolicy = ThreadPolicy;
}
operator const mfxPluginParam& () const {
return m_param;
}
operator mfxPluginParam& () {
return m_param;
}
};
//common interface part for every plugin: decoder/encoder and generic
struct MFXPlugin
{
virtual ~MFXPlugin() {};
//init function always required for any transform or codec plugins, for codec plugins it maps to callback from MediaSDK
//for generic plugin application should call it
//MediaSDK mfxPlugin API mapping
virtual mfxStatus PluginInit(mfxCoreInterface *core) = 0;
//release CoreInterface, and destroy plugin state, not destroy plugin instance
virtual mfxStatus PluginClose() = 0;
virtual mfxStatus GetPluginParam(mfxPluginParam *par) = 0;
virtual mfxStatus Execute(mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a) = 0;
virtual mfxStatus FreeResources(mfxThreadTask task, mfxStatus sts) = 0;
//destroy plugin due to shared module distribution model plugin wont support virtual destructor
virtual void Release() = 0;
//release resources associated with current instance of plugin, but do not release CoreInterface related resource set in pluginInit
virtual mfxStatus Close() = 0;
//communication protocol between particular version of plugin and application
virtual mfxStatus SetAuxParams(void* auxParam, int auxParamSize) = 0;
};
//common extension interface that codec plugins should expose additionally to MFXPlugin
struct MFXCodecPlugin : MFXPlugin
{
virtual mfxStatus Init(mfxVideoParam *par) = 0;
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out) = 0;
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) =0;
virtual mfxStatus Reset(mfxVideoParam *par) = 0;
virtual mfxStatus GetVideoParam(mfxVideoParam *par) = 0;
};
//common extension interface that audio codec plugins should expose additionally to MFXPlugin
struct MFXAudioCodecPlugin : MFXPlugin
{
virtual mfxStatus Init(mfxAudioParam *par) = 0;
virtual mfxStatus Query(mfxAudioParam *in, mfxAudioParam *out) =0;
virtual mfxStatus QueryIOSize(mfxAudioParam *par, mfxAudioAllocRequest *request) = 0;
virtual mfxStatus Reset(mfxAudioParam *par) = 0;
virtual mfxStatus GetAudioParam(mfxAudioParam *par) = 0;
};
//general purpose transform plugin interface, not a codec plugin
struct MFXGenericPlugin : MFXPlugin
{
virtual mfxStatus Init(mfxVideoParam *par) = 0;
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out) = 0;
virtual mfxStatus Submit(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task) = 0;
};
//decoder plugins may only support this interface
struct MFXDecoderPlugin : MFXCodecPlugin
{
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxVideoParam *par) = 0;
virtual mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) = 0;
virtual mfxStatus DecodeFrameSubmit(mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) = 0;
};
//audio decoder plugins may only support this interface
struct MFXAudioDecoderPlugin : MFXAudioCodecPlugin
{
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxAudioParam *par) = 0;
// virtual mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) = 0;
virtual mfxStatus DecodeFrameSubmit(mfxBitstream *in, mfxAudioFrame *out, mfxThreadTask *task) = 0;
};
//encoder plugins may only support this interface
struct MFXEncoderPlugin : MFXCodecPlugin
{
virtual mfxStatus EncodeFrameSubmit(mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxThreadTask *task) = 0;
};
//audio encoder plugins may only support this interface
struct MFXAudioEncoderPlugin : MFXAudioCodecPlugin
{
virtual mfxStatus EncodeFrameSubmit(mfxAudioFrame *aFrame, mfxBitstream *out, mfxThreadTask *task) = 0;
};
//vpp plugins may only support this interface
struct MFXVPPPlugin : MFXCodecPlugin
{
virtual mfxStatus VPPFrameSubmit(mfxFrameSurface1 *surface_in, mfxFrameSurface1 *surface_out, mfxExtVppAuxData *aux, mfxThreadTask *task) = 0;
virtual mfxStatus VPPFrameSubmitEx(mfxFrameSurface1 *in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) = 0;
};
struct MFXEncPlugin : MFXCodecPlugin
{
virtual mfxStatus EncFrameSubmit(mfxENCInput *in, mfxENCOutput *out, mfxThreadTask *task) = 0;
};
class MFXCoreInterface
{
protected:
mfxCoreInterface m_core;
public:
MFXCoreInterface()
: m_core() {
}
MFXCoreInterface(const mfxCoreInterface & pCore)
: m_core(pCore) {
}
MFXCoreInterface(const MFXCoreInterface & that)
: m_core(that.m_core) {
}
MFXCoreInterface &operator = (const MFXCoreInterface & that)
{
m_core = that.m_core;
return *this;
}
bool IsCoreSet() {
return m_core.pthis != 0;
}
mfxStatus GetCoreParam(mfxCoreParam *par) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.GetCoreParam(m_core.pthis, par);
}
mfxStatus GetHandle (mfxHandleType type, mfxHDL *handle) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.GetHandle(m_core.pthis, type, handle);
}
mfxStatus IncreaseReference (mfxFrameData *fd) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.IncreaseReference(m_core.pthis, fd);
}
mfxStatus DecreaseReference (mfxFrameData *fd) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.DecreaseReference(m_core.pthis, fd);
}
mfxStatus CopyFrame (mfxFrameSurface1 *dst, mfxFrameSurface1 *src) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.CopyFrame(m_core.pthis, dst, src);
}
mfxStatus CopyBuffer(mfxU8 *dst, mfxU32 size, mfxFrameSurface1 *src) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.CopyBuffer(m_core.pthis, dst, size, src);
}
mfxStatus MapOpaqueSurface(mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.MapOpaqueSurface(m_core.pthis, num, type, op_surf);
}
mfxStatus UnmapOpaqueSurface(mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.UnmapOpaqueSurface(m_core.pthis, num, type, op_surf);
}
mfxStatus GetRealSurface(mfxFrameSurface1 *op_surf, mfxFrameSurface1 **surf) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.GetRealSurface(m_core.pthis, op_surf, surf);
}
mfxStatus GetOpaqueSurface(mfxFrameSurface1 *surf, mfxFrameSurface1 **op_surf) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.GetOpaqueSurface(m_core.pthis, surf, op_surf);
}
mfxStatus CreateAccelerationDevice(mfxHandleType type, mfxHDL *handle) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.CreateAccelerationDevice(m_core.pthis, type, handle);
}
mfxFrameAllocator & FrameAllocator() {
return m_core.FrameAllocator;
}
mfxStatus GetFrameHandle(mfxFrameData *fd, mfxHDL *handle) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.GetFrameHandle(m_core.pthis, fd, handle);
}
mfxStatus QueryPlatform(mfxPlatform *platform) {
if (!IsCoreSet()) {
return MFX_ERR_NULL_PTR;
}
return m_core.QueryPlatform(m_core.pthis, platform);
}
} ;
/* Class adapter between "C" structure mfxPlugin and C++ interface MFXPlugin */
namespace detail
{
template <class T>
class MFXPluginAdapterBase
{
protected:
mfxPlugin m_mfxAPI;
public:
MFXPluginAdapterBase( T *plugin, mfxVideoCodecPlugin *pCodec = NULL)
: m_mfxAPI()
{
SetupCallbacks(plugin, pCodec);
}
MFXPluginAdapterBase( T *plugin, mfxAudioCodecPlugin *pCodec)
: m_mfxAPI()
{
SetupCallbacks(plugin, pCodec);
}
operator mfxPlugin () const {
return m_mfxAPI;
}
void SetupCallbacks(T *plugin) {
m_mfxAPI.pthis = plugin;
m_mfxAPI.PluginInit = _PluginInit;
m_mfxAPI.PluginClose = _PluginClose;
m_mfxAPI.GetPluginParam = _GetPluginParam;
m_mfxAPI.Submit = 0;
m_mfxAPI.Execute = _Execute;
m_mfxAPI.FreeResources = _FreeResources;
}
void SetupCallbacks( T *plugin, mfxVideoCodecPlugin *pCodec) {
SetupCallbacks(plugin);
m_mfxAPI.Video = pCodec;
}
void SetupCallbacks( T *plugin, mfxAudioCodecPlugin *pCodec) {
SetupCallbacks(plugin);
m_mfxAPI.Audio = pCodec;
}
private:
static mfxStatus _PluginInit(mfxHDL pthis, mfxCoreInterface *core) {
return reinterpret_cast<T*>(pthis)->PluginInit(core);
}
static mfxStatus _PluginClose(mfxHDL pthis) {
return reinterpret_cast<T*>(pthis)->PluginClose();
}
static mfxStatus _GetPluginParam(mfxHDL pthis, mfxPluginParam *par) {
return reinterpret_cast<T*>(pthis)->GetPluginParam(par);
}
static mfxStatus _Execute(mfxHDL pthis, mfxThreadTask task, mfxU32 thread_id, mfxU32 call_count) {
return reinterpret_cast<T*>(pthis)->Execute(task, thread_id, call_count);
}
static mfxStatus _FreeResources(mfxHDL pthis, mfxThreadTask task, mfxStatus sts) {
return reinterpret_cast<T*>(pthis)->FreeResources(task, sts);
}
};
template<class T>
class MFXCodecPluginAdapterBase : public MFXPluginAdapterBase<T>
{
protected:
//stub to feed mediasdk plugin API
mfxVideoCodecPlugin m_codecPlg;
public:
MFXCodecPluginAdapterBase(T * pCodecPlg)
: MFXPluginAdapterBase<T>(pCodecPlg, &m_codecPlg)
, m_codecPlg()
{
m_codecPlg.Query = _Query;
m_codecPlg.QueryIOSurf = _QueryIOSurf ;
m_codecPlg.Init = _Init;
m_codecPlg.Reset = _Reset;
m_codecPlg.Close = _Close;
m_codecPlg.GetVideoParam = _GetVideoParam;
}
MFXCodecPluginAdapterBase(const MFXCodecPluginAdapterBase<T> & that)
: MFXPluginAdapterBase<T>(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg)
, m_codecPlg() {
SetupCallbacks();
}
MFXCodecPluginAdapterBase<T>& operator = (const MFXCodecPluginAdapterBase<T> & that) {
MFXPluginAdapterBase<T> :: SetupCallbacks(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg);
SetupCallbacks();
return *this;
}
private:
void SetupCallbacks() {
m_codecPlg.Query = _Query;
m_codecPlg.QueryIOSurf = _QueryIOSurf ;
m_codecPlg.Init = _Init;
m_codecPlg.Reset = _Reset;
m_codecPlg.Close = _Close;
m_codecPlg.GetVideoParam = _GetVideoParam;
}
static mfxStatus _Query(mfxHDL pthis, mfxVideoParam *in, mfxVideoParam *out) {
return reinterpret_cast<T*>(pthis)->Query(in, out);
}
static mfxStatus _QueryIOSurf(mfxHDL pthis, mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out){
return reinterpret_cast<T*>(pthis)->QueryIOSurf(par, in, out);
}
static mfxStatus _Init(mfxHDL pthis, mfxVideoParam *par){
return reinterpret_cast<T*>(pthis)->Init(par);
}
static mfxStatus _Reset(mfxHDL pthis, mfxVideoParam *par){
return reinterpret_cast<T*>(pthis)->Reset(par);
}
static mfxStatus _Close(mfxHDL pthis) {
return reinterpret_cast<T*>(pthis)->Close();
}
static mfxStatus _GetVideoParam(mfxHDL pthis, mfxVideoParam *par) {
return reinterpret_cast<T*>(pthis)->GetVideoParam(par);
}
};
template<class T>
class MFXAudioCodecPluginAdapterBase : public MFXPluginAdapterBase<T>
{
protected:
//stub to feed mediasdk plugin API
mfxAudioCodecPlugin m_codecPlg;
public:
MFXAudioCodecPluginAdapterBase(T * pCodecPlg)
: MFXPluginAdapterBase<T>(pCodecPlg, &m_codecPlg)
, m_codecPlg()
{
m_codecPlg.Query = _Query;
m_codecPlg.QueryIOSize = _QueryIOSize ;
m_codecPlg.Init = _Init;
m_codecPlg.Reset = _Reset;
m_codecPlg.Close = _Close;
m_codecPlg.GetAudioParam = _GetAudioParam;
}
MFXAudioCodecPluginAdapterBase(const MFXCodecPluginAdapterBase<T> & that)
: MFXPluginAdapterBase<T>(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg)
, m_codecPlg() {
SetupCallbacks();
}
MFXAudioCodecPluginAdapterBase<T>& operator = (const MFXAudioCodecPluginAdapterBase<T> & that) {
MFXPluginAdapterBase<T> :: SetupCallbacks(reinterpret_cast<T*>(that.m_mfxAPI.pthis), &m_codecPlg);
SetupCallbacks();
return *this;
}
private:
void SetupCallbacks() {
m_codecPlg.Query = _Query;
m_codecPlg.QueryIOSize = _QueryIOSize;
m_codecPlg.Init = _Init;
m_codecPlg.Reset = _Reset;
m_codecPlg.Close = _Close;
m_codecPlg.GetAudioParam = _GetAudioParam;
}
static mfxStatus _Query(mfxHDL pthis, mfxAudioParam *in, mfxAudioParam *out) {
return reinterpret_cast<T*>(pthis)->Query(in, out);
}
static mfxStatus _QueryIOSize(mfxHDL pthis, mfxAudioParam *par, mfxAudioAllocRequest *request){
return reinterpret_cast<T*>(pthis)->QueryIOSize(par, request);
}
static mfxStatus _Init(mfxHDL pthis, mfxAudioParam *par){
return reinterpret_cast<T*>(pthis)->Init(par);
}
static mfxStatus _Reset(mfxHDL pthis, mfxAudioParam *par){
return reinterpret_cast<T*>(pthis)->Reset(par);
}
static mfxStatus _Close(mfxHDL pthis) {
return reinterpret_cast<T*>(pthis)->Close();
}
static mfxStatus _GetAudioParam(mfxHDL pthis, mfxAudioParam *par) {
return reinterpret_cast<T*>(pthis)->GetAudioParam(par);
}
};
template <class T>
struct MFXPluginAdapterInternal{};
template<>
class MFXPluginAdapterInternal<MFXGenericPlugin> : public MFXPluginAdapterBase<MFXGenericPlugin>
{
public:
MFXPluginAdapterInternal(MFXGenericPlugin *pPlugin)
: MFXPluginAdapterBase<MFXGenericPlugin>(pPlugin)
{
m_mfxAPI.Submit = _Submit;
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that )
: MFXPluginAdapterBase<MFXGenericPlugin>(that) {
m_mfxAPI.Submit = that._Submit;
}
MFXPluginAdapterInternal<MFXGenericPlugin>& operator = (const MFXPluginAdapterInternal<MFXGenericPlugin> & that) {
MFXPluginAdapterBase<MFXGenericPlugin>::operator=(that);
m_mfxAPI.Submit = that._Submit;
return *this;
}
private:
static mfxStatus _Submit(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task) {
return reinterpret_cast<MFXGenericPlugin*>(pthis)->Submit(in, in_num, out, out_num, task);
}
};
template<>
class MFXPluginAdapterInternal<MFXDecoderPlugin> : public MFXCodecPluginAdapterBase<MFXDecoderPlugin>
{
public:
MFXPluginAdapterInternal(MFXDecoderPlugin *pPlugin)
: MFXCodecPluginAdapterBase<MFXDecoderPlugin>(pPlugin)
{
SetupCallbacks();
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
: MFXCodecPluginAdapterBase<MFXDecoderPlugin>(that) {
SetupCallbacks();
}
MFXPluginAdapterInternal<MFXDecoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXDecoderPlugin> & that) {
MFXCodecPluginAdapterBase<MFXDecoderPlugin>::operator=(that);
SetupCallbacks();
return *this;
}
private:
void SetupCallbacks() {
m_codecPlg.DecodeHeader = _DecodeHeader;
m_codecPlg.GetPayload = _GetPayload;
m_codecPlg.DecodeFrameSubmit = _DecodeFrameSubmit;
}
static mfxStatus _DecodeHeader(mfxHDL pthis, mfxBitstream *bs, mfxVideoParam *par) {
return reinterpret_cast<MFXDecoderPlugin*>(pthis)->DecodeHeader(bs, par);
}
static mfxStatus _GetPayload(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload) {
return reinterpret_cast<MFXDecoderPlugin*>(pthis)->GetPayload(ts, payload);
}
static mfxStatus _DecodeFrameSubmit(mfxHDL pthis, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) {
return reinterpret_cast<MFXDecoderPlugin*>(pthis)->DecodeFrameSubmit(bs, surface_work, surface_out, task);
}
};
template<>
class MFXPluginAdapterInternal<MFXAudioDecoderPlugin> : public MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>
{
public:
MFXPluginAdapterInternal(MFXAudioDecoderPlugin *pPlugin)
: MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>(pPlugin)
{
SetupCallbacks();
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
: MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>(that) {
SetupCallbacks();
}
MFXPluginAdapterInternal<MFXAudioDecoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXAudioDecoderPlugin> & that) {
MFXAudioCodecPluginAdapterBase<MFXAudioDecoderPlugin>::operator=(that);
SetupCallbacks();
return *this;
}
private:
void SetupCallbacks() {
m_codecPlg.DecodeHeader = _DecodeHeader;
m_codecPlg.DecodeFrameSubmit = _DecodeFrameSubmit;
}
static mfxStatus _DecodeHeader(mfxHDL pthis, mfxBitstream *bs, mfxAudioParam *par) {
return reinterpret_cast<MFXAudioDecoderPlugin*>(pthis)->DecodeHeader(bs, par);
}
static mfxStatus _DecodeFrameSubmit(mfxHDL pthis, mfxBitstream *in, mfxAudioFrame *out, mfxThreadTask *task) {
return reinterpret_cast<MFXAudioDecoderPlugin*>(pthis)->DecodeFrameSubmit(in, out, task);
}
};
template<>
class MFXPluginAdapterInternal<MFXEncoderPlugin> : public MFXCodecPluginAdapterBase<MFXEncoderPlugin>
{
public:
MFXPluginAdapterInternal(MFXEncoderPlugin *pPlugin)
: MFXCodecPluginAdapterBase<MFXEncoderPlugin>(pPlugin)
{
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
: MFXCodecPluginAdapterBase<MFXEncoderPlugin>(that) {
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
}
MFXPluginAdapterInternal<MFXEncoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXEncoderPlugin> & that) {
MFXCodecPluginAdapterBase<MFXEncoderPlugin>::operator = (that);
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
return *this;
}
private:
static mfxStatus _EncodeFrameSubmit(mfxHDL pthis, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxThreadTask *task) {
return reinterpret_cast<MFXEncoderPlugin*>(pthis)->EncodeFrameSubmit(ctrl, surface, bs, task);
}
};
template<>
class MFXPluginAdapterInternal<MFXAudioEncoderPlugin> : public MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>
{
public:
MFXPluginAdapterInternal(MFXAudioEncoderPlugin *pPlugin)
: MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>(pPlugin)
{
SetupCallbacks();
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
: MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>(that) {
SetupCallbacks();
}
MFXPluginAdapterInternal<MFXAudioEncoderPlugin>& operator = (const MFXPluginAdapterInternal<MFXAudioEncoderPlugin> & that) {
MFXAudioCodecPluginAdapterBase<MFXAudioEncoderPlugin>::operator=(that);
SetupCallbacks();
return *this;
}
private:
void SetupCallbacks() {
m_codecPlg.EncodeFrameSubmit = _EncodeFrameSubmit;
}
static mfxStatus _EncodeFrameSubmit(mfxHDL pthis, mfxAudioFrame *aFrame, mfxBitstream *out, mfxThreadTask *task) {
return reinterpret_cast<MFXAudioEncoderPlugin*>(pthis)->EncodeFrameSubmit(aFrame, out, task);
}
};
template<>
class MFXPluginAdapterInternal<MFXEncPlugin> : public MFXCodecPluginAdapterBase<MFXEncPlugin>
{
public:
MFXPluginAdapterInternal(MFXEncPlugin *pPlugin)
: MFXCodecPluginAdapterBase<MFXEncPlugin>(pPlugin)
{
m_codecPlg.ENCFrameSubmit = _ENCFrameSubmit;
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
: MFXCodecPluginAdapterBase<MFXEncPlugin>(that) {
m_codecPlg.ENCFrameSubmit = _ENCFrameSubmit;
}
MFXPluginAdapterInternal<MFXEncPlugin>& operator = (const MFXPluginAdapterInternal<MFXEncPlugin> & that) {
MFXCodecPluginAdapterBase<MFXEncPlugin>::operator = (that);
m_codecPlg.ENCFrameSubmit = _ENCFrameSubmit;
return *this;
}
private:
static mfxStatus _ENCFrameSubmit(mfxHDL pthis,mfxENCInput *in, mfxENCOutput *out, mfxThreadTask *task) {
return reinterpret_cast<MFXEncPlugin*>(pthis)->EncFrameSubmit(in, out, task);
}
};
template<>
class MFXPluginAdapterInternal<MFXVPPPlugin> : public MFXCodecPluginAdapterBase<MFXVPPPlugin>
{
public:
MFXPluginAdapterInternal(MFXVPPPlugin *pPlugin)
: MFXCodecPluginAdapterBase<MFXVPPPlugin>(pPlugin)
{
SetupCallbacks();
}
MFXPluginAdapterInternal(const MFXPluginAdapterInternal & that)
: MFXCodecPluginAdapterBase<MFXVPPPlugin>(that) {
SetupCallbacks();
}
MFXPluginAdapterInternal<MFXVPPPlugin>& operator = (const MFXPluginAdapterInternal<MFXVPPPlugin> & that) {
MFXCodecPluginAdapterBase<MFXVPPPlugin>::operator = (that);
SetupCallbacks();
return *this;
}
private:
void SetupCallbacks() {
m_codecPlg.VPPFrameSubmit = _VPPFrameSubmit;
m_codecPlg.VPPFrameSubmitEx = _VPPFrameSubmitEx;
}
static mfxStatus _VPPFrameSubmit(mfxHDL pthis, mfxFrameSurface1 *surface_in, mfxFrameSurface1 *surface_out, mfxExtVppAuxData *aux, mfxThreadTask *task) {
return reinterpret_cast<MFXVPPPlugin*>(pthis)->VPPFrameSubmit(surface_in, surface_out, aux, task);
}
static mfxStatus _VPPFrameSubmitEx(mfxHDL pthis, mfxFrameSurface1 *surface_in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task) {
return reinterpret_cast<MFXVPPPlugin*>(pthis)->VPPFrameSubmitEx(surface_in, surface_work, surface_out, task);
}
};
}
/* adapter for particular plugin type*/
template<class T>
class MFXPluginAdapter
{
public:
detail::MFXPluginAdapterInternal<T> m_Adapter;
operator mfxPlugin () const {
return m_Adapter.operator mfxPlugin();
}
MFXPluginAdapter(T* pPlugin = NULL)
: m_Adapter(pPlugin)
{
}
};
template<class T>
inline MFXPluginAdapter<T> make_mfx_plugin_adapter(T* pPlugin) {
MFXPluginAdapter<T> adapt(pPlugin);
return adapt;
}
#endif // __MFXPLUGINPLUSPLUS_H

216
.github/actions/libmfx/include/mfx/mfxplugin.h vendored Normal file
View File

@ -0,0 +1,216 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXPLUGIN_H__
#define __MFXPLUGIN_H__
#include "mfxvideo.h"
#include "mfxaudio.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxU8 Data[16];
} mfxPluginUID;
MFX_PACK_END()
static const mfxPluginUID MFX_PLUGINID_HEVCD_SW = {{0x15, 0xdd, 0x93, 0x68, 0x25, 0xad, 0x47, 0x5e, 0xa3, 0x4e, 0x35, 0xf3, 0xf5, 0x42, 0x17, 0xa6}};
static const mfxPluginUID MFX_PLUGINID_HEVCD_HW = {{0x33, 0xa6, 0x1c, 0x0b, 0x4c, 0x27, 0x45, 0x4c, 0xa8, 0xd8, 0x5d, 0xde, 0x75, 0x7c, 0x6f, 0x8e}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_SW = {{0x2f, 0xca, 0x99, 0x74, 0x9f, 0xdb, 0x49, 0xae, 0xb1, 0x21, 0xa5, 0xb6, 0x3e, 0xf5, 0x68, 0xf7}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_GACC = {{0xe5, 0x40, 0x0a, 0x06, 0xc7, 0x4d, 0x41, 0xf5, 0xb1, 0x2d, 0x43, 0x0b, 0xba, 0xa2, 0x3d, 0x0b}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_DP_GACC = {{0x2b, 0xad, 0x6f, 0x9d, 0x77, 0x54, 0x41, 0x2d, 0xbf, 0x63, 0x03, 0xed, 0x4b, 0xb5, 0x09, 0x68}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_HW = {{0x6f, 0xad, 0xc7, 0x91, 0xa0, 0xc2, 0xeb, 0x47, 0x9a, 0xb6, 0xdc, 0xd5, 0xea, 0x9d, 0xa3, 0x47}};
static const mfxPluginUID MFX_PLUGINID_VP8D_HW = {{0xf6, 0x22, 0x39, 0x4d, 0x8d, 0x87, 0x45, 0x2f, 0x87, 0x8c, 0x51, 0xf2, 0xfc, 0x9b, 0x41, 0x31}};
static const mfxPluginUID MFX_PLUGINID_VP8E_HW = {{0xbf, 0xfc, 0x51, 0x8c, 0xde, 0x13, 0x4d, 0xf9, 0x8a, 0x96, 0xf4, 0xcf, 0x81, 0x6c, 0x0f, 0xac}};
static const mfxPluginUID MFX_PLUGINID_VP9E_HW = {{0xce, 0x44, 0xef, 0x6f, 0x1a, 0x6d, 0x22, 0x46, 0xb4, 0x12, 0xbb, 0x38, 0xd6, 0xe4, 0x51, 0x82}};
static const mfxPluginUID MFX_PLUGINID_VP9D_HW = {{0xa9, 0x22, 0x39, 0x4d, 0x8d, 0x87, 0x45, 0x2f, 0x87, 0x8c, 0x51, 0xf2, 0xfc, 0x9b, 0x41, 0x31}};
static const mfxPluginUID MFX_PLUGINID_CAMERA_HW = {{0x54, 0x54, 0x26, 0x16, 0x24, 0x33, 0x41, 0xe6, 0x93, 0xae, 0x89, 0x99, 0x42, 0xce, 0x73, 0x55}};
static const mfxPluginUID MFX_PLUGINID_CAPTURE_HW = {{0x22, 0xd6, 0x2c, 0x07, 0xe6, 0x72, 0x40, 0x8f, 0xbb, 0x4c, 0xc2, 0x0e, 0xd7, 0xa0, 0x53, 0xe4}};
static const mfxPluginUID MFX_PLUGINID_ITELECINE_HW = {{0xe7, 0x44, 0x75, 0x3a, 0xcd, 0x74, 0x40, 0x2e, 0x89, 0xa2, 0xee, 0x06, 0x35, 0x49, 0x61, 0x79}};
static const mfxPluginUID MFX_PLUGINID_H264LA_HW = {{0x58, 0x8f, 0x11, 0x85, 0xd4, 0x7b, 0x42, 0x96, 0x8d, 0xea, 0x37, 0x7b, 0xb5, 0xd0, 0xdc, 0xb4}};
static const mfxPluginUID MFX_PLUGINID_AACD = {{0xe9, 0x34, 0x67, 0x25, 0xac, 0x2f, 0x4c, 0x93, 0xaa, 0x58, 0x5c, 0x11, 0xc7, 0x08, 0x7c, 0xf4}};
static const mfxPluginUID MFX_PLUGINID_AACE = {{0xb2, 0xa2, 0xa0, 0x5a, 0x4e, 0xac, 0x46, 0xbf, 0xa9, 0xde, 0x7e, 0x80, 0xc9, 0x8d, 0x2e, 0x18}};
static const mfxPluginUID MFX_PLUGINID_HEVCE_FEI_HW = {{0x87, 0xe0, 0xe8, 0x02, 0x07, 0x37, 0x52, 0x40, 0x85, 0x25, 0x15, 0xcf, 0x4a, 0x5e, 0xdd, 0xe6}};
#if (MFX_VERSION >= 1027)
static const mfxPluginUID MFX_PLUGINID_HEVC_FEI_ENCODE = {{0x54, 0x18, 0xa7, 0x06, 0x66, 0xf9, 0x4d, 0x5c, 0xb4, 0xf7, 0xb1, 0xca, 0xee, 0x86, 0x33, 0x9b}};
#endif
typedef enum {
MFX_PLUGINTYPE_VIDEO_GENERAL = 0,
MFX_PLUGINTYPE_VIDEO_DECODE = 1,
MFX_PLUGINTYPE_VIDEO_ENCODE = 2,
MFX_PLUGINTYPE_VIDEO_VPP = 3,
MFX_PLUGINTYPE_VIDEO_ENC = 4,
MFX_PLUGINTYPE_AUDIO_DECODE = 5,
MFX_PLUGINTYPE_AUDIO_ENCODE = 6
} mfxPluginType;
typedef enum {
MFX_THREADPOLICY_SERIAL = 0,
MFX_THREADPOLICY_PARALLEL = 1
} mfxThreadPolicy;
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct mfxPluginParam {
mfxU32 reserved[6];
mfxU16 reserved1;
mfxU16 PluginVersion;
mfxVersion APIVersion;
mfxPluginUID PluginUID;
mfxU32 Type;
mfxU32 CodecId;
mfxThreadPolicy ThreadPolicy;
mfxU32 MaxThreadNum;
} mfxPluginParam;
MFX_PACK_END()
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct mfxCoreParam{
mfxU32 reserved[13];
mfxIMPL Impl;
mfxVersion Version;
mfxU32 NumWorkingThread;
} mfxCoreParam;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct mfxCoreInterface {
mfxHDL pthis;
mfxHDL reserved1[2];
mfxFrameAllocator FrameAllocator;
mfxBufferAllocator reserved3;
mfxStatus (MFX_CDECL *GetCoreParam)(mfxHDL pthis, mfxCoreParam *par);
mfxStatus (MFX_CDECL *GetHandle) (mfxHDL pthis, mfxHandleType type, mfxHDL *handle);
mfxStatus (MFX_CDECL *IncreaseReference) (mfxHDL pthis, mfxFrameData *fd);
mfxStatus (MFX_CDECL *DecreaseReference) (mfxHDL pthis, mfxFrameData *fd);
mfxStatus (MFX_CDECL *CopyFrame) (mfxHDL pthis, mfxFrameSurface1 *dst, mfxFrameSurface1 *src);
mfxStatus (MFX_CDECL *CopyBuffer)(mfxHDL pthis, mfxU8 *dst, mfxU32 size, mfxFrameSurface1 *src);
mfxStatus (MFX_CDECL *MapOpaqueSurface)(mfxHDL pthis, mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf);
mfxStatus (MFX_CDECL *UnmapOpaqueSurface)(mfxHDL pthis, mfxU32 num, mfxU32 type, mfxFrameSurface1 **op_surf);
mfxStatus (MFX_CDECL *GetRealSurface)(mfxHDL pthis, mfxFrameSurface1 *op_surf, mfxFrameSurface1 **surf);
mfxStatus (MFX_CDECL *GetOpaqueSurface)(mfxHDL pthis, mfxFrameSurface1 *surf, mfxFrameSurface1 **op_surf);
mfxStatus (MFX_CDECL *CreateAccelerationDevice)(mfxHDL pthis, mfxHandleType type, mfxHDL *handle);
mfxStatus (MFX_CDECL *GetFrameHandle) (mfxHDL pthis, mfxFrameData *fd, mfxHDL *handle);
mfxStatus (MFX_CDECL *QueryPlatform) (mfxHDL pthis, mfxPlatform *platform);
mfxHDL reserved4[1];
} mfxCoreInterface;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
/* video codec plugin extension */
typedef struct _mfxENCInput mfxENCInput;
typedef struct _mfxENCOutput mfxENCOutput;
typedef struct mfxVideoCodecPlugin{
mfxStatus (MFX_CDECL *Query)(mfxHDL pthis, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus (MFX_CDECL *QueryIOSurf)(mfxHDL pthis, mfxVideoParam *par, mfxFrameAllocRequest *in, mfxFrameAllocRequest *out);
mfxStatus (MFX_CDECL *Init)(mfxHDL pthis, mfxVideoParam *par);
mfxStatus (MFX_CDECL *Reset)(mfxHDL pthis, mfxVideoParam *par);
mfxStatus (MFX_CDECL *Close)(mfxHDL pthis);
mfxStatus (MFX_CDECL *GetVideoParam)(mfxHDL pthis, mfxVideoParam *par);
mfxStatus (MFX_CDECL *EncodeFrameSubmit)(mfxHDL pthis, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxThreadTask *task);
mfxStatus (MFX_CDECL *DecodeHeader)(mfxHDL pthis, mfxBitstream *bs, mfxVideoParam *par);
mfxStatus (MFX_CDECL *GetPayload)(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload);
mfxStatus (MFX_CDECL *DecodeFrameSubmit)(mfxHDL pthis, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task);
mfxStatus (MFX_CDECL *VPPFrameSubmit)(mfxHDL pthis, mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxThreadTask *task);
mfxStatus (MFX_CDECL *VPPFrameSubmitEx)(mfxHDL pthis, mfxFrameSurface1 *in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxThreadTask *task);
mfxStatus (MFX_CDECL *ENCFrameSubmit)(mfxHDL pthis, mfxENCInput *in, mfxENCOutput *out, mfxThreadTask *task);
mfxHDL reserved1[3];
mfxU32 reserved2[8];
} mfxVideoCodecPlugin;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct mfxAudioCodecPlugin{
mfxStatus (MFX_CDECL *Query)(mfxHDL pthis, mfxAudioParam *in, mfxAudioParam *out);
mfxStatus (MFX_CDECL *QueryIOSize)(mfxHDL pthis, mfxAudioParam *par, mfxAudioAllocRequest *request);
mfxStatus (MFX_CDECL *Init)(mfxHDL pthis, mfxAudioParam *par);
mfxStatus (MFX_CDECL *Reset)(mfxHDL pthis, mfxAudioParam *par);
mfxStatus (MFX_CDECL *Close)(mfxHDL pthis);
mfxStatus (MFX_CDECL *GetAudioParam)(mfxHDL pthis, mfxAudioParam *par);
mfxStatus (MFX_CDECL *EncodeFrameSubmit)(mfxHDL pthis, mfxAudioFrame *aFrame, mfxBitstream *out, mfxThreadTask *task);
mfxStatus (MFX_CDECL *DecodeHeader)(mfxHDL pthis, mfxBitstream *bs, mfxAudioParam *par);
// mfxStatus (MFX_CDECL *GetPayload)(mfxHDL pthis, mfxU64 *ts, mfxPayload *payload);
mfxStatus (MFX_CDECL *DecodeFrameSubmit)(mfxHDL pthis, mfxBitstream *in, mfxAudioFrame *out, mfxThreadTask *task);
mfxHDL reserved1[6];
mfxU32 reserved2[8];
} mfxAudioCodecPlugin;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct mfxPlugin{
mfxHDL pthis;
mfxStatus (MFX_CDECL *PluginInit) (mfxHDL pthis, mfxCoreInterface *core);
mfxStatus (MFX_CDECL *PluginClose) (mfxHDL pthis);
mfxStatus (MFX_CDECL *GetPluginParam)(mfxHDL pthis, mfxPluginParam *par);
mfxStatus (MFX_CDECL *Submit)(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task);
mfxStatus (MFX_CDECL *Execute)(mfxHDL pthis, mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a);
mfxStatus (MFX_CDECL *FreeResources)(mfxHDL pthis, mfxThreadTask task, mfxStatus sts);
union {
mfxVideoCodecPlugin *Video;
mfxAudioCodecPlugin *Audio;
};
mfxHDL reserved[8];
} mfxPlugin;
MFX_PACK_END()
mfxStatus MFX_CDECL MFXVideoUSER_Register(mfxSession session, mfxU32 type, const mfxPlugin *par);
mfxStatus MFX_CDECL MFXVideoUSER_Unregister(mfxSession session, mfxU32 type);
mfxStatus MFX_CDECL MFXVideoUSER_GetPlugin(mfxSession session, mfxU32 type, mfxPlugin *par);
mfxStatus MFX_CDECL MFXVideoUSER_ProcessFrameAsync(mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXVideoUSER_Load(mfxSession session, const mfxPluginUID *uid, mfxU32 version);
mfxStatus MFX_CDECL MFXVideoUSER_LoadByPath(mfxSession session, const mfxPluginUID *uid, mfxU32 version, const mfxChar *path, mfxU32 len);
mfxStatus MFX_CDECL MFXVideoUSER_UnLoad(mfxSession session, const mfxPluginUID *uid);
mfxStatus MFX_CDECL MFXAudioUSER_Register(mfxSession session, mfxU32 type, const mfxPlugin *par);
mfxStatus MFX_CDECL MFXAudioUSER_Unregister(mfxSession session, mfxU32 type);
mfxStatus MFX_CDECL MFXAudioUSER_ProcessFrameAsync(mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXAudioUSER_Load(mfxSession session, const mfxPluginUID *uid, mfxU32 version);
mfxStatus MFX_CDECL MFXAudioUSER_UnLoad(mfxSession session, const mfxPluginUID *uid);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif /* __MFXPLUGIN_H__ */

54
.github/actions/libmfx/include/mfx/mfxsc.h vendored Normal file
View File

@ -0,0 +1,54 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXSC_H__
#define __MFXSC_H__
#include "mfxdefs.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* Extended Buffer Ids */
enum
{
MFX_EXTBUFF_SCREEN_CAPTURE_PARAM = MFX_MAKEFOURCC('S','C','P','A')
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct
{
mfxExtBuffer Header;
mfxU32 DisplayIndex;
mfxU16 EnableDirtyRect;
mfxU16 EnableCursorCapture;
mfxU16 reserved[24];
} mfxExtScreenCaptureParam;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif

61
.github/actions/libmfx/include/mfx/mfxscd.h vendored Normal file
View File

@ -0,0 +1,61 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXSCD_H__
#define __MFXSCD_H__
#include "mfxenc.h"
#include "mfxplugin.h"
#define MFX_ENC_SCD_PLUGIN_VERSION 1
#ifdef __cplusplus
extern "C" {
#endif
static const mfxPluginUID MFX_PLUGINID_ENC_SCD = {{ 0xdf, 0xc2, 0x15, 0xb3, 0xe3, 0xd3, 0x90, 0x4d, 0x7f, 0xa5, 0x04, 0x12, 0x7e, 0xf5, 0x64, 0xd5 }};
/* SCD Extended Buffer Ids */
enum {
MFX_EXTBUFF_SCD = MFX_MAKEFOURCC('S','C','D',' ')
};
/* SceneType */
enum {
MFX_SCD_SCENE_SAME = 0x00,
MFX_SCD_SCENE_NEW_FIELD_1 = 0x01,
MFX_SCD_SCENE_NEW_FIELD_2 = 0x02,
MFX_SCD_SCENE_NEW_PICTURE = MFX_SCD_SCENE_NEW_FIELD_1 | MFX_SCD_SCENE_NEW_FIELD_2
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 SceneType;
mfxU16 reserved[27];
} mfxExtSCD;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif
#endif

50
.github/actions/libmfx/include/mfx/mfxsession.h vendored Normal file
View File

@ -0,0 +1,50 @@
// Copyright (c) 2017 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.
#ifndef __MFXSESSION_H__
#define __MFXSESSION_H__
#include "mfxcommon.h"
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/* Global Functions */
typedef struct _mfxSession *mfxSession;
mfxStatus MFX_CDECL MFXInit(mfxIMPL impl, mfxVersion *ver, mfxSession *session);
mfxStatus MFX_CDECL MFXInitEx(mfxInitParam par, mfxSession *session);
mfxStatus MFX_CDECL MFXClose(mfxSession session);
mfxStatus MFX_CDECL MFXQueryIMPL(mfxSession session, mfxIMPL *impl);
mfxStatus MFX_CDECL MFXQueryVersion(mfxSession session, mfxVersion *version);
mfxStatus MFX_CDECL MFXJoinSession(mfxSession session, mfxSession child);
mfxStatus MFX_CDECL MFXDisjoinSession(mfxSession session);
mfxStatus MFX_CDECL MFXCloneSession(mfxSession session, mfxSession *clone);
mfxStatus MFX_CDECL MFXSetPriority(mfxSession session, mfxPriority priority);
mfxStatus MFX_CDECL MFXGetPriority(mfxSession session, mfxPriority *priority);
mfxStatus MFX_CDECL MFXDoWork(mfxSession session);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif

2509
.github/actions/libmfx/include/mfx/mfxstructures.h vendored Normal file
View File

File diff suppressed because it is too large Load Diff

188
.github/actions/libmfx/include/mfx/mfxvideo++.h vendored Normal file
View File

@ -0,0 +1,188 @@
// Copyright (c) 2017 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.
#ifndef __MFXVIDEOPLUSPLUS_H
#define __MFXVIDEOPLUSPLUS_H
#include "mfxvideo.h"
#include "mfxenc.h"
#include "mfxpak.h"
class MFXVideoSession
{
public:
MFXVideoSession(void) { m_session = (mfxSession) 0; }
virtual ~MFXVideoSession(void) { Close(); }
virtual mfxStatus Init(mfxIMPL impl, mfxVersion *ver) { return MFXInit(impl, ver, &m_session); }
virtual mfxStatus InitEx(mfxInitParam par) { return MFXInitEx(par, &m_session); }
virtual mfxStatus Close(void)
{
mfxStatus mfxRes;
mfxRes = MFXClose(m_session); m_session = (mfxSession) 0;
return mfxRes;
}
virtual mfxStatus QueryIMPL(mfxIMPL *impl) { return MFXQueryIMPL(m_session, impl); }
virtual mfxStatus QueryVersion(mfxVersion *version) { return MFXQueryVersion(m_session, version); }
virtual mfxStatus JoinSession(mfxSession child_session) { return MFXJoinSession(m_session, child_session);}
virtual mfxStatus DisjoinSession( ) { return MFXDisjoinSession(m_session);}
virtual mfxStatus CloneSession( mfxSession *clone) { return MFXCloneSession(m_session, clone);}
virtual mfxStatus SetPriority( mfxPriority priority) { return MFXSetPriority(m_session, priority);}
virtual mfxStatus GetPriority( mfxPriority *priority) { return MFXGetPriority(m_session, priority);}
virtual mfxStatus SetBufferAllocator(mfxBufferAllocator *allocator) { return MFXVideoCORE_SetBufferAllocator(m_session, allocator); }
virtual mfxStatus SetFrameAllocator(mfxFrameAllocator *allocator) { return MFXVideoCORE_SetFrameAllocator(m_session, allocator); }
virtual mfxStatus SetHandle(mfxHandleType type, mfxHDL hdl) { return MFXVideoCORE_SetHandle(m_session, type, hdl); }
virtual mfxStatus GetHandle(mfxHandleType type, mfxHDL *hdl) { return MFXVideoCORE_GetHandle(m_session, type, hdl); }
virtual mfxStatus QueryPlatform(mfxPlatform* platform) { return MFXVideoCORE_QueryPlatform(m_session, platform); }
virtual mfxStatus SyncOperation(mfxSyncPoint syncp, mfxU32 wait) { return MFXVideoCORE_SyncOperation(m_session, syncp, wait); }
virtual mfxStatus DoWork() { return MFXDoWork(m_session); }
virtual operator mfxSession (void) { return m_session; }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
private:
MFXVideoSession(const MFXVideoSession &);
void operator=(MFXVideoSession &);
};
class MFXVideoENCODE
{
public:
MFXVideoENCODE(mfxSession session) { m_session = session; }
virtual ~MFXVideoENCODE(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoENCODE_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoENCODE_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoENCODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoENCODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoENCODE_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoENCODE_GetVideoParam(m_session, par); }
virtual mfxStatus GetEncodeStat(mfxEncodeStat *stat) { return MFXVideoENCODE_GetEncodeStat(m_session, stat); }
virtual mfxStatus EncodeFrameAsync(mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxSyncPoint *syncp) { return MFXVideoENCODE_EncodeFrameAsync(m_session, ctrl, surface, bs, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoDECODE
{
public:
MFXVideoDECODE(mfxSession session) { m_session = session; }
virtual ~MFXVideoDECODE(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoDECODE_Query(m_session, in, out); }
virtual mfxStatus DecodeHeader(mfxBitstream *bs, mfxVideoParam *par) { return MFXVideoDECODE_DecodeHeader(m_session, bs, par); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoDECODE_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoDECODE_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoDECODE_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoDECODE_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoDECODE_GetVideoParam(m_session, par); }
virtual mfxStatus GetDecodeStat(mfxDecodeStat *stat) { return MFXVideoDECODE_GetDecodeStat(m_session, stat); }
virtual mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) {return MFXVideoDECODE_GetPayload(m_session, ts, payload); }
virtual mfxStatus SetSkipMode(mfxSkipMode mode) { return MFXVideoDECODE_SetSkipMode(m_session, mode); }
virtual mfxStatus DecodeFrameAsync(mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp) { return MFXVideoDECODE_DecodeFrameAsync(m_session, bs, surface_work, surface_out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoVPP
{
public:
MFXVideoVPP(mfxSession session) { m_session = session; }
virtual ~MFXVideoVPP(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoVPP_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest request[2]) { return MFXVideoVPP_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoVPP_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoVPP_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoVPP_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoVPP_GetVideoParam(m_session, par); }
virtual mfxStatus GetVPPStat(mfxVPPStat *stat) { return MFXVideoVPP_GetVPPStat(m_session, stat); }
virtual mfxStatus RunFrameVPPAsync(mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxSyncPoint *syncp) { return MFXVideoVPP_RunFrameVPPAsync(m_session, in, out, aux, syncp); }
virtual mfxStatus RunFrameVPPAsyncEx(mfxFrameSurface1 *in, mfxFrameSurface1 *work, mfxFrameSurface1 **out, mfxSyncPoint *syncp) {return MFXVideoVPP_RunFrameVPPAsyncEx(m_session, in, work, out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoENC
{
public:
MFXVideoENC(mfxSession session) { m_session = session; }
virtual ~MFXVideoENC(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoENC_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoENC_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoENC_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoENC_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoENC_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoENC_GetVideoParam(m_session, par); }
virtual mfxStatus ProcessFrameAsync(mfxENCInput *in, mfxENCOutput *out, mfxSyncPoint *syncp) { return MFXVideoENC_ProcessFrameAsync(m_session, in, out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoPAK
{
public:
MFXVideoPAK(mfxSession session) { m_session = session; }
virtual ~MFXVideoPAK(void) { Close(); }
virtual mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoPAK_Query(m_session, in, out); }
virtual mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoPAK_QueryIOSurf(m_session, par, request); }
virtual mfxStatus Init(mfxVideoParam *par) { return MFXVideoPAK_Init(m_session, par); }
virtual mfxStatus Reset(mfxVideoParam *par) { return MFXVideoPAK_Reset(m_session, par); }
virtual mfxStatus Close(void) { return MFXVideoPAK_Close(m_session); }
virtual mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoPAK_GetVideoParam(m_session, par); }
//virtual mfxStatus GetEncodeStat(mfxEncodeStat *stat) { return MFXVideoENCODE_GetEncodeStat(m_session, stat); }
virtual mfxStatus ProcessFrameAsync(mfxPAKInput *in, mfxPAKOutput *out, mfxSyncPoint *syncp) { return MFXVideoPAK_ProcessFrameAsync(m_session, in, out, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
#endif // __MFXVIDEOPLUSPLUS_H

104
.github/actions/libmfx/include/mfx/mfxvideo.h vendored Normal file
View File

@ -0,0 +1,104 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXVIDEO_H__
#define __MFXVIDEO_H__
#include "mfxsession.h"
#include "mfxvstructures.h"
#ifdef __cplusplus
extern "C"
{
#endif
/* MFXVideoCORE */
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU32 reserved[4];
mfxHDL pthis;
mfxStatus (MFX_CDECL *Alloc) (mfxHDL pthis, mfxU32 nbytes, mfxU16 type, mfxMemId *mid);
mfxStatus (MFX_CDECL *Lock) (mfxHDL pthis, mfxMemId mid, mfxU8 **ptr);
mfxStatus (MFX_CDECL *Unlock) (mfxHDL pthis, mfxMemId mid);
mfxStatus (MFX_CDECL *Free) (mfxHDL pthis, mfxMemId mid);
} mfxBufferAllocator;
MFX_PACK_END()
MFX_PACK_BEGIN_STRUCT_W_PTR()
typedef struct {
mfxU32 reserved[4];
mfxHDL pthis;
mfxStatus (MFX_CDECL *Alloc) (mfxHDL pthis, mfxFrameAllocRequest *request, mfxFrameAllocResponse *response);
mfxStatus (MFX_CDECL *Lock) (mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr);
mfxStatus (MFX_CDECL *Unlock) (mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr);
mfxStatus (MFX_CDECL *GetHDL) (mfxHDL pthis, mfxMemId mid, mfxHDL *handle);
mfxStatus (MFX_CDECL *Free) (mfxHDL pthis, mfxFrameAllocResponse *response);
} mfxFrameAllocator;
MFX_PACK_END()
/* VideoCORE */
mfxStatus MFX_CDECL MFXVideoCORE_SetBufferAllocator(mfxSession session, mfxBufferAllocator *allocator);
mfxStatus MFX_CDECL MFXVideoCORE_SetFrameAllocator(mfxSession session, mfxFrameAllocator *allocator);
mfxStatus MFX_CDECL MFXVideoCORE_SetHandle(mfxSession session, mfxHandleType type, mfxHDL hdl);
mfxStatus MFX_CDECL MFXVideoCORE_GetHandle(mfxSession session, mfxHandleType type, mfxHDL *hdl);
mfxStatus MFX_CDECL MFXVideoCORE_QueryPlatform(mfxSession session, mfxPlatform* platform);
mfxStatus MFX_CDECL MFXVideoCORE_SyncOperation(mfxSession session, mfxSyncPoint syncp, mfxU32 wait);
/* VideoENCODE */
mfxStatus MFX_CDECL MFXVideoENCODE_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoENCODE_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoENCODE_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENCODE_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENCODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoENCODE_GetVideoParam(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoENCODE_GetEncodeStat(mfxSession session, mfxEncodeStat *stat);
mfxStatus MFX_CDECL MFXVideoENCODE_EncodeFrameAsync(mfxSession session, mfxEncodeCtrl *ctrl, mfxFrameSurface1 *surface, mfxBitstream *bs, mfxSyncPoint *syncp);
/* VideoDECODE */
mfxStatus MFX_CDECL MFXVideoDECODE_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoDECODE_DecodeHeader(mfxSession session, mfxBitstream *bs, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest *request);
mfxStatus MFX_CDECL MFXVideoDECODE_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoDECODE_GetVideoParam(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_GetDecodeStat(mfxSession session, mfxDecodeStat *stat);
mfxStatus MFX_CDECL MFXVideoDECODE_SetSkipMode(mfxSession session, mfxSkipMode mode);
mfxStatus MFX_CDECL MFXVideoDECODE_GetPayload(mfxSession session, mfxU64 *ts, mfxPayload *payload);
mfxStatus MFX_CDECL MFXVideoDECODE_DecodeFrameAsync(mfxSession session, mfxBitstream *bs, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp);
/* VideoVPP */
mfxStatus MFX_CDECL MFXVideoVPP_Query(mfxSession session, mfxVideoParam *in, mfxVideoParam *out);
mfxStatus MFX_CDECL MFXVideoVPP_QueryIOSurf(mfxSession session, mfxVideoParam *par, mfxFrameAllocRequest request[2]);
mfxStatus MFX_CDECL MFXVideoVPP_Init(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_Close(mfxSession session);
mfxStatus MFX_CDECL MFXVideoVPP_GetVideoParam(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_GetVPPStat(mfxSession session, mfxVPPStat *stat);
mfxStatus MFX_CDECL MFXVideoVPP_RunFrameVPPAsync(mfxSession session, mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxSyncPoint *syncp);
mfxStatus MFX_CDECL MFXVideoVPP_RunFrameVPPAsyncEx(mfxSession session, mfxFrameSurface1 *in, mfxFrameSurface1 *surface_work, mfxFrameSurface1 **surface_out, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif
#endif

71
.github/actions/libmfx/include/mfx/mfxvp8.h vendored Normal file
View File

@ -0,0 +1,71 @@
// Copyright (c) 2017-2019 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.
#ifndef __MFXVP8_H__
#define __MFXVP8_H__
#include "mfxdefs.h"
#ifdef __cplusplus
extern "C" {
#endif
enum {
MFX_CODEC_VP8 = MFX_MAKEFOURCC('V','P','8',' '),
};
/* CodecProfile*/
enum {
MFX_PROFILE_VP8_0 = 0+1,
MFX_PROFILE_VP8_1 = 1+1,
MFX_PROFILE_VP8_2 = 2+1,
MFX_PROFILE_VP8_3 = 3+1,
};
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_VP8_CODING_OPTION = MFX_MAKEFOURCC('V','P','8','E'),
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 Version;
mfxU16 EnableMultipleSegments;
mfxU16 LoopFilterType;
mfxU16 LoopFilterLevel[4];
mfxU16 SharpnessLevel;
mfxU16 NumTokenPartitions;
mfxI16 LoopFilterRefTypeDelta[4];
mfxI16 LoopFilterMbModeDelta[4];
mfxI16 SegmentQPDelta[4];
mfxI16 CoeffTypeQPDelta[5];
mfxU16 WriteIVFHeaders;
mfxU32 NumFramesForIVFHeader;
mfxU16 reserved[223];
} mfxExtVP8CodingOption;
MFX_PACK_END()
#ifdef __cplusplus
} // extern "C"
#endif
#endif

53
.github/actions/libmfx/include/mfx/mfxvp9.h vendored Normal file
View File

@ -0,0 +1,53 @@
// Copyright (c) 2018-2019 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.
#ifndef __MFXVP9_H__
#define __MFXVP9_H__
#include "mfxdefs.h"
#ifdef __cplusplus
extern "C" {
#endif
#if (MFX_VERSION >= MFX_VERSION_NEXT)
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_VP9_DECODED_FRAME_INFO = MFX_MAKEFOURCC('9','D','F','I')
};
MFX_PACK_BEGIN_USUAL_STRUCT()
typedef struct {
mfxExtBuffer Header;
mfxU16 DisplayWidth;
mfxU16 DisplayHeight;
mfxU16 reserved[58];
} mfxExtVP9DecodedFrameInfo;
MFX_PACK_END()
#endif
#ifdef __cplusplus
} // extern "C"
#endif
#endif

22
.github/actions/libmfx/include/mfx/mfxvstructures.h vendored Normal file
View File

@ -0,0 +1,22 @@
// Copyright (c) 2017 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 "mfxstructures.h"

BIN
.github/actions/libmfx/lib/mfx.lib vendored Normal file
View File

Binary file not shown.

BIN
.github/actions/libmfx/lib/mfxd.lib vendored Normal file
View File

Binary file not shown.