自学教程：C++ BZ2_bzDecompress函数代码示例

size_t wxBZipInputStream::OnSysRead(void* buffer, size_t bufsize){    bz_stream* hZip = (bz_stream*)m_hZip;	hZip->next_out = (char*)buffer;	hZip->avail_out = bufsize;	while (hZip->avail_out != 0)	{		if (m_nBufferPos == 0 || m_nBufferPos == WXBZBS)		{			ReadRaw(m_pBuffer, WXBZBS);			            m_nBufferPos = 0;			hZip->next_in = m_pBuffer;			hZip->avail_in = WXBZBS;            if (m_parent_i_stream->LastRead() != WXBZBS)			{                // Full amount not read, so do a last                // minute tidy up and decompress what is left				hZip->avail_in = m_parent_i_stream->LastRead();				int nRet = BZ2_bzDecompress(hZip);				if (nRet == BZ_OK || nRet == BZ_STREAM_END)					return bufsize - hZip->avail_out;				else					return 0;			}		}        // Buffer full, decompress some bytes        hZip->next_in = &m_pBuffer[m_nBufferPos];		hZip->avail_in = WXBZBS - m_nBufferPos;		int nRet = BZ2_bzDecompress(hZip);		if (nRet == BZ_OK)			{			m_nBufferPos = WXBZBS - hZip->avail_in;		}		else if(nRet == BZ_STREAM_END)			return bufsize - hZip->avail_out;		else			return 0;		} 	return bufsize - hZip->avail_out;	}

size_t wxBZipInputStream::OnSysRead(void* buffer, size_t bufsize){	wxInt32 nRead = 0;	((bz_stream*&)hZip)->next_out = &(((char*&)buffer)[nRead]);	((bz_stream*&)hZip)->avail_out = bufsize - nRead;	while (((bz_stream*&)hZip)->avail_out != 0)	{		//wxMessageBox(wxString::Format("%i %i", nRead, ((bz_stream*&)hZip)->avail_out));		if (nBufferPos == 0 || nBufferPos == WXBZBS)		{			ReadRaw(pBuffer, WXBZBS);			nBufferPos = 0;			((bz_stream*&)hZip)->next_in = &pBuffer[nBufferPos];			((bz_stream*&)hZip)->avail_in = WXBZBS - nBufferPos;			if (m_parent_i_stream->LastRead() != WXBZBS)			{				((bz_stream*&)hZip)->avail_in = m_parent_i_stream->LastRead();				int nRet = BZ2_bzDecompress((bz_stream*&)hZip);				if (nRet == BZ_OK || nRet == BZ_STREAM_END)					return bufsize - ((bz_stream*&)hZip)->avail_out;				else					return 0;			}		}		((bz_stream*&)hZip)->next_in = &pBuffer[nBufferPos];		((bz_stream*&)hZip)->avail_in = WXBZBS - nBufferPos;		int nRet = BZ2_bzDecompress((bz_stream*&)hZip);		if (nRet == BZ_OK)			{			nBufferPos += -(nRead - (			nRead += (WXBZBS - nBufferPos - ((bz_stream*&)hZip)->avail_in)			));		}		else if(nRet == BZ_STREAM_END)			return bufsize - ((bz_stream*&)hZip)->avail_out;		else			return 0;		} 	return bufsize - ((bz_stream*&)hZip)->avail_out;	}

static int bzf_read(struct open_file *f, void *buf, size_t size, size_t *resid){    struct bz_file	*bzf = (struct bz_file *)f->f_fsdata;    int			error;    bzf->bzf_bzstream.next_out = buf;			/* where and how much */    bzf->bzf_bzstream.avail_out = size;    while (bzf->bzf_bzstream.avail_out && bzf->bzf_endseen == 0) {	if ((bzf->bzf_bzstream.avail_in == 0) && (bzf_fill(bzf) == -1)) {	    printf("bzf_read: fill error/n");	    return(EIO);	}	if (bzf->bzf_bzstream.avail_in == 0) {		/* oops, unexpected EOF */	    printf("bzf_read: unexpected EOF/n");	    if (bzf->bzf_bzstream.avail_out == size)		return(EIO);	    break;	}	error = BZ2_bzDecompress(&bzf->bzf_bzstream);	/* decompression pass */	if (error == BZ_STREAM_END) {			/* EOF, all done */	    bzf->bzf_endseen = 1;	    break;	}	if (error != BZ_OK) {				/* argh, decompression error */	    printf("bzf_read: BZ2_bzDecompress returned %d/n", error);	    return(EIO);	}    }    if (resid != NULL)	*resid = bzf->bzf_bzstream.avail_out;    return(0);}

// Load from fileFXuval FXBZFileStream::readBuffer(FXuval){  register FXival n; int bzerror;  if(dir!=FXStreamLoad){fxerror("FXBZFileStream::readBuffer: wrong stream direction./n");}  FXASSERT(begptr<=rdptr);  FXASSERT(rdptr<=wrptr);  FXASSERT(wrptr<=endptr);  if(rdptr<wrptr){memmove(begptr,rdptr,wrptr-rdptr);}  wrptr=begptr+(wrptr-rdptr);  rdptr=begptr;  while(wrptr<endptr){//    n=file.readBlock(bz->buffer,BUFFERSIZE);//    if(n<=0) break;//    bz->stream.next_in=bz->buffer;//    bz->stream.avail_in=n;    if(bz->stream.avail_in<=0){ // get more input if buffer is empty      n=file.readBlock(bz->buffer,BUFFERSIZE);      if(n<0) break;      bz->stream.next_in=bz->buffer;      bz->stream.avail_in=n;      }    bz->stream.next_out=(char*)wrptr;    bz->stream.avail_out=endptr-wrptr;    bzerror=BZ2_bzDecompress(&bz->stream);//    if(bzerror!=BZ_OK) break;    if(bzerror<0) break;  // break on error condition    wrptr=(FXuchar*)bz->stream.next_out;    if(bzerror==BZ_STREAM_END) break;    }  return wrptr-rdptr;  }

long FileReaderBZ2::Read (void *buffer, long len){	int err;	Stream.next_out = (char *)buffer;	Stream.avail_out = len;	do	{		err = BZ2_bzDecompress(&Stream);		if (Stream.avail_in == 0 && !SawEOF)		{			FillBuffer ();		}	} while (err == BZ_OK && Stream.avail_out != 0);	if (err != BZ_OK && err != BZ_STREAM_END)	{		I_Error ("Corrupt bzip2 stream");	}	if (Stream.avail_out != 0)	{		I_Error ("Ran out of data in bzip2 stream");	}	return len - Stream.avail_out;}

    std::string read() final {        std::string output;        if (m_buffer) {            const size_t buffer_size = 10240;            output.resize(buffer_size);            m_bzstream.next_out = const_cast<char*>(output.data());            m_bzstream.avail_out = buffer_size;            int result = BZ2_bzDecompress(&m_bzstream);            if (result != BZ_OK) {                m_buffer = nullptr;                m_buffer_size = 0;            }            if (result != BZ_OK && result != BZ_STREAM_END) {                std::string message("bzip2 error: decompress failed: ");                throw bzip2_error(message, result);            }            output.resize(static_cast<unsigned long>(m_bzstream.next_out - output.data()));        }        return output;    }

/* this function decompress a stream using bzip2 library. */int32_t libmpq__decompress_bzip2(uint8_t *in_buf, uint32_t in_size, uint8_t *out_buf, uint32_t out_size) {	/* some common variables. */	int32_t result = 0;	int32_t tb     = 0;	bz_stream strm;	/* initialize the bzlib decompression. */	strm.bzalloc = NULL;	strm.bzfree  = NULL;	/* initialize the structure. */	if ((result = BZ2_bzDecompressInit(&strm, 0, 0)) != BZ_OK) {		/* something on bzlib initialization failed. */		return result;	}	/* fill the stream structure for bzlib. */	strm.next_in   = (char *)in_buf;	strm.avail_in  = in_size;	strm.next_out  = (char *)out_buf;	strm.avail_out = out_size;	/* do the decompression. */	while (BZ2_bzDecompress(&strm) != BZ_STREAM_END);	/* save transferred bytes. */	tb = strm.total_out_lo32;	/* cleanup of bzip stream. */	BZ2_bzDecompressEnd(&strm);	/* return transferred bytes. */	return tb;}

value camlzip_bzDecompress(value vzs, value srcbuf, value srcpos, value srclen,			   value dstbuf, value dstpos, value dstlen){#ifdef USE_BZIP2  bz_stream * zs = BZStream_val(vzs);  int retcode;  long used_in, used_out;  value res;  zs->next_in = &Byte(srcbuf, Long_val(srcpos));  zs->avail_in = Long_val(srclen);  zs->next_out = &Byte(dstbuf, Long_val(dstpos));  zs->avail_out = Long_val(dstlen);  retcode = BZ2_bzDecompress(zs);  if (retcode < 0)    camlzip_bzerror("Bzlib.decompress", retcode);  used_in = Long_val(srclen) - zs->avail_in;  used_out = Long_val(dstlen) - zs->avail_out;  zs->next_in = NULL;           /* not required, but cleaner */  zs->next_out = NULL;          /* (avoid dangling pointers into Caml heap) */  res = alloc_small(3, 0);  Field(res, 0) = Val_bool(retcode == BZ_STREAM_END);  Field(res, 1) = Val_int(used_in);  Field(res, 2) = Val_int(used_out);  return res;#else  failwith("Bzip2 compression not supported");#endif}

// xmlInputReadCallbackstatic int bz2_mem_read(struct bz2_mem *bzmem, char *buffer, int len){	if (len < 1) {		// ensure that at least one byte of output space is available at each BZ2_bzDecompress call.		return 0;	}	if (bzmem->eof) {		// If we run BZ2_bzDecompress on processed buffer we will get -1 (SEQUENCE_ERROR)		return 0;	}	// next_out should point to a buffer in which the uncompressed output is to be placed	bzmem->stream->next_out = buffer;	// with avail_out indicating how much output space is available.	bzmem->stream->avail_out = len;	int bzerror = BZ2_bzDecompress(bzmem->stream);	if (bzerror == BZ_STREAM_END) {		bzmem->eof = true;	}	if (bzerror == BZ_OK || bzerror == BZ_STREAM_END)		return (len - bzmem->stream->avail_out);	else {		oscap_seterr(OSCAP_EFAMILY_OSCAP, "Could not read from bz_stream: BZ2_bzDecompress returns %d", bzerror);		return -1;	}}

bool bz2_decompress_xml(char *in_data, int in_data_length, BYTE **pDat, int *data_length) {	const int BLOCKSIZE = 1024 * 100;	bz_stream bzs = {0};	switch(BZ2_bzDecompressInit(&bzs, 0, 0)) {	case BZ_CONFIG_ERROR: 		//MessageBox(0, "Configuration Error", "BZ2 Decompres Init", MB_OK | MB_ICONERROR); 		ShowError(TranslateT("BZ2 Decompression, configuration error"));		return false;	case BZ_PARAM_ERROR: 		//MessageBox(0, "Parameters Error", "BZ2 Decompres Init", MB_OK | MB_ICONERROR); 		ShowError(TranslateT("BZ2 Decompression, parameter error"));		return false;	case BZ_MEM_ERROR: 		//MessageBox(0, "Memory Error", "BZ2 Decompres Init", MB_OK | MB_ICONERROR); 		ShowError(TranslateT("DB2 Decompression, memory error"));		return false;	}	bzs.avail_in = in_data_length;	bzs.next_in = in_data;	bzs.avail_out = BLOCKSIZE;	*pDat = (BYTE *)malloc(bzs.avail_out + 1); // allocate 100k (at present, xml data is about 87k)  (1 byte extra for a terminating 0 for safety)	bzs.next_out = (char *)*pDat;	int blocknum = 0;	int ret;	while((ret = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {		if(bzs.avail_out == 0) {			blocknum++;			*pDat = (BYTE *)realloc(*pDat, (blocknum + 1) * BLOCKSIZE + 1);			bzs.next_out = (char *)(*pDat + (blocknum * BLOCKSIZE));			bzs.avail_out = BLOCKSIZE;		}	}	BZ2_bzDecompressEnd(&bzs);	if(ret != BZ_STREAM_END) {//		char msg[512];//		sprintf(msg, "Error decompressing, code: %d", ret);//		MessageBox(0, msg, "Error Decompressing BZ2 XML data", MB_OK);		free(*pDat);		*pDat = 0;		*data_length = 0;		return false;	}	*data_length = bzs.total_out_lo32;		// assume it's not too massive!	(*pDat)[*data_length] = 0;				// for safety - last char shouldn't matter to us	//char msg[256];	//sprintf(msg, "Bytes decompressed: %d", data_length);	//MessageBox(0, msg, "msg", MB_OK);	return true;}

static char *_qdbm_bzdecode_impl(const char *ptr, int size, int *sp) {    bz_stream zs;    char *buf, *swap, obuf[BZIPBUFSIZ];    int rv, asiz, bsiz, osiz;    zs.bzalloc = NULL;    zs.bzfree = NULL;    zs.opaque = NULL;    if(BZ2_bzDecompressInit(&zs, 0, 0) != BZ_OK) return NULL;    asiz = size * 2 + 16;    if(asiz < BZIPBUFSIZ) asiz = BZIPBUFSIZ;    if(!(buf = malloc(asiz))) {        BZ2_bzDecompressEnd(&zs);        return NULL;    }    bsiz = 0;    zs.next_in = (char *)ptr;    zs.avail_in = size;    zs.next_out = obuf;    zs.avail_out = BZIPBUFSIZ;    while((rv = BZ2_bzDecompress(&zs)) == BZ_OK) {        osiz = BZIPBUFSIZ - zs.avail_out;        if(bsiz + osiz >= asiz) {            asiz = asiz * 2 + osiz;            if(!(swap = realloc(buf, asiz))) {                free(buf);                BZ2_bzDecompressEnd(&zs);                return NULL;            }            buf = swap;        }        memcpy(buf + bsiz, obuf, osiz);        bsiz += osiz;        zs.next_out = obuf;        zs.avail_out = BZIPBUFSIZ;    }    if(rv != BZ_STREAM_END) {        free(buf);        BZ2_bzDecompressEnd(&zs);        return NULL;    }    osiz = BZIPBUFSIZ - zs.avail_out;    if(bsiz + osiz >= asiz) {        asiz = asiz * 2 + osiz;        if(!(swap = realloc(buf, asiz))) {            free(buf);            BZ2_bzDecompressEnd(&zs);            return NULL;        }        buf = swap;    }    memcpy(buf + bsiz, obuf, osiz);    bsiz += osiz;    buf[bsiz] = '/0';    if(sp) *sp = bsiz;    BZ2_bzDecompressEnd(&zs);    return buf;}

/*---------------------------------------------------*/int BZ_API(BZ2_bzRead)            ( int*    bzerror,              BZFILE* b,              void*   buf,              int     len ){   Int32   n, ret;   bzFile* bzf = (bzFile*)b;   BZ_SETERR(BZ_OK);   if (bzf == NULL || buf == NULL || len < 0)      { BZ_SETERR(BZ_PARAM_ERROR); return 0; };   if (bzf->writing)      { BZ_SETERR(BZ_SEQUENCE_ERROR); return 0; };   if (len == 0)      { BZ_SETERR(BZ_OK); return 0; };   bzf->strm.avail_out = len;   bzf->strm.next_out = buf;   while (True) {      if (ferror(bzf->handle))          { BZ_SETERR(BZ_IO_ERROR); return 0; };      if (bzf->strm.avail_in == 0 && !bz_feof(bzf->handle)) {         n = fread ( bzf->buf, sizeof(UChar),                      BZ_MAX_UNUSED, bzf->handle );         if (ferror(bzf->handle))            { BZ_SETERR(BZ_IO_ERROR); return 0; };         bzf->bufN = n;         bzf->strm.avail_in = bzf->bufN;         bzf->strm.next_in = bzf->buf;      }      ret = BZ2_bzDecompress ( &(bzf->strm) );      if (ret != BZ_OK && ret != BZ_STREAM_END)         { BZ_SETERR(ret); return 0; };      if (ret == BZ_OK && bz_feof(bzf->handle) &&           bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)         { BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };      if (ret == BZ_STREAM_END)         { BZ_SETERR(BZ_STREAM_END);           return len - bzf->strm.avail_out; };      if (bzf->strm.avail_out == 0)         { BZ_SETERR(BZ_OK); return len; };         }}

intbzip2_decompress(void *src, uint64_t srclen, void *dst, uint64_t *dstlen,		 int level, uchar_t chdr, void *data){	bz_stream bzs;	int ret;	unsigned int slen, dlen;	uint64_t _srclen = srclen;	uint64_t _dstlen = *dstlen;	uchar_t *dst1 = dst;	uchar_t *src1 = src;	bzs.bzalloc = slab_alloc_i;	bzs.bzfree = slab_free;	bzs.opaque = NULL;	ret = BZ2_bzDecompressInit(&bzs, 0, 0);	if (ret != BZ_OK) {		bzerr(ret);		return (-1);	}	while (_srclen > 0) {		if (_srclen > SINGLE_CALL_MAX) {			slen = SINGLE_CALL_MAX;		} else {			slen = _srclen;		}		if (_dstlen > SINGLE_CALL_MAX) {			dlen = SINGLE_CALL_MAX;		} else {			dlen = _dstlen;		}		bzs.next_in = src1;		bzs.avail_in = slen;		bzs.next_out = dst1;		bzs.avail_out = dlen;		ret = BZ2_bzDecompress(&bzs);		if (ret != BZ_OK && ret != BZ_STREAM_END) {			BZ2_bzDecompressEnd(&bzs);			bzerr(ret);			return (-1);		}		dst1 += (dlen - bzs.avail_out);		_dstlen -= (dlen - bzs.avail_out);		src1 += (slen - bzs.avail_in);		_srclen -= (slen - bzs.avail_in);	}	/* normal termination */	*dstlen = *dstlen - _dstlen;	BZ2_bzDecompressEnd(&bzs);	return (0);}

void BZ2Decompress(Stream& out, Stream& in, Gate2<int, int> progress){	enum { BUF_SIZE = 65536 };	Buffer<char> input(BUF_SIZE), output(BUF_SIZE);	int avail = in.Get(input, BUF_SIZE);	if(avail == 0)		return;	bz_stream z;	Zero(z);	z.bzalloc = bzalloc_new;	z.bzfree = bzfree_new;	z.opaque = 0;	if(BZ2_bzDecompressInit(&z, 0, 0) != BZ_OK)	{		out.SetError();		return;	}	z.next_in = input;	z.avail_in = avail;	z.next_out = output;	z.avail_out = BUF_SIZE;	int code;	bool running = true;	int64 total = in.GetLeft();	int done = 0;	do	{		if(z.avail_in == 0 && running)		{			if((z.avail_in = in.Get(z.next_in = input, BUF_SIZE)) == 0)				running = false;			done += z.avail_in;			if(progress(done, (int)total) || in.IsError())			{				BZ2_bzDecompressEnd(&z);				out.SetError();				return;			}		}		code = BZ2_bzDecompress(&z);		if(z.avail_out == 0)		{			out.Put(z.next_out = output, z.avail_out = BUF_SIZE);			if(out.IsError())			{				BZ2_bzDecompressEnd(&z);				return;			}		}	}	while(code == BZ_OK);	if(z.avail_out < BUF_SIZE)		out.Put(output, BUF_SIZE - z.avail_out);	BZ2_bzDecompressEnd(&z);}

static intdo_uncompress( compress_filter_context_t *zfx, bz_stream *bzs,	       IOBUF a, size_t *ret_len ){  int zrc;  int rc=0;  size_t n;  int nread, count;  int refill = !bzs->avail_in;  if( DBG_FILTER )    log_debug("begin bzDecompress: avail_in=%u, avail_out=%u, inbuf=%u/n",	      (unsigned)bzs->avail_in, (unsigned)bzs->avail_out,	      (unsigned)zfx->inbufsize );  do    {      if( bzs->avail_in < zfx->inbufsize && refill )	{	  n = bzs->avail_in;	  if( !n )	    bzs->next_in = zfx->inbuf;	  count = zfx->inbufsize - n;	  nread = iobuf_read( a, zfx->inbuf + n, count );	  if( nread == -1 ) nread = 0;	  n += nread;	  bzs->avail_in = n;	}      refill = 1;      if( DBG_FILTER )	log_debug("enter bzDecompress: avail_in=%u, avail_out=%u/n",		  (unsigned)bzs->avail_in, (unsigned)bzs->avail_out);      zrc=BZ2_bzDecompress(bzs);      if( DBG_FILTER )	log_debug("leave bzDecompress: avail_in=%u, avail_out=%u, zrc=%d/n",		  (unsigned)bzs->avail_in, (unsigned)bzs->avail_out, zrc);      if( zrc == BZ_STREAM_END )	rc = -1; /* eof */      else if( zrc != BZ_OK && zrc != BZ_PARAM_ERROR )	log_fatal("bz2lib inflate problem: rc=%d/n", zrc );    }  while( bzs->avail_out && zrc != BZ_STREAM_END && zrc != BZ_PARAM_ERROR );  /* I'm not completely happy with the two uses of BZ_PARAM_ERROR     here.  The corresponding zlib function is Z_BUF_ERROR, which     covers a narrower scope than BZ_PARAM_ERROR. -dshaw */  *ret_len = zfx->outbufsize - bzs->avail_out;  if( DBG_FILTER )    log_debug("do_uncompress: returning %u bytes/n", (unsigned)*ret_len );  return rc;}

intArchiveReader::ExtractItemToStream(const MarItem *item, FILE *fp){  /* decompress the data chunk by chunk */  bz_stream strm;  int offset, inlen, outlen, ret = OK;  memset(&strm, 0, sizeof(strm));  if (BZ2_bzDecompressInit(&strm, 0, 0) != BZ_OK)    return UNEXPECTED_BZIP_ERROR;  offset = 0;  for (;;) {    if (!item->length) {      ret = UNEXPECTED_MAR_ERROR;      break;    }    if (offset < (int) item->length && strm.avail_in == 0) {      inlen = mar_read(mArchive, item, offset, inbuf, inbuf_size);      if (inlen <= 0)        return READ_ERROR;      offset += inlen;      strm.next_in = inbuf;      strm.avail_in = inlen;    }    strm.next_out = outbuf;    strm.avail_out = outbuf_size;    ret = BZ2_bzDecompress(&strm);    if (ret != BZ_OK && ret != BZ_STREAM_END) {      ret = UNEXPECTED_BZIP_ERROR;      break;    }    outlen = outbuf_size - strm.avail_out;    if (outlen) {      if (fwrite(outbuf, outlen, 1, fp) != 1) {        ret = WRITE_ERROR_EXTRACT;        break;      }    }    if (ret == BZ_STREAM_END) {      ret = OK;      break;    }  }  BZ2_bzDecompressEnd(&strm);  return ret;}

/*---------------------------------------------------*/int BZ_API(BZ2_bzBuffToBuffDecompress)                            ( char*         dest,                              unsigned int* destLen,                             char*         source,                              unsigned int  sourceLen,                             int           small,                             int           verbosity ){   bz_stream strm;   int ret;   if (dest == NULL || destLen == NULL ||        source == NULL ||       (small != 0 && small != 1) ||       verbosity < 0 || verbosity > 4)           return BZ_PARAM_ERROR;   strm.bzalloc = NULL;   strm.bzfree = NULL;   strm.opaque = NULL;   ret = BZ2_bzDecompressInit ( &strm, verbosity, small );   if (ret != BZ_OK) return ret;   strm.next_in = source;   strm.next_out = dest;   strm.avail_in = sourceLen;   strm.avail_out = *destLen;   ret = BZ2_bzDecompress ( &strm );   if (ret == BZ_OK) goto output_overflow_or_eof;   if (ret != BZ_STREAM_END) goto errhandler;   /* normal termination */   *destLen -= strm.avail_out;   BZ2_bzDecompressEnd ( &strm );   return BZ_OK;   output_overflow_or_eof:   if (strm.avail_out > 0) {      BZ2_bzDecompressEnd ( &strm );      return BZ_UNEXPECTED_EOF;   } else {      BZ2_bzDecompressEnd ( &strm );      return BZ_OUTBUFF_FULL;   };         errhandler:   BZ2_bzDecompressEnd ( &strm );   return ret; }

size_t bzRead(int *bzerr, BZStream* stream, unsigned char* out, size_t len) {	size_t toRead;	size_t haveRead;	size_t total;		total = len;		*bzerr = BZ_OK;		while(total > 0) {		if(!stream->ended) {			memmove(stream->inBuffer, stream->bz2.next_in, stream->bz2.avail_in);			stream->file->seek(stream->file, stream->offset);			haveRead = stream->file->read(stream->file, stream->inBuffer + stream->bz2.avail_in, stream->bufferLen - stream->bz2.avail_in);			stream->offset += haveRead;			stream->bz2.avail_in += haveRead;			stream->bz2.next_in = (char*) stream->inBuffer;						*bzerr = BZ2_bzDecompress(&(stream->bz2));						if(*bzerr == BZ_STREAM_END) {				stream->ended = TRUE;			} else {				if(*bzerr != BZ_OK) {					return 0;				}			}		}				if(total > (stream->bufferLen - stream->bz2.avail_out)) {			toRead = stream->bufferLen - stream->bz2.avail_out;		} else {			toRead = total;		}				memcpy(out, stream->outBuffer, toRead);		memmove(stream->outBuffer, stream->outBuffer + toRead, stream->bufferLen - toRead);		stream->bz2.next_out -= toRead;		stream->bz2.avail_out += toRead;		out += toRead;		total -= toRead;				if(total > 0 && stream->ended) {			return (len - total);		}	}		return len;}

static off_t bz_read(io_t *io, void *buffer, off_t len){	if (DATA(io)->err == ERR_EOF)		return 0; /* EOF */	if (DATA(io)->err == ERR_ERROR) {		errno=EIO;		return -1; /* ERROR! */	}	DATA(io)->strm.avail_out = len;	DATA(io)->strm.next_out = buffer;	while (DATA(io)->err == ERR_OK && DATA(io)->strm.avail_out > 0) {		while (DATA(io)->strm.avail_in <= 0) {			int bytes_read = wandio_read(DATA(io)->parent, 				DATA(io)->inbuff,				sizeof(DATA(io)->inbuff));			if (bytes_read == 0) /* EOF */				return len-DATA(io)->strm.avail_out;			if (bytes_read < 0) { /* Error */				/* Errno should already be set */				DATA(io)->err = ERR_ERROR;				/* Return how much data we managed to read ok */				if (DATA(io)->strm.avail_out != (uint32_t)len) {					return len-DATA(io)->strm.avail_out;				}				/* Now return error */				return -1;			}			DATA(io)->strm.next_in = DATA(io)->inbuff;			DATA(io)->strm.avail_in = bytes_read;		}		/* Decompress some data into the output buffer */		int err=BZ2_bzDecompress(&DATA(io)->strm);		switch(err) {			case BZ_OK:				DATA(io)->err = ERR_OK;				break;			case BZ_STREAM_END:				DATA(io)->err = ERR_EOF;				break;			default:				errno=EIO;				DATA(io)->err = ERR_ERROR;		}	}	/* Return the number of bytes decompressed */	return len-DATA(io)->strm.avail_out;}

int FillBuffer(unsigned char* buffer, int size, bz_stream* stream) {    stream->next_out = (char*)buffer;    stream->avail_out = size;    while (stream->avail_out > 0) {        int bzerr = BZ2_bzDecompress(stream);        if (bzerr != BZ_OK && bzerr != BZ_STREAM_END) {            printf("bz error %d decompressing/n", bzerr);            return -1;        }        if (stream->avail_out > 0) {            printf("need %d more bytes/n", stream->avail_out);        }    }    return 0;}

torch::Data Bz2::Decompress(const torch::Data &data){    const int size100k = 100000;    int bufsize = size100k * Bz2::block100k;    int status = 0;        bz_stream stream = {0};        Data buf(bufsize);    Data dst;    dst.HiddenAlloc(data.GetSize() * 2);        /* next_in should point at the data to be compressed     * avail_in should indicate how many bytes the library may read     * BZ2_bzDecompress updates next_in, avail_in and total_in to reflect the number of bytes it has read */    stream.next_in = (char*) data.GetBytes();    stream.avail_in = (int)data.GetSize();        /* next_out should point to a buffer in which the compressed data is to be placed     * avail_out indicating how much output space is available.     * BZ2_bzDecompress updates next_out, avail_out and total_out to reflect the number of bytes output. */    stream.next_out = (char*)buf.GetBytes();    stream.avail_out = (int)buf.GetSize();            status = BZ2_bzDecompressInit(&stream, 0, 0);    if (status != BZ_OK) {        BZ2_bzDecompressEnd(&stream);        return dst;    }        do {        status = BZ2_bzDecompress(&stream);        if (status != BZ_OK && status != BZ_STREAM_END)            break;                dst.Append(buf.GetBytes(), bufsize - stream.avail_out);                stream.next_out = (char*)buf.GetBytes();        stream.avail_out = (int)buf.GetSize();            }while (status != BZ_STREAM_END);        BZ2_bzDecompressEnd(&stream);        return dst;}

Variant HHVM_FUNCTION(bzdecompress, const String& source, int small /* = 0 */) {  char *dest;  int source_len = source.length();  int error;  uint64_t size = 0;  bz_stream bzs;  bzs.bzalloc = NULL;  bzs.bzfree = NULL;  if (BZ2_bzDecompressInit(&bzs, 0, small) != BZ_OK) {    return false;  }  bzs.next_in = (char *) source.c_str();  bzs.avail_in = source_len;  // in most cases bz2 offers at least 2:1 compression, so we use that as our  // base  bzs.avail_out = source_len * 2;  bzs.next_out = dest = (char *) malloc(bzs.avail_out + 1);  if (!dest) {    return BZ_MEM_ERROR;  }  while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {    /* compression is better then 2:1, need to allocate more memory */    bzs.avail_out = source_len;    size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;    dest = (char *) safe_realloc(dest, size + bzs.avail_out + 1);    bzs.next_out = dest + size;  }  if (error == BZ_STREAM_END || error == BZ_OK) {    size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;    dest = (char *)safe_realloc(dest, size + 1);    dest[size] = '/0';    String ret = String(dest, size, AttachString);    BZ2_bzDecompressEnd(&bzs);    return ret;  } else {    free(dest);    BZ2_bzDecompressEnd(&bzs);    return error;  }}

voiddo_bunzip2 (void){  int result;  bz_stream strm;  strm.bzalloc = NULL;  strm.bzfree = NULL;  strm.opaque = NULL;  strm.avail_in  = 0;  strm.next_out = outbuf;  strm.avail_out = OUTBUFSIZ;  result = BZ2_bzDecompressInit (&strm, 0, SMALL_MODE);  while (result == BZ_OK)  {    if (strm.avail_in == 0)    {      strm.next_in = inbuf;      strm.avail_in  = (*unzip_read)(strm.next_in, INBUFSIZ);      if (strm.avail_in == 0)        break;    }    result = BZ2_bzDecompress (&strm);    if ((result != BZ_OK) && (result != BZ_STREAM_END))      break;    if ((strm.avail_out == 0) || (result == BZ_STREAM_END))    {      (*unzip_write) (outbuf, OUTBUFSIZ - strm.avail_out);      strm.next_out = outbuf;      strm.avail_out = OUTBUFSIZ;    }  }  BZ2_bzDecompressEnd (&strm);  if (result != BZ_STREAM_END)    (*unzip_error) (NULL);}

static int64 MojoInput_bzip2_read(MojoInput *io, void *buf, uint32 bufsize){    BZIP2info *info = (BZIP2info *) io->opaque;    MojoInput *origio = info->origio;    int64 retval = 0;    if (bufsize == 0)        return 0;    // quick rejection.    info->stream.next_out = buf;    info->stream.avail_out = bufsize;    while (retval < ((int64) bufsize))    {        const uint32 before = info->stream.total_out_lo32;        int rc;        if (info->stream.avail_in == 0)        {            int64 br = origio->length(origio) - origio->tell(origio);            if (br > 0)            {                if (br > BZIP2_READBUFSIZE)                    br = BZIP2_READBUFSIZE;                br = origio->read(origio, info->buffer, (uint32) br);                if (br <= 0)                    return -1;                info->stream.next_in = (char *) info->buffer;                info->stream.avail_in = (uint32) br;            } // if        } // if        rc = BZ2_bzDecompress(&info->stream);        retval += (info->stream.total_out_lo32 - before);        if (rc != BZ_OK)            return -1;    } // while    assert(retval >= 0);    info->uncompressed_position += (uint32) retval;    return retval;} // MojoInput_bzip2_read

static HB_SIZE hb_bz2UncompressedSize( const char * szSrc, HB_SIZE nLen,                                       int * piResult ){   char      buffer[ 1024 ];   bz_stream stream;   HB_SIZE   nDest = 0;   memset( &stream, 0, sizeof( stream ) );   stream.next_in  = ( char * ) szSrc;   stream.avail_in = ( unsigned int ) nLen;   stream.bzalloc = hb_bz2Alloc;   stream.bzfree  = hb_bz2Free;/* stream.opaque  = NULL; */   *piResult = BZ2_bzDecompressInit( &stream, 0, 0 );   if( *piResult == BZ_OK )   {      do      {         stream.next_out  = buffer;         stream.avail_out = sizeof( buffer );         *piResult        = BZ2_bzDecompress( &stream );      }      while( *piResult == BZ_OK );      if( *piResult == BZ_STREAM_END )      {         *piResult = BZ_OK;#if HB_SIZE_MAX <= UINT_MAX         if( stream.total_out_hi32 != 0 )            *piResult = BZ_MEM_ERROR;         else            nDest = ( HB_SIZE ) stream.total_out_lo32;#else         nDest = ( ( HB_SIZE ) stream.total_out_hi32 << 32 ) |                 stream.total_out_lo32;#endif      }      BZ2_bzDecompressEnd( &stream );   }   return nDest;}

bool Samurai::IO::BZip2Decompressor::exec(char* input, size_t& input_len, char* output, size_t& output_len){	if (!output_len || !d) return false;		d->stream->avail_in = input_len;	d->stream->next_in = (char*) input;	d->stream->avail_out = output_len;	d->stream->next_out = (char*) output;	int retval = BZ2_bzDecompress(d->stream);		if (retval == BZ_OK)	{		output_len -= d->stream->avail_out;		input_len -= d->stream->avail_in;		return true;	}	return false;}

  static FT_Error  ft_bzip2_file_fill_output( FT_BZip2File  zip )  {    bz_stream*  bzstream = &zip->bzstream;    FT_Error    error    = FT_Err_Ok;    zip->cursor         = zip->buffer;    bzstream->next_out  = (char*)zip->cursor;    bzstream->avail_out = FT_BZIP2_BUFFER_SIZE;    while ( bzstream->avail_out > 0 )    {      int  err;      if ( bzstream->avail_in == 0 )      {        error = ft_bzip2_file_fill_input( zip );        if ( error )          break;      }      err = BZ2_bzDecompress( bzstream );      if ( err == BZ_STREAM_END )      {        zip->limit = (FT_Byte*)bzstream->next_out;        if ( zip->limit == zip->cursor )          error = FT_THROW( Invalid_Stream_Operation );        break;      }      else if ( err != BZ_OK )      {        zip->limit = zip->cursor;        error      = FT_THROW( Invalid_Stream_Operation );        break;      }    }    return error;  }

static int hb_bz2Uncompress( const char * szSrc, HB_SIZE nSrc,                             char * szDst, HB_SIZE * pnDst ){   bz_stream stream;   int       iResult;   memset( &stream, 0, sizeof( stream ) );   stream.next_in  = ( char * ) szSrc;   stream.avail_in = ( unsigned int ) nSrc;   stream.next_out  = szDst;   stream.avail_out = ( unsigned int ) *pnDst;   stream.bzalloc = hb_bz2Alloc;   stream.bzfree  = hb_bz2Free;/* stream.opaque  = NULL; */   iResult = BZ2_bzDecompressInit( &stream, 0, 0 );   if( iResult == BZ_OK )   {      do      {         iResult = BZ2_bzDecompress( &stream );      }      while( iResult == BZ_OK );      if( iResult == BZ_STREAM_END )      {#if HB_SIZE_MAX <= UINT_MAX         *pnDst = ( HB_SIZE ) stream.total_out_lo32;#else         *pnDst = ( ( HB_SIZE ) stream.total_out_hi32 << 32 ) |                  stream.total_out_lo32;#endif         iResult = BZ_OK;      }      BZ2_bzDecompressEnd( &stream );   }   return iResult;}