int IMAGE_TUNE_ReadParamset(int value) { int retVal = OSA_EFAIL, readSize = 0; IMAGE_TUNE_ParamSetList *pPrmList; if(gImageTunePrmList != NULL) { pPrmList = gImageTunePrmList; retVal = OSA_fileReadFile(IMAGE_TUNE_PARAMSET_DIR, (Uint8*)pPrmList, sizeof(IMAGE_TUNE_ParamSetList),0, &readSize); if((retVal != OSA_SOK) || (readSize!=sizeof(IMAGE_TUNE_ParamSetList))) { if(readSize==0) { OSA_printf("IMAGE TUNE: Paramset File is not available..... Setting DEFAULT parameter\n"); } else { OSA_printf("IMAGE TUNE: Error Reading Paramset File(File Size %d)..... Setting DEFAULT parameter \n", readSize); } memset(gImageTunePrmList, 0, sizeof(IMAGE_TUNE_ParamSetList)); retVal = OSA_EFAIL; } else { retVal = OSA_SOK; } } return retVal; }
int DRV_captureClose() { #ifdef DRV_SHOW_INFO OSA_printf(" CAPTURE: Closing imager.\n"); #endif DRV_imgsClose(); #ifdef DRV_SHOW_INFO OSA_printf(" CAPTURE: Closing ISIF.\n"); #endif DRV_isifClose(); #ifdef DRV_SHOW_INFO OSA_printf(" CAPTURE: Closing H3A.\n"); #endif DRV_h3aClose(); #ifdef DRV_SHOW_INFO OSA_printf(" CAPTURE: Closing IPIPE.\n"); #endif DRV_ipipeClose(); #ifdef DRV_SHOW_INFO OSA_printf(" CAPTURE: Close DONE.\n"); #endif return OSA_SOK; }
int MCVIP_tvp5158SetHue(MCVIP_Hndl *hndl, int channel) { int status=OSA_SOK, chNum; if(channel >= 4){ if(hndl->pI2cHndl[1]==NULL) return OSA_EFAIL; OSA_printf(" MCVIP: TVP5158 set Hue[%d] for stage 1\r\n",hndl->createPrm.videoHue[channel]); chNum = channel-4; status = TVP5158_setHue(hndl->pI2cHndl[1], hndl->createPrm.videoHue[channel], chNum); if(status!=OSA_SOK) return status; } else{ if(hndl->pI2cHndl[0]==NULL) return OSA_EFAIL; OSA_printf(" MCVIP: TVP5158 set Hue[%d] for stage 0\r\n",hndl->createPrm.videoHue[channel]); status = TVP5158_setHue(hndl->pI2cHndl[0], hndl->createPrm.videoHue[channel], channel); if(status!=OSA_SOK) return status; } OSA_printf(" MCVIP: TVP5158 set Hue[%d] done !!!\r\n",hndl->createPrm.videoHue[channel]); return status; }
int OSA_tskTestMain(int argc, char **argv) { char ch; Bool done = FALSE; OSA_printf(" \r\n"); OSA_printf(" Thread Priority [ min = %d , max = %d, default = %d ] \r\n", OSA_THR_PRI_MIN, OSA_THR_PRI_MAX, OSA_THR_PRI_DEFAULT); do { OSA_printf(gOSA_TEST_strMainMenu); ch = OSA_TEST_GetInput(); OSA_printf("\r\n"); switch (ch) { case '1': OSA_TEST_ManualTestRun(); break; case '2': OSA_TEST_AutoTestRun(); break; case '0': done = TRUE; break; } } while(!done); return OSA_SOK; }
int MCVIP_tvp5158SetNoiseReduction(MCVIP_Hndl *hndl, int channel, int enable) { int status=OSA_SOK, stage=0, chNum; chNum = channel; if(channel >= 4){ stage = 1; chNum = channel-4; } if(hndl->pI2cHndl[stage]==NULL) return OSA_EFAIL; OSA_printf(" MCVIP: TVP5158 ch[%d] set NoiseReduction[%d] for stage %d\r\n",channel, enable, stage); if(enable == 0) enable = 0x09; if(enable == 1) enable = 0x08; status = TVP5158_setNoiseReduction(hndl->pI2cHndl[stage], enable, chNum); if(status!=OSA_SOK) return status; OSA_printf(" MCVIP: TVP5158 ch[%d] set NoiseReduction[%x] done !!\r\n",channel, enable); return status; }
static UInt32 VcapVencVdecVdis_ipcBitsGetMaxFileSizePerChannel(char *filePath) { UInt32 maxFileSizePerChannel = 0; unsigned long paritionFreeSize; paritionFreeSize = VcapVencVdecVdis_ipcBitsGetPartitionFreeSpace(filePath); if (0 == paritionFreeSize) { OSA_printf("Not able to determine partition size.Using default size:%d", MCFW_IPC_BITS_MAX_FILE_SIZE); maxFileSizePerChannel = MCFW_IPC_BITS_MAX_FILE_SIZE; } else { unsigned long maxFileSizeActual; maxFileSizeActual = paritionFreeSize/ VcapVencVdecVdis_ipcBitsGetNumEnabledChannels(); if (maxFileSizeActual > MCFW_IPC_BITS_MAX_SINGLE_FILE_SIZE) { OSA_printf("Limiting File Size to max[0x%X],actual[0x%lX]", MCFW_IPC_BITS_MAX_SINGLE_FILE_SIZE, maxFileSizeActual); maxFileSizeActual = MCFW_IPC_BITS_MAX_SINGLE_FILE_SIZE; } maxFileSizePerChannel = maxFileSizeActual; /* Each channel will have a buffer and a header. So divide by 2 */ maxFileSizePerChannel /= 2; OSA_printf("Max File size per channel:0x%X",maxFileSizePerChannel); } return (maxFileSizePerChannel); }
//20120105 add by sxh stream int UI_rtspStreamStart() { OSA_printf(" MCVIP UI: Starting Streaming Server...\n"); system("./wis-streamer &"); OSA_waitMsecs(2000); OSA_printf(" MCVIP UI: Starting Streaming Server...DONE\n"); return 0; }
int DRV_captureTestMain(int argc, char **argv) { int status; memset(&gDRV_testCtrl, 0, sizeof(gDRV_testCtrl)); gDRV_testCtrl.testQuit = 0; OSA_attachSignalHandler(SIGINT, DRV_captureTestSignalHandler); status = DRV_init(); if(status!=OSA_SOK) return status; status = DRV_captureTestOpen(); if(status!=OSA_SOK) goto open_exit; status = DRV_captureStart(FALSE, TRUE); if(status!=OSA_SOK) goto start_exit; OSA_printf(" CAPTURE: Running.\n"); status = OSA_SOK; while(!gDRV_testCtrl.testQuit && status==OSA_SOK) status = DRV_captureTestRun(); DRV_captureStop(); start_exit: OSA_printf(" CAPTURE: Closing capture.\n"); DRV_captureClose(); OSA_printf(" CAPTURE: Closing display.\n"); DRV_displayClose(&gDRV_testCtrl.displayHndl); #ifdef DRV_CAPTURE_TEST_ENABLE_FD DRV_faceDetectClose(); #endif #ifdef DRV_CAPTURE_TEST_ENABLE_VS ALG_vstabDelete(gDRV_testCtrl.vsHndl); #endif if(gDRV_testCtrl.tmpBufSize) { // OSA_fileWriteFile("DATA_DUMP.YUV", gDRV_testCtrl.tmpBufVirtAddr, gDRV_testCtrl.tmpBufSize); OSA_cmemFree(gDRV_testCtrl.tmpBufVirtAddr); } open_exit: OSA_printf(" CAPTURE: Exiting.\n"); DRV_exit(); OSA_printf(" CAPTURE: Bye Bye !!!\n"); return status; }
static void generate_windows(int width1, int height1, int h_start2, int v_start2, int width2, int height2, int weight, unsigned char *win_coeffs) { int total_pixels_1, total_pixels_2; int pixel_weight1, pixel_weight2; int max_weight; int shift; int i, j; float total_weight; /* calculate weight for each window */ total_pixels_2 = width2 * height2; total_pixels_1 = width1 * height1 - total_pixels_2; pixel_weight1 = (100 - weight) * 65536 / total_pixels_1; pixel_weight2 = weight * 65536 / total_pixels_2; #ifdef AEWB_PRINTS OSA_printf("weights for each window: %d, %d\n", pixel_weight1, pixel_weight2); #endif /* normalize weights */ max_weight = pixel_weight1 > pixel_weight2 ? pixel_weight1 : pixel_weight2; shift = 0; while(max_weight >= 255) { shift ++; max_weight = (max_weight + 1) >> 1; } pixel_weight1 = (pixel_weight1 + (1<<(shift-1))) >> shift; pixel_weight2 = (pixel_weight2 + (1<<(shift-1))) >> shift; if(pixel_weight2 > pixel_weight1 ) { pixel_weight2 = (pixel_weight1 * total_pixels_1 * weight) / (total_pixels_2 * (100 - weight)); } else { pixel_weight1 = (pixel_weight2 * total_pixels_2 * (100 - weight)) / (total_pixels_1 * weight); } total_weight = pixel_weight1 * total_pixels_1 + pixel_weight2 * total_pixels_2; #ifdef AEWB_PRINTS OSA_printf("weight = %f, %f\n", pixel_weight1 * total_pixels_1/total_weight, pixel_weight2 * total_pixels_2 / total_weight); OSA_printf("weights for each window after shifting: %d, %d, %d\n", pixel_weight1, pixel_weight2, shift); #endif for(i = 0; i < height1; i ++) { for(j = 0; j < width1; j ++) { if(i >= v_start2 && i < (v_start2 + height2) && j >= h_start2 && j < (h_start2 + width2)) { win_coeffs[i * width1 + j] = pixel_weight2; } else { win_coeffs[i * width1 + j] = pixel_weight1; } } } }
Int32 VdecVdis_ipcFramesDelete() { OSA_printf("Entered:%s...",__func__); VdecVdis_ipcFramesDeInitThrObj(&gVdecVdis_config.ipcFrames.thrObj); VdecVdis_ipcFramesDeInitFrameObj(gVdecVdis_config.ipcFrames.frameObj, MCFW_IPCFRAMES_MAX_NUM_ALLOC_FRAMES); OSA_printf("Leaving:%s...",__func__); return OSA_SOK; }
int AVSERVER_init() { int status; #ifdef AVSERVER_DEBUG_API OSA_printf(" AVSERVER API: Creating TSKs.\n"); #endif status = DRV_init(); if(status!=OSA_SOK) { OSA_ERROR("DRV_init()\n"); return status; } status = ALG_sysInit(); if(status!=OSA_SOK) { OSA_ERROR("ALG_sysInit()\n"); DRV_exit(); return status; } memset(&gAVSERVER_config, 0, sizeof(gAVSERVER_config)); memset(&gVIDEO_ctrl, 0, sizeof(gVIDEO_ctrl)); memset(&gAVSERVER_ctrl, 0, sizeof(gAVSERVER_ctrl)); status |= OSA_mutexCreate(&gAVSERVER_ctrl.lockMutex); status |= VIDEO_captureCreate(); //status |= VIDEO_resizeCreate(); status |= VIDEO_streamCreate(); status |= VIDEO_displayCreate(); //status |= VIDEO_ldcCreate(); //status |= VIDEO_vnfCreate(); //status |= VIDEO_vsCreate(); status |= VIDEO_aewbCreate(); //status |= VIDEO_fdCreate(); status |= VIDEO_encodeCreate(); status |= VIDEO_swosdCreate(); //status |= VIDEO_encryptCreate(); status |= VIDEO_motionCreate(); //status |= AUDIO_audioCreate(); //status |= AUDIOPLAY_audioCreate(); status |= AVSERVER_mainCreate(); if(status!=OSA_SOK) { OSA_ERROR("AVSERVER_init()\n"); ALG_sysExit(); DRV_exit(); return status; } #ifdef AVSERVER_DEBUG_API OSA_printf(" AVSERVER API: Creating TSKs...DONE\n"); #endif return status; }
/* Send Image data to ITT (PC) Used separate send data as teh other send (Image paramset) has limited size of data send and breaking image data was not handled in ITT(PC) */ int IMAGE_TUNE_CmdDataSend(IMAGE_TUNE_CmdInfo *statusInfo){ Uint32 pktDataSize = 0, dataSize = 0; int retVal = OSA_EFAIL; IMAGE_TUNE_PacketHeader packetHeader; IMAGE_TUNE_PacketFooter packetFooter; Uint32* packet; if(gDataBuff == NULL) return OSA_EFAIL; packet = (Uint32*)gDataBuff; pktDataSize = imgDataSize; //(IMAGE_TUNE_PACKET_HEADER_SIZE + packetHeader.prmSize + IMAGE_TUNE_PACKET_FOOTER_SIZE); packetHeader.headerMagicNum = IMAGE_TUNE_HEADER_MAGIC_NUM; packetHeader.checkSum = 0; packetHeader.commandId = statusInfo->commandId; packetHeader.commandFlags = statusInfo->commandFlags; packetHeader.prmSize = imgDataSize-IMAGE_TUNE_PACKET_HEADER_SIZE-IMAGE_TUNE_PACKET_FOOTER_SIZE-imgExtraSize; packetFooter.footerMagicNum = IMAGE_TUNE_FOOTER_MAGIC_NUM; memcpy( (Uint8*)packet, &packetHeader, IMAGE_TUNE_PACKET_HEADER_SIZE); memcpy(((Uint8*)packet + imgDataSize - IMAGE_TUNE_PACKET_FOOTER_SIZE), &packetFooter, IMAGE_TUNE_PACKET_FOOTER_SIZE); #ifdef IMAGE_TUNE_PACKET_DEBUG OSA_printf(" IMAGE TUNE SERVER: Image Data Packet size is %d bytes\n", imgDataSize); #endif // calculate check-sum packet[IMAGE_TUNE_CHECK_SUM_OFFSET] = IMAGE_TUNE_CalcPacketChecksum(packet); retVal = IMAGE_TUNE_ServerSendData((Uint8*)packet, pktDataSize); if(retVal!=OSA_SOK) { #ifdef IMAGE_TUNE_SERVER_DEBUG OSA_printf( " IMAGE TUNE SERVER: Reply send ERROR !!!\n"); #endif } #if 0 dataSize = WriteDataintofile((Uint8*)packet, pktDataSize, packetHeader.commandId); OSA_printf(" ITS: Send Image Data to ITT %d & copied %d, \n", pktDataSize, dataSize); OSA_printf(" ITS: imgDataSize %d, PACKET_HEADER_SIZE %d, PACKET_FOOTER_SIZE %d, imgExtraSize %d",imgDataSize,IMAGE_TUNE_PACKET_HEADER_SIZE,IMAGE_TUNE_PACKET_FOOTER_SIZE, imgExtraSize) #endif if(gDataBuff != NULL){ OSA_cmemFree(gDataBuff); #ifdef IMAGE_TUNE_SERVER_DEBUG //OSA_printf(" IMAGE TUNE SERVER: Send Iamge Data memory released\n"); #endif gDataBuff = NULL; } return OSA_SOK; }
Int32 VcapVencVdecVdis_ipcBitsExit() { OSA_printf("Entered:%s...",__func__); VcapVencVdecVdis_FreeBitBufDeInit(); if (gVcapVencVdecVdis_ipcBitsCtrl.fObj.enableFWrite == TRUE){ VcapVencVdecVdis_ipcBitsInitFileHandles(); } VcapVencVdecVdis_ipcBitsDeInitDmaObj(); VcapVencVdecVdis_ipcBitsDeInitThrObj(&gVcapVencVdecVdis_ipcBitsCtrl.thrObj); OSA_printf("Leaving:%s...",__func__); return OSA_SOK; }
int VIDEO_displayTskRun(OSA_BufInfo *pBufInfo) { int status, inBufId; static int disFrameNum = 0; #ifdef DISBUF_MEMCPY status = OSA_bufGetFull(&gVIDEO_ctrl.displayStream.bufDisplayIn, &inBufId, OSA_TIMEOUT_FOREVER); if(status!=OSA_SOK) { OSA_ERROR("OSA_bufGetFull()\n"); return status; } #ifdef AVSERVER_DEBUG_VIDEO_DISPLAY_THR #ifdef AVSERVER_DEBUG_RUNNING OSA_printf(" DISPLAY: Get Buf %d \n", inBufId); #endif #endif status = DRV_displaySwitchBuf(&gVIDEO_ctrl.displayStream.displayHndl, &inBufId, 0, NULL); #else if(gAVSERVER_config.displayEnable) { inBufId = (disFrameNum++ % gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm.numBuf); status = DRV_displaySwitchBuf(&gVIDEO_ctrl.displayStream.displayHndl, &inBufId, 1, pBufInfo->virtAddr + VIDEO_BUF_HEADER_SIZE); } else { inBufId = (disFrameNum++ % gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm.numBuf); status = DRV_displaySwitchBuf(&gVIDEO_ctrl.displayStream.displayHndl, &inBufId, 2, NULL); } #endif //#ifdef DISBUF_MEMCPY //if(!gAVSERVER_config.displayEnable) // DRV_displayEnable(&gVIDEO_ctrl.displayStream.displayHndl, FALSE); if(status==OSA_SOK) { #ifdef DISBUF_MEMCPY OSA_bufPutEmpty(&gVIDEO_ctrl.displayStream.bufDisplayIn, inBufId); #ifdef AVSERVER_DEBUG_VIDEO_DISPLAY_THR #ifdef AVSERVER_DEBUG_RUNNING OSA_printf(" DISPLAY: Put Buf %d \n", inBufId); #endif #endif #endif // #ifdef DISBUF_MEMCPY } return status; }
int DRV_imgsTestMain(int argc, char **argv) { DRV_ImgsConfig imgsConfig; int status = DRV_init(); if (status != OSA_SOK) { return status; } imgsConfig.sensorMode = DRV_IMGS_SENSOR_MODE_640x480; imgsConfig.fps = 30; imgsConfig.binEnable = TRUE; OSA_printf(" IMGS: Imager %s is selected\n", drvImgsFunc->imgsGetImagerName()); status = drvImgsFunc->imgsOpen(&imgsConfig); if (status != OSA_SOK) { OSA_ERROR("DRV_imgsOpen(%d)\n", imgsConfig.sensorMode); } if (status == OSA_SOK) { drvImgsFunc->imgsEnable(TRUE); OSA_DEBUG_WAIT; drvImgsFunc->imgsEnable(FALSE); drvImgsFunc->imgsClose(); } DRV_exit(); return status; }
int TVP5158_setNoiseReduction(DRV_I2cHndl *i2cHndl, int enable, int channel) { int status=OSA_SOK; Uint8 regAddr[2]; Uint8 regVal[2]; Uint32 k; Uint8 chVal=1; chVal = chVal << channel; status = TVP5158_selectWrite(i2cHndl, chVal); if(status!=OSA_SOK) goto error_exit; k=0; regAddr[k] = 0x5D; regVal[k] = (Uint8)enable; k++; OSA_printf(" TVP5158: NoiseReduction [Ch=%d value=%x]\n", chVal, enable); status = DRV_i2cWrite8(i2cHndl, regAddr, regVal, k); if(status!=OSA_SOK) goto error_exit; OSA_waitMsecs(20); error_exit: if(status!=OSA_SOK) OSA_ERROR("I2C-NoiseReduction"); return status; }
int TVP5158_setHybridChSelect(DRV_I2cHndl *i2cHndl, int channel) { int status=OSA_SOK; Uint8 regAddr[64]; Uint8 regVal[64]; Uint32 k; status = TVP5158_selectWrite(i2cHndl, 0xF); if(status!=OSA_SOK) goto error_exit; k=0; regAddr[k] = 0xB5; regVal[k] = (Uint8)channel; k++; #ifdef TVP5158_DEBUG OSA_printf(" TVP5158: HybridChannel [Ch=%d]\n", channel); #endif status = DRV_i2cWrite8(i2cHndl, regAddr, regVal, k); if(status!=OSA_SOK) goto error_exit; OSA_waitMsecs(20); error_exit: if(status!=OSA_SOK) OSA_ERROR("I2C-HybirdChannel"); return status; }
short ALG_aewbSetIpipeWb(AWB_PARAM *pAwb_Data ) { DRV_IpipeWb ipipeWb; static AWB_PARAM PreAwb_Data; int dGain; if( memcmp( &PreAwb_Data, pAwb_Data, sizeof(AWB_PARAM))== 0 ) return 0; PreAwb_Data = *pAwb_Data; #ifdef ALG_AEWB_DEBUG OSA_printf(" AEWB: R Gr Gb B = (%d, %d, %d, %d) DGAIN = %d\n", pAwb_Data->rGain, pAwb_Data->grGain, pAwb_Data->gbGain, pAwb_Data->bGain, pAwb_Data->dGain ); #endif ipipeWb.gainR = 4*pAwb_Data->rGain; ipipeWb.gainGr = 4*pAwb_Data->grGain; ipipeWb.gainGb = 4*pAwb_Data->gbGain; ipipeWb.gainB = 4*pAwb_Data->bGain; DRV_ipipeSetWb(&ipipeWb); dGain = pAwb_Data->dGain*2; if(gALG_aewbObj.vnfDemoCfg) dGain = 512*4; DRV_isifSetDgain(dGain, dGain, dGain, dGain, 0); return 0; }
short ALG_aewbSetSensor50_60Hz(int Is50Hz) { static int prevValue = -1; if(prevValue==Is50Hz) return 0; #ifdef ALG_AEWB_DEBUG OSA_printf(" AEWB: Sensor 50_60Hz = %d\n", Is50Hz); #endif prevValue = Is50Hz; DRV_imgsSet50_60Hz(Is50Hz); if( Is50Hz ) { DRV_displaySetMode(DRV_DISPLAY_MODE_PAL); }else{ DRV_displaySetMode(DRV_DISPLAY_MODE_NTSC); } return 0; }
short ALG_aewbSetRgb2Rgb2(RGB2RGB_PARAM *pRgb2Rgb ) { CSL_IpipeRgb2RgbConfig rgb2rgb; #ifdef ALG_AEWB_DEBUG OSA_printf(" AEWB: RGB2RGB \n"); #endif rgb2rgb.matrix[0][0] = pRgb2Rgb->rgb_mul_rr; rgb2rgb.matrix[0][1] = pRgb2Rgb->rgb_mul_gr; rgb2rgb.matrix[0][2] = pRgb2Rgb->rgb_mul_br; rgb2rgb.matrix[1][0] = pRgb2Rgb->rgb_mul_rg; rgb2rgb.matrix[1][1] = pRgb2Rgb->rgb_mul_gg; rgb2rgb.matrix[1][2] = pRgb2Rgb->rgb_mul_bg; rgb2rgb.matrix[2][0] = pRgb2Rgb->rgb_mul_rb; rgb2rgb.matrix[2][1] = pRgb2Rgb->rgb_mul_gb; rgb2rgb.matrix[2][2] = pRgb2Rgb->rgb_mul_bb; rgb2rgb.offset[0] = pRgb2Rgb->rgb_oft_or; rgb2rgb.offset[1] = pRgb2Rgb->rgb_oft_og; rgb2rgb.offset[2] = pRgb2Rgb->rgb_oft_ob; DRV_ipipeSetRgb2Rgb2(&rgb2rgb); return 0; }
short ALG_aewbSetIpipeWb2(AWB_PARAM *pAwb_Data ) { DRV_IpipeWb ipipeWb; static AWB_PARAM PreAwb_Data; int dGain; if( memcmp( &PreAwb_Data, pAwb_Data, sizeof(AWB_PARAM))== 0 ) return 0; PreAwb_Data = *pAwb_Data; #ifdef ALG_AEWB_DEBUG OSA_printf(" AEWB2: R Gr Gb B = (%d, %d, %d, %d) DGAIN = %d\n", pAwb_Data->rGain, pAwb_Data->grGain, pAwb_Data->gbGain, pAwb_Data->bGain, pAwb_Data->dGain ); #endif ipipeWb.gainR = 4*pAwb_Data->rGain; ipipeWb.gainGr = 4*pAwb_Data->grGain; ipipeWb.gainGb = 4*pAwb_Data->gbGain; ipipeWb.gainB = 4*pAwb_Data->bGain; DRV_ipipeSetWb(&ipipeWb); return 0; }
int IMAGE_TUNE_CmdExecuteIpipeDpc(IMAGE_TUNE_CmdInfo *cmdInfo, IMAGE_TUNE_CmdInfo *statusInfo) { int retVal; CSL_IpipeDpcConfig *pPrm = &gIMAGE_TUNE_ctrl.curPrm.ipipePrm.dpc; Uint32 *pTable = gIMAGE_TUNE_ctrl.curPrm.ipipePrm.dpcTable; Uint32 prmSize = sizeof(*pPrm); Uint32 tableSize = sizeof(gIMAGE_TUNE_ctrl.curPrm.ipipePrm.dpcTable); Uint32 reqdPrmSize = prmSize + tableSize; if (cmdInfo->prmSize != reqdPrmSize) { #ifdef IMAGE_TUNE_CMD_HANDLER_DEBUG OSA_printf(" IMAGE TUNE SERVER: Received parameter size (%d != %d) mismatch ERROR for CMD 0x%04x\n", cmdInfo->prmSize, reqdPrmSize, cmdInfo->commandId); #endif return OSA_EFAIL; } memcpy(pPrm, cmdInfo->prm, prmSize); memcpy(pTable, (Uint8*)cmdInfo->prm + prmSize, tableSize); pPrm->lutAddr = pTable; retVal = CSL_ipipeSetDpcConfig(&gCSL_ipipeHndl, pPrm); return retVal; }
int OSA_TEST_PSEQ_Start(OSA_TskHndl *pPrc, OSA_MsgHndl *pMsg, Uint32 curState) { OSA_TskHndl *prcToList[] = { &gOSA_testPstA, &gOSA_testPstB, &gOSA_testPstC, NULL }; Uint32 delay; delay = *(Uint32*)OSA_msgGetPrm(pMsg); OSA_tskSendMsg(&gOSA_testPstA, pPrc, OSA_TEST_CMD__INIT, &delay, OSA_MBX_WAIT_ACK); OSA_tskSendMsg(&gOSA_testPstB, pPrc, OSA_TEST_CMD__INIT, &delay, OSA_MBX_WAIT_ACK); OSA_tskSendMsg(&gOSA_testPstC, pPrc, OSA_TEST_CMD__INIT, &delay, OSA_MBX_WAIT_ACK); OSA_tskBroadcastMsg(prcToList, pPrc, OSA_TEST_CMD__START, NULL, 0); OSA_printf("\r\n PSEQ : STARTED "); OSA_tskSetState(pPrc, OSA_TEST_STATE__RUN); return OSA_SOK; }
static Void *VdecVdis_bitsRdSendFxn(Void * prm) { VCODEC_BITSBUF_LIST_S emptyBufList; UInt32 resId; static Int printStatsInterval = 0; OSA_semWait(&gVdecVdis_obj.thrStartSem,OSA_TIMEOUT_FOREVER); while (FALSE == gVdecVdis_obj.thrExit) { OSA_waitMsecs(MCFW_IPCBITS_SENDFXN_PERIOD_MS); for (resId = 0; resId < gVdecVdis_config.numRes; resId++) { VdecVdis_bitsRdGetEmptyBitBufs(&emptyBufList,resId); VdecVdis_bitsRdReadData(&emptyBufList,resId); VdecVdis_bitsRdSendFullBitBufs(&emptyBufList); } #ifdef IPCBITS_OUT_HOST_DEBUG if ((printStatsInterval % MCFW_IPCBITS_INFO_PRINT_INTERVAL) == 0) { OSA_printf("MCFW_IPCBITS:%s:INFO: periodic print..",__func__); } #endif printStatsInterval++; } return NULL; }
/* Send Image data to ITT (PC) - Copy image data in to a separate buffer; same data sent to ITT(PC) while sending */ int IMAGE_TUNE_CopyImageData(int hSize, int dSize, Uint8 *headerData, Uint8 *ImgData){ Uint8* buff; imgDataSize = IMAGE_TUNE_PACKET_HEADER_SIZE + hSize + dSize + IMAGE_TUNE_PACKET_FOOTER_SIZE; if(gDataBuff != NULL){ OSA_cmemFree(gDataBuff); #ifdef IMAGE_TUNE_SERVER_DEBUG OSA_printf("IMAGE TUNE SERVER: Send data mem released\n"); #endif } imgExtraSize = (32 - (imgDataSize % 32)); imgDataSize = imgDataSize + imgExtraSize; gDataBuff = OSA_cmemAlloc(imgDataSize,32); if(gDataBuff == NULL) return OSA_EFAIL; else{ #ifdef IMAGE_TUNE_SERVER_DEBUG //OSA_printf(" IMAGE TUNE SERVER: Send Image Data Memory allocated %d\n", imgDataSize); #endif } memset(gDataBuff, 0, imgDataSize); buff = gDataBuff + IMAGE_TUNE_PACKET_HEADER_SIZE; memcpy(buff, headerData, hSize); buff = buff + hSize; memcpy(buff, ImgData, dSize); return OSA_SOK; }
int DRV_imageTuneGetRawDataStartPhase() { int phase, startX, startY; int regValue = CSL_FEXT(gCSL_vpssHndl.ipipeRegs->SRC_COL, IPIPE_SRC_COL_EE); regValue = regValue % 4; startX = gCSL_vpssHndl.ipipeRegs->SRC_HPS % 2; startY = gCSL_vpssHndl.ipipeRegs->SRC_VPS % 2; phase = regValue; if (startX) { switch (phase) { case CSL_IPIPE_SOURCE_COLOUR_R: phase = CSL_IPIPE_SOURCE_COLOUR_GR; break; case CSL_IPIPE_SOURCE_COLOUR_GR: phase = CSL_IPIPE_SOURCE_COLOUR_R; break; case CSL_IPIPE_SOURCE_COLOUR_GB: phase = CSL_IPIPE_SOURCE_COLOUR_B; break; case CSL_IPIPE_SOURCE_COLOUR_B: phase = CSL_IPIPE_SOURCE_COLOUR_GB; break; } } if (startY) { switch (phase) { case CSL_IPIPE_SOURCE_COLOUR_R: phase = CSL_IPIPE_SOURCE_COLOUR_GB; break; case CSL_IPIPE_SOURCE_COLOUR_GR: phase = CSL_IPIPE_SOURCE_COLOUR_B; break; case CSL_IPIPE_SOURCE_COLOUR_GB: phase = CSL_IPIPE_SOURCE_COLOUR_R; break; case CSL_IPIPE_SOURCE_COLOUR_B: phase = CSL_IPIPE_SOURCE_COLOUR_GR; break; } } #if 0 OSA_printf(" IMAGE TUNE: Phase Reg = %s : Start x,y = %d,%d : Phase = %s \n", phaseName[regValue], startX, startY, phaseName[phase] ); #endif return phase; }
void showUsage(char *str) { OSA_printf(" \n"); OSA_printf(" Multi Channel Video Input Port (MCVIP) Capture Demo, (c) Texas Instruments 2009\n"); OSA_printf(" \n"); OSA_printf(" USAGE: %s <videoSystem> <i2c Mode>\n", str); OSA_printf(" \n"); OSA_printf(" videoSystem = NTSC (default) or PAL \n"); OSA_printf(" i2c Mode = WinVCC or DM6467 (default) \n"); OSA_printf(" \n"); }
//ANR - Test int IMAGE_TUNE_CmdExecuteIpipeRgb2Yuv_new(Uint32 id) { CSL_IpipeRgb2YuvConfig *pPrm = &gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv; int retVal = CSL_ipipeSetRgb2YuvConfig(&gCSL_ipipeHndl, pPrm); OSA_printf(" \r\n gIMAGE_TUNE_ctrl.curPrm.ipipePrm %d, %d, %d ", gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv.matrix[0][0], gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv.matrix[1][1], gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv.offset[0]); return retVal; }
void TI_2A_init_tables_ar0331(int width, int height) { #ifdef AEWB_PRINTS OSA_printf("TI2A weight matrix: width = %d, height = %d\n", width, height); #endif generate_windows(width, height, 0, 0, width, height/2, 50, TI_WEIGHTING_MATRIX); generate_windows(width, height, width/4, height/4, width/2, height/2, 50, TI_WEIGHTING_CENTER); generate_windows(width, height, width*3/8, height/3, width/4, height/4, 80, TI_WEIGHTING_SPOT); }
int main(int argc, char **argv) { int status, videoSys; int debug=0; showUsage(argv[0]); if(argc > 2) { if(strcmp(argv[2], "WinVCC")==0) { // run in debug mode, WinVCC controls TVP5158 I2C debug=1; } } status = SYSTEM_init(debug); if(status!=OSA_SOK) return status; videoSys = MCVIP_VIDEO_SYSTEM_NTSC; if(argc > 1) { if(strcmp(argv[1], "PAL")==0) videoSys = MCVIP_VIDEO_SYSTEM_PAL; } #if 1 UI_menuMain(videoSys); #else UI_sysStart(MCVIP_VIDEO_DECODER_MODE_2CH_D1_PORT_A, MCVIP_VIDEO_IF_MODE_BT656, videoSys); OSA_waitMsecs(1000*60); UI_sysStop(); SYSTEM_profileInfoShow(); #endif OSA_printf(" MCVIP: System Exiting !!!\n"); SYSTEM_exit(); OSA_printf(" MCVIP: Bye Bye !!!\n"); OSA_printf(" \n"); return 0; }