/*
* ======== Algorithm_activate ========
*/
Void Algorithm_activate(Algorithm_Handle alg)
{
Algorithm_Obj *pObject = (Algorithm_Obj *)alg;
Log_print1(Diags_ENTRY, "[+E] Algorithm_activate> Enter(alg=0x%x)",
(IArg)alg);
DSKT2_activateAlg(pObject->groupId, pObject->alg);
if (pObject->iresFxns) {
RMAN_activateAllResources(pObject->alg, pObject->iresFxns,
pObject->groupId);
}
Log_print0(Diags_EXIT, "[+X] Algorithm_activate> Exit");
}
/*
* ======== rmanTask ========
*/
Void rmanTask(UArg arg0, UArg arg1)
{
Int taskId = (Int)arg0;
Int index = (Int)arg1; /* index into attrsTable */
IALG_Fxns * algFxns = (IALG_Fxns *)&DUMALG_TI_IDUMALG;
IRES_Fxns * resFxns = &DUMALG_TI_IRES;
IDUMALG_Handle dumHandle = NULL;
IDUMALG_Params params;
Int scratchId = attrsTable[index].scratchId;
Int yieldFlag = attrsTable[index].yieldFlag;
Int priority = attrsTable[index].priority;
Arg resourceId = (Arg)(&(attrsTable[index].id));
Int i;
IRES_Status status;
Log_print0(Diags_ENTRY, "[+E] rmanTask> Enter ");
params.size = sizeof(IDUMALG_Params);
Log_print4(Diags_USER4, "[+4] rmanTask> "
"Task #%d: ScratchId %d, Priority %d Yield %d",
(IArg)taskId, (IArg)scratchId, (IArg)priority, (IArg)yieldFlag);
params.yieldFlag = yieldFlag;
params.taskId = taskId;
for (i = 0; i < NUM_RESOURCES; i++) {
params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i);
Log_print1(Diags_USER4, "[+4] rmanTask> "
"Requesting resource %d (2 => ANY)",
(IArg)((Int)params.hdvicp[i]));
}
/*
* Create an instance of the algorithm using "algFxns"
*/
SemThread_pend(mutex, SemThread_FOREVER, NULL);
dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms);
if (dumHandle == NULL) {
Log_print0(Diags_USER7, "[+7] rmanTask> Alg creation failed");
System_abort("DSKT2_createAlg() failed, aborting...\n");
}
SemThread_post(mutex, NULL);
/* Assign resources to the algorithm */
status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] rmanTask> Assign resource failed [%d]",
(IArg)status);
System_abort("RMAN_assignResources() failed, aborting...\n");
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Use IALG interfaces to do something */
dumHandle->fxns->useHDVICP(dumHandle, taskId);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId);
if (status != IRES_OK) {
Log_print1(Diags_USER7, "[+7] rmanTask> Free resource failed [%d]",
(IArg)status);
System_abort("RMAN_freeResources() failed, aborting...\n");
}
/*
* Free instance of the algorithm created
*/
SemThread_pend(mutex, SemThread_FOREVER, NULL);
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
SemThread_post(mutex, NULL);
SemThread_post(done, NULL);
Log_print0(Diags_EXIT, "[+X] rmanTask> Exit ");
}
Int rmanTask(Arg scratchId, Arg resourceId, Arg priority, Arg taskId,
Arg yieldFlag)
{
Int i;
IALG_Fxns * algFxns = &DUMALG_TI_IALG;
IRES_Fxns * resFxns = &DUMALG_TI_IRES;
IDUMALG_Handle dumHandle = NULL;
IDUMALG_Params params;
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Enter \n");
params.size = sizeof(IDUMALG_Params);
GT_4trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> "
"Task #%d: ScratchId %d, Priority %d Yield %d\n",taskId, scratchId,
priority, yieldFlag);
params.yieldFlag = yieldFlag;
params.taskId = taskId;
for (i = 0; i < NUM_RESOURCES; i++) {
params.hdvicp[i] = *((IRES_HDVICP_RequestType *)resourceId + i);
GT_1trace(ti_sdo_fc_rman_examples_hdvicp, GT_4CLASS, "_rmanTask> "
"Requesting resource %d (2 => ANY)\n",(Int)params.hdvicp[i]);
}
/*
* Create an instance of the algorithm using "algFxns"
*/
SEM_pend(mutex, SYS_FOREVER);
dumHandle = (IDUMALG_Handle)DSKT2_createAlg((Int)scratchId,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)¶ms);
if (dumHandle == NULL) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Alg creation failed\n");
return -1;
}
SEM_post(mutex);
/* Assign resources to the algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle,
resFxns, scratchId)) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Assign resource failed\n");
return -1;
}
/*
* Activate the Algorithm
*/
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/*
* Use IALG interfaces to do something
*/
dumHandle->fxns->useHDVICP(dumHandle, taskId);
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/*
* Deactivate algorithm
*/
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle),
resFxns, scratchId)) {
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_7CLASS, "_rmanTask> "
"Free resource failed\n");
return -1;
}
/*
* Free instance of the algorithm created
*/
SEM_pend(mutex, SYS_FOREVER);
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
SEM_post(mutex);
SEM_post(done);
GT_0trace(ti_sdo_fc_rman_examples_hdvicp, GT_ENTER, "_rmanTask> Exit \n");
return 0;
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(Int argc, Char * argv[])
{
IRES_Status status;
Int size = 0;
Int scratchId = 2;
IALG_Fxns * algFxns = (IALG_Fxns *)&TEMPLATE_TI_CODECIRES;
IRES_Fxns * resFxns = &TEMPLATE_TI_IRES;
IALG_Handle dumHandle = NULL;
ITEMPLATE_Status algStatus;
/*
* Create an instance of the algorithm using "algFxns"
*/
dumHandle = DSKT2_createAlg(scratchId, (IALG_Fxns *)algFxns, NULL,
(IALG_Params *)NULL);
if (dumHandle == NULL) {
printf("Alg creation failed \n");
return -1;
}
/*
* Supply initialization information for the RESMAN while registering
*/
size = sizeof(IRESMAN_Params);
configParams.allocFxn = RMAN_PARAMS.allocFxn;
configParams.freeFxn = RMAN_PARAMS.freeFxn;
configParams.size = size;
/*
* Register the NULL protocol/resource manager with the generic resource
* manager
*/
status = RMAN_register(&IRESMAN_NULLRES, (IRESMAN_Params *)&configParams);
if (IRES_EEXISTS == status) {
printf("Protocol Already Registered\n");
}
/* Create an instance of an algorithm that implements IALG and IRES_Fxns */
if (IRES_OK != RMAN_assignResources((IALG_Handle)dumHandle,
resFxns,scratchId)) {
printf("Assign Resource Failed \n");
return (-1);
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, -1);
/* Use IALG interfaces to do something */
((ITEMPLATE_Handle)dumHandle)->fxns->process((ITEMPLATE_Handle)dumHandle,
(ITEMPLATE_InArgs *)NULL, (ITEMPLATE_OutArgs *)NULL);
((ITEMPLATE_Handle)dumHandle)->fxns->control((ITEMPLATE_Handle)dumHandle,
(ITEMPLATE_Cmd )0, (ITEMPLATE_DynamicParams *)NULL, &algStatus);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, -1);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
if (IRES_OK != RMAN_freeResources((IALG_Handle)(dumHandle),
resFxns, -1)) {
printf("Free Resource Failed\n");
return (-1);
}
/* Free instance of the algorithm created */
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
/* Unregister the protocol */
if (IRES_OK != RMAN_unregister(&IRESMAN_NULLRES)) {
printf("Unregister Protocol Failed\n");
return (-1);
}
RMAN_exit();
return (0);
}
Int32 AlgLink_ScdalgProcess(AlgLink_ScdObj *pScdAlgLinkObj, UInt32 chId, AlgLink_ScdResult * scdResultBuff)
{
SCD_Status chanStatus;
SCD_Result scdResult;
UInt32 chanID;
SCD_chPrm chanParam;
AlgLink_ScdchPrm * chPrm;
UInt32 blkIdx;
/* Activate the Algorithm */
DSKT2_activateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
chanID = pScdAlgLinkObj->chParams[chId].chId;
chPrm = &(pScdAlgLinkObj->chParams[chId]);
chanParam.chId = chPrm->chId;
chanParam.mode = (SCD_Mode)chPrm->mode;
chanParam.width = chPrm->width;
chanParam.height = chPrm->height;
chanParam.stride = chPrm->stride;
chanParam.curFrame = chPrm->curFrame;
chanParam.frmSensitivity = (SCD_Sensitivity)chPrm->frmSensitivity;
chanParam.frmIgnoreLightsON = chPrm->frmIgnoreLightsON;
chanParam.frmIgnoreLightsOFF = chPrm->frmIgnoreLightsOFF;
chanParam.frmEdgeThreshold = chPrm->frmEdgeThreshold;
if(chPrm->chBlkConfigUpdate == TRUE)
{
chanParam.blkConfig = (SCD_blkChngConfig *) chPrm->blkConfig;
}
else
{
chanParam.blkConfig = NULL;
}
chanStatus = SCD_TI_setPrms(pScdAlgLinkObj->algHndl, &chanParam, chanID);
if(chanStatus != SCD_NO_ERROR)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : ERROR: Alg Set Params (chanID = %d) - 0x%08X !!!\n",
Utils_getCurTimeInMsec(), chanID, chanStatus);
#endif
/* Deactivate algorithm */
DSKT2_deactivateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
return FVID2_EFAIL;
}
scdResult.frmResult = SCD_DETECTOR_NO_CHANGE;
scdResult.blkResult = (SCD_blkChngMeta *)(scdResultBuff->blkResult);
chanStatus = SCD_TI_process(pScdAlgLinkObj->algHndl, chanID, &scdResult);
/* Deactivate algorithm */
DSKT2_deactivateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
if(chanStatus != SCD_NO_ERROR)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : ERROR: Alg Process (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
return FVID2_EFAIL;
}
scdResultBuff->frmResult = (AlgLink_ScdOutput) scdResult.frmResult;
scdResultBuff->chId = chanID;
// if(pScdAlgLinkObj->createArgs.chDefaultParams[chId].mode & SCD_DETECTMODE_MONITOR_BLOCKS)
if(pScdAlgLinkObj->chParams[chId].mode & SCD_DETECTMODE_MONITOR_BLOCKS)
{
UInt32 numBlkChg;
UInt32 monitoredBlk;
UInt32 numHorzBlks, numVertBlks, numBlksInFrame, blkHeight;
AlgLink_ScdResult *pChResult = scdResultBuff;
pChResult->frmResult = ALG_LINK_SCD_DETECTOR_CHANGE;
pChResult->chId = chanID;
monitoredBlk = 0;
numBlkChg = 0;
numHorzBlks = ((pScdAlgLinkObj->chParams[chId].width + 0x1F ) & (~0x1F)) / 32; /* Rounding to make divisible by 32 */
if((pScdAlgLinkObj->chParams[chId].height%ALG_LINK_SCD_BLK_HEIGHT_MIN) == 0)/* For Block height is divisible by 10 */
blkHeight = ALG_LINK_SCD_BLK_HEIGHT_MIN;
else /* For Block height is divisible by 12 */
blkHeight = ALG_LINK_SCD_BLK_HEIGHT;
numVertBlks = pScdAlgLinkObj->chParams[chId].height / blkHeight;
numBlksInFrame = numHorzBlks * numVertBlks;
for(blkIdx = 0; blkIdx < numBlksInFrame; blkIdx++)
{
if(pScdAlgLinkObj->chParams[chId].blkConfig[blkIdx].monitored == 1)
{
monitoredBlk++;
if(scdResultBuff->blkResult[blkIdx].numPixelsChanged > MOTION_DETECTION_SENSITIVITY(ALG_LINK_SCD_BLK_WIDTH, blkHeight))
numBlkChg++;
}
}
if((monitoredBlk > 0) && (numBlkChg > (NUM_BLOCK_MOTION_DETECTION_THRESOLD(monitoredBlk))))
{
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_printf(" %d: SCD : Motion Detected (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_MOTION_DETECT, pChResult, sizeof(AlgLink_ScdResult), FALSE);
}
}
if(scdResult.frmResult == SCD_DETECTOR_CHANGE)
{
AlgLink_ScdChStatus *pChStatus = &pScdAlgLinkObj->scdChStat[chanID];
pChStatus->size = sizeof(AlgLink_ScdChStatus);
pChStatus->frmResult = (UInt32) ALG_LINK_SCD_DETECTOR_CHANGE;
pChStatus->chId = chanID;
#if 0
/* Will be used post GA */
AlgLink_ScdprocessSCDmetadata(scdResultBuff,
&(pScdAlgLinkObj->chParams[chId]),
pChStatus);
#endif
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_printf(" %d: SCD : Tamper Detected (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_TAMPER_DETECT, pChStatus, sizeof(AlgLink_ScdChStatus), FALSE);
}
return FVID2_SOK;
}
/*
* ======== smain ========
*/
Int smain(Int argc, Char * argv[])
{
ISHMALG_Handle alg;
ISHMALG_Fxns fxns = SHMALG_TI_ISHMALG;
ISHMALG_Params params = ISHMALG_PARAMS;
IRES_Fxns iresFxns = SHMALG_TI_IRES;
IRES_Status status;
Int scratchId;
Bool passed = FALSE;
Bool retVal = TRUE;
Int fillVal = 1;
if (argc > 1) {
fillVal = atoi(argv[1]);
}
params.fillVal = fillVal;
System_printf("shmbuf_test2> Started. buffer fill value: %d\n", fillVal);
/* Initialize and register resource manager */
System_printf("Calling RMAN_init()...\n");
status = RMAN_init();
if (status != IRES_OK) {
/* Test failed */
System_printf("RMAN_init() failed: %s [%d]\n", getError(status),
status);
goto done;
}
SHMBUF_PARAMS.bufsize = SHMBUFSIZE;
SHMBUF_PARAMS.isScratch = TRUE; /* Make the buffer sharable */
System_printf("Calling RMAN_register()...\n");
status = RMAN_register(&SHMBUF_MGRFXNS, (IRESMAN_Params *)&SHMBUF_PARAMS);
if (status != IRES_OK) {
/* Test failed */
System_printf("RMAN_register() failed %s [%d]\n", getError(status),
status);
goto done;
}
scratchId = 1;
System_printf("Calling DSKT2_createAlg()...\n");
alg = (ISHMALG_Handle)DSKT2_createAlg(scratchId, (IALG_Fxns *)&fxns,
NULL, (IALG_Params *)¶ms);
if (alg == NULL) {
System_printf("DSKT2_createAlg() failed\n");
goto done;
}
/* Assign resources to the algorithm */
System_printf("Calling RMAN_assignResources()...\n");
status = RMAN_assignResources((IALG_Handle)alg, &iresFxns, scratchId);
if (status != IRES_OK) {
System_printf("RMAN_assignResources() failed %s [%d]\n",
getError(status), status);
goto done;
}
System_printf("Calling DSKT2_activateAlg()...\n");
DSKT2_activateAlg(scratchId, (IALG_Handle)alg);
/* Activate All Resources */
System_printf("Calling RMAN_activateAllResources()...\n");
status = RMAN_activateAllResources((IALG_Handle)alg, &iresFxns, scratchId);
if (status != IRES_OK) {
System_printf("RMAN_activateAllResourceRMAN_unregister(&SHMBUF_MGRFXNS);s() failed %s [%d]\n",
getError(status), status);
goto done;
}
/* Use the buffer */
alg->fxns->useBufs(alg);
/* Hold onto the resource for awhile */
System_printf("Sleeping...\n");
sleep(10);
/* Check contents of the buffer */
if (!(retVal = alg->fxns->checkBufs(alg))) {
System_printf("Buffer overwritten by another alg.\n");
}
/* Deactivate All Resources */
System_printf("Calling RMAN_deactivateAllResources()...\n");
status = RMAN_deactivateAllResources((IALG_Handle)alg, &iresFxns,
scratchId);
if (status != IRES_OK) {
System_printf("RMAN_deactivateAllResources() failed %s [%d]\n",
getError(status), status);
goto done;
}
/* Deactivate algorithm */
System_printf("Calling DSKT2_deactivateAlg()...\n");
DSKT2_deactivateAlg(scratchId, (IALG_Handle)alg);
/* Free resources assigned to this algorihtm */
System_printf("Calling RMAN_freeResources()...\n");
status = RMAN_freeResources((IALG_Handle)(alg), &iresFxns, scratchId);
if (status != IRES_OK) {
System_printf("RMAN_freeResources() failed %s [%d]\n",
getError(status), status);
goto done;
}
/* Free instance of the algorithm created */
System_printf("Calling DSKT2_freeAlg()...\n");
DSKT2_freeAlg(scratchId, (IALG_Handle)alg);
System_printf("Calling RMAN_unregister()...\n");
status = RMAN_unregister(&SHMBUF_MGRFXNS);
if (status != IRES_OK) {
System_printf("RMAN_unregister() failed %s [%d]\n", getError(status),
status);
goto done;
}
System_printf("Calling RMAN_exit()...\n");
status = RMAN_exit();
if (status != IRES_OK) {
System_printf("RMAN_exit() failed %s [%d]\n", getError(status),
status);
goto done;
}
else {
if (retVal) {
passed = TRUE;
}
}
done:
RMAN_exit();
if (passed) {
System_printf("TEST PASSED\n");
}
else {
System_printf("TEST FAILED\n");
}
return (0);
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(Int argc, Char * argv[])
{
Int scratchId1 = 0;
Int scratchId2 = 0;
IALG_Status algStatus;
IALG_Fxns * algFxns = &DUMRES_TI_IALG;
IRES_Fxns * resFxns = &DUMRES_TI_IRES;
DUMRES_TI_Handle algHandle1 = NULL;
DUMRES_TI_Handle algHandle2 = NULL;
EDMA3_RM_Handle rmHandle = NULL;
EDMA3_RM_ResDesc resObj;
MEM_Stat stat;
Bool retVal;
Int i = 0;
/*
* Create 2 instances of the algorithm using "algFxns"
*/
algHandle1 = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId1,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)NULL);
if (algHandle1 == NULL) {
printf("Alg creation failed for algHandle1\n");
return -1;
}
algHandle2 = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId2,
(IALG_Fxns *)algFxns, NULL,(IALG_Params *)NULL);
if (algHandle2 == NULL) {
printf("Alg creation failed for algHandle2\n");
return -1;
}
/* Assign resources to the algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)algHandle1,
resFxns, scratchId1)) {
GT_0trace(ti_sdo_fc_rman_examples_scratchEdma3_GTMask, GT_7CLASS,
"Assign Resource Failed \n");
goto AppEnd1;
}
/*
* Activate the Algorithm
*/
DSKT2_activateAlg(scratchId1, (IALG_Handle)algHandle1);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)algHandle1, resFxns, scratchId1);
/*
* Use IALG interfaces to do something
*/
DSKT2_controlAlg((IALG_Handle)algHandle1, (IALG_Cmd)NULL, &algStatus);
/* Assign resources to the second algorithm */
if (IRES_OK != RMAN_assignResources((IALG_Handle)algHandle2,
resFxns, scratchId2)) {
printf("Assign Resource Failed \n");
return -1;
}
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)algHandle1, resFxns, scratchId1);
/*
* Deactivate algorithm
*/
DSKT2_deactivateAlg(scratchId1, (IALG_Handle)algHandle1);
/*
* Activate the Algorithm
*/
DSKT2_activateAlg(scratchId2, (IALG_Handle)algHandle2);
/*
* Activate All Resources
*/
RMAN_activateAllResources((IALG_Handle)algHandle2, resFxns, scratchId2);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(algHandle1),
resFxns, scratchId1)) {
printf("Free Resource Failed \n");
return -1;
}
/*
* Acquire the EDMA3 handle first
*/
rmHandle = EDMA3_getResourceManager(NULL, -1);
if (NULL == rmHandle) {
printf("Error obtaining SYSTEM resource Manager Handle \n");
return (-1);
}
resObj.resId = 151;
resObj.type = EDMA3_RM_RES_PARAM_SET;
if (EDMA3_RM_SOK != EDMA3_RM_allocResource(rmHandle, &resObj)) {
printf("Could not allocate this resource, as it is already owned by "
"the algorithm\n");
}
resObj.resId = 256;
if (EDMA3_RM_SOK != EDMA3_RM_allocResource(rmHandle, &resObj)) {
printf("Error, could not allocate resource %d\n"
"ERROR for 6467, OK for 6446\n", resObj.resId);
}
if (EDMA3_RM_SOK != EDMA3_releaseResourceManager(NULL, -1)) {
printf("Error releasing system resource manager handle\n");
}
/*
* Deactivate All Resources
*/
RMAN_deactivateAllResources((IALG_Handle)algHandle2, resFxns, scratchId2);
/*
* Deactivate algorithm
*/
DSKT2_deactivateAlg(scratchId2, (IALG_Handle)algHandle2);
/*
* Free resources assigned to this algorihtm
*/
if (IRES_OK != RMAN_freeResources((IALG_Handle)(algHandle2),
resFxns, scratchId2)) {
printf("Free Resource Failed \n");
return -1;
}
AppEnd1:
/*
* Free instance of the algorithm created
*/
DSKT2_freeAlg(scratchId1, (IALG_Handle)algHandle1);
/*
* Free instance of the algorithm created
*/
DSKT2_freeAlg(scratchId2, (IALG_Handle)algHandle2);
/*
* Unregister the protocol
*/
if (IRES_OK != RMAN_unregister(&IRESMAN_EDMA3CHAN)) {
printf("Unregister Protocol Failed \n");
return -1;
}
for (i = 0; i < MAXMEMSEGMENTS; i++) {
retVal = MEM_stat(i, &stat);
if (!retVal) {
GT_assert(ti_sdo_fc_rman_examples_scratchEdma3_GTMask,
memStat[i].size == 0);
}
else {
if (memStat[i].used != stat.used) {
GT_3trace(ti_sdo_fc_rman_examples_scratchEdma3_GTMask,
GT_7CLASS, "MEM seg [%d]: orig used = 0x%x, "
"curr used = 0x%x", i, memStat[i].used,
stat.used);
return (-1);
}
}
}
RMAN_exit();
return (0);
}
/* ARGSUSED - this line tells the compiler to not generate compiler warnings
* for unused arguments */
Int smain(UArg arg0, UArg arg1)
{
IRES_Status status;
Int size = 0;
Int scratchId = 2;
IALG_Status algStatus;
IALG_Fxns * algFxns = &DUMRES_TI_IALG;
IRES_Fxns * resFxns = &DUMRES_TI_IRES;
DUMRES_TI_Handle dumHandle = NULL;
status = RMAN_init();
if (IRES_OK != status) {
System_abort("RMAN initialization Failed \n");
}
/*
* Create an instance of the algorithm using "algFxns"
*/
dumHandle = (DUMRES_TI_Handle)DSKT2_createAlg(scratchId,
(IALG_Fxns *)algFxns, NULL, (IALG_Params *)NULL);
if (dumHandle == NULL) {
System_abort("Alg creation failed \n");
}
/* Create an instance of an algorithm that implements IALG and IRES_Fxns */
status = RMAN_assignResources((IALG_Handle)dumHandle, resFxns, scratchId);
if (status != IRES_OK) {
System_printf("Assign Resource Failed [%d]\n", status);
System_abort("Aborting...\n");
}
/* Activate the Algorithm */
DSKT2_activateAlg(scratchId, (IALG_Handle)dumHandle);
/* Activate All Resources */
RMAN_activateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Use IALG interfaces to do something */
DSKT2_controlAlg((IALG_Handle)dumHandle, (IALG_Cmd)NULL, &algStatus);
/* Deactivate All Resources */
RMAN_deactivateAllResources((IALG_Handle)dumHandle, resFxns, scratchId);
/* Deactivate algorithm */
DSKT2_deactivateAlg(scratchId, (IALG_Handle)dumHandle);
/* Free resources assigned to this algorihtm */
status = RMAN_freeResources((IALG_Handle)(dumHandle), resFxns, scratchId);
if (status != IRES_OK) {
System_printf("Free Resource Failed [%d]\n", status);
System_abort("Aborting...\n");
}
/* Free instance of the algorithm created */
DSKT2_freeAlg(scratchId, (IALG_Handle)dumHandle);
RMAN_exit();
return (1);
}
Int32 AlgLink_ScdalgProcess(AlgLink_ScdObj *pScdAlgLinkObj, UInt32 chId, AlgLink_ScdResult * scdResultBuff)
{
SCD_Status chanStatus;
SCD_Result scdResult;
UInt32 chanID;
SCD_chPrm chanParam;
AlgLink_ScdchPrm * chPrm;
AlgLink_ScdChObj * chObj;
UInt32 blkIdx;
//System_FrameInfo *pInFrameInfo;
/* Activate the Algorithm */
DSKT2_activateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
chanID = pScdAlgLinkObj->chParams[chId].chId;
chPrm = &(pScdAlgLinkObj->chParams[chId]);
chObj = &(pScdAlgLinkObj->chObj[chId]);
chanParam.chId = chPrm->chId;
chanParam.mode = (SCD_Mode)chPrm->mode;
chanParam.width = chPrm->width;
chanParam.height = chPrm->height;
chanParam.stride = chPrm->stride;
chanParam.curFrame = chPrm->curFrame;
chanParam.frmSensitivity = (SCD_Sensitivity)chPrm->frmSensitivity;
chanParam.frmIgnoreLightsON = chPrm->frmIgnoreLightsON;
chanParam.frmIgnoreLightsOFF = chPrm->frmIgnoreLightsOFF;
chanParam.frmEdgeThreshold = chPrm->frmEdgeThreshold;
if(chPrm->chBlkConfigUpdate == TRUE)
{
chanParam.blkConfig = (SCD_blkChngConfig *) chPrm->blkConfig;
}
else
{
chanParam.blkConfig = NULL;
}
chanStatus = SCD_TI_setPrms(pScdAlgLinkObj->algHndl, &chanParam, chanID);
if(chanStatus != SCD_NO_ERROR)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : ERROR: Alg Set Params (chanID = %d) - 0x%08X !!!\n",
Utils_getCurTimeInMsec(), chanID, chanStatus);
#endif
/* Deactivate algorithm */
DSKT2_deactivateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
return FVID2_EFAIL;
}
scdResult.frmResult = SCD_DETECTOR_NO_TAMPER;
scdResult.blkResult = (SCD_blkChngMeta *)(scdResultBuff->blkResult);
chanStatus = SCD_TI_process(pScdAlgLinkObj->algHndl, chanID, &scdResult);
chanStatus = SCD_NO_ERROR;
/* Deactivate algorithm */
DSKT2_deactivateAlg(gScratchId, (IALG_Handle)pScdAlgLinkObj->algHndl);
if(chanStatus != SCD_NO_ERROR)
{
#ifdef SYSTEM_DEBUG_SCD
Vps_printf(" %d: SCD : ERROR: Alg Process (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
return FVID2_EFAIL;
}
scdResultBuff->frmResult = (AlgLink_ScdOutput) scdResult.frmResult;
scdResultBuff->chId = chanID;
// if(pScdAlgLinkObj->createArgs.chDefaultParams[chId].mode & SCD_DETECTMODE_MONITOR_BLOCKS)
/* Motion detect event notification. */
if(pScdAlgLinkObj->chParams[chId].mode & SCD_DETECTMODE_MONITOR_BLOCKS)
{
UInt32 numBlkChg;
UInt32 monitoredBlk;
UInt32 numHorzBlks, numVertBlks, numBlksInFrame, blkHeight;
monitoredBlk = 0;
numBlkChg = 0;
numHorzBlks = ((pScdAlgLinkObj->chParams[chId].width + 0x1F ) & (~0x1F)) / 32; /* Rounding to make divisible by 32 */
if((pScdAlgLinkObj->chParams[chId].height%ALG_LINK_SCD_BLK_HEIGHT_MIN) == 0)/* For Block height is divisible by 10 */
blkHeight = ALG_LINK_SCD_BLK_HEIGHT_MIN;
else /* For Block height is divisible by 12 */
blkHeight = ALG_LINK_SCD_BLK_HEIGHT;
numVertBlks = pScdAlgLinkObj->chParams[chId].height / blkHeight;
numBlksInFrame = numHorzBlks * numVertBlks;
/* Logic to see how many blocks of total enabled blocks experienced change.
* For each block, algorithm returns no. of pixels changed in the current
* frame. This is compared against thresold determined using SCD sensitivity .
* if changed pixels are more than the calculated thresold, block is marked as changed
* i.e. motion is detected in the block.
* Minimum value of thresold is 20% and then it is incrmented by 10% for
* each sensitivity level change. Thresold can vary from 20% - 100%
* At max sensitivity, thresold would be 20%. That means if 20% pixels
* are changed block is marked as changed.
* At minimu sensitivity, thresold would be 100%. That means if 100% pixels
* are changed block is marked as changed */
for(blkIdx = 0; blkIdx < numBlksInFrame; blkIdx++)
{
SCD_blkChngConfig * blockConfig;
blockConfig = &pScdAlgLinkObj->chParams[chId].blkConfig[blkIdx];
scdResultBuff->blkConfig[blkIdx].monitored = blockConfig->monitored;
scdResultBuff->blkConfig[blkIdx].sensitivity = blockConfig->sensitivity;
if(blockConfig->monitored == 1)
{
UInt32 threshold;
monitoredBlk++;
threshold = MOTION_DETECTION_SENSITIVITY(ALG_LINK_SCD_BLK_WIDTH, blkHeight) +
(MOTION_DETECTION_SENSITIVITY_STEP * (SCD_SENSITIVITY_MAX - blockConfig->sensitivity));
#if 0
if(scdResultBuff->blkResult[blkIdx].numPixelsChanged > 0)
Vps_printf("===========blkIdx:%d,numPixelsChanged:%d\n",blkIdx,scdResultBuff->blkResult[blkIdx].numPixelsChanged);
#endif
if(scdResultBuff->blkResult[blkIdx].numPixelsChanged > threshold)
{
numBlkChg++;
}
}
}
/* Logic to notify A8-host about motion detection.
* Currently, if atleast 1 block is detected as changed A8 is notified.
* User can use commented logic to chnage this behavior. */
/* if((monitoredBlk > 0) && (numBlkChg > (NUM_BLOCK_MOTION_DETECTION_THRESOLD(monitoredBlk)))) */
if(pScdAlgLinkObj->createArgs.enableMotionNotify)
{
if((monitoredBlk > 0) && (numBlkChg > 0))
{
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_printf(" %d: SCD : Motion Detected (chanID = %d), !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_MOTION_DETECT, scdResultBuff, sizeof(AlgLink_ScdResult), TRUE);
}
}
}
chObj->scdChStat = ALG_LINK_SCD_DETECTOR_UNAVAILABLE;
if(scdResult.frmResult == SCD_DETECTOR_NO_TAMPER)
chObj->scdChStat = ALG_LINK_SCD_DETECTOR_NO_CHANGE;
else if(scdResult.frmResult == SCD_DETECTOR_TAMPER)
chObj->scdChStat = ALG_LINK_SCD_DETECTOR_CHANGE;
if(pScdAlgLinkObj->createArgs.enableTamperNotify)
{
/* Tamper detect event notification. */
if(scdResult.frmResult == SCD_DETECTOR_TAMPER)
{
AlgLink_ScdChStatus pChStatus;
pChStatus.frmResult = (UInt32) ALG_LINK_SCD_DETECTOR_CHANGE;
pChStatus.chId = chObj->chId;
#ifdef SYSTEM_DEBUG_SCD_RT
Vps_printf(" %d: SCD : Tamper Detected (chanID = %d) !!!\n",
Utils_getCurTimeInMsec(), chanID );
#endif
System_linkControl(SYSTEM_LINK_ID_HOST, VSYS_EVENT_TAMPER_DETECT, &pChStatus, sizeof(AlgLink_ScdChStatus), TRUE);
}
}
return FVID2_SOK;
}
