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

/*--------------------------------------*/
/* private huffman.c defines and macros */
/*--------------------------------------*/

#define HUFF_EOB    0x00
#define HUFF_ZRL    0xF0

#define HUFF_ID(class, id)       (2*(class)+(id))

#define DC_CLASS        0
#define AC_CLASS        1

VLD::VLD(
  const Id&     n, 
  In<Marker>&   markerIn,
  In<Bits>&   restartIntervalBitsIn,
  In<Bits>&   Cin,
  In<VYAimageDepth>&  imageDepthIn,
  In<VYAimageComponent>&  imageComponentIdIn,
  In<VYAimageH>&    imageHIn,
  In<VYAimageV>&    imageVIn,
  In<VYAimageDepth>&  scanDepthIn,
  In<VYAimageComponent>&  scanComponentIdIn,
  In<Bits>&   HuffmanTableIn,
  In<VYAid>&    HuffmanTableIdIn,
  Out<VYApixel>&    Cout)
:
        Process(n),
        markerInP(    id("markerInP"),      markerIn),
        restartIntervalBitsInP( id("restartIntervalBitsInP"), restartIntervalBitsIn),
        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),
        HuffmanTableInP(  id("HuffmanTableInP"),    HuffmanTableIn),
        HuffmanTableIdInP(  id("HuffmanTableIdInP"),  HuffmanTableIdIn),
        CoutP(      id("CoutP"),      Cout)
{
  window = 0;
  restartInterval = 0;
}

void VLD::abort()
{
  printf("\n");
    printf("%s:\n", fullName());
  printf("\tERROR:\tAbnormal end of decompression process!\n");
  exit(1);
}

#define GLOB_SIZE   32
/* number of HTable words sacrificed to bookkeeping */

#define MAX_SIZE(group)   ((group)?384:64)
/* Memory size of HTables */
#define MAX_CELLS(group)  (MAX_SIZE(group) - GLOB_SIZE)
/* Available cells, top of storage */

/* for Huffman tree descent */
/* lower 8 bits are for value/left son */

#define GOOD_NODE_FLAG    0x100
#define GOOD_LEAF_FLAG    0x200
#define BAD_LEAF_FLAG   0x300
#define SPECIAL_FLAG    0x000
#define HUFF_FLAG_MSK   0x300

#define HUFF_FLAG(c)    ((c) & HUFF_FLAG_MSK)
#define HUFF_VALUE(c)   ((unsigned char)( (c) & (~HUFF_FLAG_MSK) ))

/*--------------------------------------*/
/* some static structures for storage */
/*--------------------------------------*/

static unsigned int DC_Table0[MAX_SIZE(DC_CLASS)],
    DC_Table1[MAX_SIZE(DC_CLASS)];

static unsigned int AC_Table0[MAX_SIZE(AC_CLASS)],
    AC_Table1[MAX_SIZE(AC_CLASS)];

static unsigned int    *HTable[4] = {
    &DC_Table0[0], &DC_Table1[0],
    &AC_Table0[0], &AC_Table1[0]
};


/*----------------------------------------------------------*/
/* Loading of Huffman table, with leaves drop ability     */
/*----------------------------------------------------------*/

int VLD::load_huff_tables()
{
  Bits aux;
  Bits c;
  int size, group, id;
  int LeavesN, NodesN, CellsN;
  int MaxDepth, i, k, done;
  int NextCellPt; /* where shall we put next cell */
  int NextLevelPt;  /* where shall node point to */
  unsigned int flag;

  size = get_size(); /* this is the tables' size */

  size -= 2;

  while(size>0) 
  {
          read(HuffmanTableInP, c);
    aux = c;
          group = first_quad(aux);  /* AC or DC */
          id = second_quad(aux);    /* table no */
          if (id>1) 
    {
                printf("%s:\n\tERROR:\tBad HTable identity %d!\n",fullName(),id);
                return -1;
          }
          id = HUFF_ID(group, id);
    #ifdef VERBOSE
      printf("%s:\n\tLoading Huffman Table %d\n", fullName(), id);
    #endif
          size--;
          CellsN = NodesN = 1;        /* the root one */
          LeavesN = 0;

          for(i=0; i<MAX_CELLS(group); i++)
    {
                HTable[id][i] = SPECIAL_FLAG; /* secure memory with crash value */
    }

          /* first load the sizes of code elements */
    /* and compute contents of each tree level */
          /* Adress Content   */
          /* Top    Leaves 0  */
          /* Top-1  Nodes  0  */
          /* ...... .......   */
          /* Top-2k Leaves k  */
          /* Top-2k-1 Nodes  k  */

          MaxDepth = 0;
          for(i=0; i<16; i++) 
    {
                read(HuffmanTableInP, c);
                LeavesN = HTable[id][MAX_SIZE(group)-2*i-1] = c;
                CellsN = 2*NodesN; /* nodes is old */
                NodesN = HTable[id][MAX_SIZE(group)-2*i-2] = CellsN-LeavesN;
                if (LeavesN) MaxDepth = i;
          }
          size-=16;

          /* build root at address 0, then deeper levels at */
          /* increasing addresses until MAX_CELLS reached */

          HTable[id][0] = 1 | GOOD_NODE_FLAG;   /* points to cell _2_ ! */
          /* we give up address one to keep left brothers on even adresses */
          NextCellPt = 2;
          i = 0;      /* this is actually length 1 */

          done = 0;

          while (i<= MaxDepth) 
    {

                /* then load leaves for other levels */
                LeavesN = HTable[id][MAX_SIZE(group)-2*i-1];
                for(k = 0; k<LeavesN; k++) 
      {
                    if (!done) 
        {
                          read(HuffmanTableInP, c);
                          HTable[id][NextCellPt++] = c | GOOD_LEAF_FLAG;
                          if (NextCellPt >= MAX_CELLS(group)) 
          {
            done = 1;
            printf("%s:\n\tWARNING:\tTruncating Table at depth %d\n",fullName(), i+1);
                          }
                    } else {
                          read(HuffmanTableInP, c); /* throw it away, just to keep file sync */
                    }
                }
                size -= LeavesN;

                if (done || (i == MaxDepth)) { i++; continue; }
                /* skip useless node building */

                /* then build nodes at that level */
                NodesN = HTable[id][MAX_SIZE(group)-2*i-2];
    
                NextLevelPt = NextCellPt+NodesN;
                for(k = 0; k<NodesN; k++) 
      {
                    if (NextCellPt >= MAX_CELLS(group)) { done = 1; break; }

                    flag = ((NextLevelPt|1)>=MAX_CELLS(group))?BAD_LEAF_FLAG:GOOD_NODE_FLAG;
                    /* we OR by 1 to check even right brother within range */
                    HTable[id][NextCellPt++] = (NextLevelPt/2) | flag;
                    NextLevelPt += 2;
                }

                i++;  /* now for next level */
          } /* nothing left to read from file after maxdepth */
    #ifdef VERBOSE
      printf("%s:\n\tUsing %d words of table memory\n", fullName(), NextCellPt);
    #endif
      } /* loop on tables */

      /*-- this is useful for displaying the uploaded tree --*/
/*       for(i=0; i<NextCellPt; i++) {
      switch (HUFF_FLAG(HTable[id][i])) {
      case GOOD_NODE_FLAG:
      printf("Cell %X: Node to %X and %X\n", i,
      HUFF_VALUE(HTable[id][i])*2,
      HUFF_VALUE(HTable[id][i])*2 +1);
      break;
      case GOOD_LEAF_FLAG:
      printf("Cell %X: Leaf with value %X\n", i,
      HUFF_VALUE(HTable[id][i]) );
      break;
      case SPECIAL_FLAG:
      printf("Cell %X: Special flag\n", i);
      break;
      case BAD_LEAF_FLAG:
      printf("Cell %X: Bad leaf\n", i);
      break;
      }
      }
*/
  return 0;
}

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

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

void VLD::main()
{
  VYAimageDepth   nrOfImageComponents;
  VYAimageComponent*  imageComponent;
  VYAimageH*    H;
  VYAimageV*    V;
  Marker      marker;
  unsigned int    numberOfMCU;

  read(markerInP, marker);
  while (marker != SOS_MK)
  {
    if (marker == DHT_MK)
    {
      load_huff_tables();
    } else
    if (marker == DRI_MK)
    {
      load_restart_interval();
    }
    read(markerInP, marker);
  }

  read(imageDepthInP, nrOfImageComponents);

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

  while (true)
  {
    VYAimageDepth   nrOfScanComponents;
    VYAimageComponent*  scanComponentId;
    VYAid*      huffmanTableId;
    VYApixel*   prediction;
    
    read(scanDepthInP, nrOfScanComponents);
  
    scanComponentId = new VYAimageComponent[nrOfScanComponents];
    huffmanTableId = new VYAid[nrOfScanComponents];
    prediction = new VYApixel[nrOfScanComponents];
    
    for(unsigned int i=0; i<nrOfScanComponents; i++)
    {
      read(scanComponentIdInP, scanComponentId[i]);
      read(HuffmanTableIdInP, huffmanTableId[i]);
      prediction[i] = 0;
    }

    bit_count = 0; 
    numberOfMCU = 0;
    while (true)
    {
      for(unsigned int i=0; i<nrOfScanComponents; i++)
      {
        int     hi = H[scanComponentId[i]];
        int     vi = V[scanComponentId[i]];
        VYApixel  value;
        unsigned int  cat, run;
              unsigned char   DC_HT = first_quad(huffmanTableId[i]);
              unsigned char   AC_HT = second_quad(huffmanTableId[i]);
        unsigned char   symbol;
            
        for(int j=0; j<hi; j++)
        {
          for(int k=0; k<vi; k++)
          {
            // decode DC coefficient
            symbol = get_symbol(HUFF_ID(DC_CLASS, DC_HT));
            value = reformat(get_bits(symbol), symbol);
            value += prediction[scanComponentId[i]];
            write(CoutP, value);
            prediction[scanComponentId[i]] = value;

            // decode AC coefficients
            unsigned int l;
            unsigned int m;
            for (l=1; l<64; l++)
            {
              symbol = get_symbol(HUFF_ID(AC_CLASS, AC_HT));
              if (symbol == HUFF_EOB) break;
              if (symbol == HUFF_ZRL) 
              { 
                for (m=l; m<=l+15; m++)
                {
                  write(CoutP, (VYApixel)0);
                }
                l += 15; 
              } else {
                cat = symbol & 15;
                run = (symbol>>4) & 15;
                for (m=l; m<l+run; m++)
                {
                  write(CoutP, (VYApixel)0);
                }
                l += run;
                value = reformat(get_bits(cat), cat);
                  write(CoutP, value);
              }
            }
            for (m=l; m<64; m++)
            {
              write(CoutP, (VYApixel)0);
            }
          }
        }
      }
      numberOfMCU++;
      
      if (numberOfMCU == restartInterval)
      { 
        Bits aux;
        read(CinP, aux);
        if (aux == 0xFF)
        {
          read(CinP, aux);    
                            if (RST_MK(0xFF00 | aux))
          {
            bit_count = 0;
            for(unsigned int i=0; i<nrOfScanComponents; i++)
            {
              prediction[i] = 0;
            }
            numberOfMCU = 0;
          } else {
                                  printf("%s:\n\tERROR:\tDid not find restart marker!\n",fullName());
            abort();
          }
        }
        
      }
    }
    delete [] scanComponentId;
    delete [] huffmanTableId;
    delete [] prediction;
  }
      
  delete [] imageComponent;
  delete [] H;
  delete [] V;    
}


/* transform JPEG number format into usual 2's complement format */
VYApixel VLD::reformat(unsigned long S, int good)
{
      unsigned int St;

      if (!good) 
    return 0;
      St = 1 << (good-1); /* 2^(good-1) */
      if (S < St) 
    return (S+1+((-1)<<good));
      else 
    return S;
}

/*---------------------------------------------------------------------*/

int VLD::get_bits(int number)
{
  int i, newbit;
  int result = 0;
  Bits wwindow;
  Bits aux;
  
  if (!number)
    return 0;
  for (i=0; i<number; i++) 
  {
          if (bit_count == 0) 
    {
                read(CinP, wwindow);
                if (wwindow == 0xFF)  
      {
                    read(CinP, aux);
                    switch (aux) 
        { /* skip stuffer 0 byte */
                        case EOF:
                        case 0xFF:
                            printf("%s:\n\tERROR:\tRan out of bit stream\n",fullName());
                            abort();
                            break;
          
                        case 0x00:
//                            stuffers++;
                            break;
          
                        default:
                            if (RST_MK(0xFF00 | aux))
                                  printf("%s:\n\tERROR:\tSpontaneously found restart marker!\n",fullName());
                            printf("\tERROR:\tLost sync in bit stream\n");
                            abort();
                            break;
                    }
                }
                bit_count = 8;
          } else {
                wwindow = window;
    }
          newbit = (wwindow>>7) & 1;
          window = wwindow << 1;
          bit_count--;
          result = (result << 1) | newbit;
      }
  return result;
}

unsigned char VLD::get_symbol(int select)
{
  int cellPt;

  cellPt = 0; /* this is the root cell */

  while(HUFF_FLAG(HTable[select][cellPt]) == GOOD_NODE_FLAG)
  {
    cellPt = get_bits(1) | (HUFF_VALUE(HTable[select][cellPt])<<1);
  }
  
      switch (HUFF_FLAG(HTable[select][cellPt])) 
  {
        case SPECIAL_FLAG:
              printf("%s:\n\tERROR:\tFound forbidden Huffman symbol !\n", fullName());
              abort();
              break;

        case GOOD_LEAF_FLAG:
              return HUFF_VALUE(HTable[select][cellPt]);
              break;

        case BAD_LEAF_FLAG:
              /* how do we fall back in case of truncated tree ? */
              /* suggest we send an EOB and warn */
              printf("%s:\n\tWARNING:\tFalling out of truncated tree !\n", fullName());
              return 0;
              break;

        default:
              break;
  }
  return 0;
}

void VLD::load_restart_interval()
{
  Bits firstc;
  Bits nextc;

  read(restartIntervalBitsInP, firstc);
  restartInterval = firstc;
  read(restartIntervalBitsInP, nextc);
  restartInterval = (restartInterval<<8) | nextc; // big endian
}

---