github-code/QWidgetDemo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增视频流播放

Browse Source
This commit is contained in:
feiyangqingyun
2020-04-22 14:37:21 +08:00
parent 9d8ff1c5cb
commit 08132be41f
915 changed files with 231380 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxdefs.h Normal file
View File

@@ -0,0 +1,112 @@
/* ****************************************************************************** *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2007-2012 Intel Corporation. All Rights Reserved.
File Name: mfxdefs.h
\* ****************************************************************************** */
#ifndef __MFXDEFS_H__
#define __MFXDEFS_H__
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#if defined( _WIN32 ) || defined ( _WIN64 )
#define __INT64 __int64
#define __UINT64 unsigned __int64
#else
#define __INT64 long long
#define __UINT64 unsigned long long
#endif
#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 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 */
/* warnings >0 */
MFX_WRN_IN_EXECUTION = 1, /* the previous asynchrous 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 */
/* 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 */
} mfxStatus;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __MFXDEFS_H__ */

45
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxjpeg.h Normal file
View File

@@ -0,0 +1,45 @@
/******************************************************************************* *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2010 - 2011 Intel Corporation. All Rights Reserved.
File Name: mfxjpeg.h
*******************************************************************************/
#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
};
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif // __MFX_JPEG_H__

91
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxmvc.h Normal file
View File

@@ -0,0 +1,91 @@
/******************************************************************************* *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2010 - 2011 Intel Corporation. All Rights Reserved.
File Name: mfxmvc.h
*******************************************************************************/
#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')
};
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;
typedef struct {
mfxU16 TemporalId; /* operation point temporal ID */
mfxU16 LevelIdc;
mfxU16 NumViews; /* total number of views, including "depend on" views */
mfxU16 NumTargetViews; /* number of the output views for the current operation point */
mfxU16 *TargetViewId; /* array of target view ID, it points to mfxExtMVCSeqDesc::ViewId, set by SDK */
} mfxMVCOperationPoint;
typedef struct {
mfxExtBuffer Header;
mfxU32 NumView; /* number of view in the stream, set by SDK */
mfxU32 NumViewAlloc; /* number of allocated elements, set by application */
mfxMVCViewDependency *View; /* view ID and list of views used as reference for this view, allocated by application */
mfxU32 NumViewId; /* num of views IDs, to simplify copying, set by SDK */
mfxU32 NumViewIdAlloc; /* number of allocated elements, set by application */
mfxU16 *ViewId; /* allocated by application */
mfxU32 NumOP; /* number of operation points in OP array, set by SDK */
mfxU32 NumOPAlloc; /* number of allocated elements in OP array, set by application */
mfxMVCOperationPoint *OP; /* allocated by application */
mfxU16 NumRefsTotal; /* total number of reference frames in the sequence */
mfxU32 Reserved[16];
} mfxExtMVCSeqDesc;
typedef struct {
mfxExtBuffer Header;
mfxU16 TemporalId;
mfxU32 NumView; /* number of view to decode */
mfxU16 ViewId[1024];
} mfxExtMVCTargetViews ;
#ifdef __cplusplus
} // extern "C"
#endif
#endif

55
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxplugin++.h Normal file
View File

@@ -0,0 +1,55 @@
/* ****************************************************************************** *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2011 Intel Corporation. All Rights Reserved.
File Name: mfxplugin++.h
\* ****************************************************************************** */
#ifndef __MFXPLUGINPLUSPLUS_H
#define __MFXPLUGINPLUSPLUS_H
#include "mfxvideo.h"
#include "mfxplugin.h"
class MFXPlugin
{
public:
virtual mfxStatus mfxPluginInit(mfxCoreInterface *core) = 0;
virtual mfxStatus mfxPluginClose() = 0;
virtual mfxStatus mfxGetPluginParam(mfxPluginParam *par) = 0;
virtual mfxStatus mfxSubmit(const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task) = 0;
virtual mfxStatus mfxExecute(mfxThreadTask task, mfxU32 uid_p, mfxU32 uid_a) = 0;
virtual mfxStatus mfxFreeResources(mfxThreadTask task, mfxStatus sts) = 0;
};
/* Class adapter between "C" structure mfxPlugin and C++ interface MFXPlugin */
class MFXPluginAdapter : public mfxPlugin
{
public:
MFXPluginAdapter(MFXPlugin *pPlugin)
{
pthis = pPlugin;
PluginInit = MFXPluginAdapter::_PluginInit;
PluginClose = MFXPluginAdapter::_PluginClose;
GetPluginParam = MFXPluginAdapter::_GetPluginParam;
Submit = MFXPluginAdapter::_Submit;
Execute = MFXPluginAdapter::_Execute;
FreeResources = MFXPluginAdapter::_FreeResources;
}
private:
static mfxStatus _PluginInit(mfxHDL pthis, mfxCoreInterface *core) { return ((MFXPlugin*)pthis)->mfxPluginInit(core); }
static mfxStatus _PluginClose(mfxHDL pthis) { return ((MFXPlugin*)pthis)->mfxPluginClose(); }
static mfxStatus _GetPluginParam(mfxHDL pthis, mfxPluginParam *par) { return ((MFXPlugin*)pthis)->mfxGetPluginParam(par); }
static mfxStatus _Submit(mfxHDL pthis, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxThreadTask *task) { return ((MFXPlugin*)pthis)->mfxSubmit(in, in_num, out, out_num, task); }
static mfxStatus _Execute(mfxHDL pthis, mfxThreadTask task, mfxU32 thread_id, mfxU32 call_count) { return ((MFXPlugin*)pthis)->mfxExecute(task, thread_id, call_count); }
static mfxStatus _FreeResources(mfxHDL pthis, mfxThreadTask task, mfxStatus sts) { return ((MFXPlugin*)pthis)->mfxFreeResources(task, sts); }
};
#endif // __MFXPLUGINPLUSPLUS_H

90
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxplugin.h Normal file
View File

@@ -0,0 +1,90 @@
/******************************************************************************* *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2007-2011 Intel Corporation. All Rights Reserved.
File Name: mfxplugin.h
*******************************************************************************/
#ifndef __MFXPLUGIN_H__
#define __MFXPLUGIN_H__
#include "mfxvideo.h"
#pragma warning(disable: 4201)
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
typedef enum {
MFX_THREADPOLICY_SERIAL = 0,
MFX_THREADPOLICY_PARALLEL = 1
} mfxThreadPolicy;
typedef struct mfxPluginParam {
mfxU32 reserved[14];
mfxThreadPolicy ThreadPolicy;
mfxU32 MaxThreadNum;
} mfxPluginParam;
typedef struct mfxCoreParam{
mfxU32 reserved[13];
mfxIMPL Impl;
mfxVersion Version;
mfxU32 NumWorkingThread;
} mfxCoreParam;
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);
mfxHDL reserved4[4];
} mfxCoreInterface;
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);
mfxHDL reserved[9];
} mfxPlugin;
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_ProcessFrameAsync(mfxSession session, const mfxHDL *in, mfxU32 in_num, const mfxHDL *out, mfxU32 out_num, mfxSyncPoint *syncp);
#ifdef __cplusplus
} // extern "C"
#endif /* __cplusplus */
#endif /* __MFXPLUGIN_H__ */

763
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxstructures.h Normal file
View File

@@ -0,0 +1,763 @@
/******************************************************************************* *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2007-2012 Intel Corporation. All Rights Reserved.
File Name: mfxstructures.h
*******************************************************************************/
#ifndef __MFXSTRUCTURES_H__
#define __MFXSTRUCTURES_H__
#include "mfxdefs.h"
#pragma warning(disable: 4201)
#ifdef __cplusplus
extern "C" {
#endif
#define MFX_MAKEFOURCC(A,B,C,D) ((((int)A))+(((int)B)<<8)+(((int)C)<<16)+(((int)D)<<24))
/* Extended Configuration Header Structure */
typedef struct {
mfxU32 BufferId;
mfxU32 BufferSz;
} mfxExtBuffer;
/* Frame ID for SVC and MVC */
typedef struct {
mfxU16 TemporalId;
mfxU16 PriorityId;
union {
struct {
mfxU16 DependencyId;
mfxU16 QualityId;
};
struct {
mfxU16 ViewId;
};
};
} mfxFrameId;
/* Frame Info */
typedef struct {
mfxU32 reserved[6];
mfxFrameId FrameId;
mfxU32 FourCC;
mfxU16 Width;
mfxU16 Height;
mfxU16 CropX;
mfxU16 CropY;
mfxU16 CropW;
mfxU16 CropH;
mfxU32 FrameRateExtN;
mfxU32 FrameRateExtD;
mfxU16 reserved3;
mfxU16 AspectRatioW;
mfxU16 AspectRatioH;
mfxU16 PicStruct;
mfxU16 ChromaFormat;
mfxU16 reserved2;
} mfxFrameInfo;
/* FourCC */
enum {
MFX_FOURCC_NV12 = MFX_MAKEFOURCC('N','V','1','2'), /* Native Format */
MFX_FOURCC_YV12 = MFX_MAKEFOURCC('Y','V','1','2'),
MFX_FOURCC_YUY2 = MFX_MAKEFOURCC('Y','U','Y','2'),
MFX_FOURCC_RGB3 = MFX_MAKEFOURCC('R','G','B','3'), /* RGB24 */
MFX_FOURCC_RGB4 = MFX_MAKEFOURCC('R','G','B','4'), /* RGB32 */
MFX_FOURCC_P8 = 41 /* D3DFMT_P8 */
};
/* PicStruct */
enum {
MFX_PICSTRUCT_UNKNOWN =0x00,
MFX_PICSTRUCT_PROGRESSIVE =0x01,
MFX_PICSTRUCT_FIELD_TFF =0x02,
MFX_PICSTRUCT_FIELD_BFF =0x04,
MFX_PICSTRUCT_FIELD_REPEATED=0x10, /* first field repeated, pic_struct=5 or 6 in H.264 */
MFX_PICSTRUCT_FRAME_DOUBLING=0x20, /* pic_struct=7 in H.264 */
MFX_PICSTRUCT_FRAME_TRIPLING=0x40 /* pic_struct=8 in H.264 */
};
/* ColorFormat */
enum {
MFX_CHROMAFORMAT_MONOCHROME =0,
MFX_CHROMAFORMAT_YUV420 =1,
MFX_CHROMAFORMAT_YUV422 =2,
MFX_CHROMAFORMAT_YUV444 =3,
MFX_CHROMAFORMAT_YUV400 = MFX_CHROMAFORMAT_MONOCHROME,
MFX_CHROMAFORMAT_YUV411 = 4,
MFX_CHROMAFORMAT_YUV422H = MFX_CHROMAFORMAT_YUV422,
MFX_CHROMAFORMAT_YUV422V = 5
};
enum {
MFX_TIMESTAMP_UNKNOWN = -1
};
enum {
MFX_FRAMEORDER_UNKNOWN = -1
};
/* DataFlag in mfxFrameData */
enum {
MFX_FRAMEDATA_ORIGINAL_TIMESTAMP = 0x0001
};
/* Corrupted in mfxFrameData */
enum {
MFX_CORRUPTION_MINOR = 0x0001,
MFX_CORRUPTION_MAJOR = 0x0002,
MFX_CORRUPTION_REFERENCE_FRAME = 0x0010,
MFX_CORRUPTION_REFERENCE_LIST = 0x0020
};
/* Frame Data Info */
typedef struct {
mfxU32 reserved[8];
mfxU64 TimeStamp;
mfxU32 FrameOrder;
mfxU16 Locked;
mfxU16 Pitch;
/* color planes */
union {
mfxU8 *Y;
mfxU8 *R;
};
union {
mfxU8 *UV; /* for UV merged formats */
mfxU8 *VU; /* for VU merged formats */
mfxU8 *CbCr; /* for CbCr merged formats */
mfxU8 *CrCb; /* for CrCb merged formats */
mfxU8 *Cb;
mfxU8 *U;
mfxU8 *G;
};
union {
mfxU8 *Cr;
mfxU8 *V;
mfxU8 *B;
};
mfxU8 *A;
mfxMemId MemId;
/* Additional Flags */
mfxU16 Corrupted;
mfxU16 DataFlag;
} mfxFrameData;
/* Frame Surface */
typedef struct {
mfxU32 reserved[4];
mfxFrameInfo Info;
mfxFrameData Data;
} mfxFrameSurface1;
enum {
MFX_TIMESTAMPCALC_UNKNOWN = 0,
MFX_TIMESTAMPCALC_TELECINE = 1,
};
/* Transcoding Info */
typedef struct {
mfxU32 reserved[7];
mfxU16 reserved4;
mfxU16 BRCParamMultiplier;
mfxFrameInfo FrameInfo;
mfxU32 CodecId;
mfxU16 CodecProfile;
mfxU16 CodecLevel;
mfxU16 NumThread;
union {
struct { /* MPEG-2/H.264 Encoding Options */
mfxU16 TargetUsage;
mfxU16 GopPicSize;
mfxU16 GopRefDist;
mfxU16 GopOptFlag;
mfxU16 IdrInterval;
mfxU16 RateControlMethod;
union {
mfxU16 InitialDelayInKB;
mfxU16 QPI;
mfxU16 Accuracy;
};
mfxU16 BufferSizeInKB;
union {
mfxU16 TargetKbps;
mfxU16 QPP;
};
union {
mfxU16 MaxKbps;
mfxU16 QPB;
mfxU16 Convergence;
};
mfxU16 NumSlice;
mfxU16 NumRefFrame;
mfxU16 EncodedOrder;
};
struct { /* H.264, MPEG-2 and VC-1 Decoding Options */
mfxU16 DecodedOrder;
mfxU16 ExtendedPicStruct;
mfxU16 TimeStampCalc;
mfxU16 reserved2[10];
};
struct { /* JPEG Decoding Options */
mfxU16 JPEGChromaFormat;
mfxU16 Rotation;
mfxU16 reserved3[11];
};
};
} mfxInfoMFX;
typedef struct {
mfxU32 reserved[8];
mfxFrameInfo In;
mfxFrameInfo Out;
} mfxInfoVPP;
typedef struct {
mfxU32 reserved[3];
mfxU16 reserved3;
mfxU16 AsyncDepth;
union {
mfxInfoMFX mfx;
mfxInfoVPP vpp;
};
mfxU16 Protected;
mfxU16 IOPattern;
mfxExtBuffer** ExtParam;
mfxU16 NumExtParam;
mfxU16 reserved2;
} mfxVideoParam;
/* IOPattern */
enum {
MFX_IOPATTERN_IN_VIDEO_MEMORY = 0x01,
MFX_IOPATTERN_IN_SYSTEM_MEMORY = 0x02,
MFX_IOPATTERN_IN_OPAQUE_MEMORY = 0x04,
MFX_IOPATTERN_OUT_VIDEO_MEMORY = 0x10,
MFX_IOPATTERN_OUT_SYSTEM_MEMORY = 0x20,
MFX_IOPATTERN_OUT_OPAQUE_MEMORY = 0x40
};
/* CodecId */
enum {
MFX_CODEC_AVC =MFX_MAKEFOURCC('A','V','C',' '),
MFX_CODEC_MPEG2 =MFX_MAKEFOURCC('M','P','G','2'),
MFX_CODEC_VC1 =MFX_MAKEFOURCC('V','C','1',' ')
};
/* CodecProfile, CodecLevel */
enum {
MFX_PROFILE_UNKNOWN =0,
MFX_LEVEL_UNKNOWN =0,
/* AVC Profiles & Levels */
MFX_PROFILE_AVC_CONSTRAINT_SET0 = (0x100 << 0),
MFX_PROFILE_AVC_CONSTRAINT_SET1 = (0x100 << 1),
MFX_PROFILE_AVC_CONSTRAINT_SET2 = (0x100 << 2),
MFX_PROFILE_AVC_CONSTRAINT_SET3 = (0x100 << 3),
MFX_PROFILE_AVC_CONSTRAINT_SET4 = (0x100 << 4),
MFX_PROFILE_AVC_CONSTRAINT_SET5 = (0x100 << 5),
MFX_PROFILE_AVC_BASELINE =66,
MFX_PROFILE_AVC_MAIN =77,
MFX_PROFILE_AVC_EXTENDED =88,
MFX_PROFILE_AVC_HIGH =100,
MFX_PROFILE_AVC_CONSTRAINED_BASELINE =MFX_PROFILE_AVC_BASELINE + MFX_PROFILE_AVC_CONSTRAINT_SET1,
MFX_PROFILE_AVC_CONSTRAINED_HIGH =MFX_PROFILE_AVC_HIGH + MFX_PROFILE_AVC_CONSTRAINT_SET4
+ MFX_PROFILE_AVC_CONSTRAINT_SET5,
MFX_PROFILE_AVC_PROGRESSIVE_HIGH =MFX_PROFILE_AVC_HIGH + MFX_PROFILE_AVC_CONSTRAINT_SET4,
MFX_LEVEL_AVC_1 =10,
MFX_LEVEL_AVC_1b =9,
MFX_LEVEL_AVC_11 =11,
MFX_LEVEL_AVC_12 =12,
MFX_LEVEL_AVC_13 =13,
MFX_LEVEL_AVC_2 =20,
MFX_LEVEL_AVC_21 =21,
MFX_LEVEL_AVC_22 =22,
MFX_LEVEL_AVC_3 =30,
MFX_LEVEL_AVC_31 =31,
MFX_LEVEL_AVC_32 =32,
MFX_LEVEL_AVC_4 =40,
MFX_LEVEL_AVC_41 =41,
MFX_LEVEL_AVC_42 =42,
MFX_LEVEL_AVC_5 =50,
MFX_LEVEL_AVC_51 =51,
/* MPEG-2 Profiles & Levels */
MFX_PROFILE_MPEG2_SIMPLE =0x50,
MFX_PROFILE_MPEG2_MAIN =0x40,
MFX_PROFILE_MPEG2_HIGH =0x10,
MFX_LEVEL_MPEG2_LOW =0xA,
MFX_LEVEL_MPEG2_MAIN =0x8,
MFX_LEVEL_MPEG2_HIGH =0x4,
MFX_LEVEL_MPEG2_HIGH1440 =0x6,
/* VC1 Profiles & Levels */
MFX_PROFILE_VC1_SIMPLE =(0+1),
MFX_PROFILE_VC1_MAIN =(4+1),
MFX_PROFILE_VC1_ADVANCED =(12+1),
/* VC1 levels for simple & main profiles */
MFX_LEVEL_VC1_LOW =(0+1),
MFX_LEVEL_VC1_MEDIAN =(2+1),
MFX_LEVEL_VC1_HIGH =(4+1),
/* VC1 levels for the advanced profile */
MFX_LEVEL_VC1_0 =(0x00+1),
MFX_LEVEL_VC1_1 =(0x01+1),
MFX_LEVEL_VC1_2 =(0x02+1),
MFX_LEVEL_VC1_3 =(0x03+1),
MFX_LEVEL_VC1_4 =(0x04+1)
};
/* GopOptFlag */
enum {
MFX_GOP_CLOSED =1,
MFX_GOP_STRICT =2
};
/* TargetUsages: from 1 to 7 inclusive */
enum {
MFX_TARGETUSAGE_UNKNOWN =0,
MFX_TARGETUSAGE_BEST_QUALITY =1,
MFX_TARGETUSAGE_BALANCED =4,
MFX_TARGETUSAGE_BEST_SPEED =7
};
/* RateControlMethod */
enum {
MFX_RATECONTROL_CBR =1,
MFX_RATECONTROL_VBR =2,
MFX_RATECONTROL_CQP =3,
MFX_RATECONTROL_AVBR =4
};
typedef struct {
mfxExtBuffer Header;
mfxU16 reserved1;
mfxU16 RateDistortionOpt; /* tri-state option */
mfxU16 MECostType;
mfxU16 MESearchType;
mfxI16Pair MVSearchWindow;
mfxU16 EndOfSequence; /* tri-state option */
mfxU16 FramePicture; /* tri-state option */
union {
struct { /* AVC */
mfxU16 CAVLC; /* tri-state option */
mfxU16 reserved2[3];
mfxU16 ViewOutput; /* tri-state option */
mfxU16 NalHrdConformance; /* tri-state option */
mfxU16 SingleSeiNalUnit; /* tri-state option */
mfxU16 VuiVclHrdParameters; /* tri-state option */
mfxU16 RefPicListReordering; /* tri-state option */
mfxU16 ResetRefList; /* tri-state option */
mfxU16 RefPicMarkRep; /* tri-state option */
mfxU16 FieldOutput; /* tri-state option */
mfxU16 IntraPredBlockSize;
mfxU16 InterPredBlockSize;
mfxU16 MVPrecision;
mfxU16 MaxDecFrameBuffering;
mfxU16 AUDelimiter; /* tri-state option */
mfxU16 EndOfStream; /* tri-state option */
mfxU16 PicTimingSEI; /* tri-state option */
mfxU16 VuiNalHrdParameters; /* tri-state option */
};
};
} mfxExtCodingOption;
/* IntraPredBlockSize/InterPredBlockSize */
enum {
MFX_BLOCKSIZE_UNKNOWN = 0,
MFX_BLOCKSIZE_MIN_16X16 = 1, /* 16x16 */
MFX_BLOCKSIZE_MIN_8X8 = 2, /* 16x16, 8x8 */
MFX_BLOCKSIZE_MIN_4X4 = 3 /* 16x16, 8x8, 4x4 */
};
/* MVPrecision */
enum {
MFX_MVPRECISION_UNKNOWN = 0,
MFX_MVPRECISION_INTEGER = (1 << 0),
MFX_MVPRECISION_HALFPEL = (1 << 1),
MFX_MVPRECISION_QUARTERPEL = (1 << 2)
};
enum {
MFX_CODINGOPTION_UNKNOWN =0,
MFX_CODINGOPTION_ON =0x10,
MFX_CODINGOPTION_OFF =0x20
};
typedef struct _mfxEncryptedData mfxEncryptedData;
typedef struct {
union {
mfxEncryptedData* EncryptedData;
mfxU32 reserved[8];
};
mfxU64 TimeStamp;
mfxU8* Data;
mfxU32 DataOffset;
mfxU32 DataLength;
mfxU32 MaxLength;
mfxU16 PicStruct;
mfxU16 FrameType;
mfxU16 DataFlag;
mfxU16 reserved2;
} mfxBitstream;
/* Data Flag */
enum {
MFX_BITSTREAM_COMPLETE_FRAME = 0x0001 /* the bitstream contains a complete frame or field pair of data */
};
/* Extended Buffer Ids */
enum {
MFX_EXTBUFF_CODING_OPTION = MFX_MAKEFOURCC('C','D','O','P'),
MFX_EXTBUFF_CODING_OPTION_SPSPPS= MFX_MAKEFOURCC('C','O','S','P'),
MFX_EXTBUFF_VPP_DONOTUSE = MFX_MAKEFOURCC('N','U','S','E'),
MFX_EXTBUFF_VPP_AUXDATA = MFX_MAKEFOURCC('A','U','X','D'),
MFX_EXTBUFF_VPP_DENOISE = MFX_MAKEFOURCC('D','N','I','S'),
MFX_EXTBUFF_VPP_SCENE_ANALYSIS = MFX_MAKEFOURCC('S','C','L','Y'),
MFX_EXTBUFF_VPP_SCENE_CHANGE = MFX_EXTBUFF_VPP_SCENE_ANALYSIS,
MFX_EXTBUFF_VPP_PROCAMP = MFX_MAKEFOURCC('P','A','M','P'),
MFX_EXTBUFF_VPP_DETAIL = MFX_MAKEFOURCC('D','E','T',' '),
MFX_EXTBUFF_VIDEO_SIGNAL_INFO = MFX_MAKEFOURCC('V','S','I','N'),
MFX_EXTBUFF_VPP_DOUSE = MFX_MAKEFOURCC('D','U','S','E'),
MFX_EXTBUFF_OPAQUE_SURFACE_ALLOCATION = MFX_MAKEFOURCC('O','P','Q','S'),
MFX_EXTBUFF_AVC_REFLIST_CTRL = MFX_MAKEFOURCC('R','L','S','T'),
MFX_EXTBUFF_VPP_FRAME_RATE_CONVERSION = MFX_MAKEFOURCC('F','R','C',' '),
MFX_EXTBUFF_PICTURE_TIMING_SEI = MFX_MAKEFOURCC('P','T','S','E'),
MFX_EXTBUFF_AVC_TEMPORAL_LAYERS = MFX_MAKEFOURCC('A','T','M','L')
};
/* VPP Conf: Do not use certain algorithms */
typedef struct {
mfxExtBuffer Header;
mfxU32 NumAlg;
mfxU32* AlgList;
} mfxExtVPPDoNotUse;
typedef struct {
mfxExtBuffer Header;
mfxU16 DenoiseFactor;
} mfxExtVPPDenoise;
typedef struct {
mfxExtBuffer Header;
mfxU16 DetailFactor;
} mfxExtVPPDetail;
typedef struct {
mfxExtBuffer Header;
mfxF64 Brightness;
mfxF64 Contrast;
mfxF64 Hue;
mfxF64 Saturation;
} mfxExtVPPProcAmp;
/* statistics collected for decode, encode and vpp */
typedef struct {
mfxU32 reserved[16];
mfxU32 NumFrame;
mfxU64 NumBit;
mfxU32 NumCachedFrame;
} mfxEncodeStat;
typedef struct {
mfxU32 reserved[16];
mfxU32 NumFrame;
mfxU32 NumSkippedFrame;
mfxU32 NumError;
mfxU32 NumCachedFrame;
} mfxDecodeStat;
typedef struct {
mfxU32 reserved[16];
mfxU32 NumFrame;
mfxU32 NumCachedFrame;
} mfxVPPStat;
typedef struct {
mfxExtBuffer Header;
mfxU32 SpatialComplexity;
mfxU32 TemporalComplexity;
mfxU16 SceneChangeRate;
mfxU16 RepeatedFrame;
} mfxExtVppAuxData;
typedef struct {
mfxU32 reserved[4];
mfxU8 *Data; /* buffer pointer */
mfxU32 NumBit; /* number of bits */
mfxU16 Type; /* SEI message type in H.264 or user data start_code in MPEG-2 */
mfxU16 BufSize; /* payload buffer size in bytes */
} mfxPayload;
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved[5];
mfxU16 reserved1;
mfxU16 QP; /* per frame QP */
mfxU16 FrameType;
mfxU16 NumExtParam;
mfxU16 NumPayload; /* MPEG-2 user data or H.264 SEI message(s) */
mfxU16 reserved2;
mfxExtBuffer **ExtParam;
mfxPayload **Payload; /* for field pair, first field uses even payloads and second field uses odd payloads */
} mfxEncodeCtrl;
/* Buffer Memory Types */
enum {
/* Buffer types */
MFX_MEMTYPE_PERSISTENT_MEMORY =0x0002
};
/* Frame Memory Types */
#define MFX_MEMTYPE_BASE(x) (0xf0ff & (x))
enum {
MFX_MEMTYPE_DXVA2_DECODER_TARGET =0x0010,
MFX_MEMTYPE_DXVA2_PROCESSOR_TARGET =0x0020,
MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET = MFX_MEMTYPE_DXVA2_DECODER_TARGET,
MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET = MFX_MEMTYPE_DXVA2_PROCESSOR_TARGET,
MFX_MEMTYPE_SYSTEM_MEMORY =0x0040,
MFX_MEMTYPE_FROM_ENCODE = 0x0100,
MFX_MEMTYPE_FROM_DECODE = 0x0200,
MFX_MEMTYPE_FROM_VPPIN = 0x0400,
MFX_MEMTYPE_FROM_VPPOUT = 0x0800,
MFX_MEMTYPE_INTERNAL_FRAME = 0x0001,
MFX_MEMTYPE_EXTERNAL_FRAME = 0x0002,
MFX_MEMTYPE_OPAQUE_FRAME = 0x0004
};
typedef struct {
mfxU32 reserved[4];
mfxFrameInfo Info;
mfxU16 Type; /* decoder or processor render targets */
mfxU16 NumFrameMin;
mfxU16 NumFrameSuggested;
mfxU16 reserved2;
} mfxFrameAllocRequest;
typedef struct {
mfxU32 reserved[4];
mfxMemId *mids; /* the array allocated by application */
mfxU16 NumFrameActual;
mfxU16 reserved2;
} mfxFrameAllocResponse;
/* FrameType */
enum {
MFX_FRAMETYPE_UNKNOWN =0x0000,
MFX_FRAMETYPE_I =0x0001,
MFX_FRAMETYPE_P =0x0002,
MFX_FRAMETYPE_B =0x0004,
MFX_FRAMETYPE_S =0x0008,
MFX_FRAMETYPE_REF =0x0040,
MFX_FRAMETYPE_IDR =0x0080,
MFX_FRAMETYPE_xI =0x0100,
MFX_FRAMETYPE_xP =0x0200,
MFX_FRAMETYPE_xB =0x0400,
MFX_FRAMETYPE_xS =0x0800,
MFX_FRAMETYPE_xREF =0x4000,
MFX_FRAMETYPE_xIDR =0x8000
};
typedef enum {
MFX_HANDLE_DIRECT3D_DEVICE_MANAGER9 =1, /* IDirect3DDeviceManager9 */
MFX_HANDLE_D3D9_DEVICE_MANAGER = MFX_HANDLE_DIRECT3D_DEVICE_MANAGER9,
MFX_HANDLE_D3D11_DEVICE_AND_CONTEXT = 2,
MFX_HANDLE_D3D11_DEVICE = 3,
MFX_HANDLE_VA_DISPLAY = 4
} mfxHandleType;
typedef enum {
MFX_SKIPMODE_NOSKIP=0,
MFX_SKIPMODE_MORE=1,
MFX_SKIPMODE_LESS=2
} mfxSkipMode;
/* 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_VIA_ANY = 0x0100,
MFX_IMPL_VIA_D3D9 = 0x0200,
MFX_IMPL_VIA_D3D11 = 0x0300,
MFX_IMPL_UNSUPPORTED = 0x0000 /* One of the MFXQueryIMPL returns */
};
/* Version Info */
typedef union {
struct {
mfxU16 Minor;
mfxU16 Major;
};
mfxU32 Version;
} mfxVersion;
typedef struct {
mfxExtBuffer Header;
mfxU8 *SPSBuffer;
mfxU8 *PPSBuffer;
mfxU16 SPSBufSize;
mfxU16 PPSBufSize;
mfxU16 SPSId;
mfxU16 PPSId;
} mfxExtCodingOptionSPSPPS;
/* session priority */
typedef enum
{
MFX_PRIORITY_LOW = 0,
MFX_PRIORITY_NORMAL = 1,
MFX_PRIORITY_HIGH = 2
} mfxPriority;
typedef struct {
mfxExtBuffer Header;
mfxU16 VideoFormat;
mfxU16 VideoFullRange;
mfxU16 ColourDescriptionPresent;
mfxU16 ColourPrimaries;
mfxU16 TransferCharacteristics;
mfxU16 MatrixCoefficients;
} mfxExtVideoSignalInfo;
typedef struct {
mfxExtBuffer Header;
mfxU32 NumAlg;
mfxU32 *AlgList;
} mfxExtVPPDoUse;
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[2];
struct {
mfxFrameSurface1 **Surfaces;
mfxU32 reserved2[5];
mfxU16 Type;
mfxU16 NumSurface;
} In, Out;
} mfxExtOpaqueSurfaceAlloc;
typedef struct {
mfxExtBuffer Header;
mfxU16 NumRefIdxL0Active;
mfxU16 NumRefIdxL1Active;
struct {
mfxU32 FrameOrder;
mfxU16 PicStruct;
mfxU16 ViewId;
mfxU32 reserved[2];
} PreferredRefList[32], RejectedRefList[16], LongTermRefList[16];
mfxU32 reserved[8];
} mfxExtAVCRefListCtrl;
enum {
MFX_FRCALGM_PRESERVE_TIMESTAMP = 1,
MFX_FRCALGM_DISTRIBUTED_TIMESTAMP = 2
};
typedef struct {
mfxExtBuffer Header;
mfxU16 Algorithm;
mfxU16 reserved;
mfxU32 reserved2[15];
} mfxExtVPPFrameRateConversion;
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved[14];
struct {
mfxU16 ClockTimestampFlag;
mfxU16 CtType;
mfxU16 NuitFieldBasedFlag;
mfxU16 CountingType;
mfxU16 FullTimestampFlag;
mfxU16 DiscontinuityFlag;
mfxU16 CntDroppedFlag;
mfxU16 NFrames;
mfxU16 SecondsFlag;
mfxU16 MinutesFlag;
mfxU16 HoursFlag;
mfxU16 SecondsValue;
mfxU16 MinutesValue;
mfxU16 HoursValue;
mfxU32 TimeOffset;
} TimeStamp[3];
} mfxExtPictureTimingSEI;
typedef struct {
mfxExtBuffer Header;
mfxU32 reserved1[4];
mfxU16 reserved2;
mfxU16 BaseLayerPID;
struct {
mfxU16 Scale;
mfxU16 reserved[3];
}Layer[8];
} mfxExtAvcTemporalLayers;
#ifdef __cplusplus
} // extern "C"
#endif
#endif

127
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxvideo++.h Normal file
View File

@@ -0,0 +1,127 @@
/* ****************************************************************************** *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2007-2010 Intel Corporation. All Rights Reserved.
File Name: mfxvideo++.h
\* ****************************************************************************** */
#ifndef __MFXVIDEOPLUSPLUS_H
#define __MFXVIDEOPLUSPLUS_H
#include "mfxvideo.h"
class MFXVideoSession
{
public:
MFXVideoSession(void) { m_session = (mfxSession) 0; }
virtual ~MFXVideoSession(void) { Close(); }
mfxStatus Init(mfxIMPL impl, mfxVersion *ver) { return MFXInit(impl, ver, &m_session); }
mfxStatus Close(void)
{
mfxStatus mfxRes;
mfxRes = MFXClose(m_session); m_session = (mfxSession) 0;
return mfxRes;
}
mfxStatus QueryIMPL(mfxIMPL *impl) { return MFXQueryIMPL(m_session, impl); }
mfxStatus QueryVersion(mfxVersion *version) { return MFXQueryVersion(m_session, version); }
mfxStatus JoinSession(mfxSession child_session) { return MFXJoinSession(m_session, child_session);}
mfxStatus DisjoinSession( ) { return MFXDisjoinSession(m_session);}
mfxStatus CloneSession( mfxSession *clone) { return MFXCloneSession(m_session, clone);}
mfxStatus SetPriority( mfxPriority priority) { return MFXSetPriority(m_session, priority);}
mfxStatus GetPriority( mfxPriority *priority) { return MFXGetPriority(m_session, priority);}
mfxStatus SetBufferAllocator(mfxBufferAllocator *allocator) { return MFXVideoCORE_SetBufferAllocator(m_session, allocator); }
mfxStatus SetFrameAllocator(mfxFrameAllocator *allocator) { return MFXVideoCORE_SetFrameAllocator(m_session, allocator); }
mfxStatus SetHandle(mfxHandleType type, mfxHDL hdl) { return MFXVideoCORE_SetHandle(m_session, type, hdl); }
mfxStatus GetHandle(mfxHandleType type, mfxHDL *hdl) { return MFXVideoCORE_GetHandle(m_session, type, hdl); }
mfxStatus SyncOperation(mfxSyncPoint syncp, mfxU32 wait) { return MFXVideoCORE_SyncOperation(m_session, syncp, wait); }
operator mfxSession (void) { return m_session; }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
class MFXVideoENCODE
{
public:
MFXVideoENCODE(mfxSession session) { m_session = session; }
virtual ~MFXVideoENCODE(void) { Close(); }
mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoENCODE_Query(m_session, in, out); }
mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoENCODE_QueryIOSurf(m_session, par, request); }
mfxStatus Init(mfxVideoParam *par) { return MFXVideoENCODE_Init(m_session, par); }
mfxStatus Reset(mfxVideoParam *par) { return MFXVideoENCODE_Reset(m_session, par); }
mfxStatus Close(void) { return MFXVideoENCODE_Close(m_session); }
mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoENCODE_GetVideoParam(m_session, par); }
mfxStatus GetEncodeStat(mfxEncodeStat *stat) { return MFXVideoENCODE_GetEncodeStat(m_session, stat); }
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(); }
mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoDECODE_Query(m_session, in, out); }
mfxStatus DecodeHeader(mfxBitstream *bs, mfxVideoParam *par) { return MFXVideoDECODE_DecodeHeader(m_session, bs, par); }
mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest *request) { return MFXVideoDECODE_QueryIOSurf(m_session, par, request); }
mfxStatus Init(mfxVideoParam *par) { return MFXVideoDECODE_Init(m_session, par); }
mfxStatus Reset(mfxVideoParam *par) { return MFXVideoDECODE_Reset(m_session, par); }
mfxStatus Close(void) { return MFXVideoDECODE_Close(m_session); }
mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoDECODE_GetVideoParam(m_session, par); }
mfxStatus GetDecodeStat(mfxDecodeStat *stat) { return MFXVideoDECODE_GetDecodeStat(m_session, stat); }
mfxStatus GetPayload(mfxU64 *ts, mfxPayload *payload) {return MFXVideoDECODE_GetPayload(m_session, ts, payload); }
mfxStatus SetSkipMode(mfxSkipMode mode) { return MFXVideoDECODE_SetSkipMode(m_session, mode); }
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(); }
mfxStatus Query(mfxVideoParam *in, mfxVideoParam *out) { return MFXVideoVPP_Query(m_session, in, out); }
mfxStatus QueryIOSurf(mfxVideoParam *par, mfxFrameAllocRequest request[2]) { return MFXVideoVPP_QueryIOSurf(m_session, par, request); }
mfxStatus Init(mfxVideoParam *par) { return MFXVideoVPP_Init(m_session, par); }
mfxStatus Reset(mfxVideoParam *par) { return MFXVideoVPP_Reset(m_session, par); }
mfxStatus Close(void) { return MFXVideoVPP_Close(m_session); }
mfxStatus GetVideoParam(mfxVideoParam *par) { return MFXVideoVPP_GetVideoParam(m_session, par); }
mfxStatus GetVPPStat(mfxVPPStat *stat) { return MFXVideoVPP_GetVPPStat(m_session, stat); }
mfxStatus RunFrameVPPAsync(mfxFrameSurface1 *in, mfxFrameSurface1 *out, mfxExtVppAuxData *aux, mfxSyncPoint *syncp) { return MFXVideoVPP_RunFrameVPPAsync(m_session, in, out, aux, syncp); }
protected:
mfxSession m_session; // (mfxSession) handle to the owning session
};
#endif // __MFXVIDEOPLUSPLUS_H

117
ffmpegdemo/ffmpeg/ffmpeg4/include/mfx/mfxvideo.h Normal file
View File

@@ -0,0 +1,117 @@
/* ****************************************************************************** *\
INTEL CORPORATION PROPRIETARY INFORMATION
This software is supplied under the terms of a license agreement or nondisclosure
agreement with Intel Corporation and may not be copied or disclosed except in
accordance with the terms of that agreement
Copyright(c) 2007-2012 Intel Corporation. All Rights Reserved.
File Name: mfxvideo.h
\* ****************************************************************************** */
#ifndef __MFXVIDEO_H__
#define __MFXVIDEO_H__
#include "mfxstructures.h"
/* This is the external include file for the Intel(R) Media Sofware Development Kit product */
#define MFX_VERSION_MAJOR 1
#define MFX_VERSION_MINOR 4
#ifdef _WIN32
#define MFX_CDECL __cdecl
#define MFX_STDCALL __stdcall
#else
#define MFX_CDECL
#define MFX_STDCALL
#endif /* _WIN32 */
#ifdef __cplusplus
extern "C"
{
#endif
/* MFXVideoCORE */
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;
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;
/* Global Functions */
typedef struct _mfxSession *mfxSession;
mfxStatus MFX_CDECL MFXInit(mfxIMPL impl, mfxVersion *ver, 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);
/* 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);
typedef struct _mfxSyncPoint *mfxSyncPoint;
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);
#ifdef __cplusplus
} // extern "C"
#endif
#endif