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;
}
