From 31f9c57bc50ae053cfaf039a1dfdb128e2494458 Mon Sep 17 00:00:00 2001 From: Miikka Heikkinen Date: Tue, 20 Oct 2015 13:18:59 +0300 Subject: Fix issues with COIN builds MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit -Fix miscellaneous compile errors -Move manual tests to manual folder and enable export of autotests -Added widgets requirement -Fixed autotests -Fixed renderer and controller synchronization in QML case -Treat fallback Mesa as ES2 similar to setting AA_UseSoftwareOpenGL Change-Id: If6619733725d079e339bef16262e5ea1450ab20f Reviewed-by: Tomi Korpipää --- .../QtKinectWrapper/OpenNI/Include/XnContext.h | 569 +++++++++++++++++++++ 1 file changed, 569 insertions(+) create mode 100644 tests/manual/kinectsurface/QtKinectWrapper/OpenNI/Include/XnContext.h (limited to 'tests/manual/kinectsurface/QtKinectWrapper/OpenNI/Include/XnContext.h') diff --git a/tests/manual/kinectsurface/QtKinectWrapper/OpenNI/Include/XnContext.h b/tests/manual/kinectsurface/QtKinectWrapper/OpenNI/Include/XnContext.h new file mode 100644 index 00000000..fb6414c4 --- /dev/null +++ b/tests/manual/kinectsurface/QtKinectWrapper/OpenNI/Include/XnContext.h @@ -0,0 +1,569 @@ +/**************************************************************************** +* * +* OpenNI 1.x Alpha * +* Copyright (C) 2011 PrimeSense Ltd. * +* * +* This file is part of OpenNI. * +* * +* OpenNI is free software: you can redistribute it and/or modify * +* it under the terms of the GNU Lesser General Public License as published * +* by the Free Software Foundation, either version 3 of the License, or * +* (at your option) any later version. * +* * +* OpenNI 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 Lesser General Public License for more details. * +* * +* You should have received a copy of the GNU Lesser General Public License * +* along with OpenNI. If not, see . * +* * +****************************************************************************/ +#ifndef __XN_CONTEXT_H__ +#define __XN_CONTEXT_H__ + +/** + * @ingroup cref + * @defgroup context Context + * This page details functions for managing an OpenNI context. + * + * @section init Initializing and Deinitializing OpenNI Context + * + * Initialization must be performed before using any OpenNI functionality, and similarly you + * must not call any OpenNI functions after deinitialization. + * + * @section trees Enumerating and Creating Production Trees + * + * A production tree is composed of a production node, and optionally a list of other + * production trees needed for this production node. Each production node has a type (one of + * the types defined by OpenNI spec), a vendor name, and a specific name (unique for this type + * and vendor), with a version. + * For example, a User generator may need a Depth generator, which in turn might need a Device node. + * + * @subsection results Enumeration Results + * + * The results from an enumeration operation is a pointer to the first node of a linked list, representing + * all the different possibilities to get data of the requested type. A single possibility contains + * the provider description, an optional instance name (that can be used by the provider as proprietary + * information, like a device S/N), and the bExists field, which tells if this node already exists in + * the context (and as such, doesn't need to be created) or not, and a list of needed nodes by this node. + * + * @subsection enumex Enumerating Example + * + * For example, let's take a look at an application in need of depth maps: + * @code +// Enumerate for production trees that can produce depth +XnNodeInfoList* pNodesList; +nRetVal = xnEnumerateProductionTrees(pNiteCtx, XN_NODE_TYPE_DEPTH, NULL, &pNodesList); +CHECK_RC(nRetVal, "Enumerate"); + +// choose a tree (for simplicity, take first one) +XnNodeInfoListIterator itChosen = xnNodeInfoListGetFirst(pNodesList); +XnNodeInfo* pChosen = xnNodeInfoListGetCurrent(itChosen); + +// create first one +XnNodeHandle hDepth; +nRetVal = xnCreateProductionTree(pNiteCtx, pChosen, &hDepth); +CHECK_RC(nRetVal, "Create"); + +// free the list (it is no longer needed) +xnNodeInfoListFree(pNodesList); + +// TODO: use handle for configuration and data extraction + * @endcode + * + * @{ +*/ + +//--------------------------------------------------------------------------- +// Includes +//--------------------------------------------------------------------------- +#include +#include +#include + +//--------------------------------------------------------------------------- +// Functions +//--------------------------------------------------------------------------- + +/** @name Initialization + * Functions for initializing and shutting down an OpenNI context. + * @{ + */ + +/** + * @brief Initializes the OpenNI library. + * + * This function must be called before calling any other OpenNI function (except for @ref xnInitFromXmlFile()) + * + * @param ppContext [out] Output location for context pointer. + */ +XN_C_API XnStatus XN_C_DECL xnInit(XnContext** ppContext); + +/** + * @brief Runs an XML script in the given context. + * + * @param pContext [in] The context to be configured. + * @param strFileName [in] The name of the file containing the script. for a full description of the XML structure, see @ref xmlscripts. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + * @param phScriptNode [out] Handle to a node holding all the nodes created from the script. When no longer + * needed, the node can be released, causing all those nodes to dec ref. + */ +XN_C_API XnStatus XN_C_DECL xnContextRunXmlScriptFromFileEx(XnContext* pContext, const XnChar* strFileName, XnEnumerationErrors* pErrors, XnNodeHandle* phScriptNode); + +/** + * @brief Runs an XML script in the given context. + * NOTE: when using this function, the context will be the owner of the created nodes, so those nodes and + * the context will only be destroyed if calling @ref xnShutdown(). It is highly suggested to use + * @ref xnContextRunXmlScriptFromFileEx() instead, which returns a node referencing created nodes, making the caller + * owner of those nodes. + * + * @param pContext [in] The context to be configured. + * @param strFileName [in] The name of the file containing the script. for a full description of the XML structure, see @ref xmlscripts. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + */ +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnContextRunXmlScriptFromFileEx() instead") xnContextRunXmlScriptFromFile(XnContext* pContext, const XnChar* strFileName, XnEnumerationErrors* pErrors); + +/** + * @brief Runs an XML script in the given context. + * + * @param pContext [in] The context. + * @param xmlScript [in] A string representation of the XML script. for a full description of the XML structure, see @ref xmlscripts. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + * @param phScriptNode [out] Handle to a node holding all the nodes created from the script. When no longer + * needed, the node can be released, causing all those nodes to dec ref. + */ +XN_C_API XnStatus XN_C_DECL xnContextRunXmlScriptEx(XnContext* pContext, const XnChar* xmlScript, XnEnumerationErrors* pErrors, XnNodeHandle* phScriptNode); + +/** + * @brief Runs an XML script in the given context. + * NOTE: when using this function, the context will be the owner of the created nodes, so those nodes and + * the context will only be destroyed if calling @ref xnShutdown(). It is highly suggested to use + * @ref xnContextRunXmlScriptEx() instead, which returns a node referencing created nodes, making the caller + * owner of those nodes. + * + * @param pContext [in] The context. + * @param xmlScript [in] A string representation of the XML script. for a full description of the XML structure, see @ref xmlscripts. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + */ +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnContextRunXmlScriptEx() instead") XN_C_DECL xnContextRunXmlScript(XnContext* pContext, const XnChar* xmlScript, XnEnumerationErrors* pErrors); + +/** + * @brief Initializes OpenNI context, and then configures it using the given file. + * + * @param strFileName [in] The name of the file to read configuration from. + * @param ppContext [out] Output location for context pointer. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + * @param phScriptNode [out] Handle to a node holding all the nodes created from the script. When no longer + * needed, the node can be released, causing all those nodes to dec ref. + */ +XN_C_API XnStatus XN_C_DECL xnInitFromXmlFileEx(const XnChar* strFileName, XnContext** ppContext, XnEnumerationErrors* pErrors, XnNodeHandle* phScriptNode); + +/** + * @brief Initializes OpenNI context, and then configures it using the given file. + * NOTE: when using this function, the context will be the owner of the created nodes, so those nodes and + * the context will only be destroyed if calling @ref xnShutdown(). It is highly suggested to use + * @ref xnInitFromXmlFileEx() instead, which returns a node referencing created nodes, making the caller + * owner of those nodes. + * + * @param strFileName [in] The name of the file to read configuration from. + * @param ppContext [out] Output location for context pointer. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + */ +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnInitFromXmlFileEx() instead") XN_C_DECL xnInitFromXmlFile(const XnChar* strFileName, XnContext** ppContext, XnEnumerationErrors* pErrors); + +/** + * @brief Opens a recording file, adding all nodes in it to the context. + * + * @param pContext [in] The context. + * @param strFileName [in] The file to open. + * @param phPlayerNode [out] The created player node. + */ +XN_C_API XnStatus XN_C_DECL xnContextOpenFileRecordingEx(XnContext* pContext, const XnChar* strFileName, XnNodeHandle* phPlayerNode); + +/** + * @brief Opens a recording file, adding all nodes in it to the context. + * NOTE: when using this function, the context will be the owner of the created player node, so this nodes and + * the context will only be destroyed if calling @ref xnShutdown(). It is highly suggested to use + * @ref xnContextOpenFileRecordingEx() instead, which returns the player node, making the caller + * owner of this node. + * + * @param pContext [in] The context. + * @param strFileName [in] The file to open. + */ +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnContextOpenFileRecordingEx() instead") XN_C_DECL xnContextOpenFileRecording(XnContext* pContext, const XnChar* strFileName); + +/** + * @brief Adds a reference to the context object. + * + * @param pContext [in] The context. + */ +XN_C_API XnStatus XN_C_DECL xnContextAddRef(XnContext* pContext); + +/** + * @brief Releases a context object, decreasing its ref count by 1. If reference count has reached 0, + * the context will be destroyed. + * + * @param pContext [in] The context. + */ +XN_C_API void XN_C_DECL xnContextRelease(XnContext* pContext); + +/** + * @brief Shuts down an OpenNI context, destroying all its nodes. Do not call any function of this + * context or any correlated node after calling this method. + * NOTE: this function destroys the context and all the nodes it holds and so should be used very carefully. + * Normally you should just call @ref xnContextRelease() + * + * @param pContext [in] The context to be destroyed. + */ +XN_C_API void XN_API_DEPRECATED("Use xnContextRelease() instead") XN_C_DECL xnShutdown(XnContext* pContext); + +/** + * @brief Forces a context to shutdown, destroying all nodes. This function is used for backwards compatibility + * and should not be called by any client. Please use @ref xnContextRelease() instead. + * + * @param pContext [in] The context to be destroyed. + */ +XN_C_API void XN_C_DECL xnForceShutdown(XnContext* pContext); + +/** + * @brief Registers for context shutting down event. This function is used for backwards compatibility and + * should not be called by any client. + */ +XN_C_API XnStatus XN_C_DECL xnContextRegisterForShutdown(XnContext* pContext, XnContextShuttingDownHandler pHandler, void* pCookie, XnCallbackHandle* phCallback); + +/** + * @brief Unregisters from context shutting down event. This function is used for backwards compatibility and + * should not be called by any client. + */ +XN_C_API void XN_C_DECL xnContextUnregisterFromShutdown(XnContext* pContext, XnCallbackHandle hCallback); + +// @} + +/** @name Enumeration + * Functions for enumeration and creation of nodes. + * @{ + */ + +/** + * @brief Enumerates all available production trees for a specific node type. The trees populated in the + * list should be freed by calling @ref xnNodeInfoListFree() once not needed. + * + * @param pContext [in] OpenNI context. + * @param Type [in] The requested node type. + * @param pQuery [in] Optional. A query object that can be used to filter results. + * @param ppTreesList [out] A list of possible production trees. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + */ +XN_C_API XnStatus XN_C_DECL xnEnumerateProductionTrees( + XnContext* pContext, + XnProductionNodeType Type, + const XnNodeQuery* pQuery, + XnNodeInfoList** ppTreesList, + XnEnumerationErrors* pErrors + ); + +/** + * @brief Creates a production node. If the tree specifies additional needed nodes, and those nodes + * do not exist, they will be created too, and passed to this node as input. + * + * @param pContext [in] OpenNI context. + * @param pTree [in] A production tree to create. + * @param phNode [out] A handle to the newly created node. + */ +XN_C_API XnStatus XN_C_DECL xnCreateProductionTree( + XnContext* pContext, + XnNodeInfo* pTree, + XnNodeHandle* phNode + ); + +/** + * @brief Enumerates for production trees for a specific node type, and creates the first found tree. + * This function is a shortcut version for using @ref xnEnumerateProductionTrees(), iterating the list, + * and then calling @ref xnCreateProductionTree(). + * + * @param pContext [in] OpenNI context. + * @param type [in] The requested node type. + * @param pQuery [in] Optional. A query object that can be used to filter results. + * @param phNode [out] A handle to the newly created node. + * @param pErrors [in/out] Optional. If provided, will be filled with enumeration errors. + */ +XN_C_API XnStatus XN_C_DECL xnCreateAnyProductionTree( + XnContext* pContext, + XnProductionNodeType type, + XnNodeQuery* pQuery, + XnNodeHandle* phNode, + XnEnumerationErrors* pErrors + ); + +/** + * @brief Creates a production node which is only a mock. This node does not represent an actual node, but only + * keeps a state and implements an interface above it. + * Mock nodes are useful when simulating nodes for playing recordings, or for use in tests. + * See also @ref xnCreateMockNodeBasedOn(). + * + * @param pContext [in] OpenNI context. + * @param type [in] The type of the mock to create. + * @param strName [in] Optional. The name of the node. If NULL is provided, a name will be automatically generated. + * @param phNode [out] A handle to the newly created node. + */ +XN_C_API XnStatus XN_C_DECL xnCreateMockNode( + XnContext* pContext, + XnProductionNodeType type, + const XnChar* strName, + XnNodeHandle* phNode + ); + +/** + * @brief Creates a production node which is only a mock, base on the type and properties of another node. + * This node does not represent an actual node, but only keeps a state and implements an interface above it. + * Mock nodes are useful when simulating nodes for playing recordings, or for use in tests. + * See also @ref xnCreateMockNode(). + * + * @param pContext [in] OpenNI context. + * @param hOriginalNode [in] A handle to an existing node on which the mock node will be based on. + * @param strName [in] The name of the node. If set to NULL, a name will be generated based on the name of hOriginalNode. + * @param phMockNode [out] A handle to the newly created mock node. + */ +XN_C_API XnStatus XN_C_DECL xnCreateMockNodeBasedOn( + XnContext* pContext, + XnNodeHandle hOriginalNode, + const XnChar* strName, + XnNodeHandle* phMockNode + ); + +/** + * @brief References a production node, increasing its reference count by 1. + * + * @param hNode [in] A handle to the node. + */ +XN_C_API XnStatus XN_C_DECL xnProductionNodeAddRef(XnNodeHandle hNode); + +/** + * References a production node, increasing its reference count by 1. + * Note: this function is deprecated. Please use @ref xnProductionNodeAddRef() instead. + * + * @param hNode [in] A handle to the node. + */ +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnProductionNodeAddRef() instead.") XN_C_DECL xnRefProductionNode(XnNodeHandle hNode); + +/** + * @brief Unreference a production node, decreasing its reference count by 1. If the reference count reaches zero, + * the node will be destroyed. + * + * @param hNode [in] A handle to the node. + */ +XN_C_API void XN_C_DECL xnProductionNodeRelease(XnNodeHandle hNode); + +/** + * Unreference a production node, decreasing its reference count by 1. If the reference count reaches zero, + * the node will be destroyed. + * Note: this function is deprecated. Please use @ref xnProductionNodeAddRef() instead. + * + * @param hNode [in] A handle to the node. + */ +XN_C_API void XN_API_DEPRECATED("Please use xnProductionNodeRelease() instead.") XN_C_DECL xnUnrefProductionNode(XnNodeHandle hNode); + +/** + * @brief Gets a list of all existing node in the context. Each node that was returned increases its ref count. + * The list must be freed using @ref xnNodeInfoListFree(). + * + * @param pContext [in] OpenNI context. + * @param ppList [out] A linked list of current existing nodes + */ +XN_C_API XnStatus XN_C_DECL xnEnumerateExistingNodes(XnContext* pContext, XnNodeInfoList** ppList); + +/** + * @brief Gets a list of all existing node in the context. Each node that was returned increases its ref count. + * The list must be freed using @ref xnNodeInfoListFree(). + * + * @param pContext [in] OpenNI context. + * @param type [in] Type to look for. + * @param ppList [out] A linked list of current existing nodes + */ +XN_C_API XnStatus XN_C_DECL xnEnumerateExistingNodesByType(XnContext* pContext, XnProductionNodeType type, XnNodeInfoList** ppList); + +/** + * @brief Returns the first found existing node of the specified type. + * + * @param pContext [in] OpenNI context. + * @param type [in] Type to look for. + * @param phNode [out] A handle to the found node. + */ +XN_C_API XnStatus XN_C_DECL xnFindExistingRefNodeByType( + XnContext* pContext, + XnProductionNodeType type, + XnNodeHandle* phNode + ); + +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnFindExistingRefNodeByType() instead") XN_C_DECL xnFindExistingNodeByType( + XnContext* pContext, + XnProductionNodeType type, + XnNodeHandle* phNode + ); + +/** + * @brief Gets a handle to an existing production node instance using that instance name. + * + * @param pContext [in] OpenNI context. + * @param strInstanceName [in] Name of the instance to get. + * @param phNode [out] A handle to that instance. + * + * @return XN_STATUS_BAD_NODE_NAME if node by name of strInstanceName doesn't exist. + */ +XN_C_API XnStatus XN_C_DECL xnGetRefNodeHandleByName( + XnContext* pContext, + const XnChar* strInstanceName, + XnNodeHandle* phNode + ); + +XN_C_API XnStatus XN_API_DEPRECATED("Please use xnGetRefNodeHandleByName() instead") XN_C_DECL xnGetNodeHandleByName( + XnContext* pContext, + const XnChar* strInstanceName, + XnNodeHandle* phNode + ); + +// @} + +/** @name Multi-Node Handling + * Functions that affect all the nodes in the context. + * @{ + */ + +/** + * @brief Updates all generators nodes in the context, waiting for all to have new data. + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnStatus XN_C_DECL xnWaitAndUpdateAll(XnContext* pContext); + +/** + * @brief Updates all generators nodes in the context, waiting for a specific one to have new data. + * + * @param pContext [in] OpenNI context. + * @param hNode [in] The node to wait for. + */ +XN_C_API XnStatus XN_C_DECL xnWaitOneUpdateAll(XnContext* pContext, XnNodeHandle hNode); + +/** + * @brief Updates all generators nodes in the context, once any of them have new data. + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnStatus XN_C_DECL xnWaitAnyUpdateAll(XnContext* pContext); + +/** + * @brief Updates all generator nodes in the context, without any waiting. If a node has new data, + * it will be updated. + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnStatus XN_C_DECL xnWaitNoneUpdateAll(XnContext* pContext); + +/** + * @brief Make sure all generators are generating data. + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnStatus XN_C_DECL xnStartGeneratingAll(XnContext* pContext); + +/** + * @brief Stop all generators from generating data. + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnStatus XN_C_DECL xnStopGeneratingAll(XnContext* pContext); + +/** + * @brief Sets the global mirror flag. This will set all current existing nodes' mirror state, and also + * affect future created nodes. The default mirror flag is FALSE. + * + * @param pContext [in] OpenNI context. + * @param bMirror [in] New Mirror state. + */ +XN_C_API XnStatus XN_C_DECL xnSetGlobalMirror(XnContext* pContext, XnBool bMirror); + +/** + * @brief Gets the global mirror flag. + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnBool XN_C_DECL xnGetGlobalMirror(XnContext* pContext); + +/** + * @brief Gets the global error state of the context. If one of the nodes in the context is in error state, + * that state will be returned. If more than one node is in error state, XN_STATUS_MULTIPLE_NODES_ERROR + * is returned. An application can query each node error state by calling @ref xnGetNodeErrorState(). + * + * @param pContext [in] OpenNI context. + */ +XN_C_API XnStatus XN_C_DECL xnGetGlobalErrorState(XnContext* pContext); + +/** + * @brief Registers a callback function to global error state changes. + * + * @param pContext [in] OpenNI context. + * @param handler [in] A pointer to a function that will be called when global error state changes. + * @param pCookie [in] A user cookie that will be passed to the callback function. + * @param phCallback [out] Optional. Will be filled with a handle to be passed to @ref xnUnregisterFromGlobalErrorStateChange(). + */ +XN_C_API XnStatus XN_C_DECL xnRegisterToGlobalErrorStateChange + (XnContext* pContext, XnErrorStateChangedHandler handler, + void* pCookie, XnCallbackHandle* phCallback); + +/** + * @brief Unregisters a callback function which was registered using @ref xnRegisterToGlobalErrorStateChange(). + * + * @param pContext [in] OpenNI context. + * @param hCallback [in] The handle to the callback returned from @ref xnRegisterToGlobalErrorStateChange(). + */ +XN_C_API void XN_C_DECL xnUnregisterFromGlobalErrorStateChange + (XnContext* pContext, XnCallbackHandle hCallback); + +/** +* @brief Registers a callback function to 'Node Creation' event. This event is raised whenever node are created. +* +* @param pContext [in] OpenNI context. +* @param handler [in] A pointer to a function that will be called when a new node is created. +* @param pCookie [in] A user cookie that will be passed to the callback function. +* @param phCallback [out] Optional. Will be filled with a handle to be passed to @ref xnUnregisterFromNodeCreation(). +*/ +XN_C_API XnStatus XN_C_DECL xnRegisterToNodeCreation + (XnContext* pContext, XnNodeCreationHandler handler, + void* pCookie, XnCallbackHandle* phCallback); + +/** + * @brief Unregisters a callback function which was registered using @ref xnRegisterToNodeCreation(). + * + * @param pContext [in] OpenNI context. + * @param hCallback [in] The handle to the callback returned from @ref xnRegisterToNodeCreation(). + */ +XN_C_API void XN_C_DECL xnUnregisterFromNodeCreation + (XnContext* pContext, XnCallbackHandle hCallback); + +/** +* @brief Registers a callback function to 'Node Destruction' event. This event is raised whenever a node is destroyed. +* +* @param pContext [in] OpenNI context. +* @param handler [in] A pointer to a function that will be called when a node is destroyed. +* @param pCookie [in] A user cookie that will be passed to the callback function. +* @param phCallback [out] Optional. Will be filled with a handle to be passed to @ref xnUnregisterFromNodeDestruction(). +*/ +XN_C_API XnStatus XN_C_DECL xnRegisterToNodeDestruction + (XnContext* pContext, XnNodeDestructionHandler handler, + void* pCookie, XnCallbackHandle* phCallback); + +/** + * @brief Unregisters a callback function which was registered using @ref xnRegisterToNodeDestruction(). + * + * @param pContext [in] OpenNI context. + * @param hCallback [in] The handle to the callback returned from @ref xnRegisterToNodeDestruction(). + */ +XN_C_API void XN_C_DECL xnUnregisterFromNodeDestruction + (XnContext* pContext, XnCallbackHandle hCallback); + +/// @} + +/** @} */ + +#endif // __XN_CONTEXT_H__ -- cgit v1.2.3