%% $RCSfile: sdspdly2.tlc,v $
%% $Revision: 1.14 $
%% $Date: 2000/08/22 14:39:29 $
%%
%% Copyright 1995-2000 The MathWorks, Inc.
%%
%% Abstract: Integer delay

%implements sdspdly2 "C"

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


%% Function: BlockInstanceSetup ===============================================
%%
%% Abstract:   Name the S-function parameters
%%             
%function BlockInstanceSetup (block, system) void
    %%
    %assign INPORT         = 0
    %assign OUTPORT        = 0
    %assign IS_DIRECT_FEED = CAST("Boolean",(SFcnParamSettings.IsDirectFeedThrough == "Yes"))
    %assign delayLen       = SIZE(SFcnParamSettings.Delays, 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 isFrame     = LibBlockInputSignalIsFrameData(INPORT) 
    %assign nChans      = SFcnParamSettings.ICs_nChans
    %assign nSamps      = portWidth / nChans
    %assign buflen      = LibBlockDWorkWidth(BUFF)/nChans

    %assign incrementDelayPerChannel = SFcnParamSettings.incrementDelayPerChannel
    %assign incrementDelayPerSample  = SFcnParamSettings.incrementDelayPerSample

    %assign block = block + INPORT   + OUTPORT + IS_DIRECT_FEED + portWidth \
                          + dtype_in + buflen  + delayLen       + 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 Delay (%<ParamSettings.FunctionName>) - %<Name> */
    %%
    %assign extra = (IS_DIRECT_FEED) ? 1 : (portWidth / nChans) 
    %%
    %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> = %<buflen - (extra + 1)>;
    %%
    %<CallCopyICsFcn(block)>
    %%

%endfunction


%% Function: Update ===========================================================
%%
%function Update(block, system) Output
%%
%if (!IS_DIRECT_FEED) 
    /* DSP Blockset Delay (%<ParamSettings.FunctionName>) - %<Name> */
    %if ((nSamps==1) && (nChans==1))
        /* Scalar input */
        {
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;

            if (++bufferStart == %<buflen>) bufferStart = 0;
            %<LibBlockDWork(BUFF,"bufferStart","",0)> = %<LibBlockInputSignal(INPORT, "", "", 0)>;
            %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>++;                
            while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
        }
    %elseif (nSamps==1)
        %% Sample-based non-scalar input
        %% or Frame-based row input
        /* %<nChans>-channel input (1 sample per channel) */
        {
            %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
            int_T i; 

            if (++bufferStart == %<buflen>) bufferStart = 0;
            %assign indexString="bufferStart + i"
            for (i=0; i < %<nChans * buflen>; i += %<buflen>) {
                %<LibBlockDWork(BUFF,indexString,"",0)> = *u++;
            }
            %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>++;                
            while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
        }
    %elseif (nChans==1)
        /* Frame-based column input (1 channel, %<nSamps> samples) */
        {
            %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
            int_T j = %<nSamps>;

            while (j-- > 0) {
                if (++bufferStart == %<buflen>) bufferStart = 0;
                %<LibBlockDWork(BUFF,"bufferStart","",0)> = *u++;
            }
            %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
            while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
        }
    %else
        /* Frame-based %<nSamps>-by-%<nChans> matrix input */
        {
            %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
            int_T i;

            for (i=0; i < %<nChans * buflen>; i += %<buflen>) { /* Channel loop */
                int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
                int_T j = %<nSamps>;

                %assign indexString="bufferStart + i"
                while (j-- > 0) { /* Sample loop */
                    if (++bufferStart == %<buflen>) bufferStart = 0;
                    %<LibBlockDWork(BUFF,indexString,"",0)> = *u++;
                }
            }
            %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
            while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
        }
    %endif
%else
    %% Block is in direct feedthrough mode - no update code required
%endif

%endfunction %% Update


%% Function: Outputs ==========================================================
%%
%function Outputs(block, system) Output
/* DSP Blockset Delay (%<ParamSettings.FunctionName>) - %<Name> */
    %% SCENARIO-SPECIFIC CODE:
    %% Valid scenarios:
    %%
    %% - Scalar input and scalar delay
    %% - Multi-channel input, 1 sample per channel, scalar delay
    %% - Multi-channel input, 1 sample per channel, non-scalar delay
    %% - Frame-based col vector input, scalar delay
    %% - Frame-based col vector input, column delay
    %% - Frame-based full-matrix input, scalar delay
    %% - Frame-based full-matrix input, row delay
    %% - Frame-based full-matrix input, column delay
    %% - Frame-based full-matrix input, matrix delay
    %%
    %if (nChans==1) && (nSamps==1)
        %%
        %% SCALAR INPUT AND SCALAR DELAY
        %%
        %<ScalarInputScalarDelay(block)>
    %elseif (nSamps == 1)
        %%
        %% MULTI-CHANNEL SINGLE-SAMPLE CASES (nChans > 1; nSamps == 1)
        %%
        %if (incrementDelayPerSample == 0) && (incrementDelayPerChannel == 0)
            %<MultiChannelInputScalarDelay(block)>
        %else
            %<MultiChannelInputNonScalarDelay(block)>
        %endif
    %else
        %%
        %% FRAME-BASED CASES (nChans >= 1; nSamps > 1)
        %%
        %if nChans==1
            %% SINGLE-CHANNEL FRAME-BASED CASE (FRAME-BASED COL VECTOR INPUT)
            %if (incrementDelayPerSample == 0)
                %<FrameColumnInputScalarDelay(block)>
            %else
                %<FrameColumnInputColumnDelay(block)>
            %endif
        %else
            %% FRAME-BASED FULL MATRIX INPUT
            %if (incrementDelayPerSample == 0) && (incrementDelayPerChannel == 0)
                %<FrameMatrixInputScalarDelay(block)>
            %elseif (incrementDelayPerSample == 0) && (incrementDelayPerChannel == 1)
                %<FrameMatrixInputRowDelay(block)>
            %elseif (incrementDelayPerSample == 1) && (incrementDelayPerChannel == 0) && (delayLen == nSamps)
                %<FrameMatrixInputColDelay(block)>
            %else
                %<FrameMatrixInputMatrixDelay(block)>
            %endif
        %endif
    %endif
%endfunction  %% Outputs


%% Function: ScalarInputScalarDelay ==========================================================
%%
%function ScalarInputScalarDelay(block) Output
    %%
    %% nChans = 1; nSamps = 1;
    %% incrementDelayPerSample = F; incrementDelayPerChannel = F;
    %% isFrame = F or T;
    %%
    %if (!IS_DIRECT_FEED)
    %%
    %% Block is NOT in direct feedthrough mode
    %%
        %if (%<SFcnParamSettings.Delays[0]> == 1)
            /* Scalar input, scalar delay (1 sample) */
            {
                int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
        %else
            /* Scalar input, scalar delay (%<SFcnParamSettings.Delays[0]> samples) */
            {
                int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - %<SFcnParamSettings.Delays[0] - 1>;
        %endif
            if (ti < 0) ti += %<buflen>;
            %<LibBlockOutputSignal(OUTPORT, "", "", 0)> = %<LibBlockDWork(BUFF, "ti", "", 0)>;
        }
    %else
        %%
        %% Block is in direct feedthrough mode
        %%
        /* Scalar input, zero delay */
        %<LibBlockOutputSignal(OUTPORT, "", "", 0)> = %<LibBlockInputSignal(INPORT, "", "", 0)>;
    %endif
%endfunction  %% ScalarInputScalarDelay


%% Function: MultiChannelInputScalarDelay ==========================================================
%%
%function MultiChannelInputScalarDelay(block) Output
    %%
    %% nChans > 1; nSamps = 1;
    %% incrementDelayPerSample = F; incrementDelayPerChannel = F;
    %%
    %if (!IS_DIRECT_FEED)
        %%
        %% Block is NOT in direct feedthrough mode
        %%
        %if (%<SFcnParamSettings.Delays[0]> == 1)
        /* %<nChans>-channel input (1 sample per channel), scalar delay (1 sample) */
        {
            int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
        %else
        /* %<nChans>-channel input (1 sample per channel), scalar delay (%<SFcnParamSettings.Delays[0]> samples) */
        {
            int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - %<SFcnParamSettings.Delays[0] - 1>;
        %endif
            %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
            int_T i;

            if (ti < 0) ti += %<buflen>;
            %assign indexString = "ti + i"
            for (i=0; i < %<nChans * buflen>; i += %<buflen> ) { /* Channel loop */
                *y++ = %<LibBlockDWork(BUFF, indexString, "", 0)>;
            }
        }
    %else
        /* %<nChans>-channel input (1 sample per channel), zero delay */
        {
            %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
            %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
            int_T i = %<nChans>;

            while (i-- > 0) { /* Channel loop */
                  *y++ = *u++;
            }
        }
    %endif
%endfunction  %% MultiChannelInputScalarDelay


%% Function: MultiChannelInputNonScalarDelay ==========================================================
%%
%function MultiChannelInputNonScalarDelay(block) Output
    /* %<nChans>-channel input (1 sample per channel), non-scalar delay */
    {
        static %<CreateParamVar(SFcnParamSettings.Delays, "delay", "int_T")>
    %%
    %% nChans > 1; nSamps = 1;
    %% incrementDelayPerSample = F; incrementDelayPerChannel = T;
    %%
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans>; i++) { /* Channel loop */
            int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - delay[i] + 1;
            if (ti < 0) ti += %<buflen>;
            %assign indexString = "ti + i*"+"%<buflen>"
            *y++ = %<LibBlockDWork(BUFF, indexString, "", 0)>;
        }
    }
    %else
        %%
        %% Direct feedthrough mode
        %%
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
        int_T i;

        if (++bufferStart == %<buflen>) bufferStart = 0;
        for (i=0; i < %<nChans>; i++) { /* Channel loop */
            int_T ti = bufferStart - delay[i];
            if (ti < 0) ti += %<buflen>;
            %assign indexString1 = "bufferStart + i*"+"%<buflen>"
            %assign indexString2 = "ti + i*"+"%<buflen>"
            %<LibBlockDWork(BUFF, indexString1, "", 0)> = *u++;
            *y++ = %<LibBlockDWork(BUFF, indexString2, "", 0)>;
        }
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>++;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% MultiChannelInputNonScalarDelay


%% Function: FrameColumnInputScalarDelay ==========================================================
%%
%function FrameColumnInputScalarDelay(block) Output
    %%
    %% nChans = 1; nSamps > 1;
    %% incrementDelayPerSample = F; incrementDelayPerChannel = F;
    %% isFrame = T;
    %%
    %if (%<SFcnParamSettings.Delays[0]> == 1)
    /* Frame-based column input (1 channel, %<nSamps> samples), scalar delay (1 sample) */
    {
    %else
    /* Frame-based column input (1 channel, %<nSamps> samples), scalar delay (%<SFcnParamSettings.Delays[0]> samples) */
    {
    %endif
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T j = 0;

        while (j++ < %<nSamps>) { /* Channel loop */
            int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - %<SFcnParamSettings.Delays[0]> + j;
            if (ti < 0) ti += %<buflen>;
            *y++ = %<LibBlockDWork(BUFF, "ti", "", 0)>;
        }
    }
    %else
        %%
        %% Direct feedthrough mode, delay is zero
        %% 
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T j = %<nSamps>;
        %if (%<SFcnParamSettings.Delays[0]> == 0)
            while (j-- > 0) { /* Channel loop */
                *y++ = *u++;
            }
        %else
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;

            while (j-- > 0) { /* Channel loop */
                int_T ti;

                if (++bufferStart == %<buflen>) bufferStart = 0;
                ti = bufferStart - %<SFcnParamSettings.Delays[0]>;
                if (ti < 0) ti += %<buflen>;
                %<LibBlockDWork(BUFF, "bufferStart", "", 0)> = *u++;
                *y++ = %<LibBlockDWork(BUFF, "ti", "", 0)>;
            }
        %endif
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% FrameColumnInputScalarDelay


%% Function: FrameColumnInputColumnDelay ==========================================================
%%
%function FrameColumnInputColumnDelay(block) Output
    /* Frame-based column input (1 channel, %<nSamps> samples), col delay vector */
    {
        static %<CreateParamVar(SFcnParamSettings.Delays, "delay", "int_T")>
    %%
    %% nChans = 1; nSamps > 1;
    %% incrementDelayPerSample = T; incrementDelayPerChannel = F;
    %% isFrame = T;
    %%
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T j = 0;

        while (j++ < %<nSamps>) { /* Channel loop */
            int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - delay[j-1] + j;
            if (ti < 0) ti += %<buflen>;
            *y++ = %<LibBlockDWork(BUFF, "ti", "", 0)>;
        }
    }
    %else
        %%
        %% Direct feedthrough mode 
        %% 
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
        int_T j = 0;

        while (j < %<nSamps>) { /* Channel loop */
            int_T ti;

            if (++bufferStart == %<buflen>) bufferStart = 0;
            ti = bufferStart - delay[j++];
            if (ti < 0) ti += %<buflen>;
            %<LibBlockDWork(BUFF, "bufferStart", "", 0)> = *u++;
            *y++ = %<LibBlockDWork(BUFF, "ti", "", 0)>;
        }
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% FrameColumnInputColumnDelay


%% Function: FrameMatrixInputScalarDelay ==========================================================
%%
%function FrameMatrixInputScalarDelay(block) Output
    %%
    %% nChans > 1; nSamps > 1;
    %% incrementDelayPerSample = F; incrementDelayPerChannel = F;
    %% isFrame = T;
    %%
    %if (%<SFcnParamSettings.Delays[0]> == 1)
    /* Frame-based %<nSamps>-by-%<nChans> matrix input, scalar delay (1 sample) */
    {
    %else
    /* Frame-based %<nSamps>-by-%<nChans> matrix input, scalar delay (%<SFcnParamSettings.Delays[0]> samples) */
    {
    %endif
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans * buflen>; i += %<buflen>) { /* Channel loop */
            int_T j = 0;
            while (j++ < %<nSamps>) { /* Sample loop */
                int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - %<SFcnParamSettings.Delays[0]> + j;
                if (ti < 0) ti += %<buflen>;
                %assign indexString = "ti + i"
                *y++ = %<LibBlockDWork(BUFF, indexString, "", 0)>;
            }
        }
    }
    %else
        %%
        %% Direct feedthrough mode
        %%
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        %if (%<SFcnParamSettings.Delays[0]> == 0)
            int_T i = %<nSamps * nChans>;

            while (i-- > 0) { /* Loop over %<nSamps>-by-%<nChans> matrix elements */
                *y++ = *u++;
            }
        %else
            int_T i;
            for (i=0; i < %<nChans * buflen>; i += %<buflen>) { /* Channel loop */
                int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
                int_T j = 0;

                while (j++ < %<nSamps>) { /* Sample loop */
                    int_T ti;

                    if (++bufferStart == %<buflen>) bufferStart = 0;
                    ti = bufferStart - %<SFcnParamSettings.Delays[0]>;
                    if (ti < 0) ti += %<buflen>;
                    %assign indexString1 = "bufferStart + i"
                    %assign indexString2 = "ti + i"
                    %<LibBlockDWork(BUFF, indexString1, "", 0)> = *u++;
                    *y++ = %<LibBlockDWork(BUFF, indexString2, "", 0)>;
                }
            }
        %endif
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% FrameMatrixInputScalarDelay


%% Function: FrameMatrixInputRowDelay ==========================================================
%%
%function FrameMatrixInputRowDelay(block) Output
    /* Frame-based %<nSamps>-by-%<nChans> matrix input, row delay vector */
    {
        static %<CreateParamVar(SFcnParamSettings.Delays, "delay", "int_T")>
    %%
    %% nChans > 1; nSamps > 1;
    %% incrementDelayPerSample = F; incrementDelayPerChannel = T;
    %% isFrame = T;
    %%
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans>; i++) { /* Channel loop */
            int_T j = 0;
            while (j++ < %<nSamps>) { /* Sample loop */
                int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - delay[i] + j;
                if (ti < 0) ti += %<buflen>;
                %assign indexString = "ti + i*"+"%<buflen>"
                *y++ = %<LibBlockDWork(BUFF, indexString, "", 0)>;
            }
        }
    }
    %else
        %%
        %% Direct feedthrough mode
        %%
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans>; i++) { /* Channel loop */
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
            int_T j = %<nSamps>;
            while (j-- > 0) { /* Sample loop */
                int_T ti;

                if (++bufferStart == %<buflen>) bufferStart = 0;
                ti = bufferStart - delay[i];
                if (ti < 0) ti += %<buflen>;
                %assign indexString1 = "bufferStart + i*"+"%<buflen>"
                %assign indexString2 = "ti + i*"+"%<buflen>"
                %<LibBlockDWork(BUFF, indexString1, "", 0)> = *u++;
                *y++ = %<LibBlockDWork(BUFF, indexString2, "", 0)>;
            }
        }
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% FrameMatrixInputRowDelay


%% Function: FrameMatrixInputColDelay ==========================================================
%%
%function FrameMatrixInputColDelay(block) Output
    /* Frame-based %<nSamps>-by-%<nChans> matrix input, col delay vector */
    {
        static %<CreateParamVar(SFcnParamSettings.Delays, "delay", "int_T")>
    %%
    %% nChans > 1; nSamps > 1;
    %% incrementDelayPerSample = T; incrementDelayPerChannel = F;
    %% isFrame = T;
    %%
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans * buflen>; i += %<buflen>) { /* Channel loop */
            int_T j = 0;
            while (j++ < %<nSamps>) { /* Sample loop */
                int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - delay[j-1] + j;
                if (ti < 0) ti += %<buflen>;
                %assign indexString = "ti + i"
                *y++ = %<LibBlockDWork(BUFF, indexString, "", 0)>;
            }
        }
    }
    %else
        %%
        %% Direct feedthrough mode
        %%
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans * buflen>; i += %<buflen>) { /* Channel loop */
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
            int_T j = 0;
            while (j < %<nSamps>) { /* Sample loop */
                int_T ti;

                if (++bufferStart == %<buflen>) bufferStart = 0;
                ti = bufferStart - delay[j++];
                if (ti < 0) ti += %<buflen>;
                %assign indexString1 = "bufferStart + i"
                %assign indexString2 = "ti + i"
                %<LibBlockDWork(BUFF, indexString1, "", 0)> = *u++;
                *y++ = %<LibBlockDWork(BUFF, indexString2, "", 0)>;
            }
        }
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% FrameMatrixInputColDelay


%% Function: FrameMatrixInputMatrixDelay ==========================================================
%%
%function FrameMatrixInputMatrixDelay(block) Output
    /* Frame-based %<nSamps>-by-%<nChans> matrix input, matrix delay */
    {
        static %<CreateParamVar(SFcnParamSettings.Delays, "delay", "int_T")>
    %%
    %% nChans > 1; nSamps > 1;
    %% incrementDelayPerSample = T; incrementDelayPerChannel = F;
    %% isFrame = T;
    %%
    %if (!IS_DIRECT_FEED)
        %%
        %% Direct feedthrough? NO
        %%
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans>; i++) { /* Channel loop */
            int_T j = 0;
            while (j++ < %<nSamps>) { /* Sample loop */
                int_T ti = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> - delay[i*%<nSamps> + j - 1] + j;
                if (ti < 0) ti += %<buflen>;
                %assign indexString = "ti + i*"+"%<buflen>"
                *y++ = %<LibBlockDWork(BUFF, indexString, "", 0)>;
            }
        }
    }
    %else
        %%
        %% Direct feedthrough mode
        %%
        %<dtype_in> *u = %<LibBlockInputSignalAddr(INPORT, "", "", 0)>;
        %<dtype_in> *y = %<LibBlockOutputSignalAddr(OUTPORT, "", "", 0)>;
        int_T i;

        for (i=0; i < %<nChans>; i++) { /* Channel loop */
            int_T bufferStart = %<LibBlockDWork(BUFF_OFFSET, "", "", 0)>;
            int_T j = 0;
            while (j++ < %<nSamps>) { /* Sample loop */
                int_T ti;
                if (++bufferStart == %<buflen>) bufferStart = 0;
                ti = bufferStart - delay[i*%<nSamps> + j - 1];
                if (ti < 0) ti += %<buflen>;
                %assign indexString1 = "bufferStart + i*"+"%<buflen>"
                %assign indexString2 = "ti + i*"+"%<buflen>"
                %<LibBlockDWork(BUFF, indexString1, "", 0)> = *u++;
                *y++ = %<LibBlockDWork(BUFF, indexString2, "", 0)>;
            }
        }
        %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> += %<nSamps>;
        while (%<LibBlockDWork(BUFF_OFFSET, "", "", 0)> >= %<buflen>) %<LibBlockDWork(BUFF_OFFSET, "", "", 0)> -= %<buflen>;
    }
    %endif
%endfunction  %% FrameMatrixInputMatrixDelay


%% [EOF] sdspdly2.tlc