1 /* 2 * simple_buffer.c 3 * Copyright : Kyle Harper 4 * License : Follows same licensing as the lz4.c/lz4.h program at any given time. Currently, BSD 2. 5 * Description: Example program to demonstrate the basic usage of the compress/decompress functions within lz4.c/lz4.h. 6 * The functions you'll likely want are LZ4_compress_default and LZ4_decompress_safe. Both of these are documented in 7 * the lz4.h header file; I recommend reading them. 8 */ 9 10 /* Includes, for Power! */ 11 #include "lz4.h" // This is all that is required to expose the prototypes for basic compression and decompression. 12 #include <stdio.h> // For printf() 13 #include <string.h> // For memcmp() 14 #include <stdlib.h> // For exit() 15 16 /* 17 * Easy show-error-and-bail function. 18 */ 19 void run_screaming(const char *message, const int code) { 20 printf("%s\n", message); 21 exit(code); 22 return; 23 } 24 25 26 /* 27 * main 28 */ 29 int main(void) { 30 /* Introduction */ 31 // Below we will have a Compression and Decompression section to demonstrate. 32 // There are a few important notes before we start: 33 // 1) The return codes of LZ4_ functions are important. 34 // Read lz4.h if you're unsure what a given code means. 35 // 2) LZ4 uses char* pointers in all LZ4_ functions. 36 // This is baked into the API and probably not going to change. 37 // If your program uses pointers that are unsigned char*, void*, or otherwise different, 38 // you may need to do some casting or set the right -W compiler flags to ignore those warnings (e.g.: -Wno-pointer-sign). 39 40 /* Compression */ 41 // We'll store some text into a variable pointed to by *src to be compressed later. 42 const char* const src = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."; 43 // The compression function needs to know how many bytes exist. Since we're using a string, we can use strlen() + 1 (for \0). 44 const int src_size = (int)(strlen(src) + 1); 45 // LZ4 provides a function that will tell you the maximum size of compressed output based on input data via LZ4_compressBound(). 46 const int max_dst_size = LZ4_compressBound(src_size); 47 // We will use that size for our destination boundary when allocating space. 48 char* compressed_data = malloc(max_dst_size); 49 if (compressed_data == NULL) 50 run_screaming("Failed to allocate memory for *compressed_data.", 1); 51 // That's all the information and preparation LZ4 needs to compress *src into *compressed_data. 52 // Invoke LZ4_compress_default now with our size values and pointers to our memory locations. 53 // Save the return value for error checking. 54 const int compressed_data_size = LZ4_compress_default(src, compressed_data, src_size, max_dst_size); 55 // Check return_value to determine what happened. 56 if (compressed_data_size < 0) 57 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); 58 if (compressed_data_size == 0) 59 run_screaming("A result of 0 means compression worked, but was stopped because the destination buffer couldn't hold all the information.", 1); 60 if (compressed_data_size > 0) 61 printf("We successfully compressed some data!\n"); 62 // Not only does a positive return_value mean success, the value returned == the number of bytes required. 63 // You can use this to realloc() *compress_data to free up memory, if desired. We'll do so just to demonstrate the concept. 64 compressed_data = (char *)realloc(compressed_data, compressed_data_size); 65 if (compressed_data == NULL) 66 run_screaming("Failed to re-alloc memory for compressed_data. Sad :(", 1); 67 68 /* Decompression */ 69 // Now that we've successfully compressed the information from *src to *compressed_data, let's do the opposite! We'll create a 70 // *new_src location of size src_size since we know that value. 71 char* const regen_buffer = malloc(src_size); 72 if (regen_buffer == NULL) 73 run_screaming("Failed to allocate memory for *regen_buffer.", 1); 74 // The LZ4_decompress_safe function needs to know where the compressed data is, how many bytes long it is, 75 // where the regen_buffer memory location is, and how large regen_buffer (uncompressed) output will be. 76 // Again, save the return_value. 77 const int decompressed_size = LZ4_decompress_safe(compressed_data, regen_buffer, compressed_data_size, src_size); 78 free(compressed_data); /* no longer useful */ 79 if (decompressed_size < 0) 80 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); 81 if (decompressed_size == 0) 82 run_screaming("I'm not sure this function can ever return 0. Documentation in lz4.h doesn't indicate so.", 1); 83 if (decompressed_size > 0) 84 printf("We successfully decompressed some data!\n"); 85 // Not only does a positive return value mean success, 86 // value returned == number of bytes regenerated from compressed_data stream. 87 88 /* Validation */ 89 // We should be able to compare our original *src with our *new_src and be byte-for-byte identical. 90 if (memcmp(src, regen_buffer, src_size) != 0) 91 run_screaming("Validation failed. *src and *new_src are not identical.", 1); 92 printf("Validation done. The string we ended up with is:\n%s\n", regen_buffer); 93 return 0; 94 } 95
