diff options
Diffstat (limited to 'intern/gpudirect/dvpapi.h')
| -rw-r--r-- | intern/gpudirect/dvpapi.h | 667 |
1 files changed, 0 insertions, 667 deletions
diff --git a/intern/gpudirect/dvpapi.h b/intern/gpudirect/dvpapi.h deleted file mode 100644 index cafc4e862ae..00000000000 --- a/intern/gpudirect/dvpapi.h +++ /dev/null @@ -1,667 +0,0 @@ -/* - * ***** BEGIN GPL LICENSE BLOCK ***** - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - * - * The Original Code is Copyright (C) 2015, Blender Foundation - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): Blender Foundation. - * - * ***** END GPL LICENSE BLOCK ***** - */ - -/** \file gpudirect/dvpapi.h - * \ingroup gpudirect - */ - -#ifndef __DVPAPI_H__ -#define __DVPAPI_H__ - -#ifdef WIN32 - -#include <stdlib.h> -#include <stdint.h> - -#include "GL/glew.h" - -#if defined(__GNUC__) && __GNUC__>=4 -# define DVPAPI extern __attribute__ ((visibility("default"))) -#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) -# define DVPAPI extern __global -#else -# define DVPAPI extern -#endif - -#define DVPAPIENTRY -#define DVP_MAJOR_VERSION 1 -#define DVP_MINOR_VERSION 63 - -typedef uint64_t DVPBufferHandle; -typedef uint64_t DVPSyncObjectHandle; - -typedef enum { - DVP_STATUS_OK = 0, - DVP_STATUS_INVALID_PARAMETER = 1, - DVP_STATUS_UNSUPPORTED = 2, - DVP_STATUS_END_ENUMERATION = 3, - DVP_STATUS_INVALID_DEVICE = 4, - DVP_STATUS_OUT_OF_MEMORY = 5, - DVP_STATUS_INVALID_OPERATION = 6, - DVP_STATUS_TIMEOUT = 7, - DVP_STATUS_INVALID_CONTEXT = 8, - DVP_STATUS_INVALID_RESOURCE_TYPE = 9, - DVP_STATUS_INVALID_FORMAT_OR_TYPE = 10, - DVP_STATUS_DEVICE_UNINITIALIZED = 11, - DVP_STATUS_UNSIGNALED = 12, - DVP_STATUS_SYNC_ERROR = 13, - DVP_STATUS_SYNC_STILL_BOUND = 14, - DVP_STATUS_ERROR = -1, -} DVPStatus; - -// Pixel component formats stored in the system memory buffer -// analogous to those defined in the OpenGL API, except for -// DVP_BUFFER and the DVP_CUDA_* types. DVP_BUFFER provides -// an unspecified format type to allow for general interpretation -// of the bytes at a later stage (in GPU shader). Note that not -// all paths will achieve optimal speeds due to lack of HW support -// for the transformation. The CUDA types are to be used when -// copying to/from a system memory buffer from-to a CUDA array, as the -// CUDA array implies a memory layout that matches the array. -typedef enum { - DVP_BUFFER, // Buffer treated as a raw buffer - // and copied directly into GPU buffer - // without any interpretation of the - // stored bytes. - DVP_DEPTH_COMPONENT, - DVP_RGBA, - DVP_BGRA, - DVP_RED, - DVP_GREEN, - DVP_BLUE, - DVP_ALPHA, - DVP_RGB, - DVP_BGR, - DVP_LUMINANCE, - DVP_LUMINANCE_ALPHA, - DVP_CUDA_1_CHANNEL, - DVP_CUDA_2_CHANNELS, - DVP_CUDA_4_CHANNELS, - DVP_RGBA_INTEGER, - DVP_BGRA_INTEGER, - DVP_RED_INTEGER, - DVP_GREEN_INTEGER, - DVP_BLUE_INTEGER, - DVP_ALPHA_INTEGER, - DVP_RGB_INTEGER, - DVP_BGR_INTEGER, - DVP_LUMINANCE_INTEGER, - DVP_LUMINANCE_ALPHA_INTEGER, -} DVPBufferFormats; - -// Possible pixel component storage types for system memory buffers -typedef enum { - DVP_UNSIGNED_BYTE, - DVP_BYTE, - DVP_UNSIGNED_SHORT, - DVP_SHORT, - DVP_UNSIGNED_INT, - DVP_INT, - DVP_FLOAT, - DVP_HALF_FLOAT, - DVP_UNSIGNED_BYTE_3_3_2, - DVP_UNSIGNED_BYTE_2_3_3_REV, - DVP_UNSIGNED_SHORT_5_6_5, - DVP_UNSIGNED_SHORT_5_6_5_REV, - DVP_UNSIGNED_SHORT_4_4_4_4, - DVP_UNSIGNED_SHORT_4_4_4_4_REV, - DVP_UNSIGNED_SHORT_5_5_5_1, - DVP_UNSIGNED_SHORT_1_5_5_5_REV, - DVP_UNSIGNED_INT_8_8_8_8, - DVP_UNSIGNED_INT_8_8_8_8_REV, - DVP_UNSIGNED_INT_10_10_10_2, - DVP_UNSIGNED_INT_2_10_10_10_REV, -} DVPBufferTypes; - -// System memory descriptor describing the size and storage formats -// of the buffer -typedef struct DVPSysmemBufferDescRec { - uint32_t width; // Buffer Width - uint32_t height; // Buffer Height - uint32_t stride; // Stride - uint32_t size; // Specifies the surface size if - // format == DVP_BUFFER - DVPBufferFormats format; // see enum above - DVPBufferTypes type; // see enum above - void *bufAddr; // Buffer memory address -} DVPSysmemBufferDesc; - -// Flags specified at sync object creation: -// ---------------------------------------- -// Tells the implementation to use events wherever -// possible instead of software spin loops. Note if HW -// wait operations are supported by the implementation -// then events will not be used in the dvpMemcpy* -// functions. In such a case, events may still be used -// in dvpSyncObjClientWait* functions. -#define DVP_SYNC_OBJECT_FLAGS_USE_EVENTS 0x00000001 - -typedef struct DVPSyncObjectDescRec { - uint32_t *sem; // Location to write semaphore value - uint32_t flags; // See above DVP_SYNC_OBJECT_FLAGS_* bits - DVPStatus (*externalClientWaitFunc) (DVPSyncObjectHandle sync, - uint32_t value, - bool GEQ, // If true then the function should wait for the sync value to be - // greater than or equal to the value parameter. Otherwise just a - // straight forward equality comparison should be performed. - uint64_t timeout); - // If non-null, externalClientWaitFunc allows the DVP library - // to call the application to wait for a sync object to be - // released. This allows the application to create events, - // which can be triggered on device interrupts instead of - // using spin loops inside the DVP library. Upon succeeding - // the function must return DVP_STATUS_OK, non-zero for failure - // and DVP_STATUS_TIMEOUT on timeout. The externalClientWaitFunc should - // not alter the current GL or CUDA context state -} DVPSyncObjectDesc; - -// Time used when event timeouts should be ignored -#define DVP_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull - -typedef DVPStatus (DVPAPIENTRY * PFNDVPBEGIN) (void); -typedef DVPStatus (DVPAPIENTRY * PFNDVPEND) (void); -typedef DVPStatus (DVPAPIENTRY * PFNDVPCREATEBUFFER)(DVPSysmemBufferDesc *desc, DVPBufferHandle *hBuf); -typedef DVPStatus (DVPAPIENTRY * PFNDVPDESTROYBUFFER)(DVPBufferHandle hBuf); -typedef DVPStatus (DVPAPIENTRY * PFNDVPFREEBUFFER)(DVPBufferHandle gpuBufferHandle); -typedef DVPStatus (DVPAPIENTRY * PFNDVPMEMCPYLINED)(DVPBufferHandle srcBuffer, - DVPSyncObjectHandle srcSync, - uint32_t srcAcquireValue, - uint64_t timeout, - DVPBufferHandle dstBuffer, - DVPSyncObjectHandle dstSync, - uint32_t dstReleaseValue, - uint32_t startingLine, - uint32_t numberOfLines); -typedef DVPStatus (DVPAPIENTRY * PFNDVPMEMCPY)(DVPBufferHandle srcBuffer, - DVPSyncObjectHandle srcSync, - uint32_t srcAcquireValue, - uint64_t timeout, - DVPBufferHandle dstBuffer, - DVPSyncObjectHandle dstSync, - uint32_t dstReleaseValue, - uint32_t srcOffset, - uint32_t dstOffset, - uint32_t count); -typedef DVPStatus (DVPAPIENTRY * PFNDVPIMPORTSYNCOBJECT)(DVPSyncObjectDesc *desc, - DVPSyncObjectHandle *syncObject); -typedef DVPStatus (DVPAPIENTRY * PFNDVPFREESYNCOBJECT)(DVPSyncObjectHandle syncObject); -typedef DVPStatus (DVPAPIENTRY * PFNDVPGETREQUIREDCONSTANTSGLCTX)(uint32_t *bufferAddrAlignment, - uint32_t *bufferGPUStrideAlignment, - uint32_t *semaphoreAddrAlignment, - uint32_t *semaphoreAllocSize, - uint32_t *semaphorePayloadOffset, - uint32_t *semaphorePayloadSize); -typedef DVPStatus (DVPAPIENTRY * PFNDVPBINDTOGLCTX)(DVPBufferHandle hBuf); -typedef DVPStatus (DVPAPIENTRY * PFNDVPUNBINDFROMGLCTX)(DVPBufferHandle hBuf); -typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERENDAPI)(DVPBufferHandle gpuBufferHandle); -typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERWAITDVP)(DVPBufferHandle gpuBufferHandle); -typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERENDDVP)(DVPBufferHandle gpuBufferHandle); -typedef DVPStatus (DVPAPIENTRY * PFNDVPMAPBUFFERWAITAPI)(DVPBufferHandle gpuBufferHandle); -typedef DVPStatus (DVPAPIENTRY * PFNDVPCREATEGPUTEXTUREGL)(GLuint texID, - DVPBufferHandle *bufferHandle); - -// Flags supplied to the dvpInit* functions: -// -// DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT is only supported for OpenGL -// contexts and is the only supported flag for CUDA. It allows for -// certain cases to be optimized by sharing the context -// of the application for the DVP operations. This removes the -// need to do certain synchronizations. See issue 5 for parallel -// issues. When used, the app's GL context must be current for all calls -// to the DVP library. -// the DVP library. -#define DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT 0x000000001 - -//------------------------------------------------------------------------ -// Function: dvpInitGLContext -// -// To be called before any DVP resources are allocated. -// This call allows for specification of flags that may -// change the way DVP operations are performed. See above -// for the list of flags. -// -// The OpenGL context must be current at time of call. -// -// Parameters: flags[IN] - Buffer description structure -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -extern DVPStatus dvpInitGLContext(uint32_t flags); - -//------------------------------------------------------------------------ -// Function: dvpCloseGLContext -// -// Function to be called when app closes to allow freeing -// of any DVP library allocated resources. -// -// The OpenGL context must be current at time of call. -// -// Parameters: none -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -extern DVPStatus dvpCloseGLContext(); - -//------------------------------------------------------------------------ -// Function: dvpGetLibrayVersion -// -// Description: Returns the current version of the library -// -// Parameters: major[OUT] - returned major version -// minor[OUT] - returned minor version -// -// Returns: DVP_STATUS_OK -//------------------------------------------------------------------------ -extern DVPStatus dvpGetLibrayVersion(uint32_t *major, uint32_t *minor); - -//------------------------------------------------------------------------ -// Function: dvpBegin -// -// Description: dvpBegin must be called before any combination of DVP -// function calls dvpMemCpy*, dvpMapBufferWaitDVP, -// dvpSyncObjClientWait*, and dvpMapBufferEndDVP. After -// the last of these functions has been called is dvpEnd -// must be called. This allows for more efficient batched -// DVP operations. -// -// Parameters: none -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpBegin DVPAPI_GET_FUN(__dvpBegin) - -//------------------------------------------------------------------------ -// Function: dvpEnd -// -// Description: dvpEnd signals the end of a batch of DVP function calls -// that began with dvpBegin -// -// Parameters: none -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpEnd DVPAPI_GET_FUN(__dvpEnd) - - -//------------------------------------------------------------------------ -// Function: dvpCreateBuffer -// -// Description: Create a DVP buffer using system memory, wrapping a user -// passed pointer. The pointer must be aligned -// to values returned by dvpGetRequiredAlignments* -// -// Parameters: desc[IN] - Buffer description structure -// hBuf[OUT] - DVP Buffer handle -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpCreateBuffer DVPAPI_GET_FUN(__dvpCreateBuffer) - - -//------------------------------------------------------------------------ -// Function: dvpDestroyBuffer -// -// Description: Destroy a previously created DVP buffer. -// -// Parameters: hBuf[IN] - DVP Buffer handle -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpDestroyBuffer DVPAPI_GET_FUN(__dvpDestroyBuffer) - -//------------------------------------------------------------------------ -// Function: dvpFreeBuffer -// -// Description: dvpFreeBuffer frees the DVP buffer reference -// -// Parameters: gpuBufferHandle[IN] - DVP Buffer handle -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpFreeBuffer DVPAPI_GET_FUN(__dvpFreeBuffer) - -//------------------------------------------------------------------------ -// Function: dvpMemcpyLined -// -// Description: dvpMemcpyLined provides buffer copies between a -// DVP sysmem buffer and a graphics API texture (as opposed to -// a buffer type). Other buffer types (such -// as graphics API buffers) return DVP_STATUS_INVALID_PARAMETER. -// -// In addition, see "dvpMemcpy* general comments" above. -// -// Parameters: srcBuffer[IN] - src buffer handle -// srcSync[IN] - sync to acquire on before transfer -// srcAcquireValue[IN] - value to acquire on before transfer -// timeout[IN] - time out value in nanoseconds. -// dstBuffer[IN] - src buffer handle -// dstSync[IN] - sync to release on transfer completion -// dstReleaseValue[IN] - value to release on completion -// startingLine[IN] - starting line of buffer -// numberOfLines[IN] - number of lines to copy -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -// -// GL state effected: The following GL state may be altered by this -// function (not relevant if no GL source or destination -// is used): -// -GL_PACK_SKIP_ROWS, GL_PACK_SKIP_PIXELS, -// GL_PACK_ROW_LENGTH -// -The buffer bound to GL_PIXEL_PACK_BUFFER -// -The current bound framebuffer (GL_FRAMEBUFFER_EXT) -// -GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_PIXELS, -// GL_UNPACK_ROW_LENGTH -// -The buffer bound to GL_PIXEL_UNPACK_BUFFER -// -The texture bound to GL_TEXTURE_2D -//------------------------------------------------------------------------ -#define dvpMemcpyLined DVPAPI_GET_FUN(__dvpMemcpyLined) - - -//------------------------------------------------------------------------ -// Function: dvpMemcpy -// -// Description: dvpMemcpy provides buffer copies between a -// DVP sysmem buffer and a graphics API pure buffer (as -// opposed to a texture type). Other buffer types (such -// as graphics API textures) return -// DVP_STATUS_INVALID_PARAMETER. -// -// The start address of the srcBuffer is given by srcOffset -// and the dstBuffer start address is given by dstOffset. -// -// In addition, see "dvpMemcpy* general comments" above. -// -// Parameters: srcBuffer[IN] - src buffer handle -// srcSync[IN] - sync to acquire on before transfer -// srcAcquireValue[IN] - value to acquire on before transfer -// timeout[IN] - time out value in nanoseconds. -// dstBuffer[IN] - src buffer handle -// dstSync[IN] - sync to release on completion -// dstReleaseValue[IN] - value to release on completion -// uint32_t srcOffset[IN] - byte offset of srcBuffer -// uint32_t dstOffset[IN] - byte offset of dstBuffer -// uint32_t count[IN] - number of bytes to copy -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -// -// GL state effected: The following GL state may be altered by this -// function (not relevant if no GL source or destination -// is used): -// - The buffer bound to GL_COPY_WRITE_BUFFER -// - The buffer bound to GL_COPY_READ_BUFFER -// -//------------------------------------------------------------------------ -#define dvpMemcpy DVPAPI_GET_FUN(__dvpMemcpy) - -//------------------------------------------------------------------------ -// Function: dvpImportSyncObject -// -// Description: dvpImportSyncObject creates a DVPSyncObject from the -// DVPSyncObjectDesc. Note that a sync object is not -// supported for copy operations targeting different APIs. -// This means, for example, it is illegal to call dvpMemCpy* -// for source or target GL texture with sync object A and -// then later use that same sync object in dvpMemCpy* -// operation for a source or target CUDA buffer. The same -// semaphore memory can still be used for two different sync -// objects. -// -// Parameters: desc[IN] - data describing the sync object -// syncObject[OUT] - handle to sync object -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpImportSyncObject DVPAPI_GET_FUN(__dvpImportSyncObject) - -//------------------------------------------------------------------------ -// Function: dvpFreeSyncObject -// -// Description: dvpFreeSyncObject waits for any outstanding releases on -// this sync object before freeing the resources allocated for -// the specified sync object. The application must make sure -// any outstanding acquire operations have already been -// completed. -// -// If OpenGL is being used and the app's GL context is being -// shared (via the DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT flag), -// then dvpFreeSyncObject needs to be called while each context, -// on which the sync object was used, is current. If -// DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT is used and there are out -// standing contexts from which this sync object must be free'd -// then dvpFreeSyncObject will return DVP_STATUS_SYNC_STILL_BOUND. -// -// Parameters: syncObject[IN] - handle to sync object to be free'd -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -// DVP_STATUS_SYNC_STILL_BOUND -//------------------------------------------------------------------------ -#define dvpFreeSyncObject DVPAPI_GET_FUN(__dvpFreeSyncObject) - - -//------------------------------------------------------------------------ -// Function: dvpMapBufferEndAPI -// -// Description: Tells DVP to setup a signal for this buffer in the -// callers API context or device. The signal follows all -// previous API operations up to this point and, thus, -// allows subsequent DVP calls to know when then this buffer -// is ready for use within the DVP library. This function -// would be followed by a call to dvpMapBufferWaitDVP to -// synchronize rendering in the API stream and the DVP -// stream. -// -// If OpenGL or CUDA is used, the OpenGL/CUDA context -// must be current at time of call. -// -// The use of dvpMapBufferEndAPI is NOT recommended for -// CUDA synchronisation, as it is more optimal to use a -// applcation CUDA stream in conjunction with -// dvpMapBufferEndCUDAStream. This allows the driver to -// do optimisations, such as parllelise the copy operations -// and compute. -// -// This must be called outside the dvpBegin/dvpEnd pair. In -// addition, this call is not thread safe and must be called -// from or fenced against the rendering thread associated with -// the context or device. -// -// Parameters: gpuBufferHandle[IN] - buffer to track -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -// DVP_STATUS_UNSIGNALED - returned if the API is -// unable to place a signal in the API context queue -//------------------------------------------------------------------------ -#define dvpMapBufferEndAPI DVPAPI_GET_FUN(__dvpMapBufferEndAPI) - -//------------------------------------------------------------------------ -// Function: dvpMapBufferEndAPI -// -// Description: Tells DVP to setup a signal for this buffer in the -// callers API context or device. The signal follows all -// previous API operations up to this point and, thus, -// allows subsequent DVP calls to know when then this buffer -// is ready for use within the DVP library. This function -// would be followed by a call to dvpMapBufferWaitDVP to -// synchronize rendering in the API stream and the DVP -// stream. -// -// If OpenGL or CUDA is used, the OpenGL/CUDA context -// must be current at time of call. -// -// The use of dvpMapBufferEndAPI is NOT recommended for -// CUDA synchronisation, as it is more optimal to use a -// applcation CUDA stream in conjunction with -// dvpMapBufferEndCUDAStream. This allows the driver to -// do optimisations, such as parllelise the copy operations -// and compute. -// -// This must be called outside the dvpBegin/dvpEnd pair. In -// addition, this call is not thread safe and must be called -// from or fenced against the rendering thread associated with -// the context or device. -// -// Parameters: gpuBufferHandle[IN] - buffer to track -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -// DVP_STATUS_UNSIGNALED - returned if the API is -// unable to place a signal in the API context queue -//------------------------------------------------------------------------ -#define dvpMapBufferEndAPI DVPAPI_GET_FUN(__dvpMapBufferEndAPI) - -//------------------------------------------------------------------------ -// Function: dvpMapBufferWaitDVP -// -// Description: Tells DVP to make the DVP stream wait for a previous -// signal triggered by a dvpMapBufferEndAPI call. -// -// This must be called inside the dvpBegin/dvpEnd pair. -// -// Parameters: gpuBufferHandle[IN] - buffer to track -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpMapBufferWaitDVP DVPAPI_GET_FUN(__dvpMapBufferWaitDVP) - -//------------------------------------------------------------------------ -// Function: dvpMapBufferEndDVP -// -// Description: Tells DVP to setup a signal for this buffer after -// DVP operations are complete. The signal allows -// the API to know when then this buffer is -// ready for use within a API stream. This function would -// be followed by a call to dvpMapBufferWaitAPI to -// synchronize copies in the DVP stream and the API -// rendering stream. -// -// This must be called inside the dvpBegin/dvpEnd pair. -// -// Parameters: gpuBufferHandle[IN] - buffer to track -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpMapBufferEndDVP DVPAPI_GET_FUN(__dvpMapBufferEndDVP) - -//------------------------------------------------------------------------ -// Function: dvpMapBufferWaitAPI -// -// Description: Tells DVP to make the current API context or device to -// wait for a previous signal triggered by a -// dvpMapBufferEndDVP call. -// -// The use of dvpMapBufferWaitCUDAStream is NOT recommended for -// CUDA synchronisation, as it is more optimal to use a -// applcation CUDA stream in conjunction with -// dvpMapBufferEndCUDAStream. This allows the driver to -// do optimisations, such as parllelise the copy operations -// and compute. -// -// If OpenGL or CUDA is used, the OpenGL/CUDA context -// must be current at time of call. -// -// This must be called outside the dvpBegin/dvpEnd pair. In -// addition, this call is not thread safe and must be called -// from or fenced against the rendering thread associated with -// the context or device. -// -// Parameters: gpuBufferHandle[IN] - buffer to track -// -// Returns: DVP_STATUS_OK -// DVP_STATUS_INVALID_PARAMETER -// DVP_STATUS_ERROR -//------------------------------------------------------------------------ -#define dvpMapBufferWaitAPI DVPAPI_GET_FUN(__dvpMapBufferWaitAPI) - -//------------------------------------------------------------------------ -// If the multiple GL contexts used in the application access the same -// sysmem buffers, then application must create those GL contexts with -// display list shared. -//------------------------------------------------------------------------ -#define dvpBindToGLCtx DVPAPI_GET_FUN(__dvpBindToGLCtx) -#define dvpGetRequiredConstantsGLCtx DVPAPI_GET_FUN(__dvpGetRequiredConstantsGLCtx) -#define dvpCreateGPUTextureGL DVPAPI_GET_FUN(__dvpCreateGPUTextureGL) -#define dvpUnbindFromGLCtx DVPAPI_GET_FUN(__dvpUnbindFromGLCtx) - - -DVPAPI PFNDVPBEGIN __dvpBegin; -DVPAPI PFNDVPEND __dvpEnd; -DVPAPI PFNDVPCREATEBUFFER __dvpCreateBuffer; -DVPAPI PFNDVPDESTROYBUFFER __dvpDestroyBuffer; -DVPAPI PFNDVPFREEBUFFER __dvpFreeBuffer; -DVPAPI PFNDVPMEMCPYLINED __dvpMemcpyLined; -DVPAPI PFNDVPMEMCPY __dvpMemcpy; -DVPAPI PFNDVPIMPORTSYNCOBJECT __dvpImportSyncObject; -DVPAPI PFNDVPFREESYNCOBJECT __dvpFreeSyncObject; -DVPAPI PFNDVPMAPBUFFERENDAPI __dvpMapBufferEndAPI; -DVPAPI PFNDVPMAPBUFFERWAITDVP __dvpMapBufferWaitDVP; -DVPAPI PFNDVPMAPBUFFERENDDVP __dvpMapBufferEndDVP; -DVPAPI PFNDVPMAPBUFFERWAITAPI __dvpMapBufferWaitAPI; - - -//------------------------------------------------------------------------ -// If the multiple GL contexts used in the application access the same -// sysmem buffers, then application must create those GL contexts with -// display list shared. -//------------------------------------------------------------------------ -DVPAPI PFNDVPBINDTOGLCTX __dvpBindToGLCtx; -DVPAPI PFNDVPGETREQUIREDCONSTANTSGLCTX __dvpGetRequiredConstantsGLCtx; -DVPAPI PFNDVPCREATEGPUTEXTUREGL __dvpCreateGPUTextureGL; -DVPAPI PFNDVPUNBINDFROMGLCTX __dvpUnbindFromGLCtx; - -#define DVPAPI_GET_FUN(x) x - -#endif // WIN32 - -#endif // __DVPAPI_H__ - |