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

DMX::DMX(
  Id            n, 
  In<Bits>&     jpegBits,
  Out<Bits>&    quantTableBits, 
  Out<Bits>&    huffTableBits,
  Out<Bits>&    frameHeaderBits,
  Out<Bits>&    scanHeaderBits,
  Out<Bits>&    MCUBits,
  Out<Bits>&    restartIntervalBitsOut,
  Out<Marker>&  DHTmarkerOut,
  Out<Marker>&  DQTmarkerOut)
:
  Process(n),
  jpegIn(                 id("jpegIn"),                 jpegBits),
  quantizationTableOut(   id("quantizationTableOut"),   quantTableBits),
  huffmanTableOut(        id("huffmanTableOut"),        huffTableBits),
  frameHeaderOut(         id("frameHeaderOut"),         frameHeaderBits),
  scanHeaderOut(          id("scanHeaderOut"),          scanHeaderBits),
  MCUOut(                 id("MCUOut"),                 MCUBits),
  restartIntervalBitsOutP(id("restartIntervalBitsOutP"),restartIntervalBitsOut),
  DHTmarkerOutP(          id("DHTmarkerOutP"),          DHTmarkerOut),
  DQTmarkerOutP(          id("DQTmarkerOutP"),          DQTmarkerOut)
{ 
}

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

void DMX::main()
{
  Bits  bits;
  Bits  bits1;
  Marker  marker;

  // get SOI marker
  get_marker(marker);
  if (marker == SOI_MK)
  {
    #ifdef VERBOSE
      printf("%s:\n\tFound the SOI marker!\n", fullName());
    #endif
  } else {
    #ifdef VERBOSE
      printf("%s:\n\tCould not find the SOI marker!\n", fullName());
    #endif
    abort();
  }

  // get next marker
  get_marker(marker);   
  while (marker != EOI_MK)  
  {
    Bits firstc;
    Bits nextc;
    unsigned int size;
    
    switch (marker) 
    {
      case COM_MK:
                  #ifdef VERBOSE
                  printf("%s:\n\tSkipping comments\n", fullName());
                  #endif
                  get_marker(marker);
                  break;
      
      case DQT_MK:
                  #ifdef VERBOSE
                  printf("%s:\n\tDefining Quantization Tables\n", fullName());
                  #endif
                  write(DQTmarkerOutP, marker);
                  while (get_bits(bits,marker))
                  {
                    write(quantizationTableOut, bits);
                  }
                  break;

    case SOF_MK:
                  #ifdef VERBOSE
                  printf("%s:\n\tFound the SOF marker!\n",fullName());
                  #endif
                  while (get_bits(bits,marker))
                  {
                    write(frameHeaderOut, bits);
                  }
                  break;

    case DHT_MK:
                  #ifdef VERBOSE
                  printf("%s:\n\tDefining Huffman Tables\n",fullName());
                  #endif
                  write(DHTmarkerOutP, marker);
                  while (get_bits(bits,marker))
                  {
                    write(huffmanTableOut, bits);
                  }
                  break;

    case DRI_MK:
                  {
                    #ifdef VERBOSE
                    printf("%s:\n\tDefining Restart Interval\n",fullName());
                    #endif
                    write(DHTmarkerOutP, marker); 

                    read(jpegIn, firstc);
                    size = firstc;
                    read(jpegIn, nextc);
                    size = (size<<8) | nextc; // big endian
      
                    for(unsigned int i=0; i<size-2; i++)
                    {
                      read(jpegIn, bits);
                      write(restartIntervalBitsOutP, bits);
                    }
      
                    get_marker(marker);

                    break;
                  }
    case SOS_MK:
                  {
                    #ifdef VERBOSE
                    printf("%s:\n\tFound the SOS marker!\n",fullName());
                    #endif
                    write(DHTmarkerOutP, marker); 
                    write(DQTmarkerOutP, marker); 

                    read(jpegIn, firstc);
                    write(scanHeaderOut, firstc);
                    size = firstc;
                    read(jpegIn, nextc);
                    write(scanHeaderOut, nextc);
                    size = (size<<8) | nextc; // big endian
      
                    for(unsigned int i=0; i<size-2; i++)
                    {
                      read(jpegIn, bits);
                      write(scanHeaderOut, bits);
                    }
            
                    bool newmarker;
                    newmarker = false;
                    while (!newmarker)
                    {
                      read(jpegIn, bits);
                      if (bits != 0xFF)
                      {       
                        write(MCUOut, bits);
                      } else {
                        read(jpegIn, bits1);
                        if (bits1 == 0x00 || RST_MK(0xFF00|bits1))
                        {
                          write(MCUOut, bits);
                          write(MCUOut, bits1);
                        } else {
                          marker = (0xFF00 | bits1);
                          newmarker = true;
                        }
                      }
                    }
                    break;
                   }  
    case EOF:
                  #ifdef VERBOSE
                  printf("%s:\n\tRan out of input data!\n",fullName());
                  #endif
                  abort();

    default:
                  {
                    if ((marker&MK_MSK) == APP_MK) 
                    {
                      Bits firstc;
                      Bits nextc;
                      unsigned int size;

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

                      #ifdef VERBOSE
                      printf("%s:\n\tSkipping application data\n",fullName());
                      #endif
                      for(unsigned int i=0; i<size-2; i++)
                      {
                        read(jpegIn, bits);
                      }
    
                      get_marker(marker);
                    } else {
                      #ifdef VERBOSE
                      printf("%s:\n\tWARNING:\tLost sync outside scan, %x!\n",fullName(),marker);
                      #endif
                      abort();
                    }
                    break;
                  }
    } /* end switch */
  }
  #ifdef VERBOSE
  printf("%s:\n\tFound the EOI marker!\n",fullName());
  #endif
}

bool DMX::get_bits(Bits& bits, Marker& marker)
{
  read(jpegIn, bits);
  if (bits == 0xFF)
  {
    read(jpegIn, bits);
    if (bits == 0x00)
    {
      bits = 0xFF;
      return true;
    } else {
      marker = (0xFF00 | bits);
      return false;
    }
  }
  return true;
}

void DMX::get_marker(Marker& marker)
{
  Bits bits;
  while (get_bits(bits,marker));
}

---