/* * ***** 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 #include #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__