%% $RCSfile: sdspvidly2.tlc,v $
%% $Revision: 1.7 $ 
%% $Date: 2000/05/09 18:55:45 $
%%
%% Dale Shpak, R. Firtion
%% Copyright (c) 1995-2000 The MathWorks, Inc. 
%%
%% Abstract: Variable integer delay
%% 

%implements sdspvidly2 "C"

%include "dsplib.tlc"
%include "dsp_ic.tlc"


%% Function: BlockTypeSetup ================================================
%% Abstract:
%%
%function BlockTypeSetup(block, system) void

%% Render the roundDelayValue function

%% First, cache the function prototype for roundDelayValue:
%%
%openfile RoundDelayBuff
extern int roundDelayValue(const real_T *delay, int_T dmax);
%closefile RoundDelayBuff
%<DSPAddToFileHeader(RoundDelayBuff)>

%% Next, cache the roundDelayValue function itself:
%%
%openfile RoundDelayBuff
/* Function: roundDelayValue
 *	Rounds the delay values if they are greater than the maximum
 *		or are not whole numbers.
 */
extern int roundDelayValue(const real_T *delay, int_T dmax)
{
    /* Get rounded delay time: */
    int_T dly = (int_T) (*delay + 0.5); 
    /* Clip delay time to legal range: [0,dmax] */
    dly = (dly < 0 ? 0 : (dly > dmax ? dmax : dly));
    
    return(dly);
} /* roundDelayValue */

%closefile RoundDelayBuff
%<DSPAddToFile(RoundDelayBuff)>

%endfunction  %% BlockTypeSetup


%% Function: BlockInstanceSetup ===============================================
%%
%% Abstract:
%%		Name the S-function parameters
%function BlockInstanceSetup (block, system) void
    %%
    %assign INPORT      = 0
    %assign DELAY_PORT  = 1
    %assign OUTPORT     = 0
    %assign BUFF_OFFSET = block.DWork[0]
    %assign BUFF        = block.DWork[1]
    %assign portWidth   = LibDataInputPortWidth(INPORT)
    %assign cplx_in     = LibBlockInputSignalIsComplex(INPORT)
	%%
    %assign sl_dtype_in = LibBlockInputSignalDataTypeName(INPORT,"%<tRealPart>")
    %assign dtype_in    = (cplx_in) ? "c" + sl_dtype_in : sl_dtype_in
	%%
    %assign dmax        = SFcnParamSettings.maxDelay
    %assign buffLen     = dmax + 1
	%assign isFrame     = LibBlockInputSignalIsFrameData(INPORT) 
	%assign nChans      = SFcnParamSettings.ICs_nChans
	%assign nSamps      = portWidth / nChans
	%assign incrementDelayPerChannel = SFcnParamSettings.incrementDelayPerChannel
	%assign incrementDelayPerSample  = SFcnParamSettings.incrementDelayPerSample

    %assign block = block + INPORT + OUTPORT + DELAY_PORT + BUFF_OFFSET + BUFF \
					+ portWidth + dtype_in + dmax + buffLen \
					+ isFrame +  nChans + nSamps \
					+ incrementDelayPerChannel + incrementDelayPerSample 

    %% Setup the initial condition handler:
    %%
    %<CopyICsInstanceSetup(block)>

%endfunction %% BlockInstanceSetup


%% Function: InitializeConditions =============================================
%%
%% Abstract:
%%      Initialize the delay buffer and counters to their initial values.
%%
%function InitializeConditions(block, system) Output
    /* DSP Blockset Variable Integer Delay (%<ParamSettings.FunctionName>) - %<Name> */
	%%
    %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> = %<dmax - 1>;
	%%
	%<CallCopyICsFcn(block)>

%endfunction


%% Function: Outputs ===========================================================
%%
%function Outputs(block, system) Output
    %%
    %assign delayLen = LibDataInputPortWidth(DELAY_PORT)
    %%
{
  /* DSP Blockset Variable Integer Delay (%<ParamSettings.FunctionName>) - %<Name> */
  %%
  %% Block could be multirate if and only if it has more than
  %% one input port (eg, a "Delay" input).  If it is multirate,
  %% generate "sample hit" conditional so code executes at the
  %% block's base rate, and not the overall model base rate.
  %%
  %assign differentPortRates = !LibIsSFcnSingleRate(block)
  %%
  %if differentPortRates
    if (%<LibIsSFcnSampleHit("InputPortIdx0")>) { %<LibTaskSFcnComment("InputPortIdx0")>
  %endif
    %<dtype_in>  *u         = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
    real_T       *delayPort = %<LibBlockInputSignalAddr(DELAY_PORT, "", "", 0)>;
    %if (incrementDelayPerSample || incrementDelayPerChannel) 
	    real_T   *dtmp      = delayPort;
	%endif
    %<dtype_in>  *buff      = %<LibBlockDWorkAddr(BUFF, "", "", 0)>;
	int_T        *bufoff    = (int_T *)%<LibBlockDWorkAddr(BUFF_OFFSET, "", "", 0)>;
    %<dtype_in>  *y         = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
	%%
    %if (!incrementDelayPerSample && !incrementDelayPerChannel) 
        int_T dly = roundDelayValue(delayPort,%<dmax>);
    %endif
	%%
    int_T i,j;
	{
        int_T ti;

        for (i=0; i++ < %<nChans>; ) {   /* Record input samples */
            int_T buffstart = *bufoff;
            %if (incrementDelayPerChannel) 
                int_T dly = roundDelayValue(dtmp++, %<dmax>);
            %endif
			%%
            for (j=0; j++ < %<nSamps>; ) {
                %if (incrementDelayPerSample) 
                    int_T dly = roundDelayValue(dtmp++,%<dmax>);
                %endif
				%%
                /* Rotate the circular buffer */
                if (++buffstart == %<buffLen>) buffstart = 0;
                *(buff + buffstart) = *u++;
				%%
                %%
                ti = buffstart - dly;
                if (ti < 0) ti += %<buffLen>;
                *y++ = *(buff + ti);
            }
            buff += %<buffLen>;
            %if (incrementDelayPerSample && delayLen == nSamps)
				/* Bump pointer back to beginning of delay vector */ 
				dtmp = delayPort;
			%endif
        }
    }
	%%
    *bufoff += %<nSamps>;
    while (*bufoff >= %<buffLen>) *bufoff -= %<buffLen>;
  %if differentPortRates
    }
  %endif
}

%endfunction  %% Outputs

%% [EOF] sdspvidly2.tlc