void TextVU_Ctor(TextVU* unit)
{
	SETCALC(TextVU_next_kk);

	unit->m_trig = IN0(0);
	unit->m_id = IN0(4); // number of chars in the id string
	unit->m_id_string = (char*)RTAlloc(unit->mWorld, ((int)unit->m_id + 1) * sizeof(char));
	Print("TextVU: string length %g\n", unit->m_id);
	for(int i = 0; i < (int)unit->m_id; i++){
		unit->m_id_string[i] = (char)IN0(5+i);
	};
	unit->m_id_string[(int)unit->m_id] = '\0';

	size_t width = (size_t)std::max(IN0(2), 2.f);
	unit->m_width = width;
	// Now we want to initialise the set of cutoffs, where the first is -60dB and last is 0dB.
	unit->m_cutoffs = (float*)RTAlloc(unit->mWorld, width * sizeof(float));
	unit->m_vustring  = (char*)RTAlloc(unit->mWorld, (width+1) * sizeof(char));
	unit->m_vustring[width] = 0;
	float cutstep = 60.f / (float)(width-1);
	float db = -60.f;
	for(size_t i=0; i<width; ++i){
		// calc cutoffs in amplitude from the db vals
		unit->m_cutoffs[i] = sc_dbamp(db);
		//Print("cutoff %i: %g\n", i, unit->m_cutoffs[i]);
		db += cutstep;
	}
	unit->m_maxinepoch = 0.f;
	unit->m_maxever = 0;

	unit->m_mayprint = unit->mWorld->mVerbosity >= 0;

	TextVU_next_kk(unit, 1);
}

void FeatureSave_next(FeatureSave *unit, int inNumSamples) {

	float trig = IN0(1); //trigger input

	//if trigger and file open 

	//printf("%f %d %d %d \n",trig, unit->fileready_, unit->numfeatures_, trig>(-0.01f));
	//printf("FeatureSave:next sanity check: unit pointer %p \n",unit->mUnitDef); 
	
	if((trig>(-0.01f)) && (unit->fileready_==1)) {
		
		//printf("%f %d \n",trig, unit->fileready_); 
		
		//write to file
		
		for (int i=0; i<unit->numfeatures_; ++i) {
		
			float featureval = IN0(i+2);  
			//printf("%d %f trig %f \n",i, featureval, trig); 
			
			//printf("featureval %f %d \n",featureval, unit->fileready_);
			
			
			fwrite(&featureval, sizeof(float),1, unit->fp);
			
		}
		
		
		++unit->frameswritten_; 
		
	}
	
	
}

void MatchingP_Ctor(MatchingP* unit)
{
	SETCALC(MatchingP_next);

	//  [trigger, residual, activ0, activ1,...] = MatchingP.ar(dict, in, dictsize, ntofind, hop=1, method=0)

	CTOR_GET_BUF

	// initialize the unit generator state variables.
	unit->m_dictsize = IN0(2);
	if(unit->m_dictsize != buf->channels){
		printf("ERROR: (unit->m_dictsize != bufChannels)\n");
		SETCALC(ClearUnitOutputs);
		return;
	}
	unit->m_hopspls  = static_cast<int>(sc_max(0.f, sc_min(1.f, IN0(4))) * buf->frames);
	unit->m_shuntspls = buf->frames - unit->m_hopspls;
	const int ntofind = (const int)IN0(3);
	// UNUSED: unit->mMethod = IN0(5);

	unit->m_audiowritepos    = unit->m_hopspls;
	unit->m_audioplaybackpos = 0;
	// audiobuf size is bufFrames + hopspls -- playback happens in first bufFrames, input is written in last hopspls, analysis is in last bufFrames
	unit->m_audiobuf    = (float* )RTAlloc(unit->mWorld, sizeof(float)  * (buf->frames + unit->m_hopspls));
	Clear(buf->frames + unit->m_hopspls, unit->m_audiobuf);
	// "activations" will contain [index0, activ0, index1, activ1, ... ]
	unit->m_activations = (float* )RTAlloc(unit->mWorld, sizeof(float)  * 2 * ntofind);

	// calculate one sample of output.
	unit->m_fbufnum = -9.9e9; // set it to something that will force the buffer info to be updated when _next runs
	MatchingP_next(unit, 1);
}

void Dpoll_Ctor(Dpoll *unit)
{
	SETCALC(Dpoll_next);
	unit->m_id = IN0(3); // number of chars in the id string
	unit->m_id_string = (char*)RTAlloc(unit->mWorld, ((int)unit->m_id + 1) * sizeof(char));
	for(int i = 0; i < (int)unit->m_id; i++) {
		unit->m_id_string[i] = (char)IN0(4+i);
	}
	unit->m_id_string[(int)unit->m_id] = '\0';
	unit->m_mayprint = unit->mWorld->mVerbosity >= 0;
	OUT0(0) = 0.f;
}

void DbufTag_Ctor(DbufTag *unit)
{
    SETCALC(DbufTag_next);
    unit->m_fbufnum = -1e9f;
    unit->m_axiom_size = (int) IN0(dtag_axiom_size);
    unit->m_numRules = (int) IN0(dtag_num_rules);

    DbufTag_initInputs(unit, dtag_argoffset + unit->m_axiom_size, unit->m_numRules);
    DbufTag_reset(unit, 0, 1);

    OUT0(0) = 0.f;
}

void Dtag_Ctor(Dtag *unit)
{

    SETCALC(Dtag_next);

    unit->m_axiom_size = (int) IN0(dtag_axiom_size);
    unit->m_numRules = (int) IN0(dtag_num_rules);

    // initialise and reset
    Dtag_initInputs(unit, dtag_argoffset + unit->m_axiom_size, unit->m_numRules);
    Dtag_reset(unit, 0, 1);

    OUT0(0) = 0.f;
}

void Dpoll_next(Dpoll *unit, int inNumSamples)
{
	if (inNumSamples) {
			float x = DEMANDINPUT_A(0, inNumSamples);
			float run = DEMANDINPUT_A(2, inNumSamples) > 0.f;
			if(unit->m_mayprint && run) {
				Print("%s: %g block offset: %d\n", unit->m_id_string, x, inNumSamples - 1);
			}
			if(IN0(1) >= 0.0) SendTrigger(&unit->mParent->mNode, (int)IN0(1), x);
			OUT0(0) = x;
	} else {
		RESETINPUT(0);
	}
}

void Membrane_next_a(Membrane *unit, int inNumSamples) {
  // get the pointer to the output buffer
  float *out = OUT(0);
  int input_n = 0;
  // get the control rate input
#ifdef AUDIO_INPUT
  float *in = IN(input_n++);
#else
  float trigger = IN0(input_n++);
#endif
  float tension = IN0(input_n++);
  float loss = IN0(input_n++);
  if (tension == 0) {
    // default tension
    tension =  0.0001;
  }
  unit->yj = 2.f * DELTA * DELTA / (tension * tension * GAMMA * GAMMA);
  float yj_r = 1.0f / unit->yj;

  if (loss >= 1) {
    loss = 0.99999;
  }
  unit->loss = loss;

#ifndef AUDIO_INPUT
  if (trigger >= 0.5 && (! unit->triggered)) {
    unit->triggered = 1;
    unit->excite = TRIGGER_DURATION;

  }
  else if (trigger < 0.5 && unit->triggered) {
    unit->triggered = 0;
  }
#endif

  for (int k=0; k < inNumSamples; ++k) {
    float input = 0.0;
#ifdef AUDIO_INPUT
    input = in[k];
#else
    if (unit->excite > 0) {
      input = (0.01 - (((float) rand() / RAND_MAX) * 0.02));
      unit->excite--;
    }
#endif
    out[k] = cycle(unit, input, yj_r);
  }
}

OMX_ERRORTYPE IFM_NmfProcessingComp::doBufferDeAllocation(OMX_U32 nPortIndex,OMX_U32 nBufferIndex, void * pBufferMetaData){
	IN0("\n");

	OMX_ERRORTYPE error = OMX_ErrorNone;
	OMX_PARAM_PORTDEFINITIONTYPE   portdef;
	OMX_VERSIONTYPE version = {{0, 0, 0, 0}};
    getOmxIlSpecVersion(&version);
    portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
    portdef.nVersion = version;
	ENS_Port * port = mENSComponent.getPort(nPortIndex);
    port->getParameter(OMX_IndexParamPortDefinition, &portdef);


	if ((portdef.eDomain == OMX_PortDomainVideo)&&(nBufferIndex == 0)) {
	    ENS_Port *port = mENSComponent.getPort(nPortIndex);
		MMHwBuffer *sharedChunk = port->getSharedChunk();
		error = MMHwBuffer::Destroy(sharedChunk);
		if (error != OMX_ErrorNone)	{
			OUTR(" ",error);
			return error;
		}
	}
	else if (portdef.eDomain != OMX_PortDomainVideo)
	{
		delete [] (char *) pBufferMetaData;
	}



	OUTR(" ",OMX_ErrorNone);
	return OMX_ErrorNone;
}

// Ctor is called to initialize the unit generator.
// It only executes once.
void PhaseInIrm_Ctor(PhaseInIrm* unit)
{

    if (INRATE(0) == calc_FullRate) {
        SETCALC(PhaseInIrm_next_k);
    } else {
        SETCALC(PhaseInIrm_next_k);
    }

    unit->curstate = 0;
    unit->timeCallRest = 0;
    unit->timeInhibited = 0;
    unit->callTrig = 0;
    unit->changeState = true;
    unit->timeInhibitedBeforeCall = 0;
    unit->avgScore = 0;


    unit->restTime = IN0(_restPeriod);
    unit->lastRestPeriod = unit->restTime;

    for (int i = 0; i < NUMSCORES; i++) {
        unit->scores[i] = 1;
    };
    unit->scoreIndex = 0;

    unit->score = 1;

    PhaseInIrm_next_k(unit, 1);
}

TuningLoaderMgrError_t CTuningLoaderManager::saveNvmTuningData(const t_camera_info* pCamInfo,unsigned char* pNvm, t_uint32 aSize)
{
    IN0("\n");
    OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::saveNvmTuningData", (mTraceObject));

    // Check if constructed
    if(iNmfInstance == NULL) {
        MSG0("Instance not constructed\n");
        OstTraceFiltStatic0(TRACE_ERROR, "Instance not constructed", (mTraceObject));
        OUTR(" ",TUNING_LOADER_MGR_NOT_CONSTRUCTED);
        OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadNvmTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_NOT_CONSTRUCTED);
        return TUNING_LOADER_MGR_NOT_CONSTRUCTED;
    }

    // Aguments sanity check
    if( (pCamInfo == NULL) || (pNvm ==NULL) || (aSize == 0))
    {
        MSG1("Bad argument: pCamInfo=%x, pNvm=0x%x, aSize=%x\n", (unsigned int)pCamInfo,(unsigned int)pNvm,(unsigned int)aSize);
        OstTraceFiltStatic3(TRACE_ERROR, "Bad argument: pCamInfo=0x%x pNvm=0x%x, aSize=%d", (mTraceObject), (t_uint32)pCamInfo,(t_uint32)pNvm,aSize);
        OUTR(" ",TUNING_LOADER_MGR_BAD_ARGUMENT);
        OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadNvmTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_BAD_ARGUMENT);
        return TUNING_LOADER_MGR_BAD_ARGUMENT;
    }

    // Send command to NMF
    MSG0("Send 'SaveNvmTuning' command to NMF\n");
    OstTraceFiltStatic0(TRACE_DEBUG, "Send 'loadNvmTuning' command to NMF", (mTraceObject));
    iNmfQueryIntf.saveNvmTuning(*pCamInfo,(t_uint32)pNvm,aSize);

    OUTR(" ",TUNING_LOADER_MGR_OK);
    OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadNvmTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_OK);
    return TUNING_LOADER_MGR_OK;
}

/*
 * This function sets the DefCor dampers
 */
t_damper_error_code CDefCorDamper::SetDamper( const t_defcor_damper_id aDamperId,
                                              const float*             pValues,
                                              const int                aNumRows,
                                              const int                aNumCols)
{
   IN0("\n");
   OstTraceFiltStatic0(TRACE_FLOW, "Entry CDefCorDamper::SetDamper", (mTraceObject));
   t_damper_error_code err = DAMPER_OK;
   if(aDamperId<0 || aDamperId>=DEFCOR_DAMPERS_NUM)
   {
      DBGT_ERROR("Invalid damper Id: %d\n", aDamperId);
      OstTraceFiltStatic1(TRACE_ERROR, "Invalid damper Id: %d", (mTraceObject), aDamperId);
      OUTR(" ",DAMPER_INVALID_ARGUMENT);
      OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), DAMPER_INVALID_ARGUMENT);
      return DAMPER_INVALID_ARGUMENT;
   }
   MSG3("[%s] NumRows=%d, NumCols=%d\n", KDefCorDamperInfo[aDamperId].name, aNumRows, aNumCols);
   OstTraceFiltStatic3(TRACE_DEBUG, "[KDefCorDamperInfo[%d].name] NumRows=%d, NumCols=%d", (mTraceObject), aDamperId, aNumRows, aNumCols);
   err = DoSetDamper( aDamperId, pValues, aNumRows, aNumCols);
   if(err!=DAMPER_OK)
   {
      DBGT_ERROR("[%s] failed to set damper: err=%d\n", KDefCorDamperInfo[aDamperId].name, err);
      OstTraceFiltStatic2(TRACE_ERROR, "[KDefCorDamperInfo[%d].name] failed to set damper: err=%d", (mTraceObject), aDamperId, err);
      OUTR(" ",err);
      OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), err);
      return err;
   }
   OUTR(" ",DAMPER_OK);
   OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), DAMPER_OK);
   return DAMPER_OK;
}

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

void openmax_processor::processEvent(void)
//*************************************************************************************************************
{// fsm.component.component.type interface posteven method processEvent
	IN0("\n");
	Component::processEvent();
	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];
    }
}

void AnnBasic_Ctor(AnnBasic* unit)
{
    unit->ann_i = -1;
    unit->inputs = 0;

    int ann_i = IN0( IN_ANN_NUM );
    unsigned int inc = sigInCount(unit);
    unsigned int outc = sigOutCount(unit);

    // init ANN input buffer

    fann_type* ann_ins = (fann_type*) RTAlloc( unit->mWorld, sizeof(fann_type) * inc);
    for(int i=0; i < inc; ++i) ann_ins[i] = 0.f;

    // set up the unit

    unit->ann_i = ann_i;
    unit->inputs = ann_ins;
    SETCALC( AnnBasic_next);

    // Calculate one sample of output

    AnnBasic_next( unit, 1 );
    //AnnBasic_idle( unit, 1 );
}

OMX_ERRORTYPE MPEG4Enc_ArmNmf_ProcessingComponent::codecConfigure()
{
	IN0("");

    OUT0("");
    return OMX_ErrorNone;
}

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

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

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