C++ compress2函数代码示例

static void
run (int format, gboolean alpha)
{
  guint8 data[2000] = { 0, };
  guint8 compressed[2000] = { 0, };
  gsize len; 
  gulong clen;
  int ret;
  char *s;

  switch (format) {
    case 3:
      len = create_palletized (data, alpha);
      g_print ("%u\n", len);
      break;
    default:
      g_assert_not_reached ();
      return;
  }
  
  if (alpha) {
    clen = sizeof (compressed);
    ret = compress2 (compressed, &clen, data, len, 9);
  } else {
    clen = sizeof (compressed) - 1;
    ret = compress2 (compressed + 1, &clen, data + 1, len - 1, 9);
    compressed[0] = data[0];
  }
  g_assert (ret == Z_OK);

  s = g_base64_encode (compressed, clen + 1);
  g_print ("%s\n\n", s);
  g_free (s);
}

static TACommandVerdict compress2_cmd(TAThread thread,TAInputStream stream)
{
    Bytef * dest, *source;
    uLongf destLen, sourceLen;
    int res, level;

    dest = readPointer(&stream);
    destLen = readULong(&stream);
    source = readPointer(&stream);
    sourceLen = readULong(&stream);
    level = readInt(&stream);

    ta_debug_printf("level==%d\n", level);
    ta_debug_printf("source==%s\n", source);

    START_TARGET_OPERATION(thread);

    if(level==-1)
        res = compress2(dest, &destLen, source, sourceLen,
                                                Z_DEFAULT_COMPRESSION);
    else
        res = compress2(dest, &destLen, source, sourceLen, level);

    END_TARGET_OPERATION(thread);

    ta_debug_printf("dest==%s\n", dest);

    writePointer(thread, dest);
    writeULong(thread, destLen);
    writeInt(thread, res);

    sendResponse(thread);

    return taDefaultVerdict;
}

bool compress(uint8 *dst, size_t &dst_size, const uint8 *src, size_t src_size,
              level l)
{
    return Z_OK == compress2(reinterpret_cast<Bytef*>(dst), reinterpret_cast<uLongf*>(&dst_size),
                             reinterpret_cast<const Bytef*>(src), static_cast<uLong>(src_size),
                             static_cast<int>(l));
}

//Deryabin Andrew: vst chunks support
template <typename T> void
rdwr_writeRaw(T fd, std::vector<char> rawdata, const char *file, int line)
{
    unsigned long complen = compressBound(rawdata.size());
    char *compressed = new char [complen];
    if(!compressed)
    {
        fprintf(stderr, "Failed to allocate %lu bytes of memory at %s:%d\n", complen, file, line);
        throw RemotePluginClosedException();
    }

    std::vector<char>::pointer ptr = &rawdata [0];

    if(compress2((Bytef *)compressed, &complen, (Bytef *)ptr, rawdata.size(), 9) != Z_OK)
    {
        delete compressed;
        fprintf(stderr, "Failed to compress source buffer at %s:%d\n", file, line);
        throw RemotePluginClosedException();
    }

    fprintf(stderr, "compressed source buffer. size=%lu bytes\n", complen);

    int len = complen;
    rdwr_tryWrite(fd, &len, sizeof(int), file, line);
    len = rawdata.size();
    rdwr_tryWrite(fd, &len, sizeof(int), file, line);    
    rdwr_tryWrite(fd, compressed, complen, file, line);

    delete [] compressed;
}

/*
 * Function:    compress_buffer
 * Purpose:     Compress the buffer.
 * Returns:     Z_OK            - success
 *              Z_MEM_ERROR     - not enough memory
 *              Z_BUF_ERROR     - not enough room in the output buffer
 *              Z_STREAM_ERROR  - level parameter is invalid
 * Programmer:  Bill Wendling, 05. June 2002
 * Modifications:
 */
static void
compress_buffer(Bytef *dest, uLongf *destLen, const Bytef *source,
                uLong sourceLen)
{
    int rc = compress2(dest, destLen, source, sourceLen, compress_level);

    if (rc != Z_OK) {
        /* compress2 failed - cleanup and tell why */
        cleanup();

        switch (rc) {
        case Z_MEM_ERROR:
            error("not enough memory");
            break;
        case Z_BUF_ERROR:
            error("not enough room in the output buffer");
            break;
        case Z_STREAM_ERROR:
            error("level parameter (%d) is invalid", compress_level);
            break;
        default:
            error("unknown compression error");
            break;
        }
    }
}

static length_t compress_packet(uint8_t *dest, const uint8_t *source, length_t len, int level) {
	if(level == 0) {
		memcpy(dest, source, len);
		return len;
	} else if(level == 10) {
#ifdef HAVE_LZO
		lzo_uint lzolen = MAXSIZE;
		lzo1x_1_compress(source, len, dest, &lzolen, lzo_wrkmem);
		return lzolen;
#else
		return -1;
#endif
	} else if(level < 10) {
#ifdef HAVE_ZLIB
		unsigned long destlen = MAXSIZE;
		if(compress2(dest, &destlen, source, len, level) == Z_OK)
			return destlen;
		else
#endif
			return -1;
	} else {
#ifdef HAVE_LZO
		lzo_uint lzolen = MAXSIZE;
		lzo1x_999_compress(source, len, dest, &lzolen, lzo_wrkmem);
		return lzolen;
#else
		return -1;
#endif
	}
	
	return -1;
}

static void gzip_compress_buf(struct stream *s, int *c_type, i64 *c_len)
{
	uchar *c_buf;
	unsigned long dlen = s->buflen;

	c_buf = malloc(dlen);
	if (!c_buf)
		return;

	if (compress2(c_buf, &dlen, s->buf, s->buflen, control.compression_level) != Z_OK) {
		free(c_buf);
		return;
	}

	if ((i64)dlen >= *c_len) {
		/* Incompressible, leave as CTYPE_NONE */
		free(c_buf);
		return;
	}

	*c_len = dlen;
	free(s->buf);
	s->buf = c_buf;
	*c_type = CTYPE_GZIP;
}

static void writeDat( std::ofstream & os, const std::vector<char> & data ) {
	std::vector<char> cdata( data.size() );
	uLongf len = data.size();
	compress2( (Bytef*)cdata.data(), &len, (const Bytef*)data.data(), data.size(), 9 );
	cdata.resize( len );
	writeChunk( os, "IDAT", cdata );
}

void
TestCompress(CuTest * tc)
{
    char input[] =
        {
 "This is a test input string.  I like to test inputThis is a test input string.  I like to test input."
};

    uLongf output_len = 2000;
    void *output = malloc(output_len);
    uLongf input_len = (uLongf) strlen(input);

  /**
   * Attempt the compression.
   */
    int ret =
        compress2(output, &output_len, (void *)input, input_len,
                  Z_BEST_SPEED);

  /**
   * Assert it 1.  Worked.
   */
    CuAssertTrue(tc, ret == Z_OK);

  /**
   * The output size is smaller than the input size.
   */
    CuAssertTrue(tc, output_len < input_len);

    free(output);
}

/**
 * Attempt to compress and decompress.
 */
void
TestDecompress(CuTest * tc)
{
    char input[] =
        {
 "This is a test input string.  I like to test inputThis is a test input string.  I like to test input."
};
    uLongf input_len = (uLongf) strlen(input);

    uLongf compressed_len = 2000;
    void *compressed = malloc(compressed_len);

    uLongf decompressed_len = 2000;
    void *decompressed = malloc(decompressed_len);


  /**
   * Attempt the compression.
   */
    int ret =
        compress2(compressed, &compressed_len, (void *)input, input_len,
                  Z_BEST_SPEED);

  /**
   * Assert it 1.  Worked.
   */
    CuAssertTrue(tc, ret == Z_OK);

  /**
   * The output size is smaller than the input size.
   */
    CuAssertTrue(tc, compressed_len < input_len);


  /**
   * OK now we decompress.
   */
    ret =
        uncompress(decompressed, &decompressed_len, (void *)compressed,
                   compressed_len);

  /**
   * Assert: 1. it worked.
   */
    CuAssertTrue(tc, ret == Z_OK);

  /**
   * 2. Output is longer than the input.
   */
    CuAssertTrue(tc, compressed_len < decompressed_len);

  /**
   * 3. Ouptut is equal to original starting point.
   */
    CuAssertTrue(tc, decompressed_len == input_len);
    CuAssertTrue(tc, (strcmp(decompressed, input) == 0));

    free(compressed);
    free(decompressed);
}

  void ZlibCompressor::Compress(std::string& compressed,
                                const void* uncompressed,
                                size_t uncompressedSize)
  {
    if (uncompressedSize == 0)
    {
      compressed.clear();
      return;
    }

    uLongf compressedSize = compressBound(uncompressedSize) + 1024 /* security margin */;
    if (compressedSize == 0)
    {
      compressedSize = 1;
    }

    uint8_t* target;
    if (HasPrefixWithUncompressedSize())
    {
      compressed.resize(compressedSize + sizeof(uint64_t));
      target = reinterpret_cast<uint8_t*>(&compressed[0]) + sizeof(uint64_t);
    }
    else
    {
      compressed.resize(compressedSize);
      target = reinterpret_cast<uint8_t*>(&compressed[0]);
    }

    int error = compress2(target,
                          &compressedSize,
                          const_cast<Bytef *>(static_cast<const Bytef *>(uncompressed)), 
                          uncompressedSize,
                          GetCompressionLevel());

    if (error != Z_OK)
    {
      compressed.clear();

      switch (error)
      {
      case Z_MEM_ERROR:
        throw OrthancException(ErrorCode_NotEnoughMemory);

      default:
        throw OrthancException(ErrorCode_InternalError);
      }  
    }

    // The compression was successful
    if (HasPrefixWithUncompressedSize())
    {
      uint64_t s = static_cast<uint64_t>(uncompressedSize);
      memcpy(&compressed[0], &s, sizeof(uint64_t));
      compressed.resize(compressedSize + sizeof(uint64_t));
    }
    else
    {
      compressed.resize(compressedSize);
    }
  }

int CDataFileWriter::AddData(int Size, void *pData)
{
	if(!m_File) return 0;

	dbg_assert(m_NumDatas < 1024, "too much data");

	CDataInfo *pInfo = &m_pDatas[m_NumDatas];
	unsigned long s = compressBound(Size);
	void *pCompData = mem_alloc(s, 1); // temporary buffer that we use during compression

	int Result = compress2((Bytef*)pCompData, &s, (Bytef*)pData, Size, CompressionLevel); // ignore_convention
	if(Result != Z_OK)
	{
		dbg_msg("datafile", "compression error %d", Result);
		dbg_assert(0, "zlib error");
	}

	pInfo->m_UncompressedSize = Size;
	pInfo->m_CompressedSize = (int)s;
	pInfo->m_pCompressedData = mem_alloc(pInfo->m_CompressedSize, 1);
	mem_copy(pInfo->m_pCompressedData, pCompData, pInfo->m_CompressedSize);
	mem_free(pCompData);

	m_NumDatas++;
	return m_NumDatas-1;
}

int segment_compress(int *source, int size, char *compress_source, long int *compress_size)
{	
	int err;
	
	uLong sourceLen = (uLongf)size;
	uLongf destLen = (uLongf)(*compress_size);
	Bytef *byte_source;
	Bytef *byte_dest;
	
	byte_source = (Bytef *)source;
	byte_dest = (Bytef *)compress_source;
	
	err = compress2(byte_dest, &destLen, byte_source, sourceLen, COMPRESS_LEVEL);
	
	if(err != Z_OK) {
		printf("ERROR: Error compress!\n");
		if(err == Z_BUF_ERROR)
			printf("ERROR: The buffer was not large enough to hold the uncompressed data.\n");
		if(err == Z_MEM_ERROR)
			printf("ERROR: Insufficient memory.\n");
		if(err == Z_STREAM_ERROR)
			printf("ERROR: The compressed data (referenced by source) was corrupted.\n");
	}

	*compress_size = (long int)destLen;
	
	return 0;
}

std::vector<uint8_t> compress(const std::vector<uint8_t> & input, int level)
{
    uLongf destlen = input.size();
    std::vector<uint8_t> output;
    output.resize(2 * input.size());

    Bytef* dest = reinterpret_cast<Bytef*>(&output.front());

    uLongf srclen = input.size();
    const Bytef* src = input.data();

    int ret = ::compress2(dest, &destlen, src, srclen, level);

    // realloc a larger buffer if the current one is too small
    while (ret == Z_BUF_ERROR)
    {
        output.resize(2 * output.size());
        dest = reinterpret_cast<Bytef*>(&output.front());
        destlen = output.size();
        dest = reinterpret_cast<Bytef*>(&output.front());
        ret = compress2(dest, &destlen, src, srclen, level);
    }

    output.resize(destlen);
    output.shrink_to_fit();
    return output;
}

	/// Compress data by Zlib
	bool nekoByteBuffer::Compress(int32 level)
	{
		nekoAssert(level >= 0 && level <= 9, "압축 레벨은 0과 9 사이의 정수 입니다.");

		// No data
		if(!length)
			return false;

		// Compress it.
		int32 destLen;
		char8 *destData = nekoNew char8[(destLen = (int32)((length + 12) * 1.1)) + sizeof(int32)];
		if(compress2((Bytef *)(destData + sizeof(int32)), (uLongf *)&destLen, (Bytef *)buf, (uLongf)length, level) != Z_OK)
		{
			delete []destData;
			return false;
		}

		SafeDeleteArray(buf);

		// 앞부분에 원래 길이 넣어두기
		memcpy(destData, &length, sizeof(int32));
		buf = destData;
		length = destLen + sizeof(int32);
		writePos = length;
		return true;
	}