* Retain the device. * \param device A valid device created using createSubDevices * \return * CL_SUCCESS if the function executed s

cl_platform_id does not have retain().

* Resets the position of the directory stream to which dirp refers to the * beginning of the directory. It also causes the directory stream to refer

Run, run once every frames

! \brief Registers a user callback function for a specific command execution status. * * Wraps clSetEventCallback(). */

! \brief Registers a callback function to be called when the memory object * is no longer needed. * * Wraps clSetMemObjectDest

! \brief Sets the execution status of a user event object. * * Wraps clSetUserEventStatus(). */

Doing non-trivial things in signal handler is bad. If you want to pause, do it in another thread. Though libusb operations are generally thread safe,

Doing non-trivial things in signal handler is bad. If you want to pause, do it in another thread. Though libusb operations are generally thread safe,

* Execute the given event loop. * @param cookie Event loop to run. */

* Wrapper function to start the thread. * @param data The #AsyncPacketProcessor object to use. */

* Transform measurement. * @param [in, out] m Measurement. */

Try to lock the mutex. The method will try to lock the mutex. If it fails, the function will return immediately (non-blocking). @return @c true if the

The inverse of distort() using Newton's method Return true if converged correctly This function considers tangential distortion with double precision.

\brief Wrapper for clUnloadCompiler().

Unlock the mutex. If any threads are waiting for the lock on this mutex, one of them will be unblocked.

! \brief Blocks the calling thread until every event specified is complete. * * Wraps clWaitForEvents(). */

! \brief Get error string associated with exception * * \return A memory pointer to the error message string. */

* Get the width of the image. * @return Width of the image. */

Yield execution to another thread. Offers the operating system the opportunity to schedule another thread that is ready to run on the current processo