refactored simple_buffer.c example (#363)
This commit is contained in:
parent
7e15e240ab
commit
775e63ee01
1
examples/.gitignore
vendored
1
examples/.gitignore
vendored
@ -6,4 +6,5 @@
|
||||
/ringBufferHC
|
||||
/lineCompress
|
||||
/frameCompress
|
||||
/simpleBuffer
|
||||
/*.exe
|
||||
|
@ -27,9 +27,10 @@
|
||||
# kindly provided by Takayuki Matsuoka
|
||||
# ##########################################################################
|
||||
|
||||
CFLAGS ?= -O3
|
||||
CFLAGS += -std=gnu99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes
|
||||
FLAGS := -I../lib $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
|
||||
CPPFLAGS += -I../lib
|
||||
CFLAGS ?= -O3
|
||||
CFLAGS += -std=gnu99 -Wall -Wextra -Wundef -Wshadow -Wcast-align -Wstrict-prototypes
|
||||
FLAGS := $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)
|
||||
|
||||
TESTFILE= Makefile
|
||||
LZ4DIR := ../lib
|
||||
@ -48,7 +49,8 @@ endif
|
||||
|
||||
default: all
|
||||
|
||||
all: printVersion doubleBuffer dictionaryRandomAccess ringBuffer ringBufferHC lineCompress frameCompress
|
||||
all: printVersion doubleBuffer dictionaryRandomAccess ringBuffer ringBufferHC \
|
||||
lineCompress frameCompress simpleBuffer
|
||||
|
||||
printVersion: $(LZ4DIR)/lz4.c printVersion.c
|
||||
$(CC) $(FLAGS) $^ -o $@$(EXT)
|
||||
@ -85,6 +87,7 @@ test : all
|
||||
./ringBufferHC$(EXT) $(TESTFILE)
|
||||
./lineCompress$(EXT) $(TESTFILE)
|
||||
./frameCompress$(EXT) $(TESTFILE)
|
||||
./simpleBuffer$(EXT)
|
||||
$(LZ4) -vt $(TESTFILE).lz4
|
||||
|
||||
clean:
|
||||
|
@ -8,10 +8,10 @@
|
||||
*/
|
||||
|
||||
/* Includes, for Power! */
|
||||
#include "lz4.h" // This is all that is required to expose the prototypes for basic compression and decompression.
|
||||
#include <stdio.h> // For printf()
|
||||
#include <string.h> // For memcmp()
|
||||
#include <stdlib.h> // For exit()
|
||||
#include "lz4.h" // This is all that is required to expose the prototypes for basic compression and decompression.
|
||||
#include <stdio.h> // For printf()
|
||||
#include <string.h> // For memcmp()
|
||||
#include <stdlib.h> // For exit()
|
||||
|
||||
/*
|
||||
* Easy show-error-and-bail function.
|
||||
@ -28,37 +28,39 @@ void run_screaming(const char *message, const int code) {
|
||||
*/
|
||||
int main(void) {
|
||||
/* Introduction */
|
||||
// Below we will have a Compression and Decompression section to demonstrate. There are a few important notes before we start:
|
||||
// 1) The return codes of LZ4_ functions are important. Read lz4.h if you're unsure what a given code means.
|
||||
// 2) LZ4 uses char* pointers in all LZ4_ functions. This is baked into the API and probably not going to change. If your
|
||||
// program uses pointers that are unsigned char*, void*, or otherwise different you may need to do some casting or set the
|
||||
// right -W compiler flags to ignore those warnings (e.g.: -Wno-pointer-sign).
|
||||
// Below we will have a Compression and Decompression section to demonstrate.
|
||||
// There are a few important notes before we start:
|
||||
// 1) The return codes of LZ4_ functions are important.
|
||||
// Read lz4.h if you're unsure what a given code means.
|
||||
// 2) LZ4 uses char* pointers in all LZ4_ functions.
|
||||
// This is baked into the API and probably not going to change.
|
||||
// If your program uses pointers that are unsigned char*, void*, or otherwise different,
|
||||
// you may need to do some casting or set the right -W compiler flags to ignore those warnings (e.g.: -Wno-pointer-sign).
|
||||
|
||||
/* Compression */
|
||||
// We'll store some text into a variable pointed to by *src to be compressed later.
|
||||
const char *src = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
|
||||
// The compression function needs to know how many bytes of exist. Since we're using a string, we can use strlen() + 1 (for \0).
|
||||
const size_t src_size = strlen(src) + 1;
|
||||
const char* const src = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
|
||||
// The compression function needs to know how many bytes exist. Since we're using a string, we can use strlen() + 1 (for \0).
|
||||
const int src_size = (int)(strlen(src) + 1);
|
||||
// LZ4 provides a function that will tell you the maximum size of compressed output based on input data via LZ4_compressBound().
|
||||
const size_t max_dst_size = LZ4_compressBound(src_size);
|
||||
const int max_dst_size = LZ4_compressBound(src_size);
|
||||
// We will use that size for our destination boundary when allocating space.
|
||||
char *compressed_data = malloc(max_dst_size);
|
||||
char* compressed_data = malloc(max_dst_size);
|
||||
if (compressed_data == NULL)
|
||||
run_screaming("Failed to allocate memory for *compressed_data.", 1);
|
||||
// That's all the information and preparation LZ4 needs to compress *src into *compressed_data. Invoke LZ4_compress_default now
|
||||
// with our size values and pointers to our memory locations. Save the return value for error checking.
|
||||
int return_value = 0;
|
||||
return_value = LZ4_compress_default(src, compressed_data, src_size, max_dst_size);
|
||||
// That's all the information and preparation LZ4 needs to compress *src into *compressed_data.
|
||||
// Invoke LZ4_compress_default now with our size values and pointers to our memory locations.
|
||||
// Save the return value for error checking.
|
||||
const int compressed_data_size = LZ4_compress_default(src, compressed_data, src_size, max_dst_size);
|
||||
// Check return_value to determine what happened.
|
||||
if (return_value < 0)
|
||||
run_screaming("A negative result from LZ4_compress_default indicates a failure trying to compress the data. See exit code (echo $?) for value returned.", return_value);
|
||||
if (return_value == 0)
|
||||
if (compressed_data_size < 0)
|
||||
run_screaming("A negative result from LZ4_compress_default indicates a failure trying to compress the data. See exit code (echo $?) for value returned.", compressed_data_size);
|
||||
if (compressed_data_size == 0)
|
||||
run_screaming("A result of 0 means compression worked, but was stopped because the destination buffer couldn't hold all the information.", 1);
|
||||
if (return_value > 0)
|
||||
if (compressed_data_size > 0)
|
||||
printf("We successfully compressed some data!\n");
|
||||
// Not only does a positive return_value mean success, the value returned == the number of bytes required. You can use this to
|
||||
// realloc() *compress_data to free up memory, if desired. We'll do so just to demonstrate the concept.
|
||||
const size_t compressed_data_size = return_value;
|
||||
// Not only does a positive return_value mean success, the value returned == the number of bytes required.
|
||||
// You can use this to realloc() *compress_data to free up memory, if desired. We'll do so just to demonstrate the concept.
|
||||
compressed_data = (char *)realloc(compressed_data, compressed_data_size);
|
||||
if (compressed_data == NULL)
|
||||
run_screaming("Failed to re-alloc memory for compressed_data. Sad :(", 1);
|
||||
@ -66,25 +68,26 @@ int main(void) {
|
||||
/* Decompression */
|
||||
// Now that we've successfully compressed the information from *src to *compressed_data, let's do the opposite! We'll create a
|
||||
// *new_src location of size src_size since we know that value.
|
||||
char *new_src = malloc(src_size);
|
||||
if (new_src == NULL)
|
||||
run_screaming("Failed to allocate memory for *new_src.", 1);
|
||||
// The LZ4_decompress_safe function needs to know where the compressed data is, how many bytes long it is, where the new_src
|
||||
// memory location is, and how large the new_src (uncompressed) output will be. Again, save the return_value.
|
||||
return_value = LZ4_decompress_safe(compressed_data, new_src, compressed_data_size, src_size);
|
||||
if (return_value < 0)
|
||||
run_screaming("A negative result from LZ4_decompress_fast indicates a failure trying to decompress the data. See exit code (echo $?) for value returned.", return_value);
|
||||
if (return_value == 0)
|
||||
char* const regen_buffer = malloc(src_size);
|
||||
if (regen_buffer == NULL)
|
||||
run_screaming("Failed to allocate memory for *regen_buffer.", 1);
|
||||
// The LZ4_decompress_safe function needs to know where the compressed data is, how many bytes long it is,
|
||||
// where the regen_buffer memory location is, and how large regen_buffer (uncompressed) output will be.
|
||||
// Again, save the return_value.
|
||||
const int decompressed_size = LZ4_decompress_safe(compressed_data, regen_buffer, compressed_data_size, src_size);
|
||||
if (decompressed_size < 0)
|
||||
run_screaming("A negative result from LZ4_decompress_safe indicates a failure trying to decompress the data. See exit code (echo $?) for value returned.", decompressed_size);
|
||||
if (decompressed_size == 0)
|
||||
run_screaming("I'm not sure this function can ever return 0. Documentation in lz4.h doesn't indicate so.", 1);
|
||||
if (return_value > 0)
|
||||
if (decompressed_size > 0)
|
||||
printf("We successfully decompressed some data!\n");
|
||||
// Not only does a positive return value mean success, the value returned == the number of bytes read from the compressed_data
|
||||
// stream. I'm not sure there's ever a time you'll need to know this in most cases...
|
||||
// Not only does a positive return value mean success,
|
||||
// value returned == number of bytes regenerated from compressed_data stream.
|
||||
|
||||
/* Validation */
|
||||
// We should be able to compare our original *src with our *new_src and be byte-for-byte identical.
|
||||
if (memcmp(src, new_src, src_size) != 0)
|
||||
if (memcmp(src, regen_buffer, src_size) != 0)
|
||||
run_screaming("Validation failed. *src and *new_src are not identical.", 1);
|
||||
printf("Validation done. The string we ended up with is:\n%s\n", new_src);
|
||||
printf("Validation done. The string we ended up with is:\n%s\n", regen_buffer);
|
||||
return 0;
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user