Coverage for cuda/bindings/_lib/cyruntime/cyruntime.pxi: 0.60%

1# SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 

2# SPDX-License-Identifier: Apache-2.0 

3  

4# These graphics API are the reimplemented version of what's supported by CUDA Runtime. 

5# Issue https://github.com/NVIDIA/cuda-python/issues/488 will remove them by letting us 

6# use call into the static library directly. 

7  

8# This file is included from cuda/bindings/_bindings/cyruntime.pyx.in but kept in a 

9# separate file to keep it separated from the auto-generated code there. 

10  

11# Prior to https://github.com/NVIDIA/cuda-python/pull/914, this was two 

12# independent modules (c.b._lib.cyruntime.cyruntime and 

13# c.b._lib.cyruntime.utils), but was merged into one. 

14import cython 

15cimport cython 

16  

17from libc.string cimport memset 

18cimport cuda.bindings._internal.driver as cydriver 

19  

20# Call make_cudaPitchedPtr directly from the C header to avoid a runtime import 

21# of cuda.bindings.cyruntime (the Cython wrapper lives there but including it 

22# here would create a circular import via _internal.runtime → cyruntime → _internal.runtime). 

23cdef extern from 'driver_functions.h': 

24 cudaPitchedPtr _cylib_make_cudaPitchedPtr "make_cudaPitchedPtr"(void* d, size_t p, size_t xsz, size_t ysz) nogil 

25  

26cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: 

27 cdef cudaError_t err = cudaSuccess 

28 # cudaFree(0) is a NOP operations that initializes the context state 

29 err = _cudaFree(<void*>0) 

30 if err != cudaSuccess: 

31 return err 

32 cdef cydriver.CUeglFrame cueglFrame 

33 err = getDriverEglFrame(&cueglFrame, eglframe) 

34 if err != cudaSuccess: 

35 return err 

36 err = <cudaError_t>cydriver._cuEGLStreamProducerPresentFrame(<cydriver.CUeglStreamConnection*>conn, cueglFrame, <cydriver.CUstream*>pStream) 

37 return err 

38  

39cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: 

40 cdef cudaError_t err = cudaSuccess 

41 # cudaFree(0) is a NOP operations that initializes the context state 

42 err = _cudaFree(<void*>0) 

43 if err != cudaSuccess: 

44 return err 

45 if eglframe == NULL: 

46 err = cudaErrorInvalidResourceHandle 

47 return err 

48 cdef cydriver.CUeglFrame cueglFrame 

49 err = <cudaError_t>cydriver._cuEGLStreamProducerReturnFrame(<cydriver.CUeglStreamConnection*>conn, &cueglFrame, <cydriver.CUstream*>pStream) 

50 if err != cudaSuccess: 

51 return err 

52 err = getRuntimeEglFrame(eglframe, cueglFrame) 

53 return err 

54  

55cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil: 

56 cdef cudaError_t err = cudaSuccess 

57 # cudaFree(0) is a NOP operations that initializes the context state 

58 err = _cudaFree(<void*>0) 

59 if err != cudaSuccess: 

60 return err 

61 cdef cydriver.CUeglFrame cueglFrame 

62 memset(&cueglFrame, 0, sizeof(cueglFrame)) 

63 err = <cudaError_t>cydriver._cuGraphicsResourceGetMappedEglFrame(&cueglFrame, <cydriver.CUgraphicsResource>resource, index, mipLevel) 

64 if err != cudaSuccess: 

65 return err 

66 err = getRuntimeEglFrame(eglFrame, cueglFrame) 

67 return err 

68  

69cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: 

70 return cudaErrorNotSupported 

71  

72cdef cudaError_t _cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil: 

73 cdef cudaError_t err = cudaSuccess 

74 # cudaFree(0) is a NOP operations that initializes the context state 

75 err = _cudaFree(<void*>0) 

76 if err != cudaSuccess: 

77 return err 

78 err = <cudaError_t>cydriver._cuVDPAUGetDevice(<cydriver.CUdevice*>device, vdpDevice, vdpGetProcAddress) 

79 return err 

80  

81cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

82 cdef cudaError_t err = cudaSuccess 

83 # cudaFree(0) is a NOP operations that initializes the context state 

84 err = _cudaFree(<void*>0) 

85 if err != cudaSuccess: 

86 return err 

87 err = <cudaError_t>cydriver._cuGraphicsVDPAURegisterVideoSurface(<cydriver.CUgraphicsResource*>resource, vdpSurface, flags) 

88 return err 

89  

90cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

91 cdef cudaError_t err = cudaSuccess 

92 # cudaFree(0) is a NOP operations that initializes the context state 

93 err = _cudaFree(<void*>0) 

94 if err != cudaSuccess: 

95 return err 

96 err = <cudaError_t>cydriver._cuGraphicsVDPAURegisterOutputSurface(<cydriver.CUgraphicsResource*>resource, vdpSurface, flags) 

97 return err 

98  

99cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil: 

100 cdef cudaError_t err = cudaSuccess 

101 # cudaFree(0) is a NOP operations that initializes the context state 

102 err = _cudaFree(<void*>0) 

103 if err != cudaSuccess: 

104 return err 

105 err = <cudaError_t>cydriver._cuGLGetDevices_v2(pCudaDeviceCount, <cydriver.CUdevice*>pCudaDevices, cudaDeviceCount, <cydriver.CUGLDeviceList>deviceList) 

106 return err 

107  

108cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

109 cdef cudaError_t err = cudaSuccess 3 ctx1abc

110 # cudaFree(0) is a NOP operations that initializes the context state 

111 err = _cudaFree(<void*>0) 3 ctx1abc

112 if err != cudaSuccess: 3 ctx1abc

113 return err 

114 err = <cudaError_t>cydriver._cuGraphicsGLRegisterImage(<cydriver.CUgraphicsResource*>resource, image, target, flags) 3 ctx1abc

115 return err 3 ctx1abc

116  

117cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

118 cdef cudaError_t err = cudaSuccess 

119 # cudaFree(0) is a NOP operations that initializes the context state 

120 err = _cudaFree(<void*>0) 

121 if err != cudaSuccess: 

122 return err 

123 err = <cudaError_t>cydriver._cuGraphicsGLRegisterBuffer(<cydriver.CUgraphicsResource*>resource, buffer, flags) 

124 return err 

125  

126cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

127 cdef cudaError_t err = cudaSuccess 

128 # cudaFree(0) is a NOP operations that initializes the context state 

129 err = _cudaFree(<void*>0) 

130 if err != cudaSuccess: 

131 return err 

132 err = <cudaError_t>cydriver._cuGraphicsEGLRegisterImage(<cydriver.CUgraphicsResource*>pCudaResource, image, flags) 

133 return err 

134  

135cdef cudaError_t _cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil: 

136 cdef cudaError_t err = cudaSuccess 

137 # cudaFree(0) is a NOP operations that initializes the context state 

138 err = _cudaFree(<void*>0) 

139 if err != cudaSuccess: 

140 return err 

141 err = <cudaError_t>cydriver._cuEGLStreamConsumerConnect(<cydriver.CUeglStreamConnection*>conn, eglStream) 

142 return err 

143  

144cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

145 cdef cudaError_t err = cudaSuccess 

146 # cudaFree(0) is a NOP operations that initializes the context state 

147 err = _cudaFree(<void*>0) 

148 if err != cudaSuccess: 

149 return err 

150 err = <cudaError_t>cydriver._cuEGLStreamConsumerConnectWithFlags(<cydriver.CUeglStreamConnection*>conn, eglStream, flags) 

151 return err 

152  

153cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: 

154 cdef cudaError_t err = cudaSuccess 

155 # cudaFree(0) is a NOP operations that initializes the context state 

156 err = _cudaFree(<void*>0) 

157 if err != cudaSuccess: 

158 return err 

159 err = <cudaError_t>cydriver._cuEGLStreamConsumerDisconnect(<cydriver.CUeglStreamConnection*>conn) 

160 return err 

161  

162cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil: 

163 cdef cudaError_t err = cudaSuccess 

164 # cudaFree(0) is a NOP operations that initializes the context state 

165 err = _cudaFree(<void*>0) 

166 if err != cudaSuccess: 

167 return err 

168 err = <cudaError_t>cydriver._cuEGLStreamConsumerAcquireFrame(<cydriver.CUeglStreamConnection*>conn, <cydriver.CUgraphicsResource*>pCudaResource, <cydriver.CUstream*>pStream, timeout) 

169 return err 

170  

171cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil: 

172 cdef cudaError_t err = cudaSuccess 

173 # cudaFree(0) is a NOP operations that initializes the context state 

174 err = _cudaFree(<void*>0) 

175 if err != cudaSuccess: 

176 return err 

177 err = <cudaError_t>cydriver._cuEGLStreamConsumerReleaseFrame(<cydriver.CUeglStreamConnection*>conn, <cydriver.CUgraphicsResource>pCudaResource, <cydriver.CUstream*>pStream) 

178 return err 

179  

180cdef cudaError_t _cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil: 

181 cdef cudaError_t err = cudaSuccess 

182 # cudaFree(0) is a NOP operations that initializes the context state 

183 err = _cudaFree(<void*>0) 

184 if err != cudaSuccess: 

185 return err 

186 err = <cudaError_t>cydriver._cuEGLStreamProducerConnect(<cydriver.CUeglStreamConnection*>conn, eglStream, width, height) 

187 return err 

188  

189cdef cudaError_t _cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil: 

190 cdef cudaError_t err = cudaSuccess 

191 # cudaFree(0) is a NOP operations that initializes the context state 

192 err = _cudaFree(<void*>0) 

193 if err != cudaSuccess: 

194 return err 

195 err = <cudaError_t>cydriver._cuEGLStreamProducerDisconnect(<cydriver.CUeglStreamConnection*>conn) 

196 return err 

197  

198cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil: 

199 cdef cudaError_t err = cudaSuccess 

200 # cudaFree(0) is a NOP operations that initializes the context state 

201 err = _cudaFree(<void*>0) 

202 if err != cudaSuccess: 

203 return err 

204 err = <cudaError_t>cydriver._cuEventCreateFromEGLSync(<cydriver.CUevent*>phEvent, eglSync, flags) 

205 return err 

206  

207## utility functions 

208  

209cdef int case_desc(const cudaChannelFormatDesc* d, int x, int y, int z, int w, int f) except ?cudaErrorCallRequiresNewerDriver nogil: 

210 return d[0].x == x and d[0].y == y and d[0].z == z and d[0].w == w and d[0].f == f 

211  

212  

213cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChannels, cydriver.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil: 

214 # Check validity 

215 if d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindSigned, 

216 cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

217 if (d[0].x != 8) and (d[0].x != 16) and (d[0].x != 32): 

218 return cudaErrorInvalidChannelDescriptor 

219 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindFloat,): 

220 if (d[0].x != 16) and (d[0].x != 32): 

221 return cudaErrorInvalidChannelDescriptor 

222 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindNV12,): 

223 if (d[0].x != 8) or (d[0].y != 8) or (d[0].z != 8) or (d[0].w != 0): 

224 return cudaErrorInvalidChannelDescriptor 

225 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1, 

226 cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2, 

227 cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4, 

228 cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1, 

229 cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2, 

230 cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4,): 

231 if (d[0].x != 8): 

232 return cudaErrorInvalidChannelDescriptor 

233 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1, 

234 cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2, 

235 cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4, 

236 cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1, 

237 cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2, 

238 cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4,): 

239 if (d[0].x != 16): 

240 return cudaErrorInvalidChannelDescriptor 

241 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1, 

242 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB, 

243 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2, 

244 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB, 

245 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3, 

246 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB, 

247 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4, 

248 cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4, 

249 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5, 

250 cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5, 

251 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7, 

252 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB,): 

253 if (d[0].x != 8): 

254 return cudaErrorInvalidChannelDescriptor 

255 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H, 

256 cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H,): 

257 if (d[0].x != 16) or (d[0].y != 16) or (d[0].z != 16) or (d[0].w != 0): 

258 return cudaErrorInvalidChannelDescriptor 

259 elif d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102,): 

260 if (d[0].x != 10) or (d[0].y != 10) or (d[0].z != 10) or (d[0].w != 2): 

261 return cudaErrorInvalidChannelDescriptor 

262 else: 

263 return cudaErrorInvalidChannelDescriptor 

264  

265 # If Y is non-zero, it must match X 

266 # If Z is non-zero, it must match Y 

267 # If W is non-zero, it must match Z 

268 if (((d[0].y != 0) and (d[0].y != d[0].x)) or 

269 ((d[0].z != 0) and (d[0].z != d[0].y)) or 

270 ((d[0].w != 0) and (d[0].w != d[0].z))): 

271 if d[0].f != cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102: 

272 return cudaErrorInvalidChannelDescriptor 

273 if case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

274 numberOfChannels[0] = 1 

275 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8 

276 elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

277 numberOfChannels[0] = 2 

278 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8 

279 elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

280 numberOfChannels[0] = 3 

281 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8 

282 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

283 numberOfChannels[0] = 4 

284 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8 

285 elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

286 numberOfChannels[0] = 1 

287 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8 

288 elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

289 numberOfChannels[0] = 2 

290 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8 

291 elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

292 numberOfChannels[0] = 3 

293 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8 

294 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

295 numberOfChannels[0] = 4 

296 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8 

297 elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

298 numberOfChannels[0] = 1 

299 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16 

300 elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

301 numberOfChannels[0] = 2 

302 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16 

303 elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

304 numberOfChannels[0] = 3 

305 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16 

306 elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

307 numberOfChannels[0] = 4 

308 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16 

309 elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

310 numberOfChannels[0] = 1 

311 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16 

312 elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

313 numberOfChannels[0] = 2 

314 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16 

315 elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

316 numberOfChannels[0] = 3 

317 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16 

318 elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

319 numberOfChannels[0] = 4 

320 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16 

321 elif case_desc(d, 32, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

322 numberOfChannels[0] = 1 

323 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32 

324 elif case_desc(d, 32, 32, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

325 numberOfChannels[0] = 2 

326 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32 

327 elif case_desc(d, 32, 32, 32, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

328 numberOfChannels[0] = 3 

329 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32 

330 elif case_desc(d, 32, 32, 32, 32, cudaChannelFormatKind.cudaChannelFormatKindSigned): 

331 numberOfChannels[0] = 4 

332 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32 

333 elif case_desc(d, 32, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

334 numberOfChannels[0] = 1 

335 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32 

336 elif case_desc(d, 32, 32, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

337 numberOfChannels[0] = 2 

338 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32 

339 elif case_desc(d, 32, 32, 32, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

340 numberOfChannels[0] = 3 

341 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32 

342 elif case_desc(d, 32, 32, 32, 32, cudaChannelFormatKind.cudaChannelFormatKindUnsigned): 

343 numberOfChannels[0] = 4 

344 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32 

345 elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

346 numberOfChannels[0] = 1 

347 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF 

348 elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

349 numberOfChannels[0] = 2 

350 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF 

351 elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

352 numberOfChannels[0] = 3 

353 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF 

354 elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

355 numberOfChannels[0] = 4 

356 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF 

357 elif case_desc(d, 32, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

358 numberOfChannels[0] = 1 

359 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT 

360 elif case_desc(d, 32, 32, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

361 numberOfChannels[0] = 2 

362 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT 

363 elif case_desc(d, 32, 32, 32, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

364 numberOfChannels[0] = 3 

365 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT 

366 elif case_desc(d, 32, 32, 32, 32, cudaChannelFormatKind.cudaChannelFormatKindFloat): 

367 numberOfChannels[0] = 4 

368 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT 

369 elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindNV12): 

370 numberOfChannels[0] = 3 

371 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_NV12 

372 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1): 

373 numberOfChannels[0] = 4 

374 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM 

375 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB): 

376 numberOfChannels[0] = 4 

377 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM_SRGB 

378 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2): 

379 numberOfChannels[0] = 4 

380 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM 

381 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB): 

382 numberOfChannels[0] = 4 

383 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM_SRGB 

384 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3): 

385 numberOfChannels[0] = 4 

386 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM 

387 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB): 

388 numberOfChannels[0] = 4 

389 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM_SRGB 

390 elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4): 

391 numberOfChannels[0] = 1 

392 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC4_UNORM 

393 elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4): 

394 numberOfChannels[0] = 1 

395 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC4_SNORM 

396 elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5): 

397 numberOfChannels[0] = 2 

398 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC5_UNORM 

399 elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5): 

400 numberOfChannels[0] = 2 

401 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC5_SNORM 

402 elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H): 

403 numberOfChannels[0] = 3 

404 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC6H_UF16 

405 elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H): 

406 numberOfChannels[0] = 3 

407 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC6H_SF16 

408 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7): 

409 numberOfChannels[0] = 4 

410 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM 

411 elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB): 

412 numberOfChannels[0] = 4 

413 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM_SRGB 

414 elif case_desc(d, 10, 10, 10, 2, cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102): 

415 numberOfChannels[0] = 4 

416 format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT_101010_2 

417 else: 

418 return cudaErrorInvalidChannelDescriptor 

419  

420 if d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindNV12, 

421 cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H, 

422 cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H,): 

423 if numberOfChannels[0] != 3: 

424 return cudaErrorInvalidChannelDescriptor 

425 else: 

426 if (numberOfChannels[0] != 1) and (numberOfChannels[0] != 2) and (numberOfChannels[0] != 4): 

427 return cudaErrorInvalidChannelDescriptor 

428 return cudaSuccess 

429  

430cdef cudaError_t getChannelFormatDescFromDriverDesc(cudaChannelFormatDesc* pRuntimeDesc, size_t* pDepth, size_t* pHeight, size_t* pWidth, const cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2* pDriverDesc) except ?cudaErrorCallRequiresNewerDriver nogil: 

431 cdef int channel_size = 0 

432 if pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT8: 

433 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned 

434 channel_size = 8 

435 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT16: 

436 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned 

437 channel_size = 16 

438 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT32: 

439 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned 

440 channel_size = 32 

441 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SIGNED_INT8: 

442 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSigned 

443 channel_size = 8 

444 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SIGNED_INT16: 

445 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSigned 

446 channel_size = 16 

447 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SIGNED_INT32: 

448 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSigned 

449 channel_size = 32 

450 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_HALF: 

451 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindFloat 

452 channel_size = 16 

453 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_FLOAT: 

454 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindFloat 

455 channel_size = 32 

456 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_NV12: 

457 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindNV12 

458 channel_size = 8 

459 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT8X1: 

460 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1 

461 channel_size = 8 

462 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT8X2: 

463 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2 

464 channel_size = 8 

465 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT8X4: 

466 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4 

467 channel_size = 8 

468 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT8X1: 

469 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1 

470 channel_size = 8 

471 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT8X2: 

472 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2 

473 channel_size = 8 

474 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT8X4: 

475 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4 

476 channel_size = 8 

477 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT16X1: 

478 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1 

479 channel_size = 16 

480 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT16X2: 

481 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2 

482 channel_size = 16 

483 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT16X4: 

484 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4 

485 channel_size = 16 

486 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT16X1: 

487 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1 

488 channel_size = 16 

489 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT16X2: 

490 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2 

491 channel_size = 16 

492 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT16X4: 

493 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4 

494 channel_size = 16 

495 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC1_UNORM: 

496 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1 

497 channel_size = 8 

498 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC1_UNORM_SRGB: 

499 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB 

500 channel_size = 8 

501 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC2_UNORM: 

502 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2 

503 channel_size = 8 

504 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC2_UNORM_SRGB: 

505 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB 

506 channel_size = 8 

507 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC3_UNORM: 

508 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3 

509 channel_size = 8 

510 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC3_UNORM_SRGB: 

511 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB 

512 channel_size = 8 

513 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC4_UNORM: 

514 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4 

515 channel_size = 8 

516 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC4_SNORM: 

517 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4 

518 channel_size = 8 

519 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC5_UNORM: 

520 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5 

521 channel_size = 8 

522 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC5_SNORM: 

523 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5 

524 channel_size = 8 

525 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC6H_UF16: 

526 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H 

527 channel_size = 16 

528 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC6H_SF16: 

529 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H 

530 channel_size = 16 

531 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC7_UNORM: 

532 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7 

533 channel_size = 8 

534 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC7_UNORM_SRGB: 

535 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB 

536 channel_size = 8 

537 elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT_101010_2: 

538 pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized1010102 

539 else: 

540 return cudaErrorInvalidChannelDescriptor 

541  

542 # populate bits per channel 

543 pRuntimeDesc[0].x = 0 

544 pRuntimeDesc[0].y = 0 

545 pRuntimeDesc[0].z = 0 

546 pRuntimeDesc[0].w = 0 

547  

548 if pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT_101010_2 and pDriverDesc[0].NumChannels == 4: 

549 pRuntimeDesc[0].w = 2 

550 pRuntimeDesc[0].z = 10 

551 pRuntimeDesc[0].y = 10 

552 pRuntimeDesc[0].x = 10 

553 else: 

554 if pDriverDesc[0].NumChannels >= 4: 

555 pRuntimeDesc[0].w = channel_size 

556 if pDriverDesc[0].NumChannels >= 3: 

557 pRuntimeDesc[0].z = channel_size 

558 if pDriverDesc[0].NumChannels >= 2: 

559 pRuntimeDesc[0].y = channel_size 

560 if pDriverDesc[0].NumChannels >= 1: 

561 pRuntimeDesc[0].x = channel_size 

562  

563 if pDriverDesc[0].NumChannels not in (4, 3, 2, 1): 

564 return cudaErrorInvalidChannelDescriptor 

565  

566 # populate dimensions 

567 if pDepth != NULL: 

568 pDepth[0] = pDriverDesc[0].Depth 

569 if pHeight != NULL: 

570 pHeight[0] = pDriverDesc[0].Height 

571 if pWidth != NULL: 

572 pWidth[0] = pDriverDesc[0].Width 

573 return cudaSuccess 

574  

575cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil: 

576 cdef cudaError_t err = cudaSuccess 

577 cdef unsigned int i = 0 

578  

579 err = getDescInfo(&eglFrame.planeDesc[0].channelDesc, <int*>&cuEglFrame[0].numChannels, &cuEglFrame[0].cuFormat) 

580 if err != cudaSuccess: 

581 return err 

582 for i in range(eglFrame.planeCount): 

583 if eglFrame.frameType == cudaEglFrameTypeArray: 

584 cuEglFrame[0].frame.pArray[i] = <cydriver.CUarray>eglFrame.frame.pArray[i] 

585 else: 

586 cuEglFrame[0].frame.pPitch[i] = eglFrame.frame.pPitch[i].ptr 

587 cuEglFrame[0].width = eglFrame.planeDesc[0].width 

588 cuEglFrame[0].height = eglFrame.planeDesc[0].height 

589 cuEglFrame[0].depth = eglFrame.planeDesc[0].depth 

590 cuEglFrame[0].pitch = eglFrame.planeDesc[0].pitch 

591 cuEglFrame[0].planeCount = eglFrame.planeCount 

592 if eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar: 

593 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR 

594 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar: 

595 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR 

596 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422Planar: 

597 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR 

598 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422SemiPlanar: 

599 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR 

600 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444Planar: 

601 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR 

602 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444SemiPlanar: 

603 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR 

604 elif eglFrame.eglColorFormat == cudaEglColorFormatYUYV422: 

605 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422 

606 elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY422: 

607 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422 

608 elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY709: 

609 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709 

610 elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY709_ER: 

611 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709_ER 

612 elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY2020: 

613 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_2020 

614 elif eglFrame.eglColorFormat == cudaEglColorFormatARGB: 

615 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB 

616 elif eglFrame.eglColorFormat == cudaEglColorFormatRGBA: 

617 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA 

618 elif eglFrame.eglColorFormat == cudaEglColorFormatABGR: 

619 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR 

620 elif eglFrame.eglColorFormat == cudaEglColorFormatBGRA: 

621 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA 

622 elif eglFrame.eglColorFormat == cudaEglColorFormatL: 

623 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L 

624 elif eglFrame.eglColorFormat == cudaEglColorFormatR: 

625 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R 

626 elif eglFrame.eglColorFormat == cudaEglColorFormatA: 

627 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A 

628 elif eglFrame.eglColorFormat == cudaEglColorFormatRG: 

629 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG 

630 elif eglFrame.eglColorFormat == cudaEglColorFormatAYUV: 

631 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV 

632 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444SemiPlanar: 

633 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR 

634 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422SemiPlanar: 

635 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR 

636 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar: 

637 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR 

638 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar: 

639 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR 

640 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar: 

641 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR 

642 elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar: 

643 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR 

644 elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar: 

645 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR 

646 elif eglFrame.eglColorFormat == cudaEglColorFormatVYUY_ER: 

647 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER 

648 elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY_ER: 

649 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER 

650 elif eglFrame.eglColorFormat == cudaEglColorFormatYUYV_ER: 

651 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER 

652 elif eglFrame.eglColorFormat == cudaEglColorFormatYVYU_ER: 

653 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER 

654 elif eglFrame.eglColorFormat == cudaEglColorFormatYUVA_ER: 

655 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER 

656 elif eglFrame.eglColorFormat == cudaEglColorFormatAYUV_ER: 

657 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER 

658 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444Planar_ER: 

659 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER 

660 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422Planar_ER: 

661 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER 

662 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_ER: 

663 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER 

664 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444SemiPlanar_ER: 

665 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER 

666 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422SemiPlanar_ER: 

667 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER 

668 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_ER: 

669 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER 

670 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444Planar_ER: 

671 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER 

672 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422Planar_ER: 

673 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER 

674 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_ER: 

675 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER 

676 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444SemiPlanar_ER: 

677 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER 

678 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422SemiPlanar_ER: 

679 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER 

680 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_ER: 

681 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER 

682 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerRGGB: 

683 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB 

684 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerBGGR: 

685 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR 

686 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerGRBG: 

687 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG 

688 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerGBRG: 

689 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG 

690 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10RGGB: 

691 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB 

692 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10BGGR: 

693 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR 

694 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10GRBG: 

695 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG 

696 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10GBRG: 

697 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG 

698 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12RGGB: 

699 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB 

700 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12BGGR: 

701 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR 

702 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12GRBG: 

703 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG 

704 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12GBRG: 

705 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG 

706 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14RGGB: 

707 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB 

708 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14BGGR: 

709 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR 

710 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14GRBG: 

711 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG 

712 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14GBRG: 

713 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG 

714 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20RGGB: 

715 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB 

716 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20BGGR: 

717 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR 

718 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20GRBG: 

719 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG 

720 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20GBRG: 

721 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG 

722 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspRGGB: 

723 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB 

724 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspBGGR: 

725 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR 

726 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspGRBG: 

727 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG 

728 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspGBRG: 

729 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG 

730 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444Planar: 

731 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR 

732 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422Planar: 

733 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR 

734 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar: 

735 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR 

736 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerBCCR: 

737 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR 

738 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerRCCB: 

739 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB 

740 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerCRBC: 

741 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC 

742 elif eglFrame.eglColorFormat == cudaEglColorFormatBayerCBRC: 

743 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC 

744 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10CCCC: 

745 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC 

746 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12BCCR: 

747 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR 

748 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12RCCB: 

749 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB 

750 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CRBC: 

751 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC 

752 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CBRC: 

753 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC 

754 elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CCCC: 

755 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC 

756 elif eglFrame.eglColorFormat == cudaEglColorFormatY: 

757 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y 

758 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_2020: 

759 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 

760 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_2020: 

761 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 

762 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_2020: 

763 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 

764 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_2020: 

765 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 

766 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_709: 

767 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 

768 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_709: 

769 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 

770 elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_709: 

771 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 

772 elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_709: 

773 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709 

774 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_709: 

775 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 

776 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_2020: 

777 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 

778 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar_2020: 

779 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 

780 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar: 

781 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR 

782 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar_709: 

783 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709 

784 elif eglFrame.eglColorFormat == cudaEglColorFormatY_ER: 

785 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER 

786 elif eglFrame.eglColorFormat == cudaEglColorFormatY_709_ER: 

787 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER 

788 elif eglFrame.eglColorFormat == cudaEglColorFormatY10_ER: 

789 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER 

790 elif eglFrame.eglColorFormat == cudaEglColorFormatY10_709_ER: 

791 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER 

792 elif eglFrame.eglColorFormat == cudaEglColorFormatY12_ER: 

793 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER 

794 elif eglFrame.eglColorFormat == cudaEglColorFormatY12_709_ER: 

795 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER 

796 elif eglFrame.eglColorFormat == cudaEglColorFormatYUVA: 

797 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA 

798 elif eglFrame.eglColorFormat == cudaEglColorFormatYVYU: 

799 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU 

800 elif eglFrame.eglColorFormat == cudaEglColorFormatVYUY: 

801 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY 

802 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_ER: 

803 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER 

804 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER: 

805 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER 

806 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar_ER: 

807 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER 

808 elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER: 

809 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER 

810 elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar_ER: 

811 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER 

812 elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER: 

813 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER 

814 elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar_ER: 

815 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER 

816 elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER: 

817 cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER 

818 else: 

819 return cudaErrorInvalidValue 

820 if eglFrame.frameType == cudaEglFrameTypeArray: 

821 cuEglFrame[0].frameType = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY 

822 elif eglFrame.frameType == cudaEglFrameTypePitch: 

823 cuEglFrame[0].frameType = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH 

824 else: 

825 return cudaErrorInvalidValue 

826  

827@cython.show_performance_hints(False) 

828cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil: 

829 cdef cudaError_t err = cudaSuccess 

830 cdef unsigned int i 

831 cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 ad 

832 cdef cudaPitchedPtr pPtr 

833 memset(eglFrame, 0, sizeof(eglFrame[0])) 

834 memset(&ad, 0, sizeof(ad)) 

835 for i in range(cueglFrame.planeCount): 

836 ad.Depth = cueglFrame.depth 

837 ad.Flags = 0 

838 ad.Format = cueglFrame.cuFormat 

839 ad.Height = cueglFrame.height 

840 ad.NumChannels = cueglFrame.numChannels 

841 ad.Width = cueglFrame.width 

842  

843 err = getChannelFormatDescFromDriverDesc(&eglFrame[0].planeDesc[i].channelDesc, NULL, NULL, NULL, &ad) 

844 if err != cudaSuccess: 

845 return err 

846  

847 eglFrame[0].planeDesc[i].depth = cueglFrame.depth 

848 eglFrame[0].planeDesc[i].numChannels = cueglFrame.numChannels 

849 if i == 0: 

850 eglFrame[0].planeDesc[i].width = cueglFrame.width 

851 eglFrame[0].planeDesc[i].height = cueglFrame.height 

852 eglFrame[0].planeDesc[i].pitch = cueglFrame.pitch 

853 elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR or 

854 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER or 

855 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR or 

856 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER or 

857 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 or 

858 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 or 

859 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 or 

860 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709): 

861 eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2) 

862 eglFrame[0].planeDesc[i].height = <unsigned int>(cueglFrame.height / 2) 

863 eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2) 

864 elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR or 

865 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER or 

866 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR or 

867 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER or 

868 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR or 

869 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR or 

870 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 or 

871 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 or 

872 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 or 

873 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 or 

874 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 or 

875 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 or 

876 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER or 

877 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER or 

878 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER or 

879 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER): 

880 eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2) 

881 eglFrame[0].planeDesc[i].height = <unsigned int>(cueglFrame.height / 2) 

882 eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2) 

883 eglFrame[0].planeDesc[1].channelDesc.y = 8 

884 if (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR or 

885 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR or 

886 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 or 

887 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 or 

888 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER or 

889 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER or 

890 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER or 

891 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER): 

892 eglFrame[0].planeDesc[1].channelDesc.y = 16 

893 elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR or 

894 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER or 

895 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR or 

896 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER): 

897 eglFrame[0].planeDesc[i].height = cueglFrame.height 

898 eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2) 

899 eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2) 

900 elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR or 

901 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER or 

902 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR or 

903 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER or 

904 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 or 

905 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR or 

906 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709): 

907 eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2) 

908 eglFrame[0].planeDesc[i].height = cueglFrame.height 

909 eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2) 

910 eglFrame[0].planeDesc[1].channelDesc.y = 8 

911 if (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 or 

912 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR or 

913 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709): 

914 eglFrame[0].planeDesc[1].channelDesc.y = 16 

915 elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR or 

916 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER or 

917 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR or 

918 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER): 

919 eglFrame[0].planeDesc[i].height = cueglFrame.height 

920 eglFrame[0].planeDesc[i].width = cueglFrame.width 

921 eglFrame[0].planeDesc[i].pitch = cueglFrame.pitch 

922 elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR or 

923 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER or 

924 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR or 

925 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER or 

926 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR or 

927 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR or 

928 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER or 

929 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER or 

930 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER or 

931 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER): 

932 eglFrame[0].planeDesc[i].height = cueglFrame.height 

933 eglFrame[0].planeDesc[i].width = cueglFrame.width 

934 eglFrame[0].planeDesc[i].pitch = cueglFrame.pitch 

935 eglFrame[0].planeDesc[1].channelDesc.y = 8 

936 if (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR or 

937 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR or 

938 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER or 

939 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER or 

940 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER or 

941 cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER): 

942 eglFrame[0].planeDesc[1].channelDesc.y = 16 

943 if cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY: 

944 eglFrame[0].frame.pArray[i] = <cudaArray_t>cueglFrame.frame.pArray[i] 

945 else: 

946 pPtr = _cylib_make_cudaPitchedPtr(cueglFrame.frame.pPitch[i], eglFrame[0].planeDesc[i].pitch, 

947 eglFrame[0].planeDesc[i].width, eglFrame[0].planeDesc[i].height) 

948 eglFrame[0].frame.pPitch[i] = pPtr 

949  

950 eglFrame[0].planeCount = cueglFrame.planeCount 

951 if cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR: 

952 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar 

953 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR: 

954 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar 

955 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR: 

956 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422Planar 

957 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR: 

958 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422SemiPlanar 

959 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR: 

960 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444Planar 

961 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR: 

962 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444SemiPlanar 

963 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422: 

964 eglFrame[0].eglColorFormat = cudaEglColorFormatYUYV422 

965 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422: 

966 eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY422 

967 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709: 

968 eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY709 

969 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_709_ER: 

970 eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY709_ER 

971 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_2020: 

972 eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY2020 

973 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB: 

974 eglFrame[0].eglColorFormat = cudaEglColorFormatARGB 

975 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA: 

976 eglFrame[0].eglColorFormat = cudaEglColorFormatRGBA 

977 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR: 

978 eglFrame[0].eglColorFormat = cudaEglColorFormatABGR 

979 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA: 

980 eglFrame[0].eglColorFormat = cudaEglColorFormatBGRA 

981 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L: 

982 eglFrame[0].eglColorFormat = cudaEglColorFormatL 

983 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R: 

984 eglFrame[0].eglColorFormat = cudaEglColorFormatR 

985 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A: 

986 eglFrame[0].eglColorFormat = cudaEglColorFormatA 

987 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG: 

988 eglFrame[0].eglColorFormat = cudaEglColorFormatRG 

989 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV: 

990 eglFrame[0].eglColorFormat = cudaEglColorFormatAYUV 

991 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR: 

992 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444SemiPlanar 

993 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR: 

994 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422SemiPlanar 

995 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR: 

996 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar 

997 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR: 

998 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar 

999 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR: 

1000 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar 

1001 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR: 

1002 eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar 

1003 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR: 

1004 eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar 

1005 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER: 

1006 eglFrame[0].eglColorFormat = cudaEglColorFormatVYUY_ER 

1007 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER: 

1008 eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY_ER 

1009 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER: 

1010 eglFrame[0].eglColorFormat = cudaEglColorFormatYUYV_ER 

1011 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER: 

1012 eglFrame[0].eglColorFormat = cudaEglColorFormatYVYU_ER 

1013 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER: 

1014 eglFrame[0].eglColorFormat = cudaEglColorFormatYUVA_ER 

1015 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER: 

1016 eglFrame[0].eglColorFormat = cudaEglColorFormatAYUV_ER 

1017 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER: 

1018 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444Planar_ER 

1019 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER: 

1020 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422Planar_ER 

1021 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER: 

1022 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_ER 

1023 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER: 

1024 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444SemiPlanar_ER 

1025 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER: 

1026 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422SemiPlanar_ER 

1027 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER: 

1028 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_ER 

1029 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER: 

1030 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444Planar_ER 

1031 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER: 

1032 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422Planar_ER 

1033 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER: 

1034 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_ER 

1035 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER: 

1036 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444SemiPlanar_ER 

1037 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER: 

1038 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422SemiPlanar_ER 

1039 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER: 

1040 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_ER 

1041 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB: 

1042 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerRGGB 

1043 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR: 

1044 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerBGGR 

1045 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG: 

1046 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerGRBG 

1047 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG: 

1048 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerGBRG 

1049 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB: 

1050 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10RGGB 

1051 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR: 

1052 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10BGGR 

1053 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG: 

1054 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10GRBG 

1055 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG: 

1056 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10GBRG 

1057 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB: 

1058 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12RGGB 

1059 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR: 

1060 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12BGGR 

1061 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG: 

1062 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12GRBG 

1063 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG: 

1064 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12GBRG 

1065 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB: 

1066 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14RGGB 

1067 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR: 

1068 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14BGGR 

1069 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG: 

1070 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14GRBG 

1071 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG: 

1072 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14GBRG 

1073 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB: 

1074 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20RGGB 

1075 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR: 

1076 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20BGGR 

1077 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG: 

1078 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20GRBG 

1079 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG: 

1080 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20GBRG 

1081 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB: 

1082 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspRGGB 

1083 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR: 

1084 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspBGGR 

1085 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG: 

1086 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspGRBG 

1087 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG: 

1088 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspGBRG 

1089 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR: 

1090 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444Planar 

1091 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR: 

1092 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422Planar 

1093 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR: 

1094 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar 

1095 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR: 

1096 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerBCCR 

1097 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB: 

1098 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerRCCB 

1099 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC: 

1100 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerCRBC 

1101 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC: 

1102 eglFrame[0].eglColorFormat = cudaEglColorFormatBayerCBRC 

1103 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC: 

1104 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10CCCC 

1105 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR: 

1106 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12BCCR 

1107 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB: 

1108 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12RCCB 

1109 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC: 

1110 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CRBC 

1111 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC: 

1112 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CBRC 

1113 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC: 

1114 eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CCCC 

1115 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y: 

1116 eglFrame[0].eglColorFormat = cudaEglColorFormatY 

1117 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020: 

1118 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_2020 

1119 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020: 

1120 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_2020 

1121 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020: 

1122 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_2020 

1123 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020: 

1124 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_2020 

1125 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709: 

1126 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_709 

1127 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709: 

1128 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_709 

1129 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709: 

1130 eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_709 

1131 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709: 

1132 eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_709 

1133 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709: 

1134 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_709 

1135 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020: 

1136 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_2020 

1137 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020: 

1138 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar_2020 

1139 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR: 

1140 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar 

1141 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709: 

1142 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar_709 

1143 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER: 

1144 eglFrame[0].eglColorFormat = cudaEglColorFormatY_ER 

1145 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER: 

1146 eglFrame[0].eglColorFormat = cudaEglColorFormatY_709_ER 

1147 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER: 

1148 eglFrame[0].eglColorFormat = cudaEglColorFormatY10_ER 

1149 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER: 

1150 eglFrame[0].eglColorFormat = cudaEglColorFormatY10_709_ER 

1151 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER: 

1152 eglFrame[0].eglColorFormat = cudaEglColorFormatY12_ER 

1153 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER: 

1154 eglFrame[0].eglColorFormat = cudaEglColorFormatY12_709_ER 

1155 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA: 

1156 eglFrame[0].eglColorFormat = cudaEglColorFormatYUVA 

1157 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU: 

1158 eglFrame[0].eglColorFormat = cudaEglColorFormatYVYU 

1159 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY: 

1160 eglFrame[0].eglColorFormat = cudaEglColorFormatVYUY 

1161 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER: 

1162 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_ER 

1163 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER: 

1164 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER 

1165 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER: 

1166 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar_ER 

1167 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER: 

1168 eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER 

1169 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER: 

1170 eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar_ER 

1171 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER: 

1172 eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER 

1173 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER: 

1174 eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar_ER 

1175 elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER: 

1176 eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER 

1177 else: 

1178 return cudaErrorInvalidValue 

1179 if cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY: 

1180 eglFrame[0].frameType = cudaEglFrameTypeArray 

1181 elif cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH: 

1182 eglFrame[0].frameType = cudaEglFrameTypePitch 

1183 else: 

1184 return cudaErrorInvalidValue