diff options
Diffstat (limited to 'intern/gpudirect/dvpapi.h')
| -rw-r--r-- | intern/gpudirect/dvpapi.h | 667 |
1 files changed, 667 insertions, 0 deletions
diff --git a/intern/gpudirect/dvpapi.h b/intern/gpudirect/dvpapi.h new file mode 100644 index 00000000000..cafc4e862ae --- /dev/null +++ b/intern/gpudirect/dvpapi.h @@ -0,0 +1,667 @@ +/* + * ***** 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__ + |