Introduction to LZ4

LZ4 is a fast and efficient compression library that excels in both speed and compression ratio. It is widely used in various applications to optimize storage and accelerate data transfer by minimizing data sizes.

Getting Started with LZ4

To use the LZ4 compression library, you need to include its header files and link against the LZ4 library. Here are some essentials to get started:

Basic Compression

  
  #include <lz4.h>

  int main() {
      char input[] = "Hello, LZ4!";
      char compressed[64];
      int compressedSize = LZ4_compress_default(input, compressed, sizeof(input), sizeof(compressed));
      printf("Compressed Size: %d\n", compressedSize);
      return 0;
  }
  

Basic Decompression

  
  #include <lz4.h>

  int main() {
      char compressed[] = { /* compressed data */ };
      char decompressed[64];
      int originalSize = sizeof(decompressed);
      
      int decompressedSize = LZ4_decompress_safe(compressed, decompressed, sizeof(compressed), originalSize);
      printf("Decompressed Size: %d\n", decompressedSize);
      return 0;
  }
  

Streaming Decompression

  
  #include <lz4frame.h>

  int decompress_stream(FILE* inputFile, FILE* outputFile) {
      LZ4F_dctx* dctx;
      LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION);
      
      char inputBuffer[65536];
      char outputBuffer[65536];
      size_t inputSize;
      size_t outputSize = sizeof(outputBuffer);
      
      while ((inputSize = fread(inputBuffer, 1, sizeof(inputBuffer), inputFile)) > 0) {
          size_t bytesDecompressed = 0;
          LZ4F_decompressOptions_t options = {0};

          while (bytesDecompressed < inputSize) {
              bytesDecompressed += LZ4F_decompress(dctx, outputBuffer, &outputSize, inputBuffer + bytesDecompressed, &inputSize, &options);
              fwrite(outputBuffer, 1, outputSize, outputFile);
          }
      }
      
      LZ4F_freeDecompressionContext(dctx);
      return 0;
  }
  

Advanced Usage of LZ4

Using Custom Allocators

  
  #include <lz4.h>

  void* customAlloc(size_t size) {
      return malloc(size);
  }

  void customFree(void* ptr) {
      free(ptr);
  }

  int main() {
      LZ4_stream_t* lz4Stream = LZ4_createStream();
      LZ4_resetStream(lz4Stream);
      
      char input[] = "Using custom allocators in LZ4";
      char compressed[LZ4_COMPRESSBOUND(sizeof(input))];
      
      LZ4_compress_fast_extState(lz4Stream, input, compressed, sizeof(input), sizeof(compressed), 1);
      LZ4_freeStream(lz4Stream, customFree);
      
      return 0;
  }
  

Block Mode Compression

  
  #include <lz4.h>

  int main() {
      char input[] = "Block mode compression with LZ4";
      char compressed[LZ4_BLOCKSIZE_MAX];
      LZ4F_compressionContext_t ctx;
      
      LZ4F_createCompressionContext(&ctx, LZ4F_VERSION);
      size_t compressedSize = LZ4F_compressBegin(ctx, compressed, LZ4F_BLOCKSIZE_ID_DEFAULT, NULL);
      
      compressedSize += LZ4F_compressUpdate(ctx, compressed + compressedSize, LZ4_BLOCKSIZE_MAX - compressedSize, input, sizeof(input), NULL);
      compressedSize += LZ4F_compressEnd(ctx, compressed + compressedSize, LZ4_BLOCKSIZE_MAX - compressedSize, NULL);
      
      LZ4F_freeCompressionContext(ctx);
      
      printf("Compressed Size: %zu\n", compressedSize);
      return 0;
  }
  

Example Application Using LZ4 APIs

  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <lz4.h>

  int main() {
      const char* original = "Example application utilizing LZ4 compression and decompression.";
      size_t originalSize = strlen(original) + 1;
      
      char* compressed = (char*)malloc(LZ4_COMPRESSBOUND(originalSize));
      int compressedSize = LZ4_compress_default(original, compressed, originalSize, LZ4_COMPRESSBOUND(originalSize));
      
      if (compressedSize <= 0) {
          fprintf(stderr, "Compression failed!\n");
          free(compressed);
          return 1;
      }
      
      char* decompressed = (char*)malloc(originalSize);
      int decompressedSize = LZ4_decompress_safe(compressed, decompressed, compressedSize, originalSize);
      
      if (decompressedSize < 0) {
          fprintf(stderr, "Decompression failed!\n");
          free(compressed);
          free(decompressed);
          return 1;
      }
      
      printf("Original: %s\n", original);
      printf("Decompressed: %s\n", decompressed);
      
      free(compressed);
      free(decompressed);
      return 0;
  }
  

Hash: d846fc5d0425258664cb17e29c4e6db4f40ae1bcb6a68399747cf6ed81157887