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 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;
}
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;
}
int ALG_vidEncTestMain(int argc, char **argv)
{
int status, i, k, numFrames=1000;
Uint8 *inVirtAddr=NULL, *inPhysAddr, *outVirtAddr=NULL, *outPhysAddr, *curOutAddr;
OSA_PrfHndl prfVidEnc[ALG_VID_ENC_TEST_CHANNELS];
Uint32 size=4*MB, fileSize;
void *algVidEncHndl[ALG_VID_ENC_TEST_CHANNELS];
ALG_VidEncCreate createPrm;
ALG_VidEncRunPrm runPrm;
ALG_VidEncRunStatus runStatus;
FILE *fileHndl[ALG_VID_ENC_TEST_CHANNELS];
char filename[20];
status = DRV_init();
if(status!=OSA_SOK) {
OSA_ERROR("DRV_init()\n");
return status;
}
status = ALG_sysInit();
if(status!=OSA_SOK) {
DRV_exit();
return status;
}
inVirtAddr = OSA_cmemAlloc(size, 32);
outVirtAddr = OSA_cmemAlloc(size, 32);
inPhysAddr = OSA_cmemGetPhysAddr(inVirtAddr);
outPhysAddr = OSA_cmemGetPhysAddr(outVirtAddr);
memset(inVirtAddr, 0x0, size);
memset(outVirtAddr, 0x0, size);
if( inVirtAddr==NULL || outVirtAddr == NULL
|| inPhysAddr==NULL || outPhysAddr == NULL
) {
OSA_ERROR("OSA_cmemAlloc()\n");
goto error_exit;
}
memset(fileHndl, 0, sizeof(fileHndl));
createPrm.codec = ALG_VID_CODEC_H264;
createPrm.dataFormat = DRV_DATA_FORMAT_YUV420;
createPrm.width = 1920; //320
createPrm.height = 1088; //240
createPrm.offsetH = 1920; //320
createPrm.offsetV = 1088; //240
createPrm.bitrate = 6*1000*1000;
createPrm.mode = ALG_VID_ENC_MODE_STANDARD;
createPrm.keyFrameInterval= 30;
createPrm.mbMvOutEnable = FALSE;
createPrm.qValue = 75;
createPrm.ddrEnable = 0;
createPrm.forceKeyFrame = FALSE;
if(createPrm.dataFormat==DRV_DATA_FORMAT_YUV420)
status = OSA_fileReadFile("videoQVGA.yuv420", inVirtAddr, size, &fileSize);
else
status = OSA_fileReadFile("video.yuv422", inVirtAddr, size, &fileSize);
if(status!=OSA_SOK) {
OSA_ERROR("OSA_fileReadFile()\n");
goto error_exit;
}
memset(algVidEncHndl, 0, sizeof(algVidEncHndl));
for(k=0; k<ALG_VID_ENC_TEST_CHANNELS; k++) {
algVidEncHndl[k] = ALG_vidEncCreate(&createPrm);
if(algVidEncHndl[k]==NULL) {
OSA_ERROR("ALG_vidEncCreate()\n");
goto error_exit;
}
OSA_prfReset(&prfVidEnc[k]);
sprintf( filename, "%s/CH%02d.bits", ALG_VID_ENC_TEST_FILESYS, k);
fileHndl[k] = fopen(filename, "wb");
if(fileHndl[k]==NULL) {
OSA_ERROR("fopen(%s)", filename);
goto error_exit;
}
}
curOutAddr = outVirtAddr;
for(i=0; i<numFrames; i++) {
runPrm.inStartX = 0;
runPrm.inStartY = 0;
runPrm.inAddr = inVirtAddr;
runPrm.outAddr = curOutAddr;
runPrm.mbMvInfo = NULL;
runPrm.outDataMaxSize = size;
runPrm.roiPrm.numROI = 0;
for(k=0; k<ALG_VID_ENC_TEST_CHANNELS; k++) {
#if 1
OSA_prfBegin(&prfVidEnc[k]);
status = ALG_vidEncRun(algVidEncHndl[k], &runPrm, &runStatus,NULL);
OSA_prfEnd(&prfVidEnc[k], 1);
#endif
if(status==OSA_SOK) {
#ifdef ALG_VID_ENC_TEST_DEBUG
OSA_printf(" ALG: VidEnc: CH %d: %d: %ld bytes, key_frame = %ld, MB = %d\n", k, i, runStatus.bytesGenerated, runStatus.isKeyFrame, runStatus.numMB);
#endif
fwrite(curOutAddr, runStatus.bytesGenerated, 1, fileHndl[k]);
} else {
OSA_printf(" ALG: VidEnc: ALG_vidEncRun() ERROR !!!\n");
break;
}
}
#if 0
if((i%11)==0) {
ALG_vidDecTestMain(0, NULL);
}
#endif
}
#ifdef ALG_VID_ENC_TEST_DEBUG
for(k=0; k<ALG_VID_ENC_TEST_CHANNELS; k++) {
OSA_prfPrint(&prfVidEnc[k], "VID ENC", 0);
}
#endif
error_exit:
for(k=0; k<ALG_VID_ENC_TEST_CHANNELS; k++) {
ALG_vidEncDelete(algVidEncHndl[k]);
if(fileHndl[k])
fclose(fileHndl[k]);
}
if(inVirtAddr)
OSA_cmemFree(inVirtAddr);
if(outVirtAddr)
OSA_cmemFree(outVirtAddr);
ALG_sysExit();
DRV_exit();
return status;
}
int
ACE_TMAIN (int argc, ACE_TCHAR *argv[])
{
ACE_Argv_Type_Converter atc (argc, argv);
try
{
if (0 != DRV_init (atc.get_argc (), atc.get_TCHAR_argv ()))
{
throw Bailout ();
}
// Parse arguments.
DRV_parse_args (atc.get_argc (), atc.get_ASCII_argv ());
// If a version message is requested, print it and exit cleanly.
if (idl_global->compile_flags () & IDL_CF_VERSION)
{
DRV_version ();
DRV_cleanup ();
return 0;
}
// If a usage message is requested, print it and exit cleanly.
if (idl_global->compile_flags () & IDL_CF_ONLY_USAGE)
{
DRV_usage ();
DRV_cleanup ();
return 0;
}
// If there are no input files, and we are not using the
// directory recursion option, there's no sense going any further.
if (0 == DRV_nfiles && 0 == idl_global->recursion_start ())
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("IDL: No input files\n")));
throw Bailout ();
}
AST_Generator *gen = be_util::generator_init ();
if (0 == gen)
{
ACE_ERROR ((
LM_ERROR,
ACE_TEXT ("IDL: DRV_generator_init() failed to create ")
ACE_TEXT ("generator, exiting\n")
));
throw Bailout ();
}
else
{
idl_global->set_gen (gen);
}
// Initialize AST and load predefined types.
FE_populate ();
// Does various things in various backends.
BE_post_init (DRV_files, DRV_nfiles);
FILE *output_file = 0;
if (idl_global->multi_file_input ())
{
output_file =
ACE_OS::fopen (idl_global->big_file_name (), "w");
}
for (DRV_file_index = 0;
DRV_file_index < DRV_nfiles;
++DRV_file_index)
{
if (idl_global->multi_file_input ())
{
ACE_OS::fprintf (output_file,
"#include \"%s\"\n",
DRV_files[DRV_file_index]);
}
else
{
DRV_drive (DRV_files[DRV_file_index]);
}
}
if (idl_global->multi_file_input ())
{
ACE_OS::fclose (output_file);
DRV_drive (idl_global->big_file_name ());
ACE_OS::unlink (idl_global->big_file_name ());
}
}
catch (Bailout)
{
// Incrementing here may be redundant, but the error count
// is the exit value, and we want to make sure it isn't 0
// if there was in fact an error. If a non-zero value is
// off by 1, it's not so important.
idl_global->set_err_count (idl_global->err_count () + 1);
}
int retval = idl_global->err_count ();
DRV_cleanup ();
return retval;
}
// IDL compiler main program. Logic as explained in comment at head of file.
int driver_main(int argc, char **argv)
{
int ret = 0;
#if defined (_WIN32)
char * cmdstr = DRV_param_copy (argc, argv);
#endif
// Open front-end library
DRV_FE_open ();
// Initialize driver and global variables
{
DRV_init ();
}
// Open back-end library
DRV_BE_open ();
// Parse arguments
DRV_parse_args (argc, argv);
// If a version message is requested, print it and exit
if (idl_global->compile_flags () & IDL_CF_VERSION)
{
DRV_version ();
}
else
{
// If a usage message is requested, give it and exit
if (idl_global->compile_flags () & IDL_CF_ONLY_USAGE)
{
DRV_usage ();
}
else
{
// Fork off a process for each file to process. Fork only if
// there is more than one file to process
if (DRV_nfiles > 1)
{
// DRV_fork never returns
#if !defined (_WIN32)
DRV_fork ();
#else
char tmp_command[1024];
for (int tmpcounter = 0; tmpcounter < DRV_nfiles; tmpcounter++)
{
os_sprintf(tmp_command, "%s %s\0", cmdstr, DRV_files[tmpcounter]);
_flushall ();
if (system (tmp_command))
{
cerr << "system() failed, errno: " << errno << endl;
}
}
#endif
}
else
{
// Do the one file we have to parse
// Check if stdin and handle file name appropriately
if (DRV_nfiles == 0)
{
DRV_files[0] = "standard input";
}
DRV_file_index = 0;
ret = DRV_drive (DRV_files[DRV_file_index]);
}
}
}
return ret;
}
int DRV_faceDetectTestMain(int argc, char **argv)
{
int status, i, count=1;
Uint32 readSize;
Uint8 *inBufVirtAddr=NULL;
static DRV_FaceDetectRunStatus faceStatus;
DRV_FaceDetectRunPrm facePrm;
OSA_PrfHndl prfFd;
status = DRV_init();
if(status!=OSA_SOK)
return status;
OSA_prfReset(&prfFd);
facePrm.inWidth = 320;
facePrm.inHeight = 240;
facePrm.detectThres = 4;
facePrm.detectCondition = DRV_FACE_DETECT_CONDITION_DEFAULT;
inBufVirtAddr = OSA_cmemAlloc(facePrm.inWidth*facePrm.inHeight, 32);
facePrm.inPhysAddr = OSA_cmemGetPhysAddr(inBufVirtAddr);
if(inBufVirtAddr==NULL||facePrm.inPhysAddr==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
goto error_exit;
}
status = OSA_fileReadFile("videoQVGA.yuv420", inBufVirtAddr, facePrm.inWidth*facePrm.inHeight,0, &readSize);
if(status!=OSA_SOK)
goto error_exit;
status = DRV_faceDetectOpen();
if(status!=OSA_SOK)
goto error_exit;
OSA_prfBegin(&prfFd);
for(i=0;i<count; i++)
status = DRV_faceDetectRun(&facePrm, &faceStatus);
OSA_prfEnd(&prfFd, count);
OSA_prfPrint(&prfFd, "Face Detect", 0);
if(status==OSA_SOK) {
OSA_printf(" \n");
OSA_printf(" %d Face(s) detected\n", faceStatus.numFaces);
OSA_printf(" \n");
for(i=0; i<faceStatus.numFaces; i++) {
OSA_printf(" #%2d : centre(X,Y) = (%3d,%3d), angle = %3d, size = %d, confidence = %d \n",
1+i,
faceStatus.info[i].centerX,
faceStatus.info[i].centerY,
faceStatus.info[i].angle,
CSL_FACE_DETECT_GET_SIZE(faceStatus.info[i].sizeConfidence),
CSL_FACE_DETECT_GET_CONFIDENCE(faceStatus.info[i].sizeConfidence)
);
}
OSA_printf("\n");
} else {
OSA_printf(" FD: ERROR: Face detect could not complete, it timed out !!!\n")
}
DRV_faceDetectClose();
error_exit:
if(inBufVirtAddr)
OSA_cmemFree(inBufVirtAddr);
DRV_exit();
return status;
}
int DRV_reszTestMain(int argc, char **argv)
{
int status;
Uint8 *inVirtAddr=NULL, *inPhysAddr, *outVirtAddr[2]={NULL, NULL}, *outPhysAddr[2];
OSA_PrfHndl prfResz;
int i, count=10000;
Uint32 size=1*MB, fileSize;
DRV_ReszRunPrm prm;
DRV_ReszOutPrm outPrm[2];
status = DRV_init();
if(status!=OSA_SOK)
return status;
OSA_prfReset(&prfResz);
inVirtAddr = OSA_cmemAlloc(size, 32);
outVirtAddr[0] = OSA_cmemAlloc(size, 32);
outVirtAddr[1] = OSA_cmemAlloc(size, 32);
inPhysAddr = OSA_cmemGetPhysAddr(inVirtAddr);
outPhysAddr[0] = OSA_cmemGetPhysAddr(outVirtAddr[0]);
outPhysAddr[1] = OSA_cmemGetPhysAddr(outVirtAddr[1]);
if( inVirtAddr==NULL || outVirtAddr[0] == NULL || outVirtAddr[1] == NULL
|| inPhysAddr==NULL || outPhysAddr[0] == NULL || outPhysAddr[1] == NULL
) {
OSA_ERROR("OSA_cmemAlloc()\n");
goto error_exit;
}
#if 0
memset(outVirtAddr[0], 0xAA, size);
memset(outVirtAddr[1], 0xAA, size);
#endif
#if 0
status = OSA_fileReadFile("video.yuv420", inVirtAddr, size, &fileSize);
if(status!=OSA_SOK) {
OSA_ERROR("OSA_fileReadFile()\n");
goto error_exit;
}
#endif
OSA_printf(" inAddr=%x, outAddr[0]=%x outAddr[1]=%x\n", (Uint32)inPhysAddr, (Uint32)outPhysAddr[0], (Uint32)outPhysAddr[1] );
prm.inType = DRV_DATA_FORMAT_YUV422 | DRV_DATA_FORMAT_INTERLACED;
prm.inPhysAddr = inPhysAddr;
prm.inVirtAddr = inVirtAddr;
prm.inStartX = 0;
prm.inStartY = 0;
prm.inWidth = 352;
prm.inHeight = 240;
prm.inOffsetH= OSA_align(prm.inWidth, 16);
prm.inOffsetV= prm.inHeight;
prm.enableInvAlaw = FALSE;
prm.enableInvDpcm = FALSE;
prm.clkDivM = 10;
prm.clkDivN = 80;
prm.pOut[0] = NULL;
prm.pOut[1] = NULL;
prm.pOut[0] = &outPrm[0];
//prm.pOut[1] = &outPrm[1];
outPrm[0].outType = DRV_DATA_FORMAT_YUV420;
outPrm[0].flipH = FALSE;
outPrm[0].flipV = FALSE;
outPrm[0].outPhysAddr = outPhysAddr[0];
outPrm[0].outVirtAddr = outVirtAddr[0];
outPrm[0].outWidth = 352;
outPrm[0].outHeight = 240;
outPrm[0].outOffsetH = OSA_align(outPrm[0].outWidth, 32);
outPrm[0].outOffsetV = outPrm[0].outHeight;
outPrm[1].outType = outPrm[0].outType;
outPrm[1].flipH = outPrm[0].flipH;
outPrm[1].flipV = outPrm[0].flipV;
outPrm[1].outPhysAddr = outPhysAddr[1];
outPrm[1].outVirtAddr = outVirtAddr[1];
outPrm[1].outWidth = 352;
outPrm[1].outHeight = 240;
outPrm[1].outOffsetH = OSA_align(outPrm[1].outWidth, 32);
outPrm[1].outOffsetV = outPrm[1].outHeight;
#ifdef DRV_RESZ_TEST_IPIPE
{
DRV_IpipeConfig ipipeConfig;
ipipeConfig.sensorMode = DRV_IMGS_SENSOR_MODE_720x480;
ipipeConfig.inputSrc = DRV_IPIPE_INPUT_SRC_DDR;
ipipeConfig.boxcarBlockSize = DRV_IPIPE_BOXCAR_BLOCK_SIZE_NONE;
ipipeConfig.histogramMode = DRV_IPIPE_HISTO_MODE_NONE;
ipipeConfig.bscNumVectorsRow = 0;
ipipeConfig.bscNumVectorsCol = ipipeConfig.bscNumVectorsRow;
ipipeConfig.rszValidDataStartOffset = 0;
ipipeConfig.rszOutConfig[0].enable = FALSE;
ipipeConfig.rszOutConfig[0].outFormat = outPrm[0].outType;
ipipeConfig.rszOutConfig[0].width = outPrm[0].outWidth;
ipipeConfig.rszOutConfig[0].height = outPrm[0].outHeight;
ipipeConfig.rszOutConfig[0].flipH = FALSE;
ipipeConfig.rszOutConfig[0].flipV = FALSE;
ipipeConfig.rszOutConfig[0].numBuf = 0;
ipipeConfig.rszOutConfig[1].enable = FALSE;
ipipeConfig.rszOutConfig[1].outFormat = outPrm[1].outType;
ipipeConfig.rszOutConfig[1].width = outPrm[1].outWidth;
ipipeConfig.rszOutConfig[1].height = outPrm[1].outHeight;
ipipeConfig.rszOutConfig[1].flipH = FALSE;
ipipeConfig.rszOutConfig[1].flipV = FALSE;
ipipeConfig.rszOutConfig[1].numBuf = 0;
status = DRV_ipipeOpen(&ipipeConfig);
}
#endif
OSA_prfBegin(&prfResz);
for(i=0;i<count; i++)
status = DRV_reszRun(&prm);
OSA_prfEnd(&prfResz, count);
#ifdef DRV_RESZ_TEST_IPIPE
DRV_ipipeClose();
#endif
if(status!=OSA_SOK) {
OSA_ERROR("DRV_reszRun()\n");
goto error_exit;
}
OSA_prfPrint(&prfResz, "Resz", 0);
#if 0
if(prm.pOut[0]) {
OSA_printf(" Writing size=(%dx%d) offset=(%dx%d)\n", outPrm[0].outWidth, outPrm[0].outHeight, outPrm[0].outOffsetH, outPrm[0].outOffsetV);
fileSize = outPrm[0].outOffsetH*outPrm[0].outOffsetV*2;
status = OSA_fileWriteFile("output0.yuv", outVirtAddr[0], fileSize);
if(status!=OSA_SOK) {
goto error_exit;
}
}
if(prm.pOut[1]) {
OSA_printf(" Writing size=(%dx%d) offset=(%dx%d)\n", outPrm[1].outWidth, outPrm[1].outHeight, outPrm[1].outOffsetH, outPrm[1].outOffsetV);
fileSize = outPrm[1].outOffsetH*outPrm[1].outOffsetV*2;
status = OSA_fileWriteFile("output1.yuv", outVirtAddr[1], fileSize);
if(status!=OSA_SOK) {
goto error_exit;
}
}
#endif
error_exit:
if(inVirtAddr)
OSA_cmemFree(inVirtAddr);
if(outVirtAddr[0])
OSA_cmemFree(outVirtAddr[0]);
if(outVirtAddr[1])
OSA_cmemFree(outVirtAddr[1]);
status = DRV_exit();
return status;
}
int DRV_isifTestMain(int argc, char **argv)
{
int status;
DRV_ImgsConfig imgsConfig;
DRV_IsifConfig isifConfig;
OSA_attachSignalHandler(SIGINT, DRV_isifTestSignalHandler);
status = DRV_init();
if(status!=OSA_SOK)
return status;
imgsConfig.sensorMode = DRV_IMGS_SENSOR_MODE_720x480;//add by sxh 1115
imgsConfig.binEnable = FALSE;
imgsConfig.fps = 30;//add by sxh 1115
isifConfig.sensorMode = imgsConfig.sensorMode;
isifConfig.alawEnable = FALSE;
isifConfig.dpcmEnable = FALSE;
isifConfig.numBuf = DRV_ISIF_TEST_NUM_BUF;
isifConfig.numLscBuf = 0;//add by sxh 1114
OSA_printf(" ISIF: Opening imager.\n");
status = DRV_imgsOpen(&imgsConfig);
if(status!=OSA_SOK)
goto error_exit;
OSA_printf(" ISIF: Opening ISIF.\n");
status = DRV_isifOpen(&isifConfig);
if(status!=OSA_SOK)
goto isif_exit;
DRV_isifGetInfo(&gDRV_isifInfo);
OSA_printf("Isif Info,\n");
OSA_printf("Width = %d\n", gDRV_isifInfo.ddrOutDataWidth);
OSA_printf("Height = %d\n", gDRV_isifInfo.ddrOutDataHeight);
OSA_printf("Line Offset H = %d\n", gDRV_isifInfo.ddrOutDataOffsetH);
OSA_printf("\n");
DRV_isifOutEnable(TRUE);
OSA_printf(" ISIF: Starting ISIF.\n");
DRV_isifEnable(TRUE);
OSA_printf(" ISIF: Starting imager.\n");
DRV_imgsEnable(TRUE);
DRV_isifWaitInt(DRV_ISIF_INT_VD0, 2);
OSA_printf(" ISIF: Running.\n");
status=OSA_SOK;
while(!gDRV_isifTestQuit && status==OSA_SOK)
status = DRV_isifTestRun();
OSA_printf(" ISIF: Stoping ISIF.\n");
DRV_isifOutEnable(FALSE);
DRV_isifWaitInt(DRV_ISIF_INT_VD0, 2);
DRV_isifEnable(FALSE);
OSA_printf(" ISIF: Stoping imager.\n");
DRV_imgsEnable(FALSE);
OSA_printf(" ISIF: Closing ISIF.\n");
DRV_isifClose();
isif_exit:
OSA_printf(" ISIF: Closing imager.\n");
DRV_imgsClose();
error_exit:
OSA_printf(" ISIF: Exiting.\n");
DRV_exit();
return status;
}
