1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
|
/*
* 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.
*/
/** \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__
|