static __inline void vibrator_onOff(char onOff) { unsigned int arg1, arg2=0; int ret; if(onOff) { arg1 = SMEM_PC_OEM_LED_CTL_VIB_ON; PM_LOG_EVENT(PM_LOG_ON, PM_LOG_VIBRATOR); jiff_vib_on_timeout = jiffies + 5*HZ; } else { arg1 = SMEM_PC_OEM_LED_CTL_VIB_OFF; PM_LOG_EVENT(PM_LOG_OFF, PM_LOG_VIBRATOR); } ret = cust_mproc_comm1(&arg1,&arg2); if(ret != 0) { MSG2("VIB %s: FAIL!", onOff?"ON":"OFF"); jiff_vib_on_timeout = jiffies + 30*24*60*60*HZ; } else { if(onOff == 0) { if(time_after(jiffies, jiff_vib_on_timeout)) MSG2("VIB OFF! Wait more than 5 sec after VIB ON"); jiff_vib_on_timeout = jiffies + 30*24*60*60*HZ; } } }
FILE * findFileInPath(char *name, char *subdir) { register int i; char buf[PATH_MAX]; FILE *fp; if (name[0] == '/') { fp = fopen(name, "r"); if ((verbose > 7) || ((!fp) && (verbose > 0))) MSG2("%s file %s\n", (fp ? "Found" : "Didn't find"), name); return fp; } for (i = 0; (i < numInclPath); i++) { if ((strlen(inclPath[i]) + strlen(subdir) + strlen(name) + 2) > PATH_MAX) { VMSG3(0, "Path too long (%s/%s%s). Ignored.\n", inclPath[i], subdir, name); continue; } sprintf(buf, "%s/%s%s", inclPath[i], subdir, name); fp = fopen(name, "r"); if ((verbose > 7) || ((!fp) && (verbose > 5))) MSG2("%s file %s\n", (fp ? "Found" : "Didn't find"), buf); if (fp != NULL) return fp; } return NULL; }
static FILE * TT_OpenTabFile_(int id) { char *fn,*dir; FILE* f; int l; if ( (dir=getenv("TT_DIR")) == NULL ) dir = TTDir; l = strlen( dir ) + 12 ; /* MSG2("length of TTDir = \"%s\" is %i bytes\n",TTDir,strlen( TTDir ));*/ fn = malloc( l ); /* MSG2("Malloc %i bytes for Filename returns 0x%8.8X\n",l,fn);*/ sprintf(fn,"%s/ROC%2.2i.tab",dir,id); nline = 0; MSG2("Open TT file \"%s\" for id # %i\n",fn,id); if( (f=fopen(fn,"r")) == NULL ) { MSG2("Can't open file \"%s\" for TT # %i ==> FATAL !!!\n",fn,id); free(fn); return (void *)NULL; } free(fn); return (void *)f; }
FILE * findFileInPath(char *name) { register int i; char buf[PATH_MAX]; FILE *fp; if (name[0] == '/') { fp = fopen(name, "r"); if ((verbose > 7) || ((!fp) && (verbose > 0))) MSG2("%s file %s\n", (fp ? "Found" : "Didn't find"), name); return fp; } for (i = 0; (i < inclPath.num); i++) { if (snprintf(buf, PATH_MAX, "%s/%s", inclPath.item[i], name) >= PATH_MAX) { VMSG2(0, "Path too long (%s/%s). Ignored.\n", inclPath.item[i], name); continue; } fp = fopen(buf, "r"); if ((verbose > 7) || ((!fp) && (verbose > 5))) MSG2("%s file %s\n", (fp ? "Found" : "Didn't find"), buf); if (fp != NULL) return fp; } return NULL; }
/** Call by the ens framework when a command port is sending. Note that Enable/Disable port does NOT hit this function */ WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::doSpecificSendCommand(OMX_COMMANDTYPE eCmd, OMX_U32 nData, OMX_BOOL &bDeferredCmd) //************************************************************************************************************* { switch(eCmd) { case OMX_CommandStateSet: // only transition from idle -> execute and execute --> idle are visible!!! MSG3(" %s.SetState( %s=%lu)\n", GetComponentName(), GetStringOmxState(nData), nData); break; case OMX_CommandFlush: MSG2(" %s.Flush(%lu)\n", GetComponentName(), nData); break; case OMX_CommandPortDisable: MSG2("%s.DisablePort(%lu)\n", GetComponentName(), nData); break; case OMX_CommandPortEnable: MSG2("%s.EnablePort(%lu)\n", GetComponentName(), nData); break; case OMX_CommandMarkBuffer: MSG2("%s.MarkBuffer(%lu)\n", GetComponentName(), nData); break; default: MSG3("%s.Unknow specific command %d- %lu\n", GetComponentName(), eCmd, nData); break; } return OMX_ErrorNone; }
SCF_STATE CAM_SM::PowerUp_STC_ReadId(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { ENTRY; MSG0("PowerUp_STC_ReadId-SCF_STATE_ENTRY_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_ReadId-SCF_STATE_ENTRY_SIG", (&mENSComponent)); pIspctlCom->queuePE(Sensor_Tuning_Status_u16_CurrentSubBlockIdValue_Byte0,0); pIspctlCom->readQueue(); return 0; } case EVT_ISPCTL_LIST_INFO_SIG: { MSG0("PowerUp_STC_ReadId-EVT_ISPCTL_LIST_INFO_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_ReadId-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent)); if (e->type.ispctlInfo.info_id != ISP_READLIST_DONE) break; //#if defined (OSI_DEBUG) for(t_uint16 i=0; i < e->type.ispctlInfo.number_of_pe; i++) { MSG3(" PE[%d] %s = 0x%lX\n", i, pSensor->GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data ); //OstTraceFiltStatic3(TRACE_DEBUG, "PE[%d] %s = 0x%lX", (&mENSComponent), i, CXp70::GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data ); } //#endif // Store tuning BlockId value pFwSubBlockId[iCurrentFwSubBlockIndex] = (t_uint16)e->type.ispctlInfo.Listvalue[0].pe_data; MSG2(" FwSubBlockId[%d] = ID%d\n", iCurrentFwSubBlockIndex, pFwSubBlockId[iCurrentFwSubBlockIndex]); OstTraceFiltStatic2(TRACE_DEBUG, "FwSubBlockId[%d] = ID%d", (&mENSComponent), iCurrentFwSubBlockIndex, pFwSubBlockId[iCurrentFwSubBlockIndex]); // Another block to be fetched ? iCurrentFwSubBlockIndex++; if(iCurrentFwSubBlockIndex<iFwSubBlockIdsCount) { // Still some tuning blocks IDs are to be fetched MSG0(" Some blocks ID are to be fetched\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Some blocks ID are to be fetched", (&mENSComponent)); SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_QueryId); } else { // All tuning blocks IDs were fetched MSG1(" All block IDs were fetched: total %d\n", iFwSubBlockIdsCount); OstTraceFiltStatic1(TRACE_DEBUG, "All block IDs were fetched: total %d", (&mENSComponent), iFwSubBlockIdsCount); //#if defined (OSI_DEBUG) for(t_uint16 i=0; i<iFwSubBlockIdsCount; i++) { MSG2(" FwSubBlockId[%d] = ID%d\n", i, pFwSubBlockId[i]); OstTraceFiltStatic2(TRACE_DEBUG, "FwSubBlockId[%d] = ID%d", (&mENSComponent), i, pFwSubBlockId[i]); } //#endif SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_LoadData); } return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CSharpeningDamperLR::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CSharpeningDamperLR::ComputeAndQueuePEs", (mTraceObject)); float pDamperValues[SHARPENING_DAMPERS_LR_NUM] = { 0.0, 0.0}; t_damper_error_code err = DAMPER_OK; float fAdsocGain = 0.0; float fAdsocCoring = 0.0; float fScaleFactor = 0.0; // Evaluate Sharpening dampers err = DoEvaluate( pBaseValues, pDamperValues); if(err!=DAMPER_OK) { DBGT_ERROR("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Compute and queue Adsoc Gain PE (scale against omx config and clip value) fAdsocGain = pDamperValues[SHARPENING_ADSOC_GAIN_LR]; fScaleFactor = (float)iOmxSharpness * iScaleFactorGain + iScaleFactorOffset; MSG1("Scale Factor = %f\n", fScaleFactor); OstTraceFiltStatic1(TRACE_DEBUG, "Scale Factor = %f", (mTraceObject), fScaleFactor); fAdsocGain *= fScaleFactor; if( fAdsocGain < 0.0) { fAdsocGain = 0.0; } else if ( fAdsocGain > 255.0 ) { fAdsocGain = 255.0; } MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Gain_Byte0), fAdsocGain); OstTraceFiltStatic1(TRACE_DEBUG, "Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Gain = %f", (mTraceObject), fAdsocGain); pIspctlCom->queuePE( Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Gain_Byte0, (t_uint32)fAdsocGain); // Compute and queue Adsoc Coring PE fAdsocCoring = pDamperValues[SHARPENING_ADSOC_CORING_LR]; if( fAdsocCoring < 0.0) { fAdsocCoring = 0.0; } else if ( fAdsocCoring > 31.0 ) { fAdsocCoring = 31.0; } MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Coring_Level_Byte0), fAdsocCoring); OstTraceFiltStatic1(TRACE_DEBUG, "Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Coring_Level = %f", (mTraceObject), fAdsocCoring); pIspctlCom->queuePE( Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Coring_Level_Byte0, (t_uint32)fAdsocCoring); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
int output_send_data(char* cmd, OutputModule *output, int wfr) { int ret; GString *response; if (output == NULL) return -1; if (cmd == NULL) return -1; ret = safe_write(output->pipe_in[1], cmd, strlen(cmd)); fflush(NULL); if (ret == -1){ MSG(2, "Error: Broken pipe to module."); output->working = 0; speaking_module = NULL; output_check_module(output); return -1; /* Broken pipe */ } MSG2(5, "output_module", "Command sent to output module: |%s| (%d)", cmd, wfr); if (wfr){ /* wait for reply? */ int ret = 0; response = output_read_reply(output); if (response == NULL) return -1; MSG2(5, "output_module", "Reply from output module: |%s|", response->str); switch (response->str[0]){ case '3': MSG(2, "Error: Module reported error in request from speechd (code 3xx): %s.", response->str); ret = -2; /* User (speechd) side error */ break; case '4': MSG(2, "Error: Module reported error in itself (code 4xx): %s", response->str); ret = -3; /* Module side error */ break; case '2': ret = 0; break; default: /* unknown response */ MSG(3, "Unknown response from output module!"); ret = -3; break; } g_string_free(response, TRUE); return ret; } return 0; }
/* * Size method */ void fileio::size(const char* aFileName, t_uint32* aSizePtr) { ASYNC_IN0(""); FILE* theFile = NULL; // Sanity check if( aFileName == NULL || aSizePtr == NULL) { // bad parameter MSG2("Bad parameter: aFileName=%p, aSizePtr=%p\n", aFileName, aSizePtr); response.fileIoResponse(FILE_IO_BAD_PARAMETER); ASYNC_OUT0(""); return; } // Open the file MSG1("Opening file '%s' for reading\n", aFileName); theFile = fopen( aFileName, "rb"); if(theFile==NULL) { // could not open the file MSG1("File '%s' open failed\n", aFileName); response.fileIoResponse(FILE_IO_OPEN_FAILED); ASYNC_OUT0(""); return; } // Seek to end of file MSG1("Seeking to end of file '%s'\n", aFileName); if( fseek( theFile, 0, SEEK_END) != 0) { // seek failed MSG0("Seek failed"); MSG1("Closing file '%s'\n", aFileName); fclose(theFile); response.fileIoResponse(FILE_IO_SEEK_FAILED); ASYNC_OUT0(""); return; } // Retrieve file size *aSizePtr = (t_uint32)ftell(theFile); MSG2("File '%s' size %ld\n", aFileName, *aSizePtr); // File size sucessfully retrieved MSG1("Closing file '%s'\n", aFileName); fclose(theFile); response.fileIoResponse(FILE_IO_OK); ASYNC_OUT0(""); return; }
/* * Read method */ void fileio::read(const char* aFileName, void* aDestBuffer, t_uint32 aNumBytes) { ASYNC_IN0(""); FILE* theFile = NULL; size_t readBytesCount = 0; // Sanity check if( aFileName == NULL || aDestBuffer == NULL || aNumBytes == 0) { // bad parameter MSG3("Bad parameter: aFileName=%p aDestBuffer=%p aNumBytes=%ld\n", aFileName, aDestBuffer, aNumBytes); response.fileIoResponse(FILE_IO_BAD_PARAMETER); ASYNC_OUT0(""); return; } // Open the file MSG1("Opening file '%s' for reading\n", aFileName); theFile = fopen( aFileName, "rb"); if(theFile==NULL) { // could not open the file MSG1("File '%s' open failed\n", aFileName); response.fileIoResponse(FILE_IO_OPEN_FAILED); ASYNC_OUT0(""); return; } // Read the file MSG2("Reading %ld bytes from file '%s'\n", aNumBytes, aFileName); readBytesCount = fread( aDestBuffer, 1, (size_t)aNumBytes, theFile); if( readBytesCount != aNumBytes ) { // could not read the file MSG2("Read failed, expected %ld bytes, actually got %d bytes\n", aNumBytes, readBytesCount); MSG1("Closing file '%s'\n", aFileName); fclose(theFile); response.fileIoResponse(FILE_IO_READ_FAILED); ASYNC_OUT0(""); return; } // File sucessfully read MSG1("Closing file '%s'\n", aFileName); fclose(theFile); response.fileIoResponse(FILE_IO_OK); ASYNC_OUT0(""); return; }
SCF_STATE CAM_SM::PowerUp_STC_QueryId(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { ENTRY; // Ask the next block ID and toggle the coin MSG2(" Query Block[%d], coin state=%d\n", iCurrentFwSubBlockIndex, (int)iStatusCoin); OstTraceFiltStatic2(TRACE_DEBUG, " Query Block[%d], coin state=%d", (&mENSComponent), iCurrentFwSubBlockIndex, (int)iStatusCoin); pIspctlCom->queuePE(Sensor_Tuning_Control_u16_SelectedSubBlockIdIndex_Byte0,(t_uint32)iCurrentFwSubBlockIndex); pIspctlCom->queuePE(Sensor_Tuning_Control_e_Coin_SubBlock_Control_Byte0,(t_uint32)(iStatusCoin==Coin_e_Heads ? Coin_e_Tails : Coin_e_Heads)); pIspctlCom->processQueue(); return 0; } case EVT_ISPCTL_LIST_INFO_SIG: { MSG0("PowerUp_STC_QueryId-EVT_ISPCTL_LIST_INFO_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_QueryId-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent)); if (e->type.ispctlInfo.info_id != ISP_WRITELIST_DONE) break; SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_CheckCoin); return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }
void presub(unsigned long from,unsigned long to,stralloc *subject, int factype, /* action type (AC_THREAD,AC_GET,AC_DIGEST) */ char format) /* output format type (see idx.h) */ /* Starts within header, outputs "subject" and optional headers, terminates*/ /* header and handles output before table-of-contents */ { switch(format) { case MIME: case VIRGIN: case NATIVE: case MIXED: hdr_mime((format == MIXED) ? CTYPE_MULTIPART : CTYPE_DIGEST); hdr_add2("Subject: ",subject->s,subject->len); hdr_boundary(0); hdr_ctype(CTYPE_TEXT); hdr_transferenc(); /* content-transfer-enc header if needed */ break; case RFC1153: hdr_mime(CTYPE_TEXT); hdr_add2("Subject: ",subject->s,subject->len); qmail_puts(&qq,"\n"); flagcd = '\0'; /* We make 8-bit messages, not QP/base64 for rfc1153 */ break; /* Since messages themselves aren't encoded */ } if (!stralloc_cats(subject,"\n\n")) die_nomem(); code_qput(subject->s,subject->len); if (format != NATIVE && factype != AC_THREAD && factype != AC_INDEX) { strnum[fmt_ulong(strnum,from)] = 0; strnum2[fmt_ulong(strnum2,to)] = 0; code_qputs(MSG2(TXT_TOP_TOPICS,strnum,strnum2)); } }
/* * tuningloader_fileio write method */ t_fileio_error tuningloader_fileio::write(const void* pSrcBuffer, int aNumBytes) { IN0("\n"); size_t iNumBytesWritten = 0; // Sanity check if( pSrcBuffer == NULL || aNumBytes == 0) { // Bad parameter MSG2("Bad parameter: pSrcBuffer=%p aNumBytes=%d\n", pSrcBuffer, aNumBytes); OUTR(" ", FILEIO_BAD_ARGUMENT); return FILEIO_BAD_ARGUMENT; } if( pFile == NULL) { // File is not open MSG0("File not open\n"); OUTR(" ", FILEIO_FILE_NOT_OPEN); return FILEIO_FILE_NOT_OPEN; } // Write to file iNumBytesWritten = fwrite( pSrcBuffer, 1, (size_t)aNumBytes, pFile); if( iNumBytesWritten != (size_t)aNumBytes ) { // Could not write into file MSG0("Write failed, closing file\n"); OUTR(" ", FILEIO_WRITE_FAILED); return FILEIO_WRITE_FAILED; } // Sucessfully wrote to file OUTR(" ",FILEIO_OK); return FILEIO_OK; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CScorpioDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CScorpioDamper::ComputeAndQueuePEs", (mTraceObject)); float pDampedValues[1] = { 0.0 }; float fCoringLevel = 0.0; t_damper_error_code err = DAMPER_OK; // Evaluate Scorpio dampers err = DoEvaluate( pBaseValues, pDampedValues); if(err!=DAMPER_OK) { DBGT_ERROR("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CScorpioDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Queue the Page Elements list fCoringLevel = pDampedValues[0]; MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(Scorpio_Ctrl_u8_CoringLevel_Ctrl_Byte0), fCoringLevel); OstTraceFiltStatic1(TRACE_DEBUG, "Scorpio_Ctrl_u8_CoringLevel_Ctrl = %f", (mTraceObject), fCoringLevel); pIspctlCom->queuePE( Scorpio_Ctrl_u8_CoringLevel_Ctrl_Byte0, (t_uint32)fCoringLevel); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CScorpioDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/** Return the ExtraData structur associated to given index */ int WRAPPER_OPENMAX_API openmax_processor::GetExtraData(const _tConvertionConfig &Config, const int aStructType, char *&pStruct) //************************************************************************************************************* { #if 0 /* get extradata start pointer */ const OMX_BUFFERHEADERTYPE* pOmxBufHdr=Config.Input.pBufferHdr; OMX_U8* pEnd=pOmxBufHdr->pBuffer + pOmxBufHdr->nAllocLen; OMX_U8* pExtraData = pOmxBufHdr->pBuffer + pOmxBufHdr->nOffset + pOmxBufHdr->nFilledLen; OMX_OTHER_EXTRADATATYPE* pCurExtra = (OMX_OTHER_EXTRADATATYPE*)(((OMX_U32)pExtraData+ 3) & ~0x3); while ( ((OMX_U8*)pCurExtra < pEnd) && (pCurExtra->nSize>0) ) { if( pCurExtra->eType== (OMX_EXTRADATATYPE)aStructType) { //found unsigned int ComputeSize=(pCurExtra->nDataSize + sizeof(OMX_OTHER_EXTRADATATYPE) -1 + 3) &~3; if ( ComputeSize > pCurExtra->nSize) { //Corrupted metadata MSG2("*** CORRUPTED metadata, sizes are not equal %d %d\n", ComputeSize, pCurExtra->nSize); ReportError(eError_CorruptedMetada, "*** CORRUPTED metadata, sizes are not equal %d %d\n", ComputeSize, pCurExtra->nSize); } pStruct=(char *)pCurExtra->data; return(S_OK); } pExtraData +=pCurExtra->nSize; //round pointer pCurExtra = (OMX_OTHER_EXTRADATATYPE*)(((OMX_U32)pExtraData+ 3) & ~0x3); } pStruct=NULL; return(-1); #else return(::GetExtraData(Config.Input.pBufferHdr, aStructType, pStruct)); #endif }
/* * This function sets the OMX setting value */ void CSharpeningDamperLR::SetOmxMapping(float aGain, float aOffset) { iScaleFactorGain = aGain; iScaleFactorOffset = aOffset; MSG2("OMX Mapping: gain=%f, offset=%f\n", iScaleFactorGain, iScaleFactorOffset); OstTraceFiltStatic2(TRACE_DEBUG, "OMX Mapping: gain=%f, offset=%f", (mTraceObject), iScaleFactorGain, iScaleFactorOffset); }
/* * This function launches the loading of the firmware tuning data */ TuningLoaderMgrError_t CTuningLoaderManager::loadFirmwareTuningData(const t_camera_info* pCamInfo, const t_fw_blocks_info* pFwBlocksInfo) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::loadFirmwareTuningData", (mTraceObject)); // Check if constructed if(iNmfInstance == NULL) { MSG0("Instance not constructed\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Instance not constructed", (mTraceObject)); OUTR(" ",TUNING_LOADER_MGR_NOT_CONSTRUCTED); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadFirmwareTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_NOT_CONSTRUCTED); return TUNING_LOADER_MGR_NOT_CONSTRUCTED; } // Aguments sanity check if( pCamInfo == NULL || pFwBlocksInfo == NULL) { MSG2("Bad argument: pCamInfo=%p, pFwBlocksInfo=%p\n", pCamInfo, pFwBlocksInfo); OstTraceFiltStatic2(TRACE_ERROR, "Bad argument: pCamInfo=0x%x, pFwBlocksInfo=0x%x", (mTraceObject), (t_uint32)pCamInfo, (t_uint32)pFwBlocksInfo); OUTR(" ",TUNING_LOADER_MGR_BAD_ARGUMENT); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadFirmwareTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_BAD_ARGUMENT); return TUNING_LOADER_MGR_BAD_ARGUMENT; } // Send command to NMF MSG0("Send 'loadFirmwareTuning' command to NMF\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Send 'loadFirmwareTuning' command to NMF", (mTraceObject)); iNmfQueryIntf.loadFirmwareTuning(*pCamInfo, *pFwBlocksInfo); OUTR(" ",TUNING_LOADER_MGR_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadFirmwareTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_OK); return TUNING_LOADER_MGR_OK; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CDefCorDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CDefCorDamper::ComputeAndQueuePEs", (mTraceObject)); float pDamperValues[DEFCOR_DAMPERS_NUM] = {0.0, 0.0}; t_damper_error_code err = DAMPER_OK; // Evaluate DefCor dampers err = DoEvaluate( pBaseValues, pDamperValues); if(err!=DAMPER_OK) { DBGT_ERROR("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Queue the Page Elements for(int i=0; i<DEFCOR_DAMPERS_NUM; i++) { MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(KDefCorDamperInfo[i].addr), pDamperValues[i]); //OstTraceFiltStatic2(TRACE_DEBUG, "%s = %f", (mTraceObject), CXp70::GetPeName(KDefCorDamperInfo[i].addr), pDamperValues[i]); pIspctlCom->queuePE( KDefCorDamperInfo[i].addr, (t_uint32)pDamperValues[i]); } // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::sendCommand(OMX_COMMANDTYPE eCmd, OMX_U32 nData) //************************************************************************************************************* { //By default just call the base class MSG2("sendCommand %s(%ld)\n", GetStringOmxCommand(eCmd), nData); OMX_ERRORTYPE err=NmfHost_ProcessingComponent::sendCommand(eCmd, nData); return(err); }
WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::fillThisBuffer(OMX_BUFFERHEADERTYPE* pBufferHdr) //************************************************************************************************************* { //By default just call the base class MSG2("::fillThisBuffer sent to Port[%u](BufferHdr=%p)\n", (unsigned int)pBufferHdr->nOutputPortIndex, pBufferHdr); OMX_ERRORTYPE err=NmfHost_ProcessingComponent::fillThisBuffer(pBufferHdr); return(err); }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CNoiseFilterDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CNoiseFilterDamper::ComputeAndQueuePEs", (mTraceObject)); float pDampedValues[1] = { 0.0 }; t_damper_error_code err = DAMPER_OK; // Evaluate Noise Filter dampers err = DoEvaluate( pBaseValues, pDampedValues); if(err!=DAMPER_OK) { DBGT_ERROR("Failed to evaluate damper: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Failed to evaluate damper: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseFilterDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Queue the Page Elements float fGaussianWeightDamped = pDampedValues[0]; MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(DusterControl_u8_GaussianWeight_Byte0), fGaussianWeightDamped); OstTraceFiltStatic1(TRACE_DEBUG, "DusterControl_u8_GaussianWeight = %f", (mTraceObject), fGaussianWeightDamped); pIspctlCom->queuePE( DusterControl_u8_GaussianWeight_Byte0, (t_uint32)fGaussianWeightDamped); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseFilterDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CNoiseModelDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues, const float aAverageDigitalGain) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CNoiseModelDamper::ComputeAndQueuePEs", (mTraceObject)); float pDampedValues[1] = { 0.0 }; float fUserFrameSigma = 0.0; t_damper_error_code err = DAMPER_OK; // Evaluate Noise Model dampers err = DoEvaluate( pBaseValues, pDampedValues); if(err!=DAMPER_OK) { MSG1("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_DEBUG, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseModelDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Scale the damper output by the reference Shading Correction Gain, Average Digital Gain and pipeline dynamic range // NOTE: the damper output is now the noise sigma at pipeline input, normalized to pipeline dynamic range MSG2("iShadingCorrectionGain=%f, aAverageDigitalGain=%f\n", iShadingCorrectionGain, aAverageDigitalGain); OstTraceFiltStatic2(TRACE_DEBUG, "iShadingCorrectionGain=%f, aAverageDigitalGain=%f", (mTraceObject), iShadingCorrectionGain, aAverageDigitalGain); fUserFrameSigma = pDampedValues[0] * iShadingCorrectionGain * aAverageDigitalGain * 4095.0; // Clip against hardware limit if(fUserFrameSigma >= 1024) { fUserFrameSigma = 1024; } // Queue the Page Elements MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(DusterControl_u16_FrameSigma_Byte0), fUserFrameSigma); OstTraceFiltStatic1(TRACE_DEBUG, "DusterControl_u16_FrameSigma = %f", (mTraceObject), fUserFrameSigma); pIspctlCom->queuePE( DusterControl_u16_FrameSigma_Byte0, (t_uint32)fUserFrameSigma); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseModelDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::doSpecificEventHandler_cb(OMX_EVENTTYPE _event, OMX_U32 nData1, OMX_U32 nData2, OMX_BOOL &deferredEvent) //************************************************************************************************************* { IN0("\n"); switch ((unsigned int)_event) { case OMX_EventCmdComplete: if (nData1 == OMX_CommandStateSet) { //Only idle and executing are trapped! MSG3("OMX_EventCmdComplete %s.%s(%s)\n", GetComponentName(), GetStringOmxCommand(nData1), GetStringOmxState(nData2) ); } else // encapsulate OMX_EventPortSettingsChanged & OMX_EventBufferFlag MSG3("OMX_EventCmdComplete %s.%s(%d)\n", GetComponentName(), GetStringOmxCommand(nData1), (int)nData2); break; case OMX_EventError: MSG1("OMX_EventError %ld\n", nData1); break; case OMX_EventMark: MSG0("OMX_EventMark\n"); break; case OMX_EventPortSettingsChanged: MSG1("OMX_EventPortSettingsChanged(%d)\n", (int)nData1); break; case OMX_EventBufferFlag: if(nData2 == OMX_BUFFERFLAG_EOS) { MSG1("OMX_EventBufferFlag('EOS') on port %ld\n", nData1); } else MSG2("OMX_EventBufferFlag(%ld) on port %ld\n", nData2, nData1); break; case OMX_EventResourcesAcquired: MSG0("OMX_EventResourcesAcquired\n"); break; case OMX_EventComponentResumed: MSG0("OMX_EventComponentResumed\n"); break; case OMX_EventDynamicResourcesAvailable: MSG0("OMX_EventDynamicResourcesAvailable\n"); break; case OMX_EventPortFormatDetected: MSG0("OMX_EventPortFormatDetected\n"); break; case OMX_EventIndexSettingChanged: MSG0("OMX_EventIndexSettingChanged\n"); break; case OMX_EventCmdReceived: if (nData1 == OMX_CommandStateSet) { //Only idle and executing are trapped! MSG3("OMX_EventCmdReceived %s.%s(%s)\n", GetComponentName(), GetStringOmxCommand(nData1), GetStringOmxState(nData2) ); } else MSG3("OMX_EventCmdReceived %s.%s(%ld)\n", GetComponentName(), GetStringOmxCommand(nData1), (long)nData2); break; default: MSG3("unknown OMX_Event(%d, %d, %d)\n", _event, (int)nData1, (int)nData2); break; } // Don't send any more this command because it duplicate OMX_EventBufferFlag messages //((OpenMax_Component*)&mENSComponent)->eventHandler(_event, nData1, nData2) ; OUT0("\n"); return OMX_ErrorNone; }
void openmax_processor::fsmInit(fsmInit_t initFsm) //************************************************************************************************************* { //Make the initialisation of ports IN0("\n"); if (initFsm.traceInfoAddr) { setTraceInfo(initFsm.traceInfoAddr, initFsm.id1); } portInformation *pPortInfo; Port *pPort; NMF::InterfaceReference *pInterfaceRef; const size_t NbPorts=GetNbPorts(); for (size_t portIndex=0; portIndex < NbPorts ; ++portIndex) { pPort=GetPort(portIndex); pPortInfo=GetPortInfo(portIndex); pPortInfo->AllocateBufferHeader(); if (pPortInfo->direction== OMX_DirInput) { // for input pInterfaceRef=&mProcessorTemplate.emptybufferdone[portIndex]; // NMF 'return' interface } else { //for output pInterfaceRef=&mProcessorTemplate.fillbufferdone[portIndex]; // NMF 'return' interface } pPort->init(pPortInfo->direction==OMX_DirInput?InputPort: OutputPort, // Direction false /*(bool)pPortInfo->bufferSupplier*/, // Buffer supplier true, // isHWPort ca fait quoi? NULL, // sharingPort pPortInfo->BufferHeaderList, pPortInfo->fifoSize, // bufferCount (FIFO size ) pInterfaceRef, // NMF 'return' interface portIndex, // port index (initFsm.portsDisabled & (1 << portIndex) )?true:false, (initFsm.portsTunneled & (1 << portIndex) )?true:false, this // owner ); MSG4("%s->InitPort(%d) Direction=%d Fifo=%d \n", GetComponentName(), portIndex, pPortInfo->direction, pPortInfo->fifoSize); for (int i=0; i< pPortInfo->fifoSize; ++i) { MSG2("BufferHeader[i]=%p \n", i, pPortInfo->BufferHeaderList[i]); } MSG0("\n"); } init(NbPorts, m_pPort, &proxy /* Event Handler */, &me /* Postevent */, false); //Now call user init UserOpen(); OUT0("\n"); }
/* * Write method */ void fileio::write(const char* aFileName, const void* aSrcBuffer, t_uint32 aNumBytes) { ASYNC_IN0(""); FILE* theFile = NULL; size_t writtenBytesCount = 0; // Sanity check if( aFileName == NULL || aSrcBuffer == NULL || aNumBytes == 0) { // bad parameter MSG3("Bad parameter: aFileName=%p aSrcBuffer=%p aNumBytes=%ld\n", aFileName, aSrcBuffer, aNumBytes); response.fileIoResponse(FILE_IO_BAD_PARAMETER); ASYNC_OUT0(""); return; } // Open the file MSG1("Opening file '%s' for writing\n", aFileName); theFile = fopen( aFileName, "wb"); if(theFile==NULL) { // could not open the file MSG1("File '%s' open failed\n", aFileName); response.fileIoResponse(FILE_IO_OPEN_FAILED); ASYNC_OUT0(""); return; } // Actual write MSG2("Writing %ld bytes to file '%s'\n", aNumBytes, aFileName); writtenBytesCount = fwrite( aSrcBuffer, 1, (size_t)aNumBytes, theFile); if( writtenBytesCount != aNumBytes ) { // could not write into file MSG0("Write failed\n"); MSG1("Closing file '%s'\n", aFileName); fclose(theFile); response.fileIoResponse(FILE_IO_WRITE_FAILED); ASYNC_OUT0(""); return; } // File sucessfully written MSG1("Closing file '%s'\n", aFileName); fclose(theFile); response.fileIoResponse(FILE_IO_OK); ASYNC_OUT0(""); return; }
/* * tuningloader_fileio read method */ t_fileio_error tuningloader_fileio::read(void* pDestBuffer, int aNumBytes) { IN0("\n"); size_t iNumBytesRead = 0; // Sanity check if( pDestBuffer == NULL || aNumBytes == 0) { // Bad parameter MSG2("Bad parameter: pDestBuffer=%p aNumBytes=%d\n", pDestBuffer, aNumBytes); OUTR(" ", FILEIO_BAD_ARGUMENT); return FILEIO_BAD_ARGUMENT; } if( pFile == NULL) { // File is not open MSG0("File not open\n"); OUTR(" ", FILEIO_FILE_NOT_OPEN); return FILEIO_FILE_NOT_OPEN; } // Read the file MSG1("Reading %d bytes from file\n", aNumBytes); iNumBytesRead = fread( pDestBuffer, 1, (size_t)aNumBytes, pFile); if( iNumBytesRead != (size_t)aNumBytes ) { // Could not read the file MSG2("Read failed, expected %d bytes, got %d bytes\n", aNumBytes, iNumBytesRead); OUTR(" ", FILEIO_READ_FAILED); return FILEIO_READ_FAILED; } // File sucessfully read OUTR(" ",FILEIO_OK); return FILEIO_OK; }
char* output_read_reply2(OutputModule *output) { int bytes; char *reply; reply = malloc( 1024 * sizeof(char)); bytes = read(output->pipe_out[0], reply, 1024); reply[bytes] = 0; MSG2(1, "output_module", "2Read: %d bytes: <%s>", bytes, reply); return reply; }
int thzelctc(Process *proc, char * port) { int elem_no = 0; char port_name[100]; char * p = strchr(port, '['); char * q; if (p == 0) strcpy (port_name, port); else { q = strchr(p, ']'); long n = q - p - 1; char no[10]; strncpy(no, p + 1, n); elem_no = atoi(no); char * r = port; strncpy (port_name, port, p - r); port_name[p - r] = '\0'; } cp * cpp = proc -> in_cps; while (cpp != 0) { if (0 == strcmp(cpp -> port_name, port_name)){ break; } cpp = cpp -> succ; } if (cpp == 0) { cpp = proc -> out_cps; while (cpp != 0) { if (0 == strcmp(cpp -> port_name, port_name)){ break; } cpp = cpp -> succ; } if (cpp == 0) { MSG2 ("%s Port %s not found\n", proc -> procname, port_name); return -1; } } return cpp -> elem_count; }
/* * Open a file */ t_fileio_error tuningloader_fileio::open(const char* pFileName, t_fileio_mode aFileIoMode) { IN0("\n"); const char* pOpenMode = aFileIoMode==FILEIO_MODE_READ_ONLY ? "rb" : "wb"; // Close file in case previous one is still open if(pFile!=NULL) { MSG0("Attempting to open a new file without having closed previous one\n"); OUTR(" ",FILEIO_FILE_NOT_CLOSED); return FILEIO_FILE_NOT_CLOSED; } // Open file MSG2("Opening file (%s only) '%s'\n", aFileIoMode==FILEIO_MODE_READ_ONLY?"read":"write", pFileName); pFile = fopen( pFileName, pOpenMode); if(pFile==NULL) { MSG0("Failed to open file\n"); OUTR(" ",FILEIO_OPEN_FAILED); return FILEIO_OPEN_FAILED; } // File sucessfully open snprintf(iFullyQualifiedFileName, sizeof(iFullyQualifiedFileName), "%s", pFileName); if(aFileIoMode==FILEIO_MODE_READ_ONLY) { // File open in "read only" mode: retrieve file size if( fseek( pFile, 0, SEEK_END) != 0) { // Seek failed MSG0("Failed to seek to end of file, aborting\n"); close(); OUTR(" ", FILEIO_SEEK_FAILED); return FILEIO_SEEK_FAILED; } iFileSize = (int)ftell(pFile); (void)fseek(pFile, 0, SEEK_SET); } MSG1("File sucessfully open, size=%d\n", iFileSize); OUTR(" ", FILEIO_OK); return FILEIO_OK; }
camSharedMemError_t CCamSharedMemory::cacheClean(camSharedMemChunkId_t chunkId) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::cacheClean", (mTraceObject)); if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_STATE); return CAM_SHARED_MEM_ERR_BAD_STATE; } if (chunkId >= CAM_SHARED_MEM_CHUNK_MAX) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PARAMETER); return CAM_SHARED_MEM_ERR_BAD_PARAMETER; } #ifndef CAM_SHARED_MEM_DEBUG /* Exceptionally allow cleaning before the chunk has been requested. For memory debug purpose. */ if (! abBusyChunks[chunkId]) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION); return CAM_SHARED_MEM_ERR_BAD_PRECONDITION; } #endif /* CAM_SHARED_MEM_DEBUG */ OMX_U32 aPhysAddr; // out /* OMX_ERRORTYPE e_ret = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncBeforeReadHwOperation, * After the switch to the 2.6.35 kernel version, MMHwBuffer cache synchronization has changed * (switch from pmem to hwmem driver), with an impact on the API => sync before read AND before write are mandatory. */ OMX_ERRORTYPE e_ret1 = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncBeforeReadHwOperation, (OMX_U32) aChunks[chunkId].armLogicalAddress, aChunks[chunkId].size, aPhysAddr); OMX_ERRORTYPE e_ret2 = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncBeforeWriteHwOperation, (OMX_U32) aChunks[chunkId].armLogicalAddress, aChunks[chunkId].size, aPhysAddr); if ((e_ret1 != OMX_ErrorNone) || (e_ret2 != OMX_ErrorNone)){ MSG2("Problem cleaning data cache (err=%d);%d\n", e_ret1, e_ret2); OstTraceFiltStatic2(TRACE_DEBUG, "Problem cleaning data cache (err=%d);%d", (mTraceObject), e_ret1, e_ret2); OUT0(""); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NO_RESOURCE); return CAM_SHARED_MEM_ERR_NO_RESOURCE; } OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE); return CAM_SHARED_MEM_ERR_NONE; }