C++ (Cpp) wfLZ_Decompress Examples

Example #1

File: squash-wflz.c Project: Dr-Emann/squash

static SquashStatus
squash_wflz_decompress_buffer (SquashCodec* codec,
                               size_t* decompressed_size,
                               uint8_t decompressed[SQUASH_ARRAY_PARAM(*decompressed_size)],
                               size_t compressed_size,
                               const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_size)],
                               SquashOptions* options) {
  const char* codec_name = squash_codec_get_name (codec);
  uint32_t decompressed_s;

  if (SQUASH_UNLIKELY(compressed_size < 12))
    return squash_error (SQUASH_BUFFER_EMPTY);

  decompressed_s = wfLZ_GetDecompressedSize (compressed);

#if SIZE_MAX < UINT32_MAX
  if (SQUASH_UNLIKELY(SIZE_MAX < decompressed_s))
    return squash_error (SQUASH_RANGE);
#endif

  if (SQUASH_UNLIKELY(decompressed_s == 0))
    return squash_error (SQUASH_INVALID_BUFFER);

  if (SQUASH_UNLIKELY(decompressed_s > *decompressed_size))
    return squash_error (SQUASH_BUFFER_FULL);

  if (codec_name[4] == '\0') {
    wfLZ_Decompress (compressed, decompressed);
  } else {
    uint8_t* dest = decompressed;
    uint32_t* chunk = NULL;
    uint8_t* compressed_block;

    while ( (compressed_block = wfLZ_ChunkDecompressLoop ((uint8_t*) compressed, &chunk)) != NULL ) {
      const uint32_t chunk_size = wfLZ_GetDecompressedSize (compressed_block);

      if (SQUASH_UNLIKELY((dest + chunk_size) > (decompressed + *decompressed_size)))
        return squash_error (SQUASH_BUFFER_FULL);

      wfLZ_Decompress (compressed_block, dest);
      dest += chunk_size;
    }
  }

  *decompressed_size = decompressed_s;

  return SQUASH_OK;
}

Example #2

File: wlfz_nif.c Project: Zabrane/wflz-erlang-nif

//-
static
ERL_NIF_TERM
nif_decompress(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary input;

    if(!enif_inspect_iolist_as_binary(env, argv[0], &input)) 
    {
        return(enif_make_badarg(env));
    }

    ErlNifBinary bin;

    // [rad] Get decompressed size.
    uint32_t decompressed_bytes = wfLZ_GetDecompressedSize((const uint8_t* const) input.data);

    if(!decompressed_bytes)
    {
        return(erlang_produce_error(env, "not_compressed"));
    }

    // [rad] Create binary stream to hold decompressed data.
    if(!enif_alloc_binary(decompressed_bytes, &bin))
    {
        return(erlang_produce_error(env, "not_enough_memory"));
    } 

    // [rad] Perform decompression.
    wfLZ_Decompress((const uint8_t* const) input.data, bin.data);

    return(enif_make_binary(env, &bin));
}

Example #3

File: compressors.cpp Project: TurtleSimos/lzbench

int64_t lzbench_wflz_decompress(char *inbuf, size_t insize, char *outbuf, size_t outsize, size_t, size_t, char*)
{
    wfLZ_Decompress((const uint8_t*)inbuf, (uint8_t*)outbuf);
    return outsize;
}

Example #4

File: main.c Project: nemequ/wflz

int main( int argc, char** argv )
{
    const char* in;

    uint32_t hashCheck = 1;
    uint64_t hashValue, hashValue2;

    uint32_t compressedSize, uncompressedSize;
    uint8_t* uncompressed;
    uint8_t* workMem;
    uint8_t* compressed;

    if( argc < 2 )
    {
        printf( "Usage: wflz input_file" );
        return 0;
    }
    in = argv[1];

    printf( "\nwfLZ[%s]\n", in );
    {
        FILE* fh = fopen( in, "rb" );
        if( fh == NULL )
        {
            printf( "Error: Could not read input file '%s'.\n", in );
            return 0;
        }
        fseek( fh, 0, SEEK_END );
        uncompressedSize = (uint32_t)ftell( fh );
        uncompressed = (uint8_t*)Malloc( uncompressedSize );
        if( uncompressed == NULL )
        {
            fclose( fh );
            printf( "Error: Allocation failed.\n" );
            return 0;
        }
        fseek( fh, 0, SEEK_SET );
        if( fread( uncompressed, 1, uncompressedSize, fh ) != uncompressedSize )
        {
            fclose( fh );
            printf( "Error: File read failed.\n" );
            return 0;
        }
        fclose( fh );
    }

    workMem = (uint8_t*)Malloc( wfLZ_GetWorkMemSize() );
    if( workMem == NULL )
    {
        printf( "Error: Allocation failed.\n" );
        return 0;
    }

    compressed = (uint8_t*)Malloc( wfLZ_GetMaxCompressedSize( uncompressedSize ) );

    hashValue = hashCheck ? HashData( uncompressed, uncompressedSize ) : 0 ;

//#define CAPTURING_PROFILE
#ifdef CAPTURING_PROFILE
    {   uint32_t i;
        for( i = 0; i != 10000; ++i )
        {
#endif
            compressedSize = wfLZ_CompressFast( uncompressed, uncompressedSize, compressed, workMem, 0 );

            if( hashCheck ) {
                memset( uncompressed, 0, uncompressedSize );
            }

            wfLZ_Decompress( compressed, uncompressed );
#ifdef CAPTURING_PROFILE
        }
    }
#endif

    free( workMem );
    free( compressed );
    hashValue2 = hashCheck ? HashData( uncompressed, uncompressedSize ) : 0 ;

    free( uncompressed );

    printf( "Compression Ratio: %.2f\n", ((float)compressedSize)/((float)uncompressedSize) );

    if( hashCheck && hashValue != hashValue2 )
    {
        printf( "Error: Hash check mismatch!\n" );
        return -1;
    }

    return 0;
}