iq.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 "iq.h"
#include <stdio.h>

IQ::IQ(
  const Id&               n, 
  In<Marker>&             markerIn,
  In<VYApixel>&           Cin,
  In<VYAimageDepth>&      imageDepthIn,
  In<VYAimageComponent>&  imageComponentIdIn,
  In<VYAimageH>&          imageHIn,
  In<VYAimageV>&          imageVIn,
  In<VYAimageDepth>&      scanDepthIn,
  In<VYAimageComponent>&  scanComponentIdIn,
  In<Bits>&               QTableIn,
  In<VYAid>&              QTableIdIn,
  Out<VYApixel>&          Cout)
:
  Process(n),
  markerInP(            id("markerInP"),          markerIn),
  CinP(                 id("CinP"),               Cin),
  imageDepthInP(        id("imageDepthInP"),      imageDepthIn),
  imageComponentIdInP(  id("imageComponentIdInP"),imageComponentIdIn),
  imageHInP(            id("imageHInP"),          imageHIn),
  imageVInP(            id("imageVInP"),          imageVIn),
  scanDepthInP(         id("scanDepthInP"),       scanDepthIn),
  scanComponentIdInP(   id("scanComponentIdInP"), scanComponentIdIn),
  QTableInP(            id("QTableInP"),           QTableIn),
  QTableIdInP(          id("QTableIdInP"),        QTableIdIn),
  CoutP(                id("CoutP"),              Cout)
{ 
}

void IQ::main()
{
  VYAimageDepth   nrOfImageComponents;
  VYAimageComponent*  imageComponent;
  VYAimageH*    H;
  VYAimageV*    V;
  VYAid*      tid;
  VYApixel    Cin;
  VYApixel    Cout;
  Marker      marker;
  
  read(markerInP, marker);
  while (marker == DQT_MK)
  {
    load_quant_tables();
    read(markerInP, marker);
  }

  read(imageDepthInP, nrOfImageComponents);

  imageComponent = new VYAimageComponent[nrOfImageComponents];
  H = new VYAimageH[nrOfImageComponents];
  V = new VYAimageV[nrOfImageComponents];
  tid = new VYAid[nrOfImageComponents];
  
  for(unsigned int i=0; i<nrOfImageComponents; i++)
  {
    read(imageComponentIdInP, imageComponent[i]);
    read(imageHInP, H[i]);
    read(imageVInP, V[i]);
    read(QTableIdInP, tid[i]);
  }

  while (true)
  {
    VYAimageDepth   nrOfScanComponents;
    VYAimageComponent*  scanComponentId;

    read(scanDepthInP, nrOfScanComponents);
    assert(nrOfScanComponents == 3);
  
    scanComponentId = new VYAimageComponent[nrOfScanComponents];

    for(unsigned int i=0; i<nrOfScanComponents; i++)
    {
      read(scanComponentIdInP, scanComponentId[i]);
    }

    while (true)
    {
      for(unsigned int i=0; i<nrOfScanComponents; i++)
      {
        int hi = H[scanComponentId[i]];
        int vi = V[scanComponentId[i]];
        int ti = tid[scanComponentId[i]];

        for(int j=0; j<hi; j++)
        {
          for(int k=0; k<vi; k++)
          {
            for(unsigned int l=0; l<64; l++)
            {
              read(CinP, Cin);
              Cout = QTable[ti][l]*Cin;
              write(CoutP, Cout);
            }
          }
        }
      }
    }
  }
  
  delete [] imageComponent;
  delete [] H;
  delete [] V;
  delete [] tid;
}


/*----------------------------------------------------------*/
/* loading and allocating of quantization table             */
/* table elements are in ZZ order (same as unpack output)   */
/*----------------------------------------------------------*/

int IQ::load_quant_tables()
{
  Bits aux;
  unsigned int size, n, i, tid, x;
  int result;

  get_size(size); /* this is the tables' size */
  n = (size-2)/65;

  for (i=0; i<n; i++) 
  {
    read(QTableInP, aux);
          if (first_quad(aux) > 0) 
    {
                printf("%s:\n\tERROR:\tBad QTable precision!\n", fullName());
                result = -1;
                return result;
          }
          tid = second_quad(aux);
    #ifdef VERBOSE
            printf("%s:\n\tLoading Quantization Table %d\n", fullName(), tid);
    #endif
          for (x=0;x<64;x++)  
    {
                read(QTableInP, aux);
                QTable[tid][x] = aux;
          }
      }
      result = 0;
      return result;
}

void IQ::get_size(unsigned int& size)
{
  Bits firstc;
  Bits nextc;

  read(QTableInP, firstc);
  size = firstc;
  read(QTableInP, nextc);
  size = (size<<8) | nextc; // big endian
}

---