idct1d.cc

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#include "idct1d.h"

/* Useful constants: */

/* This version is IEEE compliant using 16-bit arithmetic. */

/* The number of bits coefficients are scaled up before 2-D IDCT: */
const unsigned int S_BITS = 3;

/* The number of bits in the fractional part of a fixed point constant: */
const unsigned int C_BITS = 14;

inline
VYApixel ADD(VYApixel x, VYApixel y)
{
  return x + y;
}

inline
VYApixel SUB(VYApixel x, VYApixel y)
{
  return x - y;
}

inline
VYApixel CMUL(VYApixel C, VYApixel x)
{
  return (C * x + (1 << (C_BITS-1))) >> C_BITS;
}

/* Butterfly: but(a,b,x,y) = rot(sqrt(2),4,a,b,x,y) */

inline 
void but(VYApixel a, VYApixel b, VYApixel& x, VYApixel& y)
{
  x = SUB(a, b);
  y = ADD(a, b);
}

IDCT1D::IDCT1D(
  const Id& n, 
  In<VYApixel>&   cin, 
  Out<VYApixel>&  cout)
:
      Process(n),
      CIn(  id("CIn"),  cin),
      COut( id("Cout"), cout)
{
}

/* Inverse 1-D Discrete Cosine Transform.
   Result Y is scaled up by factor sqrt(8).
   Original Loeffler algorithm.
*/
void IDCT1D::main()
{
      VYApixel Y[8];
      VYApixel z1[8], z2[8], z3[8];

      while (true)
      {
    read(CIn, Y, 8);

          // Stage 1:
          but(Y[0], Y[4], z1[1], z1[0]);
          // rot(sqrt(2), 6, Y[2], Y[6], &z1[2], &z1[3]);
          z1[2] = SUB(CMUL( 8867, Y[2]), CMUL(21407, Y[6]));
          z1[3] = ADD(CMUL(21407, Y[2]), CMUL( 8867, Y[6]));
          but(Y[1], Y[7], z1[4], z1[7]);
          // z1[5] = CMUL(sqrt(2), Y[3]);
          // z1[6] = CMUL(sqrt(2), Y[5]);
          z1[5] = CMUL(23170, Y[3]);
          z1[6] = CMUL(23170, Y[5]);

          // Stage 2:
          but(z1[0], z1[3], z2[3], z2[0]);
          but(z1[1], z1[2], z2[2], z2[1]);
          but(z1[4], z1[6], z2[6], z2[4]);
          but(z1[7], z1[5], z2[5], z2[7]);

          // Stage 3:
          z3[0] = z2[0];
          z3[1] = z2[1];
          z3[2] = z2[2];
          z3[3] = z2[3];
          // rot(1, 3, z2[4], z2[7], &z3[4], &z3[7]);
          z3[4] = SUB(CMUL(13623, z2[4]), CMUL( 9102, z2[7]));
          z3[7] = ADD(CMUL( 9102, z2[4]), CMUL(13623, z2[7]));
          // rot(1, 1, z2[5], z2[6], &z3[5], &z3[6]); 
          z3[5] = SUB(CMUL(16069, z2[5]), CMUL( 3196, z2[6]));
          z3[6] = ADD(CMUL( 3196, z2[5]), CMUL(16069, z2[6]));

          // Stage 4:
          but(z3[0], z3[7], Y[7], Y[0]);
          but(z3[1], z3[6], Y[6], Y[1]);
          but(z3[2], z3[5], Y[5], Y[2]);
          but(z3[3], z3[4], Y[4], Y[3]);

          write(COut, Y, 8);
      }
}

---