/* * 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. */ //! //! \file cm_rt.h //! \brief Contains all exposed APIs and Definitions for CM //! #ifndef __CM_RT_H__ #define __CM_RT_H__ //********************************************************************** // Version //********************************************************************** #ifndef CM_1_0 #define CM_1_0 100 #endif #ifndef CM_2_0 #define CM_2_0 200 #endif #ifndef CM_2_1 #define CM_2_1 201 #endif #ifndef CM_2_2 #define CM_2_2 202 #endif #ifndef CM_2_3 #define CM_2_3 203 #endif #ifndef CM_2_4 #define CM_2_4 204 #endif #ifndef CM_3_0 #define CM_3_0 300 #endif #ifndef CM_4_0 #define CM_4_0 400 #endif #ifndef CM_5_0 #define CM_5_0 500 #endif #ifndef CM_6_0 #define CM_6_0 600 #endif #ifndef CM_7_0 #define CM_7_0 700 #endif #ifndef CM_7_2 #define CM_7_2 702 //for MDFRT API refreshment. #endif //Legacy MACRO, will be removed later #ifndef __INTEL_MDF #define __INTEL_MDF (CM_7_2) #endif //New MACRO #ifndef __INTEL_CM #define __INTEL_CM (CM_7_2) #endif //********************************************************************** // external headers //********************************************************************** #include //********************************************************************** // Macros //********************************************************************** #ifdef __cplusplus #define EXTERN_C extern "C" #else #define EXTERN_C #endif #define CM_RT_API #define CM_KERNEL_FUNCTION(...) CM_KERNEL_FUNCTION2(__VA_ARGS__) #define _NAME_MERGE_(x, y) x ## y #define _NAME_LABEL_(name, id) _NAME_MERGE_(name, id) #define __CODEGEN_UNIQUE(name) _NAME_LABEL_(name, __LINE__) #define BITFIELD_RANGE( startbit, endbit ) ((endbit)-(startbit)+1) #define BITFIELD_BIT(bit) 1 #define CM_MIN_SURF_WIDTH 1 #define CM_MIN_SURF_HEIGHT 1 #define CM_MIN_SURF_DEPTH 2 #define CM_MAX_1D_SURF_WIDTH 0x80000000 // 2^31 2 GB #define CM_MAX_2D_SURF_WIDTH 16384 #define CM_MAX_2D_SURF_HEIGHT 16384 #define CM_MAX_3D_SURF_WIDTH 2048 #define CM_MAX_3D_SURF_HEIGHT 2048 #define CM_MAX_3D_SURF_DEPTH 2048 #define CM_MAX_OPTION_SIZE_IN_BYTE 512 #define CM_MAX_KERNEL_NAME_SIZE_IN_BYTE 256 #define CM_MAX_ISA_FILE_NAME_SIZE_IN_BYTE 256 #define CM_MAX_THREADSPACE_WIDTH_FOR_MW 511 #define CM_MAX_THREADSPACE_HEIGHT_FOR_MW 511 #define CM_MAX_THREADSPACE_WIDTH_FOR_MO 512 #define CM_MAX_THREADSPACE_HEIGHT_FOR_MO 512 #define CM_MAX_THREADSPACE_WIDTH_SKLUP_FOR_MW 2047 #define CM_MAX_THREADSPACE_HEIGHT_SKLUP_FOR_MW 2047 //Time in seconds before kernel should timeout #define CM_MAX_TIMEOUT 2 //Time in milliseconds before kernel should timeout #define CM_MAX_TIMEOUT_MS CM_MAX_TIMEOUT*1000 #define CM_NO_EVENT ((CmEvent *)(-1)) //NO Event // Cm Device Create Option #define CM_DEVICE_CREATE_OPTION_SCRATCH_SPACE_DISABLE 1 #define CM_DEVICE_CREATE_OPTION_TDR_DISABLE 64 #define CM_DEVICE_CONFIG_DISABLE_TASKFLUSHEDSEMAPHORE_OFFSET 6 #define CM_DEVICE_CONFIG_DISABLE_TASKFLUSHEDSEMAPHORE_MASK (1< [true..false] bool enable_rgb_adaptive_filter; // adaptive filter for all channels. validValues => [true..false] bool enable_8_tap_adaptive_filter; // enable 8-tap filter. validValues => [true..false] bool enable_uv_8_tap_filter; // enable 8-tap filter on UV/RB channels. validValues => [true..false] bool writeback_format; // true sampleunorm, false standard. validValues => [true..false] bool writeback_mode; // true vsa, false ief. validValues => [true..false] BYTE state_selection; // 0=>first,1=>second scaler8x8 state. validValues => [0..1] // Image enhancement filter settings. bool enable_ief; // image enhancement filter enable. validValues => [true..false] bool ief_type; // true "basic" or false "advanced". validValues => [true..false] bool enable_ief_smooth; // true based on 3x3, false based on 5x5 validValues => [true..false] float r3c_coefficient; // smoothing coeffient. Valid values => [0.0..0.96875] float r3x_coefficient; // smoothing coeffient. Valid values => [0.0..0.96875] float r5c_coefficient; // smoothing coeffient. validValues => [0.0..0.96875] float r5cx_coefficient; // smoothing coeffient. validValues => [0.0..0.96875] float r5x_coefficient; // smoothing coeffient. validValues => [0.0..0.96875] // Edge processing settings. BYTE strong_edge_threshold; // validValues => [0..64] BYTE strong_edge_weight; // Sharpening strength when a strong edge. validValues => [0..7] BYTE weak_edge_threshold; // validValues => [0..64] BYTE regular_edge_weight; // Sharpening strength when a weak edge. validValues => [0..7] BYTE non_edge_weight; // Sharpening strength when no edge. validValues => [0..7] // Chroma key. bool enable_chroma_key; // Chroma keying be performed. validValues => [true..false] BYTE chroma_key_index; // ChromaKey Table entry. validValues => [0..3] // Skin tone settings. bool enable_skin_tone; // SkinToneTunedIEF_Enable. validValues => [true..false] bool enable_vy_skin_tone_detection; // Enables STD in the VY subspace. validValues => [true..false] bool skin_detail_factor; // validValues => [true..false] BYTE skin_types_margin; // validValues => [0..255] BYTE skin_types_threshold; // validValues => [0..255] // Miscellaneous settings. BYTE gain_factor; // validValues => [0..63] BYTE global_noise_estimation; // validValues => [0..255] bool mr_boost; // validValues => [true..false] BYTE mr_smooth_threshold; // validValues => [0..3] BYTE mr_threshold; bool steepness_boost; // validValues => [true..false] BYTE steepness_threshold; // validValues => [0..15] bool texture_coordinate_mode; // true: clamp, false: mirror. validValues => [true..false] BYTE max_hue; // Rectangle half width. validValued => [0..63] BYTE max_saturation; // Rectangle half length. validValued => [0..63] int angles; // validValued => [0..360] BYTE diamond_margin ; // validValues => [0..7] char diamond_du; // Rhombus center shift in the sat-direction. validValues => [-64..63] char diamond_dv; // Rhombus center shift in the hue-direction. validValues => [-64..63] float diamond_alpha; // validValues => [0.0..4.0] BYTE diamond_threshold; // validValues => [0..63] BYTE rectangle_margin; // validValues => [0..7] BYTE rectangle_midpoint[2]; // validValues => [[0..255, 0..255]] float vy_inverse_margin[2]; // validValues => [[0.0..1.0, 0.0..1.0]] // Piecewise linear function settings. BYTE piecewise_linear_y_points[4]; // validValues => [[0..255, 0..255, 0..255, 0..255]] float piecewise_linear_y_slopes[2]; // validValues => [[-4.0...4.0, -4.0...4.0]] BYTE piecewise_linear_points_lower[4]; // validValues => [[0..255, 0..255, 0..255, 0..255]] BYTE piecewise_linear_points_upper[4]; // validValues => [[0..255, 0..255, 0..255, 0..255]] float piecewise_linear_slopes_lower[4]; // validValues => [[-4.0...4.0, -4.0...4.0, -4.0...4.0, -4.0...4.0]] float piecewise_linear_slopes_upper[4]; // validValues => [[-4.0...4.0, -4.0...4.0, -4.0...4.0, -4.0...4.0]] BYTE piecewise_linear_biases_lower[4]; // validValues => [[0..255, 0..255, 0..255, 0..255]] BYTE piecewise_linear_biases_upper[4]; // validValues => [[0..255, 0..255, 0..255, 0..255]] // AVS non-pipelined states. BYTE default_sharpness_level; // default coefficient between smooth and sharp filtering. validValues => [0..255] bool enable_x_adaptive_filter; // validValues => [true, false] bool enable_y_adaptive_filter; // validValues => [true, false] BYTE max_derivative_4_pixels; // lower boundary of the smooth 4 pixel area. validValues => [0..255] BYTE max_derivative_8_pixels; // lower boundary of the smooth 8 pixel area. validValues => [0..255] BYTE transition_area_4_pixels; // used in adaptive filtering to specify the width of the transition area for the 4 pixel calculation. validValues => [0..8] BYTE transition_area_8_pixels; // Used in adaptive filtering to specify the width of the transition area for the 8 pixel calculation. validValues => [0..8] CM_AVS_COEFF_TABLE table0_x[CM_NUM_COEFF_ROWS_SKL]; CM_AVS_COEFF_TABLE table0_y[CM_NUM_COEFF_ROWS_SKL]; CM_AVS_COEFF_TABLE table1_x[CM_NUM_COEFF_ROWS_SKL]; CM_AVS_COEFF_TABLE table1_y[CM_NUM_COEFF_ROWS_SKL]; }; /* * CONVOLVE STATE DATA STRUCTURES */ typedef struct _CM_CONVOLVE_COEFF_TABLE{ float FilterCoeff_0_0; float FilterCoeff_0_1; float FilterCoeff_0_2; float FilterCoeff_0_3; float FilterCoeff_0_4; float FilterCoeff_0_5; float FilterCoeff_0_6; float FilterCoeff_0_7; float FilterCoeff_0_8; float FilterCoeff_0_9; float FilterCoeff_0_10; float FilterCoeff_0_11; float FilterCoeff_0_12; float FilterCoeff_0_13; float FilterCoeff_0_14; float FilterCoeff_0_15; float FilterCoeff_0_16; float FilterCoeff_0_17; float FilterCoeff_0_18; float FilterCoeff_0_19; float FilterCoeff_0_20; float FilterCoeff_0_21; float FilterCoeff_0_22; float FilterCoeff_0_23; float FilterCoeff_0_24; float FilterCoeff_0_25; float FilterCoeff_0_26; float FilterCoeff_0_27; float FilterCoeff_0_28; float FilterCoeff_0_29; float FilterCoeff_0_30; float FilterCoeff_0_31; }CM_CONVOLVE_COEFF_TABLE; typedef struct _CM_CONVOLVE_STATE_MSG{ bool CoeffSize; //true 16-bit, false 8-bit byte SclDwnValue; //Scale down value byte Width; //Kernel Width byte Height; //Kernel Height //SKL mode bool isVertical32Mode; bool isHorizontal32Mode; CM_CONVOLVE_SKL_TYPE nConvolveType; CM_CONVOLVE_COEFF_TABLE Table[CM_NUM_CONVOLVE_ROWS_SKL]; } CM_CONVOLVE_STATE_MSG; /* * MISC SAMPLER8x8 State */ typedef struct _CM_MISC_STATE { //DWORD 0 union{ struct{ DWORD Row0 : 16; DWORD Reserved : 8; DWORD Width : 4; DWORD Height : 4; }; struct{ DWORD value; }; } DW0; //DWORD 1 union{ struct{ DWORD Row1 : 16; DWORD Row2 : 16; }; struct{ DWORD value; }; } DW1; //DWORD 2 union{ struct{ DWORD Row3 : 16; DWORD Row4 : 16; }; struct{ DWORD value; }; } DW2; //DWORD 3 union{ struct{ DWORD Row5 : 16; DWORD Row6 : 16; }; struct{ DWORD value; }; } DW3; //DWORD 4 union{ struct{ DWORD Row7 : 16; DWORD Row8 : 16; }; struct{ DWORD value; }; } DW4; //DWORD 5 union{ struct{ DWORD Row9 : 16; DWORD Row10 : 16; }; struct{ DWORD value; }; } DW5; //DWORD 6 union{ struct{ DWORD Row11 : 16; DWORD Row12 : 16; }; struct{ DWORD value; }; } DW6; //DWORD 7 union{ struct{ DWORD Row13 : 16; DWORD Row14 : 16; }; struct{ DWORD value; }; } DW7; } CM_MISC_STATE; typedef struct _CM_MISC_STATE_MSG{ //DWORD 0 union{ struct{ DWORD Row0 : 16; DWORD Reserved : 8; DWORD Width : 4; DWORD Height : 4; }; struct{ DWORD value; }; }DW0; //DWORD 1 union{ struct{ DWORD Row1 : 16; DWORD Row2 : 16; }; struct{ DWORD value; }; }DW1; //DWORD 2 union{ struct{ DWORD Row3 : 16; DWORD Row4 : 16; }; struct{ DWORD value; }; }DW2; //DWORD 3 union{ struct{ DWORD Row5 : 16; DWORD Row6 : 16; }; struct{ DWORD value; }; }DW3; //DWORD 4 union{ struct{ DWORD Row7 : 16; DWORD Row8 : 16; }; struct{ DWORD value; }; }DW4; //DWORD 5 union{ struct{ DWORD Row9 : 16; DWORD Row10 : 16; }; struct{ DWORD value; }; }DW5; //DWORD 6 union{ struct{ DWORD Row11 : 16; DWORD Row12 : 16; }; struct{ DWORD value; }; }DW6; //DWORD 7 union{ struct{ DWORD Row13 : 16; DWORD Row14 : 16; }; struct{ DWORD value; }; }DW7; } CM_MISC_STATE_MSG; enum CM_SAMPLER_STATE_TYPE { CM_SAMPLER8X8_AVS = 0, CM_SAMPLER8X8_CONV = 1, CM_SAMPLER8X8_MISC = 3, CM_SAMPLER8X8_CONV1DH = 4, CM_SAMPLER8X8_CONV1DV = 5, CM_SAMPLER8X8_AVS_EX = 6, CM_SAMPLER8X8_NONE }; struct CM_SAMPLER_8X8_DESCR { CM_SAMPLER_STATE_TYPE stateType; union { CM_AVS_STATE_MSG *avs; CM_AVS_STATE_MSG_EX *avs_ex; CM_CONVOLVE_STATE_MSG *conv; CM_MISC_STATE_MSG *misc; //ERODE/DILATE/MINMAX }; }; typedef struct _CM_VEBOX_STATE { DWORD ColorGamutExpansionEnable : 1; DWORD ColorGamutCompressionEnable : 1; DWORD GlobalIECPEnable : 1; DWORD DNEnable : 1; DWORD DIEnable : 1; DWORD DNDIFirstFrame : 1; DWORD DownsampleMethod422to420 : 1; DWORD DownsampleMethod444to422 : 1; DWORD DIOutputFrames : 2; DWORD DemosaicEnable : 1; DWORD VignetteEnable : 1; DWORD AlphaPlaneEnable : 1; DWORD HotPixelFilteringEnable : 1; DWORD SingleSliceVeboxEnable : 1; DWORD LaceCorrectionEnable : BITFIELD_BIT(16); DWORD DisableEncoderStatistics : BITFIELD_BIT(17); DWORD DisableTemporalDenoiseFilter : BITFIELD_BIT(18); DWORD SinglePipeEnable : BITFIELD_BIT(19); DWORD __CODEGEN_UNIQUE(Reserved) : BITFIELD_BIT(20); DWORD ForwardGammaCorrectionEnable : BITFIELD_BIT(21); DWORD __CODEGEN_UNIQUE(Reserved) : BITFIELD_RANGE(22, 24); DWORD StateSurfaceControlBits : BITFIELD_RANGE(25, 31); } CM_VEBOX_STATE, *PCM_VEBOX_STATE; typedef struct _CM_POWER_OPTION { USHORT nSlice; // set number of slice to use: 0(default number), 1, 2... USHORT nSubSlice; // set number of subslice to use: 0(default number), 1, 2... USHORT nEU; // set number of EU to use: 0(default number), 1, 2... } CM_POWER_OPTION, *PCM_POWER_OPTION; // to support new flag with current API // new flag/field could be add to the end of this structure // struct CM_FLAG { CM_FLAG(); CM_ROTATION rotationFlag; INT chromaSiting; }; struct _CM_TASK_CONFIG { bool turboBoostFlag : 1; bool fusedEuDispatchFlag : 1; uint32_t reserved_bits :30; uint32_t reserved0; uint32_t reserved1; uint32_t reserved2; }; typedef enum _CM_KERNEL_EXEC_MODE { CM_KERNEL_EXECUTION_MODE_MONOPOLIZED = 0, // Kernel can occupy all DSS for execution */ CM_KERNEL_EXECUTION_MODE_CONCURRENT, // Kernel can occupy part of DSS and concurrently execute together with other workloads. } CM_KERNEL_EXEC_MODE; struct CM_EXECUTION_CONFIG { CM_KERNEL_EXEC_MODE kernelExecutionMode = CM_KERNEL_EXECUTION_MODE_MONOPOLIZED; int concurrentPolicy = 0; // Reserve for future extension. }; #define CM_TASK_CONFIG _CM_TASK_CONFIG // parameters used to set the surface state of the buffer typedef struct _CM_SURFACE_MEM_OBJ_CTRL { MEMORY_OBJECT_CONTROL mem_ctrl; MEMORY_TYPE mem_type; INT age; } CM_SURFACE_MEM_OBJ_CTRL; typedef struct _CM_BUFFER_STATE_PARAM { UINT uiSize; // the new size of the buffer, if it is 0, set it as the (original width - offset) UINT uiBaseAddressOffset; // offset should be 16-aligned CM_SURFACE_MEM_OBJ_CTRL mocs; // if not set (all zeros), then the aliases mocs setting is the same as the origin }CM_BUFFER_STATE_PARAM; typedef struct _CM_SURFACE2D_STATE_PARAM { UINT format; UINT width; UINT height; UINT depth; UINT pitch; WORD memory_object_control; UINT surface_x_offset; UINT surface_y_offset; UINT reserved[4]; // for future usage } CM_SURFACE2D_STATE_PARAM; struct _CM_QUEUE_CREATE_OPTION { CM_QUEUE_TYPE QueueType : 3; bool RAMode : 1; unsigned int Reserved0 : 3; bool UserGPUContext : 1; // Is the user-provided GPU Context already created externally unsigned int GPUContext : 8; // user-provided GPU Context ordinal CM_QUEUE_SSEU_USAGE_HINT_TYPE SseuUsageHint : 3; unsigned int Reserved1 : 1; unsigned int Reserved2 : 12; }; #define CM_QUEUE_CREATE_OPTION _CM_QUEUE_CREATE_OPTION typedef enum _CM_CONDITIONAL_END_OPERATOR_CODE { MAD_GREATER_THAN_IDD = 0, MAD_GREATER_THAN_OR_EQUAL_IDD, MAD_LESS_THAN_IDD, MAD_LESS_THAN_OR_EQUAL_IDD, MAD_EQUAL_IDD, MAD_NOT_EQUAL_IDD } CM_CONDITIONAL_END_OPERATOR_CODE; struct CM_CONDITIONAL_END_PARAM { DWORD opValue; CM_CONDITIONAL_END_OPERATOR_CODE opCode; bool opMask; bool opLevel; }; struct CM_KERNEL_SYNC_CONFIG { bool dataCacheFlush : 1; // true: cache will be flushed; uint32_t reserved : 31; }; //********************************************************************** // Classes forward declarations //********************************************************************** class CmSampler8x8; class CmEvent; class CmThreadGroupSpace; class CmKernel; class CmTask; class CmProgram; class CmBuffer; class CmBufferUP; class CmBufferSVM; class CmBufferStateless; class CmSurface2D; class CmSurface2DUP; class CmSurface2DStateless; class CmSurface3D; class CmSampler; class CmThreadSpace; class CmVebox; class CmQueue; class SurfaceIndex; class SamplerIndex; //********************************************************************** // Extended definitions if any //********************************************************************** #include "cm_rt_extension.h" //********************************************************************** // Constants //********************************************************************** const CM_QUEUE_CREATE_OPTION CM_DEFAULT_QUEUE_CREATE_OPTION = { CM_QUEUE_TYPE_RENDER, false, 0, false, 0, CM_QUEUE_SSEU_USAGE_HINT_DEFAULT, 0, 0 }; //********************************************************************** // Classes //********************************************************************** class CmSampler8x8 { public: CM_RT_API virtual INT GetIndex( SamplerIndex* & pIndex ) = 0 ; protected: ~CmSampler8x8(){}; }; class CmEvent { public: CM_RT_API virtual INT GetStatus( CM_STATUS& status) = 0 ; CM_RT_API virtual INT GetExecutionTime(UINT64& time) = 0; CM_RT_API virtual INT WaitForTaskFinished(DWORD dwTimeOutMs = CM_MAX_TIMEOUT_MS) = 0 ; CM_RT_API virtual INT GetSurfaceDetails( UINT kernIndex, UINT surfBTI,CM_SURFACE_DETAILS& outDetails )=0; CM_RT_API virtual INT GetProfilingInfo(CM_EVENT_PROFILING_INFO infoType, size_t paramSize, PVOID pInputValue, PVOID pValue) = 0; CM_RT_API virtual INT GetExecutionTickTime(UINT64& ticks) = 0; protected: ~CmEvent(){}; }; class CmKernel { public: CM_RT_API virtual INT SetThreadCount(UINT count ) = 0; CM_RT_API virtual INT SetKernelArg(UINT index, size_t size, const void * pValue ) = 0; CM_RT_API virtual INT SetThreadArg(UINT threadId, UINT index, size_t size, const void * pValue ) = 0; CM_RT_API virtual INT SetStaticBuffer(UINT index, const void * pValue ) = 0; CM_RT_API virtual INT SetSurfaceBTI(SurfaceIndex* pSurface, UINT BTIndex) = 0; CM_RT_API virtual INT AssociateThreadSpace(CmThreadSpace* & pTS) = 0; CM_RT_API virtual INT AssociateThreadGroupSpace(CmThreadGroupSpace* & pTGS) = 0; CM_RT_API virtual INT SetSamplerBTI(SamplerIndex* pSampler, UINT nIndex) = 0; CM_RT_API virtual INT DeAssociateThreadSpace(CmThreadSpace* & pTS) = 0; CM_RT_API virtual INT DeAssociateThreadGroupSpace(CmThreadGroupSpace* & pTGS) = 0; CM_RT_API virtual INT QuerySpillSize(unsigned int &spillSize) = 0; CM_RT_API virtual INT SetKernelArgPointer(UINT index, size_t size, const void *pValue) = 0; protected: ~CmKernel(){}; }; class CmTask { public: CM_RT_API virtual INT AddKernel(CmKernel *pKernel) = 0; CM_RT_API virtual INT Reset(void) = 0; CM_RT_API virtual INT AddSync(void) = 0; CM_RT_API virtual INT SetPowerOption( PCM_POWER_OPTION pCmPowerOption ) = 0; CM_RT_API virtual INT AddConditionalEnd(SurfaceIndex* pSurface, UINT offset, CM_CONDITIONAL_END_PARAM *pCondParam) = 0; CM_RT_API virtual INT SetProperty(const CM_TASK_CONFIG &taskConfig) = 0; CM_RT_API virtual INT AddKernelWithConfig( CmKernel *pKernel, const CM_EXECUTION_CONFIG *config ) = 0; CM_RT_API virtual INT GetProperty(CM_TASK_CONFIG &taskConfig) = 0; CM_RT_API virtual INT AddSyncEx(const CM_KERNEL_SYNC_CONFIG *config) = 0; protected: ~CmTask(){}; }; class CmBuffer { public: CM_RT_API virtual INT GetIndex( SurfaceIndex*& pIndex ) = 0; CM_RT_API virtual INT ReadSurface( unsigned char* pSysMem, CmEvent* pEvent, UINT64 sysMemSize = 0xFFFFFFFFFFFFFFFFULL ) = 0; CM_RT_API virtual INT WriteSurface( const unsigned char* pSysMem, CmEvent* pEvent, UINT64 sysMemSize = 0xFFFFFFFFFFFFFFFFULL ) = 0; CM_RT_API virtual INT InitSurface(const DWORD initValue, CmEvent* pEvent) = 0; CM_RT_API virtual INT SelectMemoryObjectControlSetting(MEMORY_OBJECT_CONTROL option) = 0; CM_RT_API virtual INT SetSurfaceStateParam(SurfaceIndex *pSurfIndex, const CM_BUFFER_STATE_PARAM *pSSParam) = 0; protected: ~CmBuffer(){}; }; class CmBufferUP { public: CM_RT_API virtual INT GetIndex( SurfaceIndex*& pIndex ) = 0; CM_RT_API virtual INT SelectMemoryObjectControlSetting(MEMORY_OBJECT_CONTROL option) = 0; protected: ~CmBufferUP(){}; }; class CmBufferSVM { public: CM_RT_API virtual INT GetIndex( SurfaceIndex*& pIndex ) = 0; CM_RT_API virtual INT GetAddress( void * &pAddr) = 0; protected: ~CmBufferSVM(){}; }; class CmBufferStateless { public: CM_RT_API virtual INT GetGfxAddress(uint64_t &gfxAddr) = 0; CM_RT_API virtual INT GetSysAddress(void *&pSysAddr) = 0; CM_RT_API virtual INT ReadSurface(unsigned char *pSysMem, CmEvent *pEvent, uint64_t sysMemSize = 0xFFFFFFFFFFFFFFFFULL) = 0; CM_RT_API virtual INT WriteSurface(const unsigned char *pSysMem, CmEvent *pEvent, uint64_t sysMemSize = 0xFFFFFFFFFFFFFFFFULL) = 0; protected: ~CmBufferStateless() {}; }; class CmSurface2DUP { public: CM_RT_API virtual INT GetIndex( SurfaceIndex*& pIndex ) = 0; CM_RT_API virtual INT SelectMemoryObjectControlSetting(MEMORY_OBJECT_CONTROL option) = 0; CM_RT_API virtual INT SetProperty(CM_FRAME_TYPE frameType) = 0; protected: ~CmSurface2DUP(){}; }; class CmSurface2DStateless { public: CM_RT_API virtual INT GetGfxAddress(uint64_t &gfxAddr) = 0; CM_RT_API virtual INT ReadSurface(unsigned char *pSysMem, CmEvent *pEvent, uint64_t sysMemSize = 0xFFFFFFFFFFFFFFFFULL) = 0; CM_RT_API virtual INT WriteSurface(const unsigned char *pSysMem, CmEvent *pEvent, uint64_t sysMemSize = 0xFFFFFFFFFFFFFFFFULL) = 0; protected: ~CmSurface2DStateless(){}; }; class CmSurface3D { public: CM_RT_API virtual INT GetIndex( SurfaceIndex*& pIndex ) = 0; CM_RT_API virtual INT ReadSurface( unsigned char* pSysMem, CmEvent* pEvent, UINT64 sysMemSize = 0xFFFFFFFFFFFFFFFFULL ) = 0; CM_RT_API virtual INT WriteSurface( const unsigned char* pSysMem, CmEvent* pEvent, UINT64 sysMemSize = 0xFFFFFFFFFFFFFFFFULL ) = 0; CM_RT_API virtual INT InitSurface(const DWORD initValue, CmEvent* pEvent) = 0; CM_RT_API virtual INT SelectMemoryObjectControlSetting(MEMORY_OBJECT_CONTROL option) = 0; protected: ~CmSurface3D(){}; }; class CmSampler { public: CM_RT_API virtual INT GetIndex( SamplerIndex* & pIndex ) = 0 ; protected: ~CmSampler(){}; }; class CmThreadSpace { public: CM_RT_API virtual INT AssociateThread( UINT x, UINT y, CmKernel* pKernel , UINT threadId ) = 0; CM_RT_API virtual INT SelectThreadDependencyPattern ( CM_DEPENDENCY_PATTERN pattern ) = 0; CM_RT_API virtual INT AssociateThreadWithMask( UINT x, UINT y, CmKernel* pKernel , UINT threadId, BYTE nDependencyMask ) = 0; CM_RT_API virtual INT SetThreadSpaceColorCount( UINT colorCount ) = 0; CM_RT_API virtual INT SelectMediaWalkingPattern( CM_WALKING_PATTERN pattern ) = 0; CM_RT_API virtual INT Set26ZIDispatchPattern( CM_26ZI_DISPATCH_PATTERN pattern ) = 0; CM_RT_API virtual INT Set26ZIMacroBlockSize( UINT width, UINT height ) = 0; CM_RT_API virtual INT SetMediaWalkerGroupSelect(CM_MW_GROUP_SELECT groupSelect) = 0; CM_RT_API virtual INT SelectMediaWalkingParameters( CM_WALKING_PARAMETERS paramaters ) = 0; CM_RT_API virtual INT SelectThreadDependencyVectors( CM_DEPENDENCY dependVectors ) = 0; CM_RT_API virtual INT SetThreadSpaceOrder(UINT threadCount, PCM_THREAD_PARAM pThreadSpaceOrder) = 0; protected: ~CmThreadSpace(){}; }; class CmVebox { public: CM_RT_API virtual INT SetState(CM_VEBOX_STATE& VeBoxState) = 0; CM_RT_API virtual INT SetCurFrameInputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetCurFrameInputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetPrevFrameInputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetPrevFrameInputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetSTMMInputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetSTMMInputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetSTMMOutputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetSTMMOutputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetDenoisedCurFrameOutputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetDenoisedCurOutputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetCurFrameOutputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetCurFrameOutputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetPrevFrameOutputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetPrevFrameOutputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetStatisticsOutputSurface( CmSurface2D* pSurf ) = 0; CM_RT_API virtual INT SetStatisticsOutputSurfaceControlBits( const WORD ctrlBits ) = 0; CM_RT_API virtual INT SetParam(CmBufferUP *pParamBuffer) = 0; protected: ~CmVebox(){}; }; class CmQueue { public: CM_RT_API virtual INT Enqueue( CmTask* pTask, CmEvent* & pEvent, const CmThreadSpace* pTS = nullptr ) = 0; CM_RT_API virtual INT DestroyEvent( CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueWithGroup( CmTask* pTask, CmEvent* & pEvent, const CmThreadGroupSpace* pTGS = nullptr )=0; CM_RT_API virtual INT EnqueueCopyCPUToGPU( CmSurface2D* pSurface, const unsigned char* pSysMem, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyGPUToCPU( CmSurface2D* pSurface, unsigned char* pSysMem, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueInitSurface2D( CmSurface2D* pSurface, const DWORD initValue, CmEvent* &pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyGPUToGPU( CmSurface2D* pOutputSurface, CmSurface2D* pInputSurface, UINT option, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyCPUToCPU( unsigned char* pDstSysMem, unsigned char* pSrcSysMem, UINT size, UINT option, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyCPUToGPUFullStride( CmSurface2D* pSurface, const unsigned char* pSysMem, const UINT widthStride, const UINT heightStride, const UINT option, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyGPUToCPUFullStride( CmSurface2D* pSurface, unsigned char* pSysMem, const UINT widthStride, const UINT heightStride, const UINT option, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyCPUToGPUFullStrideDup( CmSurface2D* pSurface, const unsigned char* pSysMem, const UINT widthStride, const UINT heightStride, const UINT option, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueCopyGPUToCPUFullStrideDup( CmSurface2D* pSurface, unsigned char* pSysMem, const UINT widthStride, const UINT heightStride, const UINT option, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueWithHints( CmTask* pTask, CmEvent* & pEvent, UINT hints = 0) = 0; CM_RT_API virtual INT EnqueueVebox( CmVebox* pVebox, CmEvent* & pEvent ) = 0; CM_RT_API virtual INT EnqueueFast(CmTask *task, CmEvent *&event, const CmThreadSpace *threadSpace = nullptr) = 0; CM_RT_API virtual INT DestroyEventFast(CmEvent *&event) = 0; CM_RT_API virtual INT EnqueueWithGroupFast(CmTask *task, CmEvent *&event, const CmThreadGroupSpace *threadGroupSpace = nullptr) = 0; CM_RT_API virtual int32_t EnqueueReadBuffer(CmBuffer* buffer, size_t offset, const unsigned char* sysMem, uint64_t sysMemSize, CmEvent* wait_event, CmEvent*& event, unsigned option) = 0; CM_RT_API virtual int32_t EnqueueWriteBuffer(CmBuffer* buffer, size_t offset, const unsigned char* sysMem, uint64_t sysMemSize, CmEvent* wait_event, CmEvent*& event, unsigned option) = 0; CM_RT_API virtual INT SetResidentGroupAndParallelThreadNum(uint32_t residentGroupNum, uint32_t parallelThreadNum) = 0; protected: ~CmQueue(){}; }; //********************************************************************** // Function pointer types //********************************************************************** typedef void (CM_CALLBACK *callback_function)(CmEvent*, void *); typedef void (*IMG_WALKER_FUNTYPE)(void* img, void* arg); //********************************************************************** // OS-specific APIs and classes //********************************************************************** #include "cm_rt_api_os.h" //********************************************************************** // Functions declaration //********************************************************************** EXTERN_C CM_RT_API INT DestroyCmDevice(CmDevice* &device); EXTERN_C CM_RT_API INT CMRT_Enqueue(CmQueue* queue, CmTask* task, CmEvent** event, const CmThreadSpace* threadSpace = nullptr); EXTERN_C CM_RT_API const char* GetCmErrorString(int errCode); //********************************************************************** // Platfom specific definitions //********************************************************************** #include "cm_rt_g8.h" #include "cm_rt_g9.h" #include "cm_rt_g10.h" #include "cm_rt_g11.h" #include "cm_rt_g12_tgl.h" #include "cm_rt_g12_dg1.h" #endif //__CM_RT_H__