/Users/craigcornelius/Projects/SPRING Mac Release 0.2/jpeg.cpp

Go to the documentation of this file.

//*******************************************************************
//
//              National Biocomputation Center
//
//*******************************************************************

//#include "stdafx.h"
#include "jpeg.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#ifndef _WIN32
#include <dlfcn.h>
#endif

#include <iostream>

using namespace std;

#ifdef __APPLE__
#define BYTE unsigned char
#define LONG long
#define PRIVATE private
#define PUBLIC
#endif // __APPLE__

const unsigned int MAX_ALLOWED = 64 * 1024;
const int put_buff_size = DEFAULT_PUT_QUEUE_SIZE;
static BYTE myBuf[2][put_buff_size];


//*******************************************************************
// Preprocessing
//*******************************************************************
#ifndef _WIN32 // Linux/Solaris specific handling

PRIVATE LONG defer_function(PIC_PARM *p, RESPONSE res);

bool pegasusInitialized = false;
void* Peg_handle;
PUBLIC RESPONSE DLLEXPORTWINAPI (*Peg) (PIC_PARM PICHUGE *p, REQUEST req);
PUBLIC  BOOL DLLEXPORTWINAPI (*PegQuery) (PIC_PARM PICHUGE *p);
PUBLIC  LONG DLLEXPORTWINAPI (*PegLoad) (
    OPERATION Op,
    LONG ParmVer,
    char PICFAR *Path);

PUBLIC  LONG DLLEXPORTWINAPI (*PegLoadFromRes) (
    OPERATION Op,
    LONG ParmVer,
    char PICFAR *Path,
    DWORD hInstance);
PUBLIC  BOOL DLLEXPORTWINAPI (*PegLibInit) (DWORD hInstance);

PUBLIC  void DLLEXPORTWINAPI (*PegLibTerm) (void);

PUBLIC  void DLLEXPORTWINAPI (*PegLibThreadInit) (void);

PUBLIC  void DLLEXPORTWINAPI (*PegLibThreadTerm) (void);

void InitPegasus()
{
#ifdef linux
  Peg_handle = dlopen("./libs/libpicl20.so", RTLD_LAZY);
#else
  Peg_handle = dlopen("./libs/libpicu20.so", RTLD_LAZY);
#endif
  if (Peg_handle == NULL) {
    fputs(dlerror(),stderr);
    exit(0);
  }
  Peg = (RESPONSE DLLEXPORTWINAPI (*) (PIC_PARM PICHUGE *p, REQUEST req))dlsym(Peg_handle,"Pegasus");
  PegQuery = (PUBLIC  BOOL DLLEXPORTWINAPI (*) (PIC_PARM PICHUGE *p))dlsym(Peg_handle,"PegasusQuery");
  PegLoad = (PUBLIC  LONG DLLEXPORTWINAPI (*) (
                                               OPERATION Op,
                                               LONG ParmVer,
                                               char PICFAR *Path))dlsym(Peg_handle,"PegasusLoad");
  
  PegLoadFromRes = (PUBLIC  LONG DLLEXPORTWINAPI (*) (
                                                      OPERATION Op,
                                                      LONG ParmVer,
                                                      char PICFAR *Path,
                                                      DWORD hInstance))dlsym(Peg_handle,"PegasuLoadFromres");
  
  PegLibInit = (PUBLIC  BOOL DLLEXPORTWINAPI (*) (DWORD hInstance))dlsym(Peg_handle,"PegasusLibInit");
  PegLibThreadInit = (PUBLIC  void DLLEXPORTWINAPI (*) (void))dlsym(Peg_handle,"PegasusLibThreadInit");
  PegLibThreadTerm = (PUBLIC  void DLLEXPORTWINAPI (*) (void))dlsym(Peg_handle,"PegasusLibThreadTerm");
  
  if ((PegQuery != NULL) && (Peg != NULL) && (PegLoad != NULL) && (PegLibInit != NULL) &&
      (PegLibThreadInit != NULL))
    cerr << "so far so good\n";
  else 
    exit(0);
  
  LONG res = (*PegLoad)(OP_D2S,CURRENT_PARMVER,"./libs/");
        res = (*PegLoad)(OP_S2D,CURRENT_PARMVER,"./libs/");
        //   cerr << "\n\n loading dll \t" << res << "\n";
}

#define Pegasus (*Peg)
#define PegasusQuery (*PegQuery)
#define PegasusLibInit (*PegLibInit)
#define PegasusLibThreadInit (*PegLibThreadInit)
#define PegasusLibThreadTerm (*PegLibThreadTerm)


//*******************************************************************
// DeferFunction
//*******************************************************************
PRIVATE LONG    defer_function(PIC_PARM *p, RESPONSE res)
{
  cerr << "\n\n Ooops \t" << res << "\n";
  return(0);
}

// for compatibility with Windows
void MessageBox(void* dummy1, char* msg, void* dummy2, int ok)
{ cerr << msg << endl; }
#define MB_OK   0

#else // now for compatibility with Windows.

extern HINSTANCE hInst;
bool pegasusInitialized = false;
void InitPegasus() {return;}

#endif


//*******************************************************************
// ExpandJPEGTo24BitDIB
//*******************************************************************
LONG ExpandJPEGTo24BitDIB(
  LPBYTE       pbInputBuffer,       // pointer to JPEG image
  DWORD        dwInputLength,       // length of JPEG image
  LPBYTE      *ppbOutputBuffer,     // receive pointer to DIB
  DWORD       *pdwOutputLength)     // receive length of DIB
{
  if (!pegasusInitialized) 
    { 
      InitPegasus(); 
      pegasusInitialized = true;
    }

  PIC_PARM PicParm;
  RESPONSE Response;
  
  // general PIC_PARM initialization for all operations
  memset(&PicParm, 0, sizeof(PicParm));
  PicParm.ParmSize     = sizeof(PicParm);
  PicParm.ParmVer      = CURRENT_PARMVER; // #define'd in PIC.H
  PicParm.ParmVerMinor = 1; // a magic number for the current version
#ifndef _WIN32
  PicParm.DeferFn = &defer_function;
#endif
  // initialize input buffer pointers
  PicParm.Get.Start  = pbInputBuffer;
  PicParm.Get.End    = pbInputBuffer + dwInputLength;

  // initialize input queue pointers
  PicParm.Get.Front  = PicParm.Get.Start;
  PicParm.Get.Rear   = PicParm.Get.End;
  PicParm.Get.QFlags = Q_EOF; // since no input follows
#ifndef _WIN32
  PicParm.Flags |= F_UseDeferFn;
#endif

  // identify and validate the source image type
  // request that PegasusQuery return the image type
  PicParm.u.QRY.BitFlagsReq = QBIT_BICOMPRESSION;
  if ( !PegasusQuery(&PicParm) ||
       ( PicParm.Head.biCompression != BI_JPEG &&
         PicParm.Head.biCompression != BI_PICJ ) )
    return ( ERR_BAD_IMAGE_TYPE );

  // initialize parameters specific to expand JPEG
  PicParm.Op = OP_S2D; // requests Sequential JPEG to DIB operation
  // memset because PegasusQuery may set values in the same union
  memset(&PicParm.u.S2D, 0, sizeof(PicParm.u.S2D));
  PicParm.u.S2D.DibSize = 24; // request 24-bit DIB output

  // JPEG expand operation initialization
  Response = Pegasus(&PicParm, REQ_INIT);

  if ( Response == RES_ERR )
    return ( PicParm.Status );
  assert(Response == RES_DONE); // any other response is unexpected

  // Allocate DIB output buffer
  *pdwOutputLength = PicParm.Head.biHeight * PicParm.u.S2D.WidthPad;

  *ppbOutputBuffer = (unsigned char*)malloc(*pdwOutputLength);
  if ( *ppbOutputBuffer == 0 )
    {
    Pegasus(&PicParm, REQ_TERM);
    return ( ERR_OUT_OF_SPACE );
    }            
  // initialize output buffer pointers
  PicParm.Put.Start  = *ppbOutputBuffer;
  PicParm.Put.End    = *ppbOutputBuffer + *pdwOutputLength;

  // initialize output queue pointers
  PicParm.Put.Front  = PicParm.Put.End;
  PicParm.Put.Rear   = PicParm.Put.Front;
  //PicParm.Put.QFlags = Q_REVERSE; // top DIB line is at buffer bottom

  // JPEG expand operation execution
  Response = Pegasus(&PicParm, REQ_EXEC);

  if ( Response == RES_ERR )
    {
    // operation cleanup has already taken place
    free(*ppbOutputBuffer); 
    return ( PicParm.Status );
    }
  assert(Response == RES_DONE);

  // JPEG expand operation cleanup
  Response = Pegasus(&PicParm, REQ_TERM);
  assert(Response == RES_DONE);

  return ( ERR_NONE );
}


//*******************************************************************
// CompressToJPEG
//*******************************************************************
LONG CompressToJPEG(
  LPBYTE       pbInputBuffer,       // pointer to DIB image
  DWORD        dwInputLength,       // length of DIB image
  LPBYTE*      ppbOutputBuffer,     // receive pointer to JPEG
  DWORD*       pdwOutputLength,     // receive length of JPEG
  int code
  ) 
{

#ifdef _WIN32
//      PegasusLibInit((unsigned int)hInst);
//      PegasusLibThreadInit();
#endif

  if (!pegasusInitialized) 
    { 
      InitPegasus(); 
      pegasusInitialized = true;
    }

  PIC_PARM PicParm;
  RESPONSE Response;

  // general PIC_PARM initialization for all operations
  memset(&PicParm, 0, sizeof(PicParm));
  PicParm.ParmSize     = sizeof(PicParm);
  PicParm.ParmVer      = CURRENT_PARMVER; // #define'd in PIC.H
  PicParm.ParmVerMinor = 1; // a magic number for the current version
#ifndef _WIN32
  PicParm.DeferFn = &defer_function;
#endif

  // initialize input buffer pointers
  PicParm.Get.Start  = pbInputBuffer;
  PicParm.Get.End    = pbInputBuffer + dwInputLength;

  // initialize input queue pointers
  PicParm.Get.Front  = PicParm.Get.Start;
  PicParm.Get.Rear   = PicParm.Get.End;

#ifndef _WIN32
  PicParm.Flags |= F_UseDeferFn;
#endif

  // identify and validate the source image type
  // request that PegasusQuery return the image type
  PicParm.u.QRY.BitFlagsReq = QBIT_BICOMPRESSION;
  if ( !PegasusQuery(&PicParm) 
          ||
       ( PicParm.Head.biCompression != BI_RGB ))
    return ( ERR_BAD_IMAGE_TYPE );
  memset(&PicParm.u.QRY, 0, sizeof(PicParm.u.QRY));
  PicParm.Get.QFlags |= Q_EOF;

  // initialize parameters specific to compress DIB
  PicParm.Op = OP_D2S; // requests DIB to Sequential JPEG operation
  // memset because PegasusQuery may set values in the same union
  memset(&PicParm.u.D2S, 0, sizeof(PicParm.u.D2S));

  // Set some compression paramaters
  PicParm.Get.Front  += 54;
  PicParm.u.D2S.LumFactor = 24;
  PicParm.u.D2S.ChromFactor =  30;
  PicParm.u.D2S.SubSampling = 2;
  PicParm.u.D2S.JpegType = JT_RAW;
  PicParm.u.D2S.PicFlags |= PF_OptimizeHuff;

  //PicParm.Get.QFlags |= Q_REVERSE;
  PicParm.Head.biHeight = -PicParm.Head.biHeight; /* so .pic file will be top-down */

  // allocate memory for compression
  PicParm.Put.Start = myBuf[code];
  PicParm.Put.Front = PicParm.Put.Rear = PicParm.Put.Start + 3;
  PicParm.Put.End = PicParm.Put.Start + put_buff_size;


  // JPEG compression operation initialization
  Response = Pegasus(&PicParm, REQ_INIT);
  if ( Response == RES_ERR )
    return ( PicParm.Status );
  assert(Response == RES_DONE); // any other response is unexpected
   
        if(PicParm.Get.QFlags & Q_REVERSE)
        {
                PicParm.Get.Rear = PicParm.Get.Front;
                PicParm.Get.Front += PicParm.Head.biSizeImage;
        }

  // JPEG compress operation execution
  Response = Pegasus(&PicParm, REQ_EXEC);

  if ( Response == RES_ERR )
    {
    return ( PicParm.Status );
    }
  assert(Response == RES_DONE);

  // Return the compressed JPEG image
  *pdwOutputLength = PicParm.Put.Rear - PicParm.Put.Front;
 // *ppbOutputBuffer = (unsigned char*)malloc(*pdwOutputLength);
  memcpy(*ppbOutputBuffer,PicParm.Put.Front,*pdwOutputLength);
  // JPEG compress operation cleanup
  Response = Pegasus(&PicParm, REQ_TERM);
  assert(Response == RES_DONE);
  //if (myBuf != NULL) delete myBuf;

#ifdef _WIN32
//      PegasusLibTerm();
//      PegasusLibThreadTerm();
#endif


  return ( ERR_NONE );
}

---