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