cam_flash_err_e CFlashSequencer::startSeq(sequenceID_t sequence, CFlashController *pController, flashSeqClbk_t pClbk, flashSeqClbkCtxtHnd_t ctxtHnd) {
IN0("\n");
if (pController == NULL) { // Error: a valid controller handle must be passed.
OUT0("\n");
return CAM_FLASH_ERR_BAD_PARAMETER;
}
if (curSeq != NONE_SEQ) { // A running sequence cannot be interrupted
OUT0("\n");
return CAM_FLASH_ERR_BAD_PRECONDITION;
}
curSeq = sequence;
switch (sequence) {
case NONE_SEQ:
i32_remSteps = 0;
break;
case RED_EYE_REMOVAL_SEQ:
i32_remSteps = sizeof(a_RER_sequence) / sizeof(cam_flashSeq_atom_t);
break;
case PRIVACY_SEQ:
i32_remSteps = sizeof(a_PI_sequence) / sizeof(cam_flashSeq_atom_t);
break;
}
mController = pController;
mpClbk = pClbk;
mctxtHnd = ctxtHnd;
sigTimer(); // To be called after delay by the chosen timing service.
OUT0("\n");
return CAM_FLASH_ERR_NONE;
}
void Dbrown_next(Dbrown *unit, int inNumSamples)
{
if (inNumSamples) {
float lo = DEMANDINPUT_A(1, inNumSamples); if(!sc_isnan(lo)) { unit->m_lo = lo; }
float hi = DEMANDINPUT_A(2, inNumSamples); if(!sc_isnan(hi)) { unit->m_hi = hi; }
float step = DEMANDINPUT_A(3, inNumSamples); if(!sc_isnan(step)) { unit->m_step = step; }
if (unit->m_repeats < 0.) {
float x = DEMANDINPUT_A(0, inNumSamples);
unit->m_repeats = sc_isnan(x) ? 0.f : floor(x + 0.5f);
unit->m_val = unit->mParent->mRGen->frand() * (unit->m_hi - unit->m_lo) + unit->m_lo;
}
if (unit->m_repeatCount >= unit->m_repeats) {
OUT0(0) = NAN;
return;
}
unit->m_repeatCount++;
OUT0(0) = unit->m_val;
float x = unit->m_val + unit->mParent->mRGen->frand2() * unit->m_step;
unit->m_val = sc_fold(x, unit->m_lo, unit->m_hi);
} else {
unit->m_repeats = -1.f;
unit->m_repeatCount = 0;
}
}
void Dswitch_next(Dswitch *unit, int inNumSamples)
{
int index;
float ival;
if (inNumSamples) {
float val = DEMANDINPUT_A(unit->m_index, inNumSamples);
//printf("index: %i\n", (int) val);
if(sc_isnan(val)) {
ival = DEMANDINPUT_A(0, inNumSamples);
if(sc_isnan(ival)) {
OUT0(0) = ival;
return;
}
index = (int32)floor(ival + 0.5f);
index = sc_wrap(index, 0, unit->mNumInputs - 2) + 1;
val = DEMANDINPUT_A(unit->m_index, inNumSamples);
RESETINPUT(unit->m_index);
// printf("resetting index: %i\n", unit->m_index);
unit->m_index = index;
}
OUT0(0) = val;
} else {
printf("...\n");
for (int i=0; i<unit->mNumInputs; ++i) {
RESETINPUT(i);
}
index = (int32)floor(DEMANDINPUT(0) + 0.5f);
index = sc_wrap(index, 0, unit->mNumInputs - 1) + 1;
unit->m_index = index;
}
}
void Dstutter_next(Dstutter *unit, int inNumSamples)
{
if (inNumSamples) {
if (unit->m_repeatCount >= unit->m_repeats) {
float val = DEMANDINPUT_A(1, inNumSamples);
float repeats = DEMANDINPUT_A(0, inNumSamples);
if(sc_isnan(repeats) || sc_isnan(val)) {
OUT0(0) = NAN;
return;
} else {
unit->m_value = val;
unit->m_repeats = floor(repeats + 0.5f);
unit->m_repeatCount = 0.f;
}
}
OUT0(0) = unit->m_value;
unit->m_repeatCount++;
} else {
unit->m_repeats = -1.f;
unit->m_repeatCount = 0.f;
RESETINPUT(0);
RESETINPUT(1);
}
}
camSharedMemError_t CCamSharedMemory::getChunk(camSharedMemChunk_t *pChunk, camSharedMemChunkId_t chunkId)
{
IN0("\n");
OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::getChunk", (mTraceObject));
if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) {
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%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::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PARAMETER);
return CAM_SHARED_MEM_ERR_BAD_PARAMETER;
}
if (abBusyChunks[chunkId]) {
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION);
return CAM_SHARED_MEM_ERR_BAD_PRECONDITION;
}
abBusyChunks[chunkId] = true;
*pChunk = aChunks[chunkId];
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE);
return CAM_SHARED_MEM_ERR_NONE;
}
camSharedMemError_t CCamSharedMemory::cacheInvalidate(camSharedMemChunkId_t chunkId)
{
IN0("\n");
OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::cacheInvalidate", (mTraceObject));
if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) {
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%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::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PARAMETER);
return CAM_SHARED_MEM_ERR_BAD_PARAMETER;
}
if (! abBusyChunks[chunkId]) {
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION);
return CAM_SHARED_MEM_ERR_BAD_PRECONDITION;
}
// Flush the data that have been written by the ISP FW
OMX_U32 aPhysAddr; // out
OMX_ERRORTYPE e_ret = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncAfterWriteHwOperation,
(OMX_U32) aChunks[chunkId].armLogicalAddress,
aChunks[chunkId].size, aPhysAddr);
if (e_ret != OMX_ErrorNone) {
MSG1("Problem invalidating data cache (err=%d)\n", e_ret);
OstTraceFiltStatic1(TRACE_DEBUG, "Problem invalidating data cache (err=%d)", (mTraceObject), e_ret);
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NO_RESOURCE);
return CAM_SHARED_MEM_ERR_NO_RESOURCE;
}
OUT0("\n");
OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE);
return CAM_SHARED_MEM_ERR_NONE;
}
void Dibrown_next(Dibrown *unit, int inNumSamples)
{
if (inNumSamples) {
float lo = DEMANDINPUT_A(1, inNumSamples); if(!sc_isnan(lo)) { unit->m_lo = (int32)lo; }
float hi = DEMANDINPUT_A(2, inNumSamples); if(!sc_isnan(hi)) { unit->m_hi = (int32)hi; }
float step = DEMANDINPUT_A(3, inNumSamples); if(!sc_isnan(step)) { unit->m_step = (int32)step; }
if (unit->m_repeats < 0.) {
float x = DEMANDINPUT_A(0, inNumSamples);
unit->m_repeats = sc_isnan(x) ? 0.f : floor(x + 0.5f);
unit->m_val = unit->mParent->mRGen->irand(unit->m_hi - unit->m_lo + 1) + unit->m_lo;
}
if (unit->m_repeatCount >= unit->m_repeats) {
OUT0(0) = NAN;
return;
}
OUT0(0) = unit->m_val;
int32 z = unit->m_val + unit->mParent->mRGen->irand2(unit->m_step);
unit->m_val = sc_fold(z, unit->m_lo, unit->m_hi);
} else {
unit->m_repeats = -1.f;
unit->m_repeatCount = 0;
}
}
void Dbufrd_next(Dbufrd *unit, int inNumSamples)
{
int32 loop = (int32)DEMANDINPUT_A(2, inNumSamples);
D_GET_BUF_SHARED
D_CHECK_BUF
double loopMax = (double)(loop ? bufFrames : bufFrames - 1);
double phase;
if (inNumSamples)
{
float x = DEMANDINPUT_A(1, inNumSamples);
if (sc_isnan(x)) {
OUT0(0) = NAN;
return;
}
phase = x;
phase = sc_loop((Unit*)unit, phase, loopMax, loop);
int32 iphase = (int32)phase;
const float* table1 = bufData + iphase * bufChannels;
OUT0(0) = table1[0];
}
else
{
RESETINPUT(1);
}
}
void Diwhite_next(Diwhite *unit, int inNumSamples)
{
if (inNumSamples) {
float lo = DEMANDINPUT_A(1, inNumSamples);
float hi = DEMANDINPUT_A(2, inNumSamples);
if(!sc_isnan(lo)) { unit->m_lo = (int32)floor(DEMANDINPUT_A(1, inNumSamples) + 0.5f); }
if(!sc_isnan(hi)) {
int32 hi = (int32)floor(DEMANDINPUT_A(2, inNumSamples) + 0.5f);
unit->m_range = hi - unit->m_lo + 1;
}
if (unit->m_repeats < 0.) {
float x = DEMANDINPUT_A(0, inNumSamples);
unit->m_repeats = sc_isnan(x) ? 0.f : floor(x + 0.5f);
}
if (unit->m_repeatCount >= unit->m_repeats) {
OUT0(0) = NAN;
return;
}
unit->m_repeatCount++;
float x = unit->mParent->mRGen->irand(unit->m_range) + unit->m_lo;
OUT0(0) = x;
} else {
unit->m_repeats = -1.f;
unit->m_repeatCount = 0;
}
}
void DbufTag_end(DbufTag *unit, int which_case, int inNumSamples) {
int recycle = (int) DEMANDINPUT_A(dtag_recycle, inNumSamples);
int mode = (int) IN0(dtag_mode);
if(which_case == 0) {
DbufTag_reset(unit, recycle, inNumSamples);
if(mode == 4) {
printf("tag system was reset externally.\n");
if(recycle) {
printf("recycling. axiom length: %d\n", recycle);
}
}
return;
}
if((mode == 0) || (mode == which_case)) {
if(recycle) {
DbufTag_reset(unit, recycle, inNumSamples);
} else {
OUT0(0) = NAN;
}
return;
}
if(mode >= 4) {
printf("tag system halt: ");
if(which_case == 1) {
printf("divergence too large (buffer filled up).\n");
} else {
printf("terminated (string empty)\n");
}
if(recycle) {
printf("recycling. axiom length: %d\n", recycle);
//printf("new axiom:\n"); // todo.
DbufTag_reset(unit, recycle, inNumSamples);
GET_BUF
printf("new axiom (index %ld..%ld): ", unit->m_read_pos, unit->m_write_pos);
int32 n = unit->m_write_pos - unit->m_read_pos;
if(n < 0) {
n = sc_wrap(n, 0, bufFrames - 1);
}
for(int32 i=0; i < n; i++) {
int32 j = sc_wrap(unit->m_read_pos + i, 0, bufFrames - 1);
printf("%d ", (int)bufData[j]);
}
printf("\n");
} else {
OUT0(0) = NAN;
}
return;
}
OUT0(0) = NAN;
}
void MedianSeparation_Ctor( MedianSeparation* unit ) {
//fft, fftharmonic, fftpercussive, fftsize, mediansize=17, hardorsoft=0, p=1
//IFFT needs to know what it is operating on
OUT0(0) = ZIN0(1); //-1;
OUT0(1) = ZIN0(2);
unit->fftsize_ = ZIN0(3); //so can set things up in constructor, rather than later on
unit->mediansize_ = ZIN0(4); //default 17, may cause trouble otherwise?
//printf("MedianSeparation starting %d %d \n",unit->fftsize_,unit->mediansize_);
if(unit->mediansize_<3)
unit->mediansize_ = 17;
unit->midpoint_ = unit->mediansize_/2;
unit->fftbins_ = (unit->fftsize_/2) +1; //actually /2 + 1 but polar form has separate packed dc and nyquist
unit->magnitudeposition_= 0;
unit->phaseposition_= 0;
//separate storage
unit->magnitudes_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->mediansize_ * unit->fftbins_);
unit->phases_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* (unit->midpoint_+1) * unit->fftbins_); //only store half data since only need phases for midpoint about to output; this necessitates holding midpoint+1 values (to include just arrived)
//float * data_; //2D grid
//zero out all magnitudes and phases
int i;
for (i=0; i<unit->mediansize_ * unit->fftbins_; ++i)
unit->magnitudes_[i] = 0.0f;
for (i=0; i<(unit->midpoint_+1) * unit->fftbins_; ++i)
unit->phases_[i] = 0.0f;
unit->collection_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->mediansize_); //reusable array for sorting and finding median
unit->horizontalmedians_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->fftbins_);
unit->verticalmedians_ = (float *) RTAlloc(unit->mWorld, sizeof(float)* unit->fftbins_);
//need to go a step at a time over the vertical, horizontal sort and the eventual output (so takes four blocks to calculate, FFT must be at least 256)
unit->amortisationstep_=0;
SETCALC(MedianSeparation_next);
}
void Dshuf_next(Dshuf *unit, int inNumSamples)
{
// Print("->Dshuf_next %d\n", inNumSamples);
if (inNumSamples) {
//Print(" unit->m_repeats %d\n", unit->m_repeats);
if (unit->m_repeats < 0.) {
float x = DEMANDINPUT_A(0, inNumSamples);
unit->m_repeats = sc_isnan(x) ? 0.f : floor(x + 0.5f);
}
while (true) {
//Print(" unit->m_index %d unit->m_repeatCount %d\n", unit->m_index, unit->m_repeatCount);
if (unit->m_index >= (unit->mNumInputs - 1)) {
unit->m_index = 0;
unit->m_repeatCount++;
}
if (unit->m_repeatCount >= unit->m_repeats) {
//Print("done\n");
OUT0(0) = NAN;
unit->m_index = 0;
return;
}
if (ISDEMANDINPUT(unit->m_indices[unit->m_index])) {
if (unit->m_needToResetChild) {
unit->m_needToResetChild = false;
RESETINPUT(unit->m_indices[unit->m_index]);
}
float x = DEMANDINPUT_A(unit->m_indices[unit->m_index], inNumSamples);
if (sc_isnan(x)) {
unit->m_index++;
unit->m_needToResetChild = true;
} else {
OUT0(0) = x;
return;
}
} else {
OUT0(0) = DEMANDINPUT_A(unit->m_indices[unit->m_index], inNumSamples);
//Print(" unit->m_index %d OUT0(0) %g\n", unit->m_index, OUT0(0));
unit->m_index++;
unit->m_needToResetChild = true;
return;
}
}
} else {
unit->m_repeats = -1.f;
unit->m_repeatCount = 0;
unit->m_needToResetChild = true;
unit->m_index = 0;
Dshuf_scramble(unit);
}
}
void Donce_next(Donce *unit, int inNumSamples)
{
if (inNumSamples) {
if (unit->m_bufcounter == unit->mWorld->mBufCounter) {
OUT0(0) = unit->m_prev;
} else {
float x = DEMANDINPUT_A(0, inNumSamples);
unit->m_prev = x;
OUT0(0) = x;
}
} else {
RESETINPUT(0);
}
}
cam_flash_err_e CFlashSequencer::cancelSeq() {
IN0("\n");
i32_remSteps = 0;
cam_flash_err_e cam_err = mController->unConfigure();
if (cam_err != CAM_FLASH_ERR_NONE) {
MSG0("Error: Could not un-configure the flash driver.\n");
OUT0("\n");
return CAM_FLASH_ERR_DRIVER;
}
// WARNING: this is valid only if the end of sequence callback implementation can be called from the cancelSeq() caller stack.
sigTimer();
OUT0("\n");
return CAM_FLASH_ERR_NONE;
}
void OpenMax_Component_ConfigCB::setConfig(t_sint32 index, void * opaque_ptr)
//*************************************************************************************************************
{
IN0("\n");
mOMXProxy->setConfigFromProcessing((OMX_INDEXTYPE)index, (OMX_PTR)opaque_ptr);
OUT0("\n");
}
void openmax_processor::processEvent(void)
//*************************************************************************************************************
{// fsm.component.component.type interface posteven method processEvent
IN0("\n");
Component::processEvent();
OUT0("\n");
}
void openmax_processor::sendCommand(OMX_COMMANDTYPE cmd, t_uword param)
//*************************************************************************************************************
{ // fsm.component.component.type interface sendcommand method sendCommand
IN0("\n");
Component::sendCommand(cmd, param) ;
OUT0("\n");
}
void openmax_processor::setParam(t_sint32 portIndex, t_sint32 fifoSize, t_sint32 direction, t_sint32 buffSupplierType, t_sint32 correspondingPortIndex, t_sint32 width, t_sint32 height, t_sint32 colorFormat, t_sint32 stride)
//*************************************************************************************************************
{ //DEfault initialisation of the ports
IN0("\n");
MSG4("portIndex %ld, fifoSize %ld, direction %ld, buffSupplierType%ld\n", portIndex, fifoSize, direction, buffSupplierType);
MSG4("correspondingPortIndex %ld, width %ld, height %ld, colorFormat %ld\n", correspondingPortIndex, width, height, colorFormat);
MSG1("stride %ld\n", stride);
if(portIndex >= (int)GetNbPorts()) // Sanity check
{
MSG0("ERROR in setParam OMX_ErrorBadParameter\n");
OUTR(" Error", OMX_ErrorBadParameter);
return;
}
portInformation*pInfo= GetPortInfo(portIndex);
if (pInfo)
{
pInfo->fifoSize = fifoSize;
pInfo->width = width;
pInfo->height = height;
pInfo->colorFormat = (OMX_COLOR_FORMATTYPE)colorFormat;
pInfo->omxPortIndex = portIndex;
pInfo->stride = stride;
pInfo->direction = (OMX_DIRTYPE) direction;
pInfo->bufferSupplier= buffSupplierType;
pInfo->omxPortIndex = correspondingPortIndex;
}
OUT0("\n");
}
void AnnBasic_next(AnnBasic *unit, int numSamples)
{
unsigned int in_c = sigInCount(unit);
unsigned int out_c = sigOutCount(unit);
AnnDef *def = Ann_GetAnnDef<true>( unit->ann_i, sigInCount(unit), sigOutCount(unit) );
if(!def) {
SETCALC( AnnBasic_idle );
AnnBasic_idle(unit, numSamples);
return;
}
struct fann *ann = def->_ann;
float *in = unit->inputs;
for( int i = 0; i < in_c; ++i )
{
in[i] = IN0(IN_SIG + i);
}
fann_type *out = fann_run( ann, in );
for( int i = 0; i < out_c; ++i )
{
OUT0(i) = out[i];
}
}
OMX_ERRORTYPE MPEG4Enc_ArmNmf_ProcessingComponent::codecConfigure()
{
IN0("");
OUT0("");
return OMX_ErrorNone;
}
int openmax_processor::ReportError(int error, const char *format, ...)
//*************************************************************************************************************
{
IN0("\n");
if (error == eError_NoError)
return(0);
if (m_LastError ==eError_NoError)
m_LastError=error; //Memorize the error
va_list list;
va_start(list, format);
#ifndef __SYMBIAN32__
fprintf (stderr, "\n<Error-%s: %d=0x%X> ", m_pName, error, error);
vfprintf(stderr, format, list);
#else
static char ErrorString[1024];
vsprintf(ErrorString, format, list);
RDebug::Printf("\n<Error-%s: %d=0x%X: %s>", m_pName, error, error, ErrorString);
#endif
va_end(list);
//::ReportError(error, format); // Call global
OUT0("\n");
return(0);
}
void Demand_Ctor(Demand *unit)
{
//Print("Demand_Ctor\n");
if (INRATE(0) == calc_FullRate) {
if (INRATE(1) == calc_FullRate) {
SETCALC(Demand_next_aa);
} else {
SETCALC(Demand_next_ak);
}
} else {
if (INRATE(1) == calc_FullRate) {
SETCALC(Demand_next_ka);
} else {
SETCALC(Demand_next_aa);
}
}
unit->m_prevout = (float*) RTAlloc(unit->mWorld, unit->mNumOutputs * sizeof(float));
unit->m_out = (float**) RTAlloc(unit->mWorld, unit->mNumOutputs * sizeof(float*));
//Print("Demand_Ctor calc %08X\n", unit->mCalcFunc);
unit->m_prevtrig = 0.f;
unit->m_prevreset = 0.f;
for (int i=0; i<unit->mNumOutputs; ++i) {
unit->m_prevout[i] = 0.f;
OUT0(i) = 0.f;
}
}
void CFlashSequencer::sigTimer() {
IN0("\n");
cam_flashSeq_atom_t const *pSeq = NULL;
if (i32_remSteps > 0) { // Some flash action still to be done
switch (curSeq) {
default:
case NONE_SEQ:
DBGT_ERROR("CFlashSequencer::sigTimer - Error: NONE_SEQ cannot be ticked.\n");
OstTraceFiltStatic0(TRACE_ERROR, "CFlashSequencer::sigTimer - Error: NONE_SEQ cannot be ticked.", (mTraceObject));
break;
case RED_EYE_REMOVAL_SEQ:
pSeq = &a_RER_sequence[sizeof(a_RER_sequence) / sizeof(cam_flashSeq_atom_t) - i32_remSteps];
break;
case PRIVACY_SEQ:
pSeq = &a_PI_sequence[sizeof(a_PI_sequence) / sizeof(cam_flashSeq_atom_t) - i32_remSteps];
break;
}
if (NULL != pSeq) {
doAtom(pSeq);
}
i32_remSteps--;
} else { // End of sequence: call the user back if requested, and clean the request.
MSG1("CFlashSequencer::sigTimer - Sequence %d completed.\n", curSeq);
curSeq = NONE_SEQ;
if (mpClbk != NULL) {
mpClbk(mctxtHnd);
mpClbk = NULL;
mctxtHnd = NULL;
}
}
OUT0("\n");
}
void Dreset_next(Dreset *unit, int inNumSamples)
{
if (inNumSamples) {
float x = DEMANDINPUT_A(0, inNumSamples);
float reset = DEMANDINPUT_A(1, inNumSamples);
if(sc_isnan(x)) {
OUT0(0) = NAN;
return;
}
if(reset > 0.0 && (unit->prev_reset <= 0.0)) { RESETINPUT(0); }
unit->prev_reset = reset;
OUT0(0) = x;
} else {
RESETINPUT(0);
}
}
void Dxrand_next(Dxrand *unit, int inNumSamples)
{
if (inNumSamples) {
if (unit->m_repeats < 0.) {
float x = DEMANDINPUT_A(0, inNumSamples);
unit->m_repeats = sc_isnan(x) ? 0.f : floor(x + 0.5f);
}
while (true) {
if (unit->m_index >= unit->mNumInputs) {
unit->m_index = 1;
}
if (unit->m_repeatCount >= unit->m_repeats) {
OUT0(0) = NAN;
return;
}
if (ISDEMANDINPUT(unit->m_index)) {
if (unit->m_needToResetChild) {
unit->m_needToResetChild = false;
RESETINPUT(unit->m_index);
}
float x = DEMANDINPUT_A(unit->m_index, inNumSamples);
if (sc_isnan(x)) {
int newindex = unit->mParent->mRGen->irand(unit->mNumInputs - 2) + 1;
unit->m_index = newindex < unit->m_index ? newindex : newindex + 1;
unit->m_repeatCount++;
unit->m_needToResetChild = true;
} else {
OUT0(0) = x;
return;
}
} else {
OUT0(0) = DEMANDINPUT_A(unit->m_index, inNumSamples);
int newindex = unit->mParent->mRGen->irand(unit->mNumInputs - 2) + 1;
unit->m_index = newindex < unit->m_index ? newindex : newindex + 1;
unit->m_repeatCount++;
unit->m_needToResetChild = true;
return;
}
}
} else {
unit->m_repeats = -1.f;
unit->m_repeatCount = 0;
unit->m_needToResetChild = true;
int newindex = unit->mParent->mRGen->irand(unit->mNumInputs - 2) + 1;
unit->m_index = newindex < unit->m_index ? newindex : newindex + 1;
}
}
cam_flash_err_e CFlashController::unConfigure()
{
IN0("\n");
if (mFlashDriver == NULL) {
DBGT_ERROR("unConfigure: No valid flash driver.\n");
OstTraceFiltStatic0(TRACE_ERROR, "unConfigure: No valid flash driver.", (mTraceObject));
DBC_ASSERT(0);
OUT0("\n");
return CAM_FLASH_ERR_BAD_PRECONDITION;
}
if (mDriverSupportedFlashModes == 0)
{
OUT0("\n");
return CAM_FLASH_ERR_NONE;
}
TFlashReturnCode driver_err = FLASH_RET_NONE;
// User-controlled modes: switch off
if ((FLASH_MODE_INDICATOR == mFlashDriverMode)
|| (FLASH_MODE_AF_ASSISTANT == mFlashDriverMode)
|| (FLASH_MODE_VIDEO_LED == mFlashDriverMode))
{
driver_err = mFlashDriver->Strobe(mFlashDriverMode, false, mFlashDriverCamId);
if (driver_err != FLASH_RET_NONE) {
DBGT_ERROR("unConfigure: Strobe error;\n");
OstTraceFiltStatic0(TRACE_ERROR, "unConfigure: Strobe error;", (mTraceObject));
OUT0("\n");
return CAM_FLASH_ERR_DRIVER;
}
}
// Any mode: un-configure
if (FLASH_MODE_NONE != mFlashDriver)
{
driver_err = mFlashDriver->EnableFlashMode(FLASH_MODE_NONE, NULL, NULL, mFlashDriverCamId);
if (driver_err != FLASH_RET_NONE)
{
DBGT_ERROR("unConfigure: EnableFlashMode error;\n");
OstTraceFiltStatic0(TRACE_ERROR, "unConfigure: EnableFlashMode error;", (mTraceObject));
OUT0("\n");
return CAM_FLASH_ERR_DRIVER;
}
mFlashDriverMode = FLASH_MODE_NONE;
}
OUT0("\n");
return CAM_FLASH_ERR_NONE;
}
void MX_GPIO_Init(void)
{
SET_BIT(RCC->AHBENR, RCC_AHBENR_GPIOAEN | RCC_AHBENR_GPIOBEN | RCC_AHBENR_GPIOFEN);
SET_BIT(RCC->APB2ENR, RCC_APB2ENR_SYSCFGEN);
READ_BIT(RCC->AHBENR, 1); //Delay
OUT1(OneWire_GPIO_Port, ePin::P0);
OUT0(REL2_GPIO_Port, ePin::P0);
OUT0(REL1_GPIO_Port, ePin::P1);
OUT0(P_GPIO_Port, ePin::P6);
/*Configure GPIO pin : OneWire_Pin */
//GPIOF->AFR[0] = GPIOF->AFR[1]=0;
GPIOF->MODER = GPIO_MODER_MODER0_0; //00=Input, 01=Output, 10=AF, 11=Analog
//GPIOF->OSPEEDR=GPIO_SPEED_LOW;
GPIOF->OTYPER=GPIO_OTYPER_OT_0; //0=PuPu, 1=OpenDrain
//GPIOF->PUPDR = GPIO_PUPDR_PUPDR0_0; //00=no, 01=Up, 10=downPullup wird zentral gemacht
SYSCFG->EXTICR[0]=SYSCFG_EXTICR1_EXTI0_PF;
EXTI->IMR=EXTI_IMR_MR0;
EXTI->RTSR=EXTI_RTSR_TR0;
EXTI->FTSR=EXTI_FTSR_TR0;
/*Configure GPIO A*/
GPIOA->MODER=
BMODE(REL2_Pin, ePinMode::OUT) |
BMODE(REL1_Pin, ePinMode::OUT) |
BMODE(ePin::P2, ePinMode::ALT) |
BMODE(ePin::P3, ePinMode::ALT) |
BMODE(IO1_Pin, ePinMode::OUT) |
BMODE(I1_Pin, ePinMode::INP) |
BMODE(P_Pin, ePinMode::OUT) |
BMODE(I2_Pin, ePinMode::INP) |
BMODE(ePin::P9, ePinMode::ALT) |
BMODE(ePin::P10, ePinMode::ALT) |
BMODE(ePin::P13, ePinMode::ALT) |
BMODE(ePin::P14, ePinMode::ALT)
;
GPIOA->PUPDR=0x24000000 | BPULL(I1_Pin, ePull::PULLUP) | BPULL(I2_Pin, ePull::PULLUP);
GPIOB->MODER=BMODE(ePin::P1, ePinMode::INP);
/* EXTI interrupt init*/
HAL_NVIC_SetPriority(EXTI0_1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(EXTI0_1_IRQn);
}
EXPORT_C VFM_NmfMpc_ProcessingComponent::~VFM_NmfMpc_ProcessingComponent()
{
IN0("");
if(mPortPoolid){
delete[] mPortPoolid;
}
OUT0("");
}
void openmax_processor::start(void)
//*************************************************************************************************************
{ //This method is called during Idle to Execute transition
IN0("\n");
// proc_config_FILTER.nAlgoType = 0; // no algo selected
// Don't call m_fn_UserOpen here because port's parameters aren't ready
OUT0("\n");
}
void Dneuromodule_end(Dneuromodule *unit)
{
for(int i = 0; i < unit->m_size; i++) {
OUT0(i) = NAN;
}
}
