summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: c78f6aa)
raw | patch | inline | side by side (parent: c78f6aa)
author | Prasad Konnur <prasadkonnur@ti.com> | |
Thu, 12 Sep 2019 09:59:58 +0000 (15:29 +0530) | ||
committer | Prasad Konnur <prasadkonnur@ti.com> | |
Thu, 12 Sep 2019 10:23:47 +0000 (15:53 +0530) |
Signed-off-by: Prasad Konnur <prasadkonnur@ti.com>
diff --git a/include/fvid2_utils.h b/include/fvid2_utils.h
index 6e6c0857bf5a912dccc26ea34bda00496fddb0b5..0348f0e8586f33c8114f5432e2d1e33dde56eba1 100755 (executable)
--- a/include/fvid2_utils.h
+++ b/include/fvid2_utils.h
#define FVID2UTILS_NUM_TIMESTAMP_LOG (100U)
/**
- * struct Fvid2Utils_LinkListType
+ * \anchor Fvid2Utils_LinkListType
+ * \name Link List Type
+ * @{
+ */
+/**
* \brief Enums for the type of link list to be created.
*/
-typedef enum
-{
- FVID2UTILS_LLT_DOUBLE,
- /**< Double link list. */
- FVID2UTILS_LLT_CIRCULAR
- /**< Circular link list using double link list. */
-} Fvid2Utils_LinkListType;
+typedef uint32_t Fvid2Utils_LinkListType;
+#define FVID2UTILS_LLT_DOUBLE (0U)
+/**< Double link list. */
+#define FVID2UTILS_LLT_CIRCULAR (1U)
+/**< Circular link list using double link list. */
+/* @} */
/**
- * struct Fvid2Utils_LinkAddMode
+ * \anchor Fvid2Utils_LinkAddMode
+ * \name Link Add Mode
+ * @{
+ */
+/**
* \brief Enums for the different modes of adding a node to a link list.
*/
-typedef enum
-{
- FVID2UTILS_LAM_TOP,
- /**< Add nodes to the top of the list. */
- FVID2UTILS_LAM_BOTTOM,
- /**< Add nodes to the bottom of the list. */
- FVID2UTILS_LAM_PRIORITY
- /**< Add nodes to the list based on ascending order of priority.
- * Nodes with the same priority are always added to the bottom of the
- * existing nodes with same priority. */
-} Fvid2Utils_LinkAddMode;
-
-/**
- * struct Fvid2Utils_LinkAddMode
+typedef uint32_t Fvid2Utils_LinkAddMode;
+#define FVID2UTILS_LAM_TOP (0U)
+/**< Add nodes to the top of the list. */
+#define FVID2UTILS_LAM_BOTTOM (1U)
+/**< Add nodes to the bottom of the list. */
+#define FVID2UTILS_LAM_PRIORITY (2U)
+/**< Add nodes to the list based on ascending order of priority.
+ * Nodes with the same priority are always added to the bottom of the
+ * existing nodes with same priority. */
+/* @} */
+
+/**
+ * \anchor Fvid2Utils_NodDir
+ * \name Node Direction
+ * @{
+ */
+/**
* \brief Enums for the different modes of adding a node to a link list.
*/
-typedef enum
-{
- FVID2UTILS_NODE_DIR_HEAD,
- /**< Add nodes to the top of the list. */
- FVID2UTILS_NODE_DIR_TAIL
- /**< Add nodes to the bottom of the list. */
-} Fvid2Utils_NodDir;
+typedef uint32_t Fvid2Utils_NodDir;
+#define FVID2UTILS_NODE_DIR_HEAD (0U)
+/**< Add nodes to the top of the list. */
+#define FVID2UTILS_NODE_DIR_TAIL (1U)
+/**< Add nodes to the bottom of the list. */
+/* @} */
/* ========================================================================== */
/* Structure Declarations */
/* ========================================================================== */
/* Function Declarations */
/* ========================================================================== */
+/**
+ * Fvid2Utils_init
+ * \brief Initializes the Util objects and create pool semaphore
+ *
+ * \returns Returns 0 on success else returns error value
+ */
+int32_t Fvid2Utils_init(void);
+
+/**
+ * Fvid2Utils_deInit
+ * \brief De-Initializes the Util objects by removing pool semaphore
+ *
+ * \param arg Not used currently. Meant for future purpose
+ *
+ * \return Returns 0 on success else returns error value
+ */
+int32_t Fvid2Utils_deInit(void *arg);
/**
* Fvid2Utils_memset
uint32_t cnt;
/* NULL pointer check */
- GT_assert(traceMask, (NULL != params));
- GT_assert(traceMask, (NULL != mem));
- GT_assert(traceMask, (NULL != flag));
+ GT_assert(traceMask, (NULL_PTR != params));
+ GT_assert(traceMask, (NULL_PTR != mem));
+ GT_assert(traceMask, (NULL_PTR != flag));
/* Init pool parameters */
params->mem = mem;
void *allocMem = NULL;
/* NULL pointer check */
- GT_assert(traceMask, (NULL != params));
+ GT_assert(traceMask, (NULL_PTR != params));
/* Check if the requested size if within each fixed size element */
GT_assert(traceMask, (size <= params->elemSize));
GT_assert(traceMask, (0U != size));
uintptr_t cookie;
/* NULL pointer check */
- GT_assert(traceMask, (NULL != params));
- GT_assert(traceMask, (NULL != mem));
+ GT_assert(traceMask, (NULL_PTR != params));
+ GT_assert(traceMask, (NULL_PTR != mem));
/* Disable global interrupts */
cookie = HwiP_disable();
static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
{
/* NULL pointer check */
- GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+ GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
Fvid2Utils_memset(tsPrf, 0, sizeof (Fvid2Utils_TsPrfLog));
/* Min can't be init to 0, set a higher value so that actual min gets
static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
{
/* NULL pointer check */
- GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+ GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
tsPrf->startTime = Osal_getTimestamp64();
uint64_t endTime, diff;
/* NULL pointer check */
- GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+ GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
endTime = Osal_getTimestamp64();
diff = endTime - tsPrf->startTime;
diff --git a/include/trace.h b/include/trace.h
index 3d2da447729db9d418099d3424d3f0a68b898f69..25cc2403d1bb2e66bdb68205d9786f2c3b1fafaf 100755 (executable)
--- a/include/trace.h
+++ b/include/trace.h
*/
#define GT_DEFAULT_MASK (GT_ERR | GT_TraceState_Enable)
+/**
+ * \anchor GT_TraceState
+ * \name trace state
+ * @{
+ */
/*!
* @brief Enumerates the types of states of trace (enable/disable)
*/
-typedef enum {
- GT_TraceState_Disable = 0x00000000U,
- /*!< Disable trace */
- GT_TraceState_Enable = 0x00000001U,
- /*!< Enable trace */
- GT_TraceState_EndValue = 0x00000002U
- /*!< End delimiter indicating start of invalid
- *values for this enum */
-} GT_TraceState;
+typedef uint32_t GT_TraceState;
+#define GT_TraceState_Disable (0x00000000U)
+/*!< Disable trace */
+#define GT_TraceState_Enable (0x00000001U)
+/*!< Enable trace */
+#define GT_TraceState_EndValue (0x00000002U)
+/*!< End delimiter indicating start of invalid values for this enum */
+/* @} */
+/**
+ * \anchor GT_TraceClass
+ * \name trace class
+ * @{
+ */
/*!
* @brief Enumerates the types of trace classes
*/
-typedef enum {
- GT_ERR = 0x00010000U,
- /*!< Class 1 trace: Used for errors/warnings */
- GT_CRIT = 0x00020000U,
- /*!< Class 2 trace: Used for critical information */
- GT_INFO = 0x00030000U,
- /*!< Class 3 trace: Used for additional information */
- GT_INFO1 = 0x00040000U,
- /*!< Class 4 trace: Used for additional information (sub level 1) */
- GT_DEBUG = 0x00050000U,
- /*!< Class 5 trace: Used for block level information */
- GT_ENTER = 0x00060000U,
- /*!< Indicates a function entry class of trace */
- GT_LEAVE = 0x00070000U
- /*!< Indicates a function leave class of trace */
-} GT_TraceClass;
+typedef uint32_t GT_TraceClass;
+#define GT_ERR (0x00010000U)
+/*!< Class 1 trace: Used for errors/warnings */
+#define GT_CRIT (0x00020000U)
+/*!< Class 2 trace: Used for critical information */
+#define GT_INFO (0x00030000U)
+/*!< Class 3 trace: Used for additional information */
+#define GT_INFO1 (0x00040000U)
+/*!< Class 4 trace: Used for additional information (sub level 1) */
+#define GT_DEBUG (0x00050000U)
+/*!< Class 5 trace: Used for block level information */
+#define GT_ENTER (0x00060000U)
+/*!< Indicates a function entry class of trace */
+#define GT_LEAVE (0x00070000U)
+/*!< Indicates a function leave class of trace */
+/* @} */
/** \brief Log enable for FVID2 Utils. */
#define Fvid2Trace (GT_DEFAULT_MASK)
diff --git a/src/fvid2_drvMgr.c b/src/fvid2_drvMgr.c
index c4851d5b0c36d4883abf3620c0be8bd82a1c8aa7..2238f93cdc651148bbe1ec40156cc849e5cc596a 100755 (executable)
--- a/src/fvid2_drvMgr.c
+++ b/src/fvid2_drvMgr.c
*/
typedef struct
{
- char *versionString;
+ const char *versionString;
/**< FVID2 drivers version number as string. */
uint32_t versionNumber;
/**< FVID2 drivers version number as string. */
{
uint32_t cnt;
int32_t retVal = FVID2_SOK;
- int32_t initValue;
+ uint32_t initValue;
SemaphoreP_Params params;
Fvid2InitPrms_init(&gFdmInitPrms);
if (NULL != initPrms)
{
- Fvid2Utils_memcpy(&gFdmInitPrms, initPrms, sizeof (gFdmInitPrms));
+ Fvid2Utils_memcpy(&gFdmInitPrms, initPrms, (uint32_t)(sizeof (gFdmInitPrms)));
}
/* Init all global variables to zero */
/* Allocate lock semaphore */
SemaphoreP_Params_init(¶ms);
params.mode = SemaphoreP_Mode_BINARY;
- initValue = 1;
+ initValue = 1U;
gFdmObj.lockSem = SemaphoreP_create(initValue, ¶ms);
if (NULL == gFdmObj.lockSem)
{
}
SemaphoreP_Params_init(¶ms);
params.mode = SemaphoreP_Mode_BINARY;
- initValue = 1;
+ initValue = 1U;
gFdmObj.printSem = SemaphoreP_create(initValue, ¶ms);
if (NULL == gFdmObj.printSem)
{
/* Free-up memory if error occurs */
if (FVID2_SOK != retVal)
{
- Fvid2_deInit(NULL);
+ (void) Fvid2_deInit(NULL);
}
return (retVal);
/* Delete the lock semaphore */
if (NULL != gFdmObj.lockSem)
{
- SemaphoreP_delete(gFdmObj.lockSem);
+ (void) SemaphoreP_delete(gFdmObj.lockSem);
gFdmObj.lockSem = NULL;
}
if (NULL != gFdmObj.printSem)
{
- SemaphoreP_delete(gFdmObj.printSem);
+ (void) SemaphoreP_delete(gFdmObj.printSem);
gFdmObj.printSem = NULL;
}
uint32_t cnt;
/* Check for NULL pointers */
- OSAL_Assert(NULL == drvOps);
+ OSAL_Assert(NULL_PTR == drvOps);
- SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+ (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
/* Check whether the driver is already registered */
for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
if (TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed)
{
/* Check for NULL pointers */
- OSAL_Assert(NULL == gFdmObj.fdmDriverObjects[cnt].drvOps);
+ OSAL_Assert(NULL_PTR == gFdmObj.fdmDriverObjects[cnt].drvOps);
if (drvOps->drvId == gFdmObj.fdmDriverObjects[cnt].drvOps->drvId)
{
}
}
- SemaphoreP_post(gFdmObj.lockSem);
+ (void) SemaphoreP_post(gFdmObj.lockSem);
return (retVal);
}
int32_t retVal = FVID2_EFAIL;
/* Check for NULL pointers */
- OSAL_Assert(NULL == drvOps);
+ OSAL_Assert(NULL_PTR == drvOps);
- SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+ (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
/* Free the driver object */
retVal = fdmFreeDriverObject(drvOps);
- SemaphoreP_post(gFdmObj.lockSem);
+ (void) SemaphoreP_post(gFdmObj.lockSem);
return (retVal);
}
Fdm_Channel *channel = NULL;
Fvid2_DrvCbParams fdmCbParams, *tempCbParams;
- SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+ (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
/* Get the matching driver object */
for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
if (TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed)
{
/* Check for NULL pointers */
- OSAL_Assert(NULL == gFdmObj.fdmDriverObjects[cnt].drvOps);
+ OSAL_Assert(NULL_PTR == gFdmObj.fdmDriverObjects[cnt].drvOps);
if (drvId == gFdmObj.fdmDriverObjects[cnt].drvOps->drvId)
{
GT_0trace(Fvid2Trace, GT_ERR, "Driver create failed!!\r\n");
/* Free the allocated channel object */
- fdmFreeChannelObject(channel);
+ (void) fdmFreeChannelObject(channel);
channel = NULL;
}
}
GT_0trace(Fvid2Trace, GT_ERR, "EALLOC: Invalid driver ID!!\r\n");
}
- SemaphoreP_post(gFdmObj.lockSem);
+ (void) SemaphoreP_post(gFdmObj.lockSem);
return (channel);
}
int32_t retVal = FVID2_SOK;
Fdm_Channel *channel;
- SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+ (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
if (NULL != handle)
{
channel = (Fdm_Channel *) handle;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel->drv);
- OSAL_Assert(NULL == channel->drv->drvOps);
+ OSAL_Assert(NULL_PTR == channel->drv);
+ OSAL_Assert(NULL_PTR == channel->drv->drvOps);
if (NULL != channel->drv->drvOps->deleteFxn)
{
channel->cbParams.errCbFxn = NULL;
channel->cbParams.errList = NULL;
channel->cbParams.appData = NULL;
- fdmFreeChannelObject(channel);
+ (void) fdmFreeChannelObject(channel);
}
else
{
retVal = FVID2_EBADARGS;
}
- SemaphoreP_post(gFdmObj.lockSem);
+ (void) SemaphoreP_post(gFdmObj.lockSem);
return (retVal);
}
channel = (Fdm_Channel *) handle;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel->drv);
- OSAL_Assert(NULL == channel->drv->drvOps);
+ OSAL_Assert(NULL_PTR == channel->drv);
+ OSAL_Assert(NULL_PTR == channel->drv->drvOps);
if (NULL != channel->drv->drvOps->controlFxn)
{
channel = (Fdm_Channel *) handle;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel->drv);
- OSAL_Assert(NULL == channel->drv->drvOps);
+ OSAL_Assert(NULL_PTR == channel->drv);
+ OSAL_Assert(NULL_PTR == channel->drv->drvOps);
if (NULL != channel->drv->drvOps->queueFxn)
{
channel = (Fdm_Channel *) handle;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel->drv);
- OSAL_Assert(NULL == channel->drv->drvOps);
+ OSAL_Assert(NULL_PTR == channel->drv);
+ OSAL_Assert(NULL_PTR == channel->drv->drvOps);
if (NULL != channel->drv->drvOps->dequeueFxn)
{
channel = (Fdm_Channel *) handle;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel->drv);
- OSAL_Assert(NULL == channel->drv->drvOps);
+ OSAL_Assert(NULL_PTR == channel->drv);
+ OSAL_Assert(NULL_PTR == channel->drv->drvOps);
if (NULL != channel->drv->drvOps->processRequestFxn)
{
channel = (Fdm_Channel *) handle;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel->drv);
- OSAL_Assert(NULL == channel->drv->drvOps);
+ OSAL_Assert(NULL_PTR == channel->drv);
+ OSAL_Assert(NULL_PTR == channel->drv->drvOps);
if (NULL != channel->drv->drvOps->getProcessedRequestFxn)
{
uint32_t frmCnt;
/* Check for NULL pointers */
- OSAL_Assert(NULL == dest);
- OSAL_Assert(NULL == src);
+ OSAL_Assert(NULL_PTR == dest);
+ OSAL_Assert(NULL_PTR == src);
OSAL_Assert(src->numFrames >= FVID2_MAX_FRAME_PTR);
dest->numFrames = src->numFrames;
@@ -1285,8 +1285,8 @@ void Fvid2_duplicateFrameList(Fvid2_FrameList *dest, const Fvid2_FrameList *src)
uint32_t frmCnt;
/* Check for NULL pointers */
- OSAL_Assert(NULL == dest);
- OSAL_Assert(NULL == src);
+ OSAL_Assert(NULL_PTR == dest);
+ OSAL_Assert(NULL_PTR == src);
OSAL_Assert(src->numFrames >= FVID2_MAX_FRAME_PTR);
dest->numFrames = src->numFrames;
Fdm_Channel *channel;
/* Check for NULL pointers */
- OSAL_Assert(NULL == fdmData);
+ OSAL_Assert(NULL_PTR == fdmData);
channel = (Fdm_Channel *) fdmData;
- OSAL_Assert(NULL == channel->cbParams.cbFxn);
+ OSAL_Assert(NULL_PTR == channel->cbParams.cbFxn);
retVal = channel->cbParams.cbFxn(channel, channel->cbParams.appData);
return (retVal);
Fdm_Channel *channel;
/* Check for NULL pointers */
- OSAL_Assert(NULL == fdmData);
+ OSAL_Assert(NULL_PTR == fdmData);
channel = (Fdm_Channel *) fdmData;
- OSAL_Assert(NULL == channel->cbParams.errCbFxn);
+ OSAL_Assert(NULL_PTR == channel->cbParams.errCbFxn);
retVal =
channel->cbParams.errCbFxn(channel, channel->cbParams.appData, errList);
int32_t retVal = FVID2_EFAIL;
/* Check for NULL pointers */
- OSAL_Assert(NULL == drvOps);
+ OSAL_Assert(NULL_PTR == drvOps);
/* Free the driver object */
for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
int32_t retVal = FVID2_EALLOC;
/* Check for NULL pointers */
- OSAL_Assert(NULL == channel);
+ OSAL_Assert(NULL_PTR == channel);
/* Free the channel object */
if (TRUE == channel->isUsed)
va_list vaArgPtr;
char *buf = NULL;
- SemaphoreP_pend(gFdmObj.printSem, SemaphoreP_WAIT_FOREVER);
+ (void) SemaphoreP_pend(gFdmObj.printSem, SemaphoreP_WAIT_FOREVER);
buf = &gRemoteDebug_serverObj.printBuf[0];
- va_start(vaArgPtr, format);
- vsnprintf(buf, REMOTE_DEBUG_SERVER_PRINT_BUF_LEN,
+ (void) va_start(vaArgPtr, format);
+ (void) vsnprintf(buf, REMOTE_DEBUG_SERVER_PRINT_BUF_LEN,
(const char *) format, vaArgPtr);
va_end(vaArgPtr);
gFdmInitPrms.printFxn(buf);
}
- SemaphoreP_post(gFdmObj.printSem);
+ (void) SemaphoreP_post(gFdmObj.printSem);
#endif
return;
}
diff --git a/src/fvid2_graph.c b/src/fvid2_graph.c
index c5bb1b560370fc42755ca9ab04ed6920faed8ec3..9756435269fea28326819a819f68c84026e39b8b 100755 (executable)
--- a/src/fvid2_graph.c
+++ b/src/fvid2_graph.c
const Fvid2_GraphEdgeList *inEdgeList,
Fvid2_GraphInfo *graphHandle)
{
- GT_assert(Fvid2Trace, (graphHandle != NULL));
- GT_assert(Fvid2Trace, (graphHandle->nodeList != NULL));
- GT_assert(Fvid2Trace, (graphHandle->edgeList != NULL));
+ GT_assert(Fvid2Trace, (graphHandle != NULL_PTR));
+ GT_assert(Fvid2Trace, (graphHandle->nodeList != NULL_PTR));
+ GT_assert(Fvid2Trace, (graphHandle->edgeList != NULL_PTR));
- GT_assert(Fvid2Trace, (inNodeList != NULL));
- GT_assert(Fvid2Trace, (inEdgeList != NULL));
+ GT_assert(Fvid2Trace, (inNodeList != NULL_PTR));
+ GT_assert(Fvid2Trace, (inEdgeList != NULL_PTR));
graphHandle->nodeList->numNodes = inNodeList->numNodes;
graphHandle->edgeList->numEdges = inEdgeList->numEdges;
graphHandle->nodeList->list = inNodeList->list;
graphHandle->edgeList->list = inEdgeList->list;
- Fvid2_graphConnect(inNodeList, inEdgeList);
+ (void) Fvid2_graphConnect(inNodeList, inEdgeList);
return graphHandle;
}
{
Fvid2_GraphNodeInfo *startNode = Fvid2_graphGetNodeInfo(
nodeList, inputEdgeList[i].startNode);
- GT_assert(Fvid2Trace, (startNode != NULL));
+ GT_assert(Fvid2Trace, (startNode != NULL_PTR));
Fvid2_GraphNodeInfo *endNode = Fvid2_graphGetNodeInfo(
nodeList, inputEdgeList[i].endNode);
- GT_assert(Fvid2Trace, (endNode != NULL));
+ GT_assert(Fvid2Trace, (endNode != NULL_PTR));
if ((startNode->nodeId == FVID2_GRAPH_INVALID_NODE_ID) &&
(endNode->nodeId == FVID2_GRAPH_INVALID_NODE_ID))
{
GT_assert(Fvid2Trace, (pathNodeCount < maxOutNodeCnt));
outNodeList->numNodes = pathNodeCount;
- GT_assert(Fvid2Trace, (outNodeList->list != NULL));
+ GT_assert(Fvid2Trace, (outNodeList->list != NULL_PTR));
GT_assert(Fvid2Trace, (pathEdgeCount < maxOutEdgeCnt));
outEdgeList->numEdges = pathEdgeCount;
- GT_assert(Fvid2Trace, (outEdgeList->list != NULL));
+ GT_assert(Fvid2Trace, (outEdgeList->list != NULL_PTR));
for (i = 0U; i < pathEdgeCount; i++)
{
diff --git a/src/fvid2_utils.c b/src/fvid2_utils.c
index dca5d91f5aca32ebc8b36478266fe109e3047e2c..a5f47e1d3544f96d87ad8fce372d28ec50484e22 100644 (file)
--- a/src/fvid2_utils.c
+++ b/src/fvid2_utils.c
void Fvid2Utils_memset(void *mem, uint8_t ch, uint32_t byteCount)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != mem));
+ GT_assert(Fvid2Trace, (NULL_PTR != mem));
- memset(mem, (int32_t) ch, byteCount);
+ (void) memset(mem, (int32_t) ch, byteCount);
}
/**
uint32_t *memPtr = NULL;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != mem));
+ GT_assert(Fvid2Trace, (NULL_PTR != mem));
memPtr = (uint32_t *) mem;
for (count = 0; count < wordCount; count++)
void Fvid2Utils_memcpy(void *dest, const void *src, uint32_t byteCount)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != dest));
- GT_assert(Fvid2Trace, (NULL != src));
+ GT_assert(Fvid2Trace, (NULL_PTR != dest));
+ GT_assert(Fvid2Trace, (NULL_PTR != src));
- memcpy(dest, src, byteCount);
+ (void) memcpy(dest, src, byteCount);
}
/**
uint32_t byteCount)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != mem1));
- GT_assert(Fvid2Trace, (NULL != mem2));
+ GT_assert(Fvid2Trace, (NULL_PTR != mem1));
+ GT_assert(Fvid2Trace, (NULL_PTR != mem2));
return memcmp(mem1, mem2, byteCount);
}
}
else
{
- GT_assert(Fvid2Trace, (NULL != llobj));
+ GT_assert(Fvid2Trace, (NULL_PTR != llobj));
/* Initialize the variables */
llobj->listType = listType;
llobj->addMode = addMode;
void Fvid2Utils_destructLinkList(Fvid2UtilsLinkListObj *llobj)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != llobj));
- GT_assert(Fvid2Trace, (NULL == llobj->headNode));
- GT_assert(Fvid2Trace, (NULL == llobj->tailNode));
+ GT_assert(Fvid2Trace, (NULL_PTR != llobj));
+ GT_assert(Fvid2Trace, (NULL_PTR == llobj->headNode));
+ GT_assert(Fvid2Trace, (NULL_PTR == llobj->tailNode));
/* Free link list object */
Fvid2Utils_memset(llobj, 0, sizeof (Fvid2UtilsLinkListObj));
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
llobj->headNode = NULL;
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
llobj = (Fvid2UtilsLinkListObj *) handle;
}
else if (FVID2UTILS_LLT_DOUBLE == llobj->listType)
{
- dutilsLinkDoublePri(llobj, node, node->data, priority, (uint32_t) FALSE);
+ (void) dutilsLinkDoublePri(llobj, node, node->data, priority, (uint32_t) FALSE);
}
else
{
int32_t rtnValue = FVID2_SOK;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
llobj = (Fvid2UtilsLinkListObj *) handle;
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
llobj = (Fvid2UtilsLinkListObj *) handle;
if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
@@ -462,11 +462,11 @@ void Fvid2Utils_unLinkNode(Fvid2Utils_Handle handle, const Fvid2Utils_Node *node
Fvid2Utils_NodDir dir = FVID2UTILS_NODE_DIR_HEAD;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
llobj = (Fvid2UtilsLinkListObj *) handle;
- dutilsUnLinkDouble(llobj, dir, node);
+ (void) dutilsUnLinkDouble(llobj, dir, node);
return;
}
@@ -488,11 +488,11 @@ void Fvid2Utils_linkNodeToTail(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != node));
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
- dutilsLinkDouble(llobj, node, node->data, dir);
+ (void) dutilsLinkDouble(llobj, node, node->data, dir);
return;
}
@@ -514,11 +514,11 @@ void Fvid2Utils_linkNodeToHead(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != node));
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
- dutilsLinkDouble(llobj, node, node->data, dir);
+ (void) dutilsLinkDouble(llobj, node, node->data, dir);
return;
}
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
return (dutilsUnLinkDouble(llobj, dir, NULL));
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
return (dutilsUnLinkDouble(llobj, dir, NULL));
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
return (llobj->tailNode);
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
if (NULL == llobj->headNode)
uint32_t numNodes = 0U;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
numNodes++;
node = node->next;
/* Not supposed to have NULL in circular list */
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
/* Check if we have come to the end of the list */
if (node == llobj->headNode)
Fvid2Utils_NodDir dir = FVID2UTILS_NODE_DIR_TAIL;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
- dutilsLinkDouble(llobj, qElem, data, dir);
+ (void) dutilsLinkDouble(llobj, qElem, data, dir);
return;
}
Fvid2Utils_NodDir dir = FVID2UTILS_NODE_DIR_HEAD;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
node = dutilsUnLinkDouble(llobj, dir, NULL);
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
if (llobj->headNode != NULL)
Fvid2UtilsLinkListObj *llobj;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
if (llobj->tailNode != NULL)
Fvid2Utils_NodDir dir = FVID2UTILS_NODE_DIR_HEAD;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
llobj = (Fvid2UtilsLinkListObj *) handle;
- dutilsLinkDouble(llobj, qElem, data, dir);
+ (void) dutilsLinkDouble(llobj, qElem, data, dir);
return;
}
Fvid2Utils_Node *curNode;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
node->data = data;
node->priority = priority;
/* Move to next node */
curNode = curNode->next;
/* Not supposed to have NULL in circular list */
- GT_assert(Fvid2Trace, (NULL != curNode));
+ GT_assert(Fvid2Trace, (NULL_PTR != curNode));
} while (curNode != headNode);
/* Check if we have come to the end of the list */
node->prev = curNode->prev;
/* Not supposed to have NULL in circular list */
- GT_assert(Fvid2Trace, (NULL != curNode->prev));
- GT_assert(Fvid2Trace, (NULL != curNode->prev->next));
+ GT_assert(Fvid2Trace, (NULL_PTR != curNode->prev));
+ GT_assert(Fvid2Trace, (NULL_PTR != curNode->prev->next));
curNode->prev->next = node;
curNode->prev = node;
}
Fvid2Utils_Node *curNode, *prevNode = NULL;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
node->data = data;
node->priority = priority;
Fvid2Utils_Node *node)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != headNode));
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != headNode));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
/* Not supposed to have NULL in circular list */
- GT_assert(Fvid2Trace, (NULL != node->next));
- GT_assert(Fvid2Trace, (NULL != node->prev));
+ GT_assert(Fvid2Trace, (NULL_PTR != node->next));
+ GT_assert(Fvid2Trace, (NULL_PTR != node->prev));
/* Link the node's previous node to node's next node */
node->prev->next = node->next;
Fvid2Utils_Node *node)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != llobj));
- GT_assert(Fvid2Trace, (NULL != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != llobj));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
if (NULL == node->prev)
{
uint32_t nodeCnt;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != llobj));
+ GT_assert(Fvid2Trace, (NULL_PTR != llobj));
if (NULL == nodeToBeRem)
{
uint32_t Fvid2Utils_getNodeCnt(Fvid2Utils_Handle handle)
{
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != handle));
+ GT_assert(Fvid2Trace, (NULL_PTR != handle));
return (((Fvid2UtilsLinkListObj *) handle)->numElements);
}
Fvid2Utils_Node *headNode, *tailNode = NULL;
/* NULL pointer check */
- GT_assert(Fvid2Trace, (NULL != node));
- GT_assert(Fvid2Trace, (NULL != llobj));
+ GT_assert(Fvid2Trace, (NULL_PTR != node));
+ GT_assert(Fvid2Trace, (NULL_PTR != llobj));
node->data = data;
/* check for the first element in the list */