%% $RCSfile: sdspflip.tlc,v $
%% $Revision: 1.4 $ $Date: 2000/06/15 20:37:41 $
%%
%% Copyright 1995-2000 The MathWorks, Inc.
%%
%% Abstract: Target file for the S-Function sdspflip.c
%%

%implements "sdspflip" "C"


%% Function: BlockInstanceSetup ===============================================
%%
%function BlockInstanceSetup(block, system) void

    %assign INPORT  = 0
    %assign OUTPORT = 0

    %assign numDims = LibBlockInputSignalNumDimensions(INPORT)
    %assign inDims  = LibBlockInputSignalDimensions(INPORT)
    %assign inCols  = (numDims == 2) ? inDims[1] : 1
    %assign inRows  = inDims[0]

    %assign cmplx   = LibBlockOutputSignalIsComplex(OUTPORT)
    %assign DType   = cmplx ? "creal_T" : "real_T"

    %assign block = block  + INPORT + OUTPORT + numDims + ...
                    inCols + inRows + cmplx   + DType

%endfunction %% BlockInstanceSetup


%% Function: Outputs ==========================================================
%%
%% Abstract:
%%
%function Outputs(block, system) Output
  /* DSP Blockset Flip (%<ParamSettings.FunctionName>) - %<Name> */
  %%
  %assign inplace    = (LibBlockInputSignalBufferDstPort(INPORT) == OUTPORT)
  %assign direction  = SFcnParamSettings.Direction
  %assign RowFlip    = (direction == 1) && (numDims==2)
  %assign ColumnFlip = (direction == 2) && (numDims==2)
  %%
  %% Certain cases don't require any code
  %%  - Flip Cols of a row
  %%  - Flip Rows of a col
  %%  - Scalar
  %%
  %if (ColumnFlip && inRows==1) || ...
      (RowFlip    && inCols==1) || ...
      (inRows==1  && inCols==1)
    %%
    %if inplace
        /* No code gnerated for flip block because input is not modified. */
    %else
        %assign u     = LibBlockInputSignal(INPORT,"i","",0)
        %assign y     = LibBlockOutputSignal(OUTPORT,"i","",0)
        %assign width = LibDataInputPortWidth(INPORT)
        %%
        {
            /* Copy input to output. */
            int i;
            for(i=0; i<%<width>; i++) {
                %<y> = %<u>;
            }
        }
    %endif
    %%
  %else
    {
        %if numDims == 1
            %if inplace
                /* Flip vector using in-place algorithm */
                %<FlipVectorInPlace(inRows)> \
            %else
                /* Flip vector */
                %<FlipVector(inRows)> \
            %endif
        %elseif ColumnFlip  
            %%
            %if inplace
                /* Flip columns using in-place algorithm */
                %<FlipColInPlace()> \
            %else
            /* Flip columns */
                %<FlipCol()> \
            %endif
            %%
        %elseif RowFlip
            %%
            %if inplace
                /* Flip rows using in-place algorithm */
                %<FlipRowInPlace()> \
            %else
                /* Flip rows */
                %<FlipRow()> \
            %endif
        %endif
    }
  %endif

%endfunction %% Outputs


%% Function: FlipColInPlace ==========================================================
%%
%function FlipColInPlace() Output 
%%
    %if inCols > 1
        %%
        %% Matrix code
        %%  
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        int_T     rows = %<inRows>;
        %%
          int_T     cols = %<inCols>;
          int_T     c;

          for(c=0; c<cols; c++) {
            %<DType> *top    = y + (c * rows); /* top of next column */
            %<DType> *bottom = top + rows-1;
            int_T   i      = rows / 2;      /* if odd, = floor(width/2) */
            while(i-- > 0) {
                %<DType> tmp = *top;
                *top++       = *bottom;
                *bottom--    = tmp;
            }
          }
    %else
        %<FlipVectorInPlace(inRows)> \
    %endif
    %%
%endfunction  %% FlipColInPlace


%% Function: FlipCol ==========================================================
%%
%function FlipCol() Output 
%%
    %if inCols > 1
        %%
        %% Matrix code
        %%  
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        %<DType> *u    = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
        int_T     rows = %<inRows>;
        %%
          int_T     cols = %<inCols>;
          int_T     c;

          for(c=0; c<cols; c++) {
            %<DType> *ycol = y + ((c+1) * rows - 1);  /* Bottom of next column */
            int_T   i;
            for(i=0; i<rows; i++) {
                *ycol-- = *u++;
            }
          }
    %else
        %<FlipVector(inRows)> \
    %endif
    %%
%endfunction  %% FlipCol


%% Function: FlipRowInPlace ==========================================================
%%
%function FlipRowInPlace() Output 
%%
    %if inRows > 1
        %%
        %% Matrix code
        %%  
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        int_T cols = %<inCols>;
        int_T c;
        int_T rows = %<inRows>;
        int_T r;

        for(r=0; r<rows; r++) {
            int_T cols2 = cols / 2;      /* if odd, = floor(width/2) */
            int_T i = cols-1;
        
            for(c=0; c<cols2; c++, i--) {
                int_T  bak = i*rows;
                int_T  fwd = c*rows;

                %<DType> tmp   = *(y+bak);
                *(y+bak) = *(y+fwd);
                *(y+fwd) = tmp;
            }
            y++;    /* next output row */
        }
    %else
        %<FlipVectorInPlace(inCols)> \
    %endif
    %%
%endfunction  %% FlipRowInPlace


%% Function: FlipRow ==========================================================
%%
%function FlipRow() Output 
%%
    %if inRows > 1
        %%
        %% Matrix code
        %%  
        %<DType> *y    = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
        %<DType> *u = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
        int_T     cols = %<inCols>;
        int_T     c;
        %%
          int_T     rows = %<inRows>;
          int_T     r;

          for(r=0; r<rows; r++) {
            int_T i = cols-1;
            for(c=0; c<cols; c++, i--) {
                *(y+i*rows) = *(u + c*rows);
            }
            u++; /* next input row */
            y++; /* next output row */
          }
        %%
    %else
        %<FlipVector(inCols)> \
    %endif
    %%
%endfunction  %% FlipRow


%% Function: FlipVectorInPlace ==========================================================
%%
%function FlipVectorInPlace(width) Output 
%%
    %<DType> *top       = %<LibBlockOutputSignalAddr(OUTPORT,"","",0)>;
    %<DType> *bottom    = %<LibBlockOutputSignalAddr(OUTPORT,"","",width - 1)>;
    int_T     halfwidth = %<width / 2>;      /* if odd, = floor(width/2) */

    while(halfwidth-- > 0) {
        %<DType> tmp = *top;
        *top++       = *bottom;
        *bottom--    = tmp;
    }
%%
%endfunction  %% FlipVector


%% Function: FlipVector ==========================================================
%%
%function FlipVector(width) Output 
%%
    %<DType> *u     = %<LibBlockInputSignalAddr(INPORT,"","",0)>;
    %<DType> *yend  = %<LibBlockOutputSignalAddr(OUTPORT,"","",width-1)>;
    int_T     width = %<width>;

    while(width-- > 0) {
        *yend-- = *u++;
    }
%%
%endfunction  %% FlipVector


%% [EOF: sdspflip.tlc]