OptIO/src/rzipunzip.c

// $Id: rzipunzip.c,v 1.5 2009/02/27 17:39:30 bendavid Exp $

#include "MitCommon/OptIO/src/rzipunzip.h"
#include "MitCommon/OptIO/src/zlib.h"
#include "MitCommon/OptIO/src/bzlib.h"
#include "MitCommon/OptIO/src/lzo/lzo1x.h"
#include "MitCommon/OptIO/src/rle.h"
#include "MitCommon/OptIO/src/LzmaEnc.h"
#include "MitCommon/OptIO/src/LzmaDec.h"
#include "MitCommon/OptIO/src/fpc.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef HDRSIZE
#define HDRSIZE 9
#else
#error "HDRSIZE already defined."
#endif

#ifndef MYSIZE
#define MYSIZE 5*1024*1024
#else
#error "MYSIZE already defined."
#endif

typedef unsigned char uch;  /* code assumes unsigned bytes; these type- */

extern int R__ZipMode;
char mymem[MYSIZE];
char *myptr = mymem;

// the following will be set to one if code was activated
int activated = 0;

// the following can be changed using the OptInt interface
double lzipfrac = 1;
double gzipfrac = 1;
double bzipfrac = 1;
double lzmafrac = 1;
int myverbose = 0;
int mystaticm = 0;

//--------------------------------------------------------------------------------------------------
void *mymalloc(size_t size)
{
  if(!mystaticm || size>MYSIZE)
    return malloc(size);

  if(myptr-mymem>MYSIZE-size) {
    myptr=mymem;
  }

  void *v=(void*)myptr;
  myptr+=size;
  return v;
}
 
//--------------------------------------------------------------------------------------------------
void mymfree(void *ptr)
{
  if (mystaticm && (char*)ptr>=mymem && (char*)ptr<mymem+MYSIZE)
    return;
  free(ptr);
}

// memory handle functions
static void *SzAlloc(void *p, size_t size) { p = p; return mymalloc(size); }
static void SzFree(void *p, void *address) { p = p; mymfree(address); }
static ISzAlloc g_Alloc = { SzAlloc, SzFree };
static void* my_balloc (void* opaque, int items, int size)
{
  opaque = opaque; 
  return mymalloc(items*size);
}
static void my_bfree (void* opaque, void* addr)
{
  opaque = opaque;
  mymfree(addr);
}
static voidpf my_zalloc OF((voidpf opaque, unsigned items, unsigned size))
{
  opaque = opaque; 
  return mymalloc(items*size);
}
static void my_zfree  OF((voidpf opaque, voidpf ptr))
{
  opaque = opaque;
  mymfree(ptr);
}

//--------------------------------------------------------------------------------------------------
void delta_encode(char *buffer, int length)
{
  char t = 0;
  char original;
  int i;
  for (i=0; i < length; ++i) {
    original = buffer[i];
    buffer[i] -= t;
    t = original;
  }
}
 
void delta_decode(char *buffer, int length)
{
  char t = 0;
  int i;
  for (i=0; i < length; ++i) {
    buffer[i] += t;
    t = buffer[i];
  }
}

//--------------------------------------------------------------------------------------------------
void R__zip(int cxlevel, int *srcsize, char *src, int *tgtsize, char *tgt, int *irep)
     /* int cxlevel;                      compression level */
     /* int  *srcsize, *tgtsize, *irep;   source and target sizes, replay */
     /* char *tgt, *src;                  source and target buffers */
{
  int err               = 0;
  int method            = 0; 
  unsigned int in_size  = 0;
  unsigned int out_size = 0;

  if (*tgtsize <= HDRSIZE) {
    R__error("target buffer too small");
    return;
  }
  if (*srcsize > 0xffffff) {
    R__error("source buffer too big");
    return;
  }

  *irep        = 0;
  in_size      = (unsigned)(*srcsize); /* decompressed size */
  char *tgtptr = tgt+HDRSIZE;          /* compress data     */

  if (R__ZipMode == 99) { /*determine best of all methods*/
    int cont    = 1;
    int msize   = -1;
    int zmode   = -1;
    int tgtlen  = 2*in_size+64*1024;
    char *mptr1 = mymalloc(tgtlen);
    char *mptr2 = mymalloc(tgtlen);
    char *mptr  = 0;
    char *mdum  = 0;

    if (cont) {
      zmode = 4;
      msize = RLE_Compress(src, mptr1, in_size);
      mptr = mptr1;
      mdum = mptr2;
    }

    if (cont && lzipfrac>0) {
      err = lzo_init(); 
      if ( err == LZO_E_OK) {
        lzo_uint outlen = tgtlen;
        char *lwmem = mymalloc(LZO1X_999_MEM_COMPRESS);
        err = lzo1x_999_compress(src,in_size,mdum,&outlen,lwmem);
        if (err == LZO_E_OK) {
          if (outlen<lzipfrac*msize) {
            msize = outlen;
            zmode = 3;
            char *tmp = mptr;
            mptr = mdum;
            mdum = tmp;
          }
        }
        mymfree(lwmem);
      }
    }

    if (cont && gzipfrac>0) {
      int outlen = *tgtsize;
      z_stream stream;
      stream.next_in   = (Bytef*)src;
      stream.avail_in  = (uInt)(in_size);
      stream.next_out  = (Bytef*)(mdum);
      stream.avail_out = (uInt)(outlen);
      stream.zalloc    = (alloc_func)0;
      stream.zfree     = (free_func)0;
      stream.opaque    = (voidpf)0;

      err = deflateInit(&stream, cxlevel);
      if (err == Z_OK) {
        err = deflate(&stream, Z_FINISH);
        if (err == Z_STREAM_END) {
          err = deflateEnd(&stream);
          int outlen = stream.total_out;
          if (outlen<gzipfrac*msize) {
            msize = outlen;
            zmode = 1;
            char *tmp = mptr;
            mptr = mdum;
            mdum = tmp;
          }
        }
      }
    }

    if (cont && bzipfrac>0) {
      int outlen = *tgtsize;
      bz_stream stream;
      stream.next_in   = src;
      stream.avail_in  = (uInt)(in_size);
      stream.next_out  = mdum;
      stream.avail_out = (uInt)(outlen);
      stream.bzalloc = 0;
      stream.bzfree  = 0;
      stream.opaque  = 0;

      err = BZ2_bzCompressInit(&stream, 9, 0, 1);
      if (err == BZ_OK) {
        err = BZ2_bzCompress(&stream, BZ_FINISH);
        if (err == BZ_STREAM_END) {
          BZ2_bzCompressEnd(&stream);
        }
        int outlen = stream.total_out_lo32;
        if (outlen<bzipfrac*msize) {
          msize = outlen;
          zmode = 2;
          char *tmp = mptr;
          mptr = mdum;
          mdum = tmp;
        }
      }
    }
    if (cont && lzmafrac>0) {
      CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
      if (enc) {
        CLzmaEncProps props;
        LzmaEncProps_Init(&props);
        props.level = cxlevel;
        props.dictSize = (1<<24);
        props.lc = 0;
        props.lp = 2;
        SRes res = LzmaEnc_SetProps(enc, &props);
        if (res == SZ_OK) {
          SizeT outlen = *tgtsize;
          res = LzmaEnc_MemEncode(enc, mdum, &outlen, src, in_size,
                                  0, NULL, &g_Alloc, &g_Alloc);
          if (res == SZ_OK) {
            if (outlen<lzmafrac*msize) {
              msize = outlen;
              zmode = 5;
              char *tmp = mptr;
              mptr = mdum;
              mdum = tmp;
            }
          }
        }
      }
      LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
    }

    // determine best candidate
    if (msize>=in_size) {
      out_size = in_size;
      memcpy(tgtptr,src,out_size);
      tgt[0] = 'X'; /* signature xx */
      tgt[1] = 'X';
      method = 0;
    } else {
      switch (zmode) {
        case 1:
          tgt[0] = 'Z'; /* signature zlib */
          tgt[1] = 'L';
          method = Z_DEFLATED; //==8
          break;
        case 2:
          tgt[0] = 'B'; /* signature bzlib */
          tgt[1] = 'Z';
          method = 2;
          break;
        case 3:
          tgt[0] = 'L'; /* signature lzolib */
          tgt[1] = 'O';
          method = 19;
          break;
        case 4:
          tgt[0] = 'R'; /* signature rlelib */
          tgt[1] = 'E';
          method = 4;
          break;
        case 5:
          tgt[0] = 'L'; /* signature lzma */
          tgt[1] = 'M';
          method = 3;
          break;
      }
      out_size = msize;
      memcpy(tgtptr,mptr,out_size);
    }
    mymfree(mptr1);
    mymfree(mptr2);
  } else if (R__ZipMode == 5) { /*lzma*/
    CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
    if (enc == 0) {
      printf("error %d - LzmaEnc_Create()\n", SZ_ERROR_MEM);
      return;
    }
    CLzmaEncProps props;
    LzmaEncProps_Init(&props);
    props.level = cxlevel;
    props.dictSize = (1<<24);
    props.lc = 0;
    props.lp = 2;
    SRes res = LzmaEnc_SetProps(enc, &props);
    if (res != SZ_OK) {
      printf("error %d - LzmaEnc_SetProps()\n", res);
      LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
      return;
    }
    res = LzmaEnc_MemEncode(enc, tgtptr, tgtsize, src, in_size,
                            0, NULL, &g_Alloc, &g_Alloc);
    if (res != SZ_OK) {
      printf("error %d - LzmaEnc_MemEncode", res);
      LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
      return;
    }
    LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
    out_size  = *tgtsize; /* compressed size */
    if (out_size>=lzmafrac*in_size) {
      out_size = in_size;
      memcpy(tgtptr,src,out_size);
      tgt[0] = 'X'; /* signature xx */
      tgt[1] = 'X';
      method = 0;
    } else {
      tgt[0] = 'L'; /* signature lzma */
      tgt[1] = 'M';
      method = 3;
    }
  } else if (R__ZipMode == 4) { /*rle*/
    int tgtlen = 2*in_size+1;
    char *lmem1 = mymalloc(tgtlen);

    out_size = RLE_Compress(src, lmem1, in_size);
    if (out_size>=in_size) {
      out_size = in_size;
      memcpy(tgtptr,src,out_size);
      tgt[0] = 'X'; /* signature xx */
      tgt[1] = 'X';
      method = 0;
    } else {
      memcpy(tgtptr,lmem1,out_size);
      tgt[0] = 'R'; /* signature rlelib */
      tgt[1] = 'E';
      method = 4;
    }
    mymfree(lmem1);
  } else if (R__ZipMode == 3) { /*lzo*/
    err = lzo_init(); 
    if ( err != LZO_E_OK) {
      printf("error %d - lzo_init()\n", err);
      return;
    }

    lzo_uint tgtlen = 2*in_size+64*1024;
    char *lmem1 = mymalloc(tgtlen);
    char *lmem2 = 0;
    if (cxlevel<=1) {
      lmem2 = mymalloc(LZO1X_1_11_MEM_COMPRESS);
      err = lzo1x_1_11_compress(src,in_size,lmem1,&tgtlen,lmem2);
      method = 11;
    } else if (cxlevel==2) {
      lmem2 = mymalloc(LZO1X_1_12_MEM_COMPRESS);
      err = lzo1x_1_12_compress(src,in_size,lmem1,&tgtlen,lmem2);
      method = 12;
    } else if (cxlevel<=5) {
      lmem2 = mymalloc(LZO1X_1_15_MEM_COMPRESS);
      err = lzo1x_1_15_compress(src,in_size,lmem1,&tgtlen,lmem2);
      method = 15;
    } else {
      lmem2 = mymalloc(LZO1X_999_MEM_COMPRESS);
      err = lzo1x_999_compress(src,in_size,lmem1,&tgtlen,lmem2);
      method = 19;
    } 
    if (err != LZO_E_OK) {
      mymfree(lmem1);
      mymfree(lmem2);
      return;
    }

    if (tgtlen>=lzipfrac*in_size) {
      out_size = in_size;
      memcpy(tgtptr,src,out_size);
      tgt[0] = 'X'; /* signature xx */
      tgt[1] = 'X';
      method = 0;
    } else  {
      out_size  = tgtlen; /* compressed size */
      memcpy(tgtptr,lmem1,out_size);
      tgt[0] = 'L'; /* signature lzolib */
      tgt[1] = 'O';
    }
    mymfree(lmem1);
    mymfree(lmem2);
  } else if (R__ZipMode == 2) { /*bzip*/
    bz_stream stream;
    stream.next_in   = src;
    stream.avail_in  = (uInt)(in_size);
    stream.next_out  = tgtptr;
    stream.avail_out = (uInt)(*tgtsize);
    stream.bzalloc = 0;
    stream.bzfree  = 0;
    stream.opaque  = 0;

    err = BZ2_bzCompressInit(&stream, 9, 0, 1+(9-cxlevel)*25);
    if (err != BZ_OK) {
       printf("error %d in BZ2_bzCompressInit (bzlib)\n",err);
       return;
    }
    err = BZ2_bzCompress(&stream, BZ_FINISH);
    if (err != BZ_STREAM_END) {
      BZ2_bzCompressEnd(&stream);
      //printf("error %d in BZ2_bzCompress (bzlib) is not = %d\n",err,BZ_STREAM_END);
      return;
    }
    err = BZ2_bzCompressEnd(&stream);

    out_size  = stream.total_out_lo32; /* compressed size */
    if (out_size>=bzipfrac*in_size) {
      out_size = in_size;
      memcpy(tgtptr,src,out_size);
      tgt[0] = 'X'; /* signature xx */
      tgt[1] = 'X';
      method = 0;
    } else {
      tgt[0] = 'B'; /* signature bzlib */
      tgt[1] = 'Z';
      method = 2;
    }
  } else if (R__ZipMode == 1) { /*zip*/
    z_stream stream;
    stream.next_in   = (Bytef*)src;
    stream.avail_in  = (uInt)(in_size);
    stream.next_out  = (Bytef*)(tgtptr);
    stream.avail_out = (uInt)(*tgtsize);
    stream.zalloc    = (alloc_func)0;
    stream.zfree     = (free_func)0;
    stream.opaque    = (voidpf)0;

    err = deflateInit(&stream, cxlevel);
    if (err != Z_OK) {
       printf("error %d in deflateInit (zlib)\n",err);
       return;
    }
    err = deflate(&stream, Z_FINISH);
    if (err != Z_STREAM_END) {
       deflateEnd(&stream);
       //printf("error %d in deflate (zlib) is not = %d\n",err,Z_STREAM_END);
       return;
    }
    err = deflateEnd(&stream);

    out_size  = stream.total_out; /* compressed size */
    if (out_size>=gzipfrac*in_size) {
      out_size = in_size;
      memcpy(tgtptr,src,out_size);
      tgt[0] = 'X'; /* signature xx */
      tgt[1] = 'X';
      method = 0;
    } else {
      tgt[0] = 'Z'; /* signature zlib */
      tgt[1] = 'L';
      method = Z_DEFLATED;
    }
  } else if (R__ZipMode == 0) {
    printf("error: Old zip method not supported in this patch.");
    return;
  }

  // fill rest of header
  tgt[2] = (char)method;
  tgt[3] = (char)(out_size & 0xff);
  tgt[4] = (char)((out_size >> 8) & 0xff);
  tgt[5] = (char)((out_size >> 16) & 0xff);
  tgt[6] = (char)(in_size & 0xff);         
  tgt[7] = (char)((in_size >> 8) & 0xff);
  tgt[8] = (char)((in_size >> 16) & 0xff);
  *irep = out_size + HDRSIZE;

  if (myverbose==1||myverbose>9) {
    printf("R__zip:: zm=%d m=%d cl=%d: %c%c compressed %lu bytes into %lu bytes -> %.3f%%\n", 
           R__ZipMode, method, cxlevel, tgt[0], tgt[1], 
           (unsigned long)in_size, (unsigned long)out_size, (double)out_size/in_size*100.);
  }
}

//--------------------------------------------------------------------------------------------------
void R__unzip(int *srcsize, uch *src, int *tgtsize, uch *tgt, int *irep)
    /* Input: scrsize - size of input buffer                               */
    /*        src     - input buffer                                       */
    /*        tgtsize - size of target buffer                              */
    /* Output: tgt - target buffer (decompressed)                          */
    /*         irep - size of decompressed data                            */
    /*                0 - if error                                         */
{
  unsigned int osize   = 0;
  unsigned int ibufcnt = 0, obufcnt = 0;
  uch  *ibufptr = 0, *obufptr = 0;
  *irep = 0L;

  /*   C H E C K   H E A D E R   */
  if (*srcsize < HDRSIZE) {
    fprintf(stderr,"R__unzip: too small source\n");
    return;
  }

  char method = src[2];
  if (method!=0  && method!= 2 && method!= 3 && method!= 4 && method!=Z_DEFLATED && 
      method!=11 && method!=12 && method!=15 && method!=19) {
    fprintf(stderr,"R__unzip: error in header -> unknown method %d\n", method);
    return;
  }

  if ((method==0          &&  (src[0] != 'X' || src[1] != 'X'))    ||
      (method==2          &&  (src[0] != 'B' || src[1] != 'Z'))    ||
      (method==3          &&  (src[0] != 'L' || src[1] != 'M'))    ||
      (method==4          &&  (src[0] != 'R' || src[1] != 'E'))    ||
      (method==Z_DEFLATED && ((src[0] != 'C' || src[1] != 'S') && 
                              (src[0] != 'Z' || src[1] != 'L')))   ||
      ((method==11 || method==12 || method==15 || method==19)  && 
       (src[0] != 'L' || src[1] != 'O'))) {
    fprintf(stderr,"R__unzip: error in header -> m=%d with %c%c\n",
            method, src[0], src[1]);
    return;
  }

  ibufptr = src + HDRSIZE;
  ibufcnt = (unsigned int)src[3] | ((unsigned int)src[4] << 8) | ((unsigned int)src[5] << 16);
  osize   = (unsigned int)src[6] | ((unsigned int)src[7] << 8) | ((unsigned int)src[8] << 16);
  obufptr = tgt;
  obufcnt = *tgtsize;

  if (obufcnt < osize) {
    fprintf(stderr,"R__unzip: too small target\n");
    return;
  }

  if (ibufcnt + HDRSIZE != *srcsize) {
    fprintf(stderr,"R__unzip: discrepancy in source length\n");
    return;
  }

  if (myverbose==2 || myverbose>9) {
    printf("R__unzip:: zm=%d m=%d: %c%c uncompressed %lu bytes from %lu bytes (%.3f%%)\n", 
           R__ZipMode, method, src[0], src[1], osize, ibufcnt, (double)ibufcnt/osize*100.);
  }

  if (method==0) { // apparently this is not reached since underlying ROOT code catches this
    if (ibufcnt!=osize) {
      fprintf(stderr,"R__unzip: error in header -> input should be output %d!=%d\n", 
              ibufcnt, osize);
      return;
    }
    memcpy(obufptr,ibufptr,osize);
    *irep = obufcnt;
    return;
  }

  /*   D E C O M P R E S S   D A T A  */

  if (src[0] == 'L' && src[1] == 'M') { /* lzma format */
    CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
    if (enc == 0) {
      printf("error %d - LzmaEnc_Create (lzma)\n", SZ_ERROR_MEM);
      return;
    }
    CLzmaEncProps props;
    LzmaEncProps_Init(&props);
    props.dictSize = (1<<24);
    props.lc = 0;
    props.lp = 2;
    SRes res = LzmaEnc_SetProps(enc, &props);
    if (res != SZ_OK) {
      printf("error %d - LzmaEnc_SetProps (lzma)\n", res);
      LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
      return;
    }
    size_t hsize = LZMA_PROPS_SIZE;
    char *hptr = mymalloc(hsize);
    res = LzmaEnc_WriteProperties(enc, hptr, &hsize);
    if (res != SZ_OK) {
      printf("error %d - LzmaEnc_WriteProperties (lzma)\n", res);
      mymfree(hptr);
      LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
      return;
    }

    SizeT new_len = obufcnt;
    ELzmaStatus status;
    res = LzmaDecode(obufptr, &obufcnt, ibufptr, &new_len, hptr, hsize, 
                     LZMA_FINISH_END, &status, &g_Alloc);
    if (res!=SZ_OK) {
      fprintf(stderr,"R__unzip: error %d in LzmaDecode (lzolib)\n", res);
      mymfree(hptr);
      return;
    }
    mymfree(hptr);
    LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
    *irep = obufcnt;
  } else if (src[0] == 'R' && src[1] == 'E') { /* rle format */
    RLE_Uncompress(ibufptr, obufptr, ibufcnt);
    *irep = obufcnt;
  } else if (src[0] == 'L' && src[1] == 'O') { /* lolib format */

    int err = lzo_init(); 
    if ( err != LZO_E_OK) {
      fprintf(stderr,"R__unzip: error %d in lzo_init (lzolib)\n",err);
      return;
    }
    lzo_uint new_len = obufcnt;
    err = lzo1x_decompress(ibufptr,ibufcnt,obufptr,&new_len, NULL);
    if ((err != LZO_E_OK) || (new_len!=osize)) {
      fprintf(stderr,"R__unzip: error %d (%d,%d) in lzo1x_decompress (lzolib)\n",
              err, new_len, osize);
      return;
    }
    *irep = obufcnt;
  } else if (src[0] == 'B' && src[1] == 'Z') { /* bzlib format */
    bz_stream stream; /* decompression stream */
    stream.next_in   = ibufptr;
    stream.avail_in  = ibufcnt;
    stream.next_out  = obufptr;
    stream.avail_out = obufcnt;
    stream.bzalloc   = my_balloc;
    stream.bzfree    = my_bfree;
    stream.opaque    = 0;

    int err = BZ2_bzDecompressInit(&stream,0,0);
    if (err != BZ_OK) {
      fprintf(stderr,"R__unzip: error %d in BZ2_bzDecompressInit (bzlib)\n",err);
      return;
    }
    err = BZ2_bzDecompress(&stream);
    if (err != BZ_STREAM_END) {
      fprintf(stderr,"R__unzip: error %d inBZ2_bzDecompress (bzlib)\n",err);
      BZ2_bzDecompressEnd(&stream);
      return;
    }
    BZ2_bzDecompressEnd(&stream);
    *irep = stream.total_out_lo32;
  } else if (src[0] == 'Z' && src[1] == 'L') { /* zlib format */
    z_stream stream; /* decompression stream */
    stream.next_in   = (Bytef*)(&src[HDRSIZE]);
    stream.avail_in  = (uInt)(*srcsize);
    stream.next_out  = (Bytef*)tgt;
    stream.avail_out = (uInt)(*tgtsize);
    stream.zalloc    = my_zalloc;
    stream.zfree     = my_zfree;
    stream.opaque    = (voidpf)0;

    int err = inflateInit(&stream);
    if (err != Z_OK) {
      fprintf(stderr,"R__unzip: error %d in inflateInit (zlib)\n",err);
      return;
    }
    err = inflate(&stream, Z_FINISH);
    if (err != Z_STREAM_END) {
      inflateEnd(&stream);
      fprintf(stderr,"R__unzip: error %d in inflate (zlib)\n",err);
      return;
    }
    inflateEnd(&stream);
    *irep = stream.total_out;
  } else if (src[0] == 'C' && src[1] == 'S') { /* old zlib format */
    if (R__Inflate(&ibufptr, &ibufcnt, &obufptr, &obufcnt)) {
      fprintf(stderr,"R__unzip: error during decompression\n");
      return;
    }

    /* if (obufptr - tgt != osize) {
       There are some rare cases when a few more bytes are required */
    if (obufptr - tgt > *tgtsize) {
      fprintf(stderr,"R__unzip: discrepancy (%ld) with initial size: %ld, tgtsize=%d\n",
              (long)(obufptr - tgt),osize,*tgtsize);
      *irep = obufptr - tgt;
      return;
    }
    *irep = osize;
    return;
  } else {
    fprintf(stderr,"R__unzip: Format not supported -> m=%d with %d%d", method, src[0], src[1]);
    return;
  }
}
Revision:	1.6
Committed:	Wed Mar 4 07:24:50 2009 UTC (16 years, 2 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_011, Mit_010a, Mit_010, Mit_009c, Mit_009b, Mit_009a, Mit_009, Mit_008pre2
Changes since 1.5:	+4 -1 lines
Log Message:	Check if preload is activated
#	Content
1	// $Id: rzipunzip.c,v 1.5 2009/02/27 17:39:30 bendavid Exp $
2
3	#include "MitCommon/OptIO/src/rzipunzip.h"
4	#include "MitCommon/OptIO/src/zlib.h"
5	#include "MitCommon/OptIO/src/bzlib.h"
6	#include "MitCommon/OptIO/src/lzo/lzo1x.h"
7	#include "MitCommon/OptIO/src/rle.h"
8	#include "MitCommon/OptIO/src/LzmaEnc.h"
9	#include "MitCommon/OptIO/src/LzmaDec.h"
10	#include "MitCommon/OptIO/src/fpc.h"
11
12	#include <stdio.h>
13	#include <stdlib.h>
14	#include <string.h>
15
16	#ifndef HDRSIZE
17	#define HDRSIZE 9
18	#else
19	#error "HDRSIZE already defined."
20	#endif
21
22	#ifndef MYSIZE
23	#define MYSIZE 510241024
24	#else
25	#error "MYSIZE already defined."
26	#endif
27
28	typedef unsigned char uch; /* code assumes unsigned bytes; these type- */
29
30	extern int R__ZipMode;
31	char mymem[MYSIZE];
32	char *myptr = mymem;
33
34	// the following will be set to one if code was activated
35	int activated = 0;
36
37	// the following can be changed using the OptInt interface
38	double lzipfrac = 1;
39	double gzipfrac = 1;
40	double bzipfrac = 1;
41	double lzmafrac = 1;
42	int myverbose = 0;
43	int mystaticm = 0;
44
45	//--------------------------------------------------------------------------------------------------
46	void *mymalloc(size_t size)
47	{
48	if(!mystaticm \|\| size>MYSIZE)
49	return malloc(size);
50
51	if(myptr-mymem>MYSIZE-size) {
52	myptr=mymem;
53	}
54
55	void v=(void)myptr;
56	myptr+=size;
57	return v;
58	}
59
60	//--------------------------------------------------------------------------------------------------
61	void mymfree(void *ptr)
62	{
63	if (mystaticm && (char)ptr>=mymem && (char)ptr<mymem+MYSIZE)
64	return;
65	free(ptr);
66	}
67
68	// memory handle functions
69	static void SzAlloc(void p, size_t size) { p = p; return mymalloc(size); }
70	static void SzFree(void p, void address) { p = p; mymfree(address); }
71	static ISzAlloc g_Alloc = { SzAlloc, SzFree };
72	static void* my_balloc (void* opaque, int items, int size)
73	{
74	opaque = opaque;
75	return mymalloc(items*size);
76	}
77	static void my_bfree (void* opaque, void* addr)
78	{
79	opaque = opaque;
80	mymfree(addr);
81	}
82	static voidpf my_zalloc OF((voidpf opaque, unsigned items, unsigned size))
83	{
84	opaque = opaque;
85	return mymalloc(items*size);
86	}
87	static void my_zfree OF((voidpf opaque, voidpf ptr))
88	{
89	opaque = opaque;
90	mymfree(ptr);
91	}
92
93	//--------------------------------------------------------------------------------------------------
94	void delta_encode(char *buffer, int length)
95	{
96	char t = 0;
97	char original;
98	int i;
99	for (i=0; i < length; ++i) {
100	original = buffer[i];
101	buffer[i] -= t;
102	t = original;
103	}
104	}
105
106	void delta_decode(char *buffer, int length)
107	{
108	char t = 0;
109	int i;
110	for (i=0; i < length; ++i) {
111	buffer[i] += t;
112	t = buffer[i];
113	}
114	}
115
116	//--------------------------------------------------------------------------------------------------
117	void R__zip(int cxlevel, int srcsize, char src, int tgtsize, char tgt, int *irep)
118	/* int cxlevel; compression level */
119	/* int srcsize, tgtsize, irep; source and target sizes, replay /
120	/* char tgt, src; source and target buffers */
121	{
122	int err = 0;
123	int method = 0;
124	unsigned int in_size = 0;
125	unsigned int out_size = 0;
126
127	if (*tgtsize <= HDRSIZE) {
128	R__error("target buffer too small");
129	return;
130	}
131	if (*srcsize > 0xffffff) {
132	R__error("source buffer too big");
133	return;
134	}
135
136	*irep = 0;
137	in_size = (unsigned)(srcsize); / decompressed size */
138	char tgtptr = tgt+HDRSIZE; / compress data */
139
140	if (R__ZipMode == 99) { /determine best of all methods/
141	int cont = 1;
142	int msize = -1;
143	int zmode = -1;
144	int tgtlen = 2in_size+641024;
145	char *mptr1 = mymalloc(tgtlen);
146	char *mptr2 = mymalloc(tgtlen);
147	char *mptr = 0;
148	char *mdum = 0;
149
150	if (cont) {
151	zmode = 4;
152	msize = RLE_Compress(src, mptr1, in_size);
153	mptr = mptr1;
154	mdum = mptr2;
155	}
156
157	if (cont && lzipfrac>0) {
158	err = lzo_init();
159	if ( err == LZO_E_OK) {
160	lzo_uint outlen = tgtlen;
161	char *lwmem = mymalloc(LZO1X_999_MEM_COMPRESS);
162	err = lzo1x_999_compress(src,in_size,mdum,&outlen,lwmem);
163	if (err == LZO_E_OK) {
164	if (outlen<lzipfrac*msize) {
165	msize = outlen;
166	zmode = 3;
167	char *tmp = mptr;
168	mptr = mdum;
169	mdum = tmp;
170	}
171	}
172	mymfree(lwmem);
173	}
174	}
175
176	if (cont && gzipfrac>0) {
177	int outlen = *tgtsize;
178	z_stream stream;
179	stream.next_in = (Bytef*)src;
180	stream.avail_in = (uInt)(in_size);
181	stream.next_out = (Bytef*)(mdum);
182	stream.avail_out = (uInt)(outlen);
183	stream.zalloc = (alloc_func)0;
184	stream.zfree = (free_func)0;
185	stream.opaque = (voidpf)0;
186
187	err = deflateInit(&stream, cxlevel);
188	if (err == Z_OK) {
189	err = deflate(&stream, Z_FINISH);
190	if (err == Z_STREAM_END) {
191	err = deflateEnd(&stream);
192	int outlen = stream.total_out;
193	if (outlen<gzipfrac*msize) {
194	msize = outlen;
195	zmode = 1;
196	char *tmp = mptr;
197	mptr = mdum;
198	mdum = tmp;
199	}
200	}
201	}
202	}
203
204	if (cont && bzipfrac>0) {
205	int outlen = *tgtsize;
206	bz_stream stream;
207	stream.next_in = src;
208	stream.avail_in = (uInt)(in_size);
209	stream.next_out = mdum;
210	stream.avail_out = (uInt)(outlen);
211	stream.bzalloc = 0;
212	stream.bzfree = 0;
213	stream.opaque = 0;
214
215	err = BZ2_bzCompressInit(&stream, 9, 0, 1);
216	if (err == BZ_OK) {
217	err = BZ2_bzCompress(&stream, BZ_FINISH);
218	if (err == BZ_STREAM_END) {
219	BZ2_bzCompressEnd(&stream);
220	}
221	int outlen = stream.total_out_lo32;
222	if (outlen<bzipfrac*msize) {
223	msize = outlen;
224	zmode = 2;
225	char *tmp = mptr;
226	mptr = mdum;
227	mdum = tmp;
228	}
229	}
230	}
231	if (cont && lzmafrac>0) {
232	CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
233	if (enc) {
234	CLzmaEncProps props;
235	LzmaEncProps_Init(&props);
236	props.level = cxlevel;
237	props.dictSize = (1<<24);
238	props.lc = 0;
239	props.lp = 2;
240	SRes res = LzmaEnc_SetProps(enc, &props);
241	if (res == SZ_OK) {
242	SizeT outlen = *tgtsize;
243	res = LzmaEnc_MemEncode(enc, mdum, &outlen, src, in_size,
244	0, NULL, &g_Alloc, &g_Alloc);
245	if (res == SZ_OK) {
246	if (outlen<lzmafrac*msize) {
247	msize = outlen;
248	zmode = 5;
249	char *tmp = mptr;
250	mptr = mdum;
251	mdum = tmp;
252	}
253	}
254	}
255	}
256	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
257	}
258
259	// determine best candidate
260	if (msize>=in_size) {
261	out_size = in_size;
262	memcpy(tgtptr,src,out_size);
263	tgt[0] = 'X'; /* signature xx */
264	tgt[1] = 'X';
265	method = 0;
266	} else {
267	switch (zmode) {
268	case 1:
269	tgt[0] = 'Z'; /* signature zlib */
270	tgt[1] = 'L';
271	method = Z_DEFLATED; //==8
272	break;
273	case 2:
274	tgt[0] = 'B'; /* signature bzlib */
275	tgt[1] = 'Z';
276	method = 2;
277	break;
278	case 3:
279	tgt[0] = 'L'; /* signature lzolib */
280	tgt[1] = 'O';
281	method = 19;
282	break;
283	case 4:
284	tgt[0] = 'R'; /* signature rlelib */
285	tgt[1] = 'E';
286	method = 4;
287	break;
288	case 5:
289	tgt[0] = 'L'; /* signature lzma */
290	tgt[1] = 'M';
291	method = 3;
292	break;
293	}
294	out_size = msize;
295	memcpy(tgtptr,mptr,out_size);
296	}
297	mymfree(mptr1);
298	mymfree(mptr2);
299	} else if (R__ZipMode == 5) { /lzma/
300	CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
301	if (enc == 0) {
302	printf("error %d - LzmaEnc_Create()\n", SZ_ERROR_MEM);
303	return;
304	}
305	CLzmaEncProps props;
306	LzmaEncProps_Init(&props);
307	props.level = cxlevel;
308	props.dictSize = (1<<24);
309	props.lc = 0;
310	props.lp = 2;
311	SRes res = LzmaEnc_SetProps(enc, &props);
312	if (res != SZ_OK) {
313	printf("error %d - LzmaEnc_SetProps()\n", res);
314	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
315	return;
316	}
317	res = LzmaEnc_MemEncode(enc, tgtptr, tgtsize, src, in_size,
318	0, NULL, &g_Alloc, &g_Alloc);
319	if (res != SZ_OK) {
320	printf("error %d - LzmaEnc_MemEncode", res);
321	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
322	return;
323	}
324	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
325	out_size = tgtsize; / compressed size */
326	if (out_size>=lzmafrac*in_size) {
327	out_size = in_size;
328	memcpy(tgtptr,src,out_size);
329	tgt[0] = 'X'; /* signature xx */
330	tgt[1] = 'X';
331	method = 0;
332	} else {
333	tgt[0] = 'L'; /* signature lzma */
334	tgt[1] = 'M';
335	method = 3;
336	}
337	} else if (R__ZipMode == 4) { /rle/
338	int tgtlen = 2*in_size+1;
339	char *lmem1 = mymalloc(tgtlen);
340
341	out_size = RLE_Compress(src, lmem1, in_size);
342	if (out_size>=in_size) {
343	out_size = in_size;
344	memcpy(tgtptr,src,out_size);
345	tgt[0] = 'X'; /* signature xx */
346	tgt[1] = 'X';
347	method = 0;
348	} else {
349	memcpy(tgtptr,lmem1,out_size);
350	tgt[0] = 'R'; /* signature rlelib */
351	tgt[1] = 'E';
352	method = 4;
353	}
354	mymfree(lmem1);
355	} else if (R__ZipMode == 3) { /lzo/
356	err = lzo_init();
357	if ( err != LZO_E_OK) {
358	printf("error %d - lzo_init()\n", err);
359	return;
360	}
361
362	lzo_uint tgtlen = 2in_size+641024;
363	char *lmem1 = mymalloc(tgtlen);
364	char *lmem2 = 0;
365	if (cxlevel<=1) {
366	lmem2 = mymalloc(LZO1X_1_11_MEM_COMPRESS);
367	err = lzo1x_1_11_compress(src,in_size,lmem1,&tgtlen,lmem2);
368	method = 11;
369	} else if (cxlevel==2) {
370	lmem2 = mymalloc(LZO1X_1_12_MEM_COMPRESS);
371	err = lzo1x_1_12_compress(src,in_size,lmem1,&tgtlen,lmem2);
372	method = 12;
373	} else if (cxlevel<=5) {
374	lmem2 = mymalloc(LZO1X_1_15_MEM_COMPRESS);
375	err = lzo1x_1_15_compress(src,in_size,lmem1,&tgtlen,lmem2);
376	method = 15;
377	} else {
378	lmem2 = mymalloc(LZO1X_999_MEM_COMPRESS);
379	err = lzo1x_999_compress(src,in_size,lmem1,&tgtlen,lmem2);
380	method = 19;
381	}
382	if (err != LZO_E_OK) {
383	mymfree(lmem1);
384	mymfree(lmem2);
385	return;
386	}
387
388	if (tgtlen>=lzipfrac*in_size) {
389	out_size = in_size;
390	memcpy(tgtptr,src,out_size);
391	tgt[0] = 'X'; /* signature xx */
392	tgt[1] = 'X';
393	method = 0;
394	} else {
395	out_size = tgtlen; /* compressed size */
396	memcpy(tgtptr,lmem1,out_size);
397	tgt[0] = 'L'; /* signature lzolib */
398	tgt[1] = 'O';
399	}
400	mymfree(lmem1);
401	mymfree(lmem2);
402	} else if (R__ZipMode == 2) { /bzip/
403	bz_stream stream;
404	stream.next_in = src;
405	stream.avail_in = (uInt)(in_size);
406	stream.next_out = tgtptr;
407	stream.avail_out = (uInt)(*tgtsize);
408	stream.bzalloc = 0;
409	stream.bzfree = 0;
410	stream.opaque = 0;
411
412	err = BZ2_bzCompressInit(&stream, 9, 0, 1+(9-cxlevel)*25);
413	if (err != BZ_OK) {
414	printf("error %d in BZ2_bzCompressInit (bzlib)\n",err);
415	return;
416	}
417	err = BZ2_bzCompress(&stream, BZ_FINISH);
418	if (err != BZ_STREAM_END) {
419	BZ2_bzCompressEnd(&stream);
420	//printf("error %d in BZ2_bzCompress (bzlib) is not = %d\n",err,BZ_STREAM_END);
421	return;
422	}
423	err = BZ2_bzCompressEnd(&stream);
424
425	out_size = stream.total_out_lo32; /* compressed size */
426	if (out_size>=bzipfrac*in_size) {
427	out_size = in_size;
428	memcpy(tgtptr,src,out_size);
429	tgt[0] = 'X'; /* signature xx */
430	tgt[1] = 'X';
431	method = 0;
432	} else {
433	tgt[0] = 'B'; /* signature bzlib */
434	tgt[1] = 'Z';
435	method = 2;
436	}
437	} else if (R__ZipMode == 1) { /zip/
438	z_stream stream;
439	stream.next_in = (Bytef*)src;
440	stream.avail_in = (uInt)(in_size);
441	stream.next_out = (Bytef*)(tgtptr);
442	stream.avail_out = (uInt)(*tgtsize);
443	stream.zalloc = (alloc_func)0;
444	stream.zfree = (free_func)0;
445	stream.opaque = (voidpf)0;
446
447	err = deflateInit(&stream, cxlevel);
448	if (err != Z_OK) {
449	printf("error %d in deflateInit (zlib)\n",err);
450	return;
451	}
452	err = deflate(&stream, Z_FINISH);
453	if (err != Z_STREAM_END) {
454	deflateEnd(&stream);
455	//printf("error %d in deflate (zlib) is not = %d\n",err,Z_STREAM_END);
456	return;
457	}
458	err = deflateEnd(&stream);
459
460	out_size = stream.total_out; /* compressed size */
461	if (out_size>=gzipfrac*in_size) {
462	out_size = in_size;
463	memcpy(tgtptr,src,out_size);
464	tgt[0] = 'X'; /* signature xx */
465	tgt[1] = 'X';
466	method = 0;
467	} else {
468	tgt[0] = 'Z'; /* signature zlib */
469	tgt[1] = 'L';
470	method = Z_DEFLATED;
471	}
472	} else if (R__ZipMode == 0) {
473	printf("error: Old zip method not supported in this patch.");
474	return;
475	}
476
477	// fill rest of header
478	tgt[2] = (char)method;
479	tgt[3] = (char)(out_size & 0xff);
480	tgt[4] = (char)((out_size >> 8) & 0xff);
481	tgt[5] = (char)((out_size >> 16) & 0xff);
482	tgt[6] = (char)(in_size & 0xff);
483	tgt[7] = (char)((in_size >> 8) & 0xff);
484	tgt[8] = (char)((in_size >> 16) & 0xff);
485	*irep = out_size + HDRSIZE;
486
487	if (myverbose==1\|\|myverbose>9) {
488	printf("R__zip:: zm=%d m=%d cl=%d: %c%c compressed %lu bytes into %lu bytes -> %.3f%%\n",
489	R__ZipMode, method, cxlevel, tgt[0], tgt[1],
490	(unsigned long)in_size, (unsigned long)out_size, (double)out_size/in_size*100.);
491	}
492	}
493
494	//--------------------------------------------------------------------------------------------------
495	void R__unzip(int srcsize, uch src, int tgtsize, uch tgt, int *irep)
496	/* Input: scrsize - size of input buffer */
497	/* src - input buffer */
498	/* tgtsize - size of target buffer */
499	/* Output: tgt - target buffer (decompressed) */
500	/* irep - size of decompressed data */
501	/* 0 - if error */
502	{
503	unsigned int osize = 0;
504	unsigned int ibufcnt = 0, obufcnt = 0;
505	uch ibufptr = 0, obufptr = 0;
506	*irep = 0L;
507
508	/* C H E C K H E A D E R */
509	if (*srcsize < HDRSIZE) {
510	fprintf(stderr,"R__unzip: too small source\n");
511	return;
512	}
513
514	char method = src[2];
515	if (method!=0 && method!= 2 && method!= 3 && method!= 4 && method!=Z_DEFLATED &&
516	method!=11 && method!=12 && method!=15 && method!=19) {
517	fprintf(stderr,"R__unzip: error in header -> unknown method %d\n", method);
518	return;
519	}
520
521	if ((method==0 && (src[0] != 'X' \|\| src[1] != 'X')) \|\|
522	(method==2 && (src[0] != 'B' \|\| src[1] != 'Z')) \|\|
523	(method==3 && (src[0] != 'L' \|\| src[1] != 'M')) \|\|
524	(method==4 && (src[0] != 'R' \|\| src[1] != 'E')) \|\|
525	(method==Z_DEFLATED && ((src[0] != 'C' \|\| src[1] != 'S') &&
526	(src[0] != 'Z' \|\| src[1] != 'L'))) \|\|
527	((method==11 \|\| method==12 \|\| method==15 \|\| method==19) &&
528	(src[0] != 'L' \|\| src[1] != 'O'))) {
529	fprintf(stderr,"R__unzip: error in header -> m=%d with %c%c\n",
530	method, src[0], src[1]);
531	return;
532	}
533
534	ibufptr = src + HDRSIZE;
535	ibufcnt = (unsigned int)src[3] \| ((unsigned int)src[4] << 8) \| ((unsigned int)src[5] << 16);
536	osize = (unsigned int)src[6] \| ((unsigned int)src[7] << 8) \| ((unsigned int)src[8] << 16);
537	obufptr = tgt;
538	obufcnt = *tgtsize;
539
540	if (obufcnt < osize) {
541	fprintf(stderr,"R__unzip: too small target\n");
542	return;
543	}
544
545	if (ibufcnt + HDRSIZE != *srcsize) {
546	fprintf(stderr,"R__unzip: discrepancy in source length\n");
547	return;
548	}
549
550	if (myverbose==2 \|\| myverbose>9) {
551	printf("R__unzip:: zm=%d m=%d: %c%c uncompressed %lu bytes from %lu bytes (%.3f%%)\n",
552	R__ZipMode, method, src[0], src[1], osize, ibufcnt, (double)ibufcnt/osize*100.);
553	}
554
555	if (method==0) { // apparently this is not reached since underlying ROOT code catches this
556	if (ibufcnt!=osize) {
557	fprintf(stderr,"R__unzip: error in header -> input should be output %d!=%d\n",
558	ibufcnt, osize);
559	return;
560	}
561	memcpy(obufptr,ibufptr,osize);
562	*irep = obufcnt;
563	return;
564	}
565
566	/* D E C O M P R E S S D A T A */
567
568	if (src[0] == 'L' && src[1] == 'M') { /* lzma format */
569	CLzmaEncHandle enc = LzmaEnc_Create(&g_Alloc);
570	if (enc == 0) {
571	printf("error %d - LzmaEnc_Create (lzma)\n", SZ_ERROR_MEM);
572	return;
573	}
574	CLzmaEncProps props;
575	LzmaEncProps_Init(&props);
576	props.dictSize = (1<<24);
577	props.lc = 0;
578	props.lp = 2;
579	SRes res = LzmaEnc_SetProps(enc, &props);
580	if (res != SZ_OK) {
581	printf("error %d - LzmaEnc_SetProps (lzma)\n", res);
582	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
583	return;
584	}
585	size_t hsize = LZMA_PROPS_SIZE;
586	char *hptr = mymalloc(hsize);
587	res = LzmaEnc_WriteProperties(enc, hptr, &hsize);
588	if (res != SZ_OK) {
589	printf("error %d - LzmaEnc_WriteProperties (lzma)\n", res);
590	mymfree(hptr);
591	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
592	return;
593	}
594
595	SizeT new_len = obufcnt;
596	ELzmaStatus status;
597	res = LzmaDecode(obufptr, &obufcnt, ibufptr, &new_len, hptr, hsize,
598	LZMA_FINISH_END, &status, &g_Alloc);
599	if (res!=SZ_OK) {
600	fprintf(stderr,"R__unzip: error %d in LzmaDecode (lzolib)\n", res);
601	mymfree(hptr);
602	return;
603	}
604	mymfree(hptr);
605	LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
606	*irep = obufcnt;
607	} else if (src[0] == 'R' && src[1] == 'E') { /* rle format */
608	RLE_Uncompress(ibufptr, obufptr, ibufcnt);
609	*irep = obufcnt;
610	} else if (src[0] == 'L' && src[1] == 'O') { /* lolib format */
611
612	int err = lzo_init();
613	if ( err != LZO_E_OK) {
614	fprintf(stderr,"R__unzip: error %d in lzo_init (lzolib)\n",err);
615	return;
616	}
617	lzo_uint new_len = obufcnt;
618	err = lzo1x_decompress(ibufptr,ibufcnt,obufptr,&new_len, NULL);
619	if ((err != LZO_E_OK) \|\| (new_len!=osize)) {
620	fprintf(stderr,"R__unzip: error %d (%d,%d) in lzo1x_decompress (lzolib)\n",
621	err, new_len, osize);
622	return;
623	}
624	*irep = obufcnt;
625	} else if (src[0] == 'B' && src[1] == 'Z') { /* bzlib format */
626	bz_stream stream; /* decompression stream */
627	stream.next_in = ibufptr;
628	stream.avail_in = ibufcnt;
629	stream.next_out = obufptr;
630	stream.avail_out = obufcnt;
631	stream.bzalloc = my_balloc;
632	stream.bzfree = my_bfree;
633	stream.opaque = 0;
634
635	int err = BZ2_bzDecompressInit(&stream,0,0);
636	if (err != BZ_OK) {
637	fprintf(stderr,"R__unzip: error %d in BZ2_bzDecompressInit (bzlib)\n",err);
638	return;
639	}
640	err = BZ2_bzDecompress(&stream);
641	if (err != BZ_STREAM_END) {
642	fprintf(stderr,"R__unzip: error %d inBZ2_bzDecompress (bzlib)\n",err);
643	BZ2_bzDecompressEnd(&stream);
644	return;
645	}
646	BZ2_bzDecompressEnd(&stream);
647	*irep = stream.total_out_lo32;
648	} else if (src[0] == 'Z' && src[1] == 'L') { /* zlib format */
649	z_stream stream; /* decompression stream */
650	stream.next_in = (Bytef*)(&src[HDRSIZE]);
651	stream.avail_in = (uInt)(*srcsize);
652	stream.next_out = (Bytef*)tgt;
653	stream.avail_out = (uInt)(*tgtsize);
654	stream.zalloc = my_zalloc;
655	stream.zfree = my_zfree;
656	stream.opaque = (voidpf)0;
657
658	int err = inflateInit(&stream);
659	if (err != Z_OK) {
660	fprintf(stderr,"R__unzip: error %d in inflateInit (zlib)\n",err);
661	return;
662	}
663	err = inflate(&stream, Z_FINISH);
664	if (err != Z_STREAM_END) {
665	inflateEnd(&stream);
666	fprintf(stderr,"R__unzip: error %d in inflate (zlib)\n",err);
667	return;
668	}
669	inflateEnd(&stream);
670	*irep = stream.total_out;
671	} else if (src[0] == 'C' && src[1] == 'S') { /* old zlib format */
672	if (R__Inflate(&ibufptr, &ibufcnt, &obufptr, &obufcnt)) {
673	fprintf(stderr,"R__unzip: error during decompression\n");
674	return;
675	}
676
677	/* if (obufptr - tgt != osize) {
678	There are some rare cases when a few more bytes are required */
679	if (obufptr - tgt > *tgtsize) {
680	fprintf(stderr,"R__unzip: discrepancy (%ld) with initial size: %ld, tgtsize=%d\n",
681	(long)(obufptr - tgt),osize,*tgtsize);
682	*irep = obufptr - tgt;
683	return;
684	}
685	*irep = osize;
686	return;
687	} else {
688	fprintf(stderr,"R__unzip: Format not supported -> m=%d with %d%d", method, src[0], src[1]);
689	return;
690	}
691	}