//
// MATLAB Compiler: 3.0
// Date: Wed Apr 25 16:38:48 2007
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "-l" "-p" "-W" "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h"
// "libmmfile.mlib" "-h" "idct2.m" 
//
#include "images_private_idct.hpp"
#include "images_private_checknargin.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
static mwArray _mxarray0_ = mclInitializeDouble(1.0);
static mwArray _mxarray1_ = mclInitializeDouble(2.0);

static mxChar _array3_[6] = { 'd', 'o', 'u', 'b', 'l', 'e' };
static mwArray _mxarray2_ = mclInitializeString(6, _array3_);
static mwArray _mxarray4_ = mclInitializeDouble(0.0);
static mwArray _mxarray5_ = mclInitializeComplex(0.0, 1.0);
static mwArray _mxarray6_ = mclInitializeDouble(3.141592653589793);
static mwArray _mxarray7_ = mclInitializeComplex(-0.0, -1.0);
static mwArray _mxarray8_ = mclInitializeComplex(0.0, 3.141592653589793);
static mwArray _mxarray9_ = mclInitializeDouble(-1.0);

void InitializeModule_images_private_idct() {
}

void TerminateModule_images_private_idct() {
}

static mwArray Mimages_private_idct(int nargout_, mwArray b, mwArray n);

_mexLocalFunctionTable _local_function_table_images_private_idct
  = { 0, (mexFunctionTableEntry *)NULL };

//
// The function "images_private_idct" contains the normal interface for the
// "images/private/idct" M-function from file
// "d:\matlab6p5\toolbox\images\images\private\idct.m" (lines 1-85). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
mwArray images_private_idct(mwArray b, mwArray n) {
    int nargout = 1;
    mwArray a = mwArray::UNDEFINED;
    a = Mimages_private_idct(nargout, b, n);
    return a;
}

//
// The function "mlxImages_private_idct" contains the feval interface for the
// "images/private/idct" M-function from file
// "d:\matlab6p5\toolbox\images\images\private\idct.m" (lines 1-85). The feval
// function calls the implementation version of images/private/idct through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxImages_private_idct(int nlhs,
                            mxArray * plhs[],
                            int nrhs,
                            mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[2];
        mwArray mplhs[1];
        int i;
        mclCppUndefineArrays(1, mplhs);
        if (nlhs > 1) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: images/private/idct Line: 1 Colu"
                  "mn: 1 The function \"images/private/idct\" was called "
                  "with more than the declared number of outputs (1).")));
        }
        if (nrhs > 2) {
            error(
              mwVarargin(
                mwArray(
                  "Run-time Error: File: images/private/idct Line: 1 Colu"
                  "mn: 1 The function \"images/private/idct\" was called "
                  "with more than the declared number of inputs (2).")));
        }
        for (i = 0; i < 2 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 2; ++i) {
            mprhs[i].MakeDIN();
        }
        mplhs[0] = Mimages_private_idct(nlhs, mprhs[0], mprhs[1]);
        plhs[0] = mplhs[0].FreezeData();
    }
    MW_END_MLX();
}

//
// The function "Mimages_private_idct" is the implementation version of the
// "images/private/idct" M-function from file
// "d:\matlab6p5\toolbox\images\images\private\idct.m" (lines 1-85). It
// contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function a = idct(b,n)
//
static mwArray Mimages_private_idct(int nargout_, mwArray b, mwArray n) {
    mclMlineEnterFunction(
      "d:\\matlab6p5\\toolbox\\images\\images\\private\\idct.m",
      "images/private/idct")
    mwLocalFunctionTable save_local_function_table_
      = &_local_function_table_images_private_idct;
    int nargin_ = nargin(2, mwVarargin(b, n));
    mwArray a = mwArray::UNDEFINED;
    mwArray y = mwArray::UNDEFINED;
    mwArray yy = mwArray::UNDEFINED;
    mwArray W = mwArray::UNDEFINED;
    mwArray ww = mwArray::UNDEFINED;
    mwArray bb = mwArray::UNDEFINED;
    mwArray m = mwArray::UNDEFINED;
    mwArray do_trans = mwArray::UNDEFINED;
    mwArray ans = mwArray::UNDEFINED;
    //
    // %IDCT Inverse discrete cosine transform.
    // %
    // %   X = IDCT(Y) inverts the DCT transform, returning the original
    // %   vector if Y was obtained using Y = DCT(X). 
    // %
    // %   X = IDCT(Y,N) pads or truncates the vector Y to length N
    // %   before transforming. 
    // %
    // %   If Y is a matrix, the IDCT operation is applied to each
    // %   column.
    // %
    // %   See also FFT,IFFT,DCT.
    // 
    // %   Copyright 1993-2002 The MathWorks, Inc.  
    // %   $Revision: 5.12 $  $Date: 2002/03/15 15:57:45 $
    // 
    // %   References: 
    // %       1) A. K. Jain, "Fundamentals of Digital Image
    // %          Processing", pp. 150-153.
    // %       2) Wallace, "The JPEG Still Picture Compression Standard",
    // %          Communications of the ACM, April 1991.
    // 
    // checknargin(1,2,nargin,mfilename);
    //
    mclMline(24);
    images_private_checknargin(
      _mxarray0_, _mxarray1_, nargin_, "images/private/idct");
    //
    // 
    // if ~isa(b, 'double')
    //
    mclMline(26);
    if (mclNotBool(isa(mwVa(b, "b"), _mxarray2_))) {
        //
        // b = double(b);
        //
        mclMline(27);
        b = double_func(mwVa(b, "b"));
    //
    // end
    //
    mclMline(28);
    }
    //
    // 
    // if min(size(b))==1 
    //
    mclMline(30);
    if (mclEqBool(min(size(mwValueVarargout(), mwVa(b, "b"))), _mxarray0_)) {
        //
        // if size(b,2)>1
        //
        mclMline(31);
        if (mclGtBool(
              size(mwValueVarargout(), mwVa(b, "b"), _mxarray1_), _mxarray0_)) {
            //
            // do_trans = 1;
            //
            mclMline(32);
            do_trans = _mxarray0_;
        //
        // else
        //
        mclMline(33);
        } else {
            //
            // do_trans = 0;
            //
            mclMline(34);
            do_trans = _mxarray4_;
        //
        // end
        //
        mclMline(35);
        }
        //
        // b = b(:); 
        //
        mclMline(36);
        b = mclArrayRef(mwVa(b, "b"), colon());
    //
    // else  
    //
    mclMline(37);
    } else {
        //
        // do_trans = 0; 
        //
        mclMline(38);
        do_trans = _mxarray4_;
    //
    // end
    //
    mclMline(39);
    }
    //
    // if nargin==1,
    //
    mclMline(40);
    if (nargin_ == 1) {
        //
        // n = size(b,1);
        //
        mclMline(41);
        n = size(mwValueVarargout(), mwVa(b, "b"), _mxarray0_);
    //
    // end
    //
    mclMline(42);
    }
    //
    // m = size(b,2);
    //
    mclMline(43);
    m = size(mwValueVarargout(), mwVa(b, "b"), _mxarray1_);
    //
    // 
    // % Pad or truncate b if necessary
    // if size(b,1)<n,
    //
    mclMline(46);
    if (mclLtBool(
          size(mwValueVarargout(), mwVa(b, "b"), _mxarray0_), mwVa(n, "n"))) {
        //
        // bb = zeros(n,m);
        //
        mclMline(47);
        bb = zeros(mwVarargin(mwVa(n, "n"), mwVv(m, "m")));
        //
        // bb(1:size(b,1),:) = b;
        //
        mclMline(48);
        mclArrayAssign(
          &bb,
          mwVa(b, "b"),
          colon(_mxarray0_, size(mwValueVarargout(), mwVa(b, "b"), _mxarray0_)),
          colon());
    //
    // else
    //
    mclMline(49);
    } else {
        //
        // bb = b(1:n,:);
        //
        mclMline(50);
        bb
          = mclArrayRef(
              mwVa(b, "b"), colon(_mxarray0_, mwVa(n, "n")), colon());
    //
    // end
    //
    mclMline(51);
    }
    //
    // 
    // if rem(n,2)==1 | ~isreal(b), % odd case
    //
    mclMline(53);
    {
        mwArray a_ = rem(mwVa(n, "n"), _mxarray1_) == _mxarray0_;
        if (tobool(a_) || tobool(a_ | ~ isreal(mwVa(b, "b")))) {
            //
            // % Form intermediate even-symmetric matrix.
            // ww = sqrt(2*n) * exp(j*(0:n-1)*pi/(2*n)).';
            //
            mclMline(55);
            ww
              = _times_transpose(
                  sqrt(_mxarray1_ * mwVa(n, "n")),
                  exp(
                    _mxarray5_ * colon(_mxarray4_, mwVa(n, "n") - _mxarray0_)
                    * _mxarray6_
                    / (_mxarray1_ * mwVa(n, "n"))),
                  _mxarray0_);
            //
            // ww(1) = ww(1) * sqrt(2);
            //
            mclMline(56);
            mclIntArrayAssign(
              &ww, mclIntArrayRef(mwVv(ww, "ww"), 1) * sqrt(_mxarray1_), 1);
            //
            // W = ww(:,ones(1,m));
            //
            mclMline(57);
            W
              = mclArrayRef(
                  mwVv(ww, "ww"),
                  colon(),
                  ones(mwVarargin(_mxarray0_, mwVv(m, "m"))));
            //
            // yy = zeros(2*n,m);
            //
            mclMline(58);
            yy = zeros(mwVarargin(_mxarray1_ * mwVa(n, "n"), mwVv(m, "m")));
            //
            // yy(1:n,:) = W.*bb;
            //
            mclMline(59);
            mclArrayAssign(
              &yy,
              times(mwVv(W, "W"), mwVv(bb, "bb")),
              colon(_mxarray0_, mwVa(n, "n")),
              colon());
            //
            // yy(n+2:n+n,:) = -j*W(2:n,:).*flipud(bb(2:n,:));
            //
            mclMline(60);
            mclArrayAssign(
              &yy,
              times(
                _mxarray7_
                * mclArrayRef(
                    mwVv(W, "W"), colon(_mxarray1_, mwVa(n, "n")), colon()),
                flipud(
                  mclArrayRef(
                    mwVv(bb, "bb"), colon(_mxarray1_, mwVa(n, "n")), colon()))),
              colon(mwVa(n, "n") + _mxarray1_, mwVa(n, "n") + mwVa(n, "n")),
              colon());
            //
            // 
            // y = ifft(yy);
            //
            mclMline(62);
            y = ifft(mwVv(yy, "yy"));
            //
            // 
            // % Extract inverse DCT
            // a = y(1:n,:);
            //
            mclMline(65);
            a
              = mclArrayRef(
                  mwVv(y, "y"), colon(_mxarray0_, mwVa(n, "n")), colon());
        //
        // 
        // else % even case
        //
        mclMline(67);
        } else {
            //
            // % Compute precorrection factor
            // ww = sqrt(2*n) * exp(j*pi*(0:n-1)/(2*n)).';
            //
            mclMline(69);
            ww
              = _times_transpose(
                  sqrt(_mxarray1_ * mwVa(n, "n")),
                  exp(
                    _mxarray8_ * colon(_mxarray4_, mwVa(n, "n") - _mxarray0_)
                    / (_mxarray1_ * mwVa(n, "n"))),
                  _mxarray0_);
            //
            // ww(1) = ww(1)/sqrt(2);
            //
            mclMline(70);
            mclIntArrayAssign(
              &ww, mclIntArrayRef(mwVv(ww, "ww"), 1) / sqrt(_mxarray1_), 1);
            //
            // W = ww(:,ones(1,m));
            //
            mclMline(71);
            W
              = mclArrayRef(
                  mwVv(ww, "ww"),
                  colon(),
                  ones(mwVarargin(_mxarray0_, mwVv(m, "m"))));
            //
            // 
            // % Compute x tilde using equation (5.93) in Jain
            // y = ifft(W.*bb);
            //
            mclMline(74);
            y = ifft(times(mwVv(W, "W"), mwVv(bb, "bb")));
            //
            // 
            // % Re-order elements of each column according to equations (5.93) and
            // % (5.94) in Jain
            // a = zeros(n,m);
            //
            mclMline(78);
            a = zeros(mwVarargin(mwVa(n, "n"), mwVv(m, "m")));
            //
            // a(1:2:n,:) = y(1:n/2,:);
            //
            mclMline(79);
            mclArrayAssign(
              &a,
              mclArrayRef(
                mwVv(y, "y"),
                colon(_mxarray0_, mwVa(n, "n") / _mxarray1_),
                colon()),
              colon(_mxarray0_, _mxarray1_, mwVa(n, "n")),
              colon());
            //
            // a(2:2:n,:) = y(n:-1:n/2+1,:);
            //
            mclMline(80);
            mclArrayAssign(
              &a,
              mclArrayRef(
                mwVv(y, "y"),
                colon(
                  mwVa(n, "n"),
                  _mxarray9_,
                  mwVa(n, "n") / _mxarray1_ + _mxarray0_),
                colon()),
              colon(_mxarray1_, _mxarray1_, mwVa(n, "n")),
              colon());
        }
    //
    // end
    //
    mclMline(81);
    }
    //
    // 
    // if isreal(b), a = real(a); end
    //
    mclMline(83);
    if (tobool(isreal(mwVa(b, "b")))) {
        a = real(mwVv(a, "a"));
    }
    //
    // if do_trans, a = a.'; end
    //
    mclMline(84);
    if (tobool(mwVv(do_trans, "do_trans"))) {
        a = transpose(mwVv(a, "a"));
    }
    mwValidateOutput(a, 1, nargout_, "a", "images/private/idct");
    mclMlineFunctionReturn()
    return a;
    mclMlineExitFunctionReturn();
}