util/cbfstool/compress.c

   1 /* compression handling for cbfstool */
   2 /* SPDX-License-Identifier: GPL-2.0-only */
   3
   4 #include <string.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include "common.h"
   8 #include "lz4/lib/lz4frame.h"
   9 #include <commonlib/bsd/compression.h>
  10
  11 static int lz4_compress(char *in, int in_len, char *out, int *out_len)
  12 {
  13         LZ4F_preferences_t prefs = {
  14                 .compressionLevel = 20,
  15                 .frameInfo = {
  16                         .blockSizeID = max4MB,
  17                         .blockMode = blockIndependent,
  18                         .contentChecksumFlag = noContentChecksum,
  19                 },
  20         };
  21         size_t worst_size = LZ4F_compressFrameBound(in_len, &prefs);
  22         void *bounce = malloc(worst_size);
  23         if (!bounce)
  24                 return -1;
  25         *out_len = LZ4F_compressFrame(bounce, worst_size, in, in_len, &prefs);
  26         if (LZ4F_isError(*out_len) || *out_len >= in_len)
  27                 return -1;
  28         memcpy(out, bounce, *out_len);
  29         return 0;
  30 }
  31
  32 static int lz4_decompress(char *in, int in_len, char *out, int out_len,
  33                           size_t *actual_size)
  34 {
  35         size_t result = ulz4fn(in, in_len, out, out_len);
  36         if (result == 0)
  37                 return -1;
  38         if (actual_size != NULL)
  39                 *actual_size = result;
  40         return 0;
  41 }
  42
  43 static int lzma_compress(char *in, int in_len, char *out, int *out_len)
  44 {
  45         return do_lzma_compress(in, in_len, out, out_len);
  46 }
  47
  48 static int lzma_decompress(char *in, int in_len, char *out, unused int out_len,
  49                                 size_t *actual_size)
  50 {
  51         return do_lzma_uncompress(out, out_len, in, in_len, actual_size);
  52 }
  53 static int none_compress(char *in, int in_len, char *out, int *out_len)
  54 {
  55         memcpy(out, in, in_len);
  56         *out_len = in_len;
  57         return 0;
  58 }
  59
  60 static int none_decompress(char *in, int in_len, char *out, unused int out_len,
  61                                 size_t *actual_size)
  62 {
  63         memcpy(out, in, in_len);
  64         if (actual_size != NULL)
  65                 *actual_size = in_len;
  66         return 0;
  67 }
  68
  69 comp_func_ptr compression_function(enum cbfs_compression algo)
  70 {
  71         comp_func_ptr compress;
  72         switch (algo) {
  73         case CBFS_COMPRESS_NONE:
  74                 compress = none_compress;
  75                 break;
  76         case CBFS_COMPRESS_LZMA:
  77                 compress = lzma_compress;
  78                 break;
  79         case CBFS_COMPRESS_LZ4:
  80                 compress = lz4_compress;
  81                 break;
  82         default:
  83                 ERROR("Unknown compression algorithm %d!\n", algo);
  84                 return NULL;
  85         }
  86         return compress;
  87 }
  88
  89 decomp_func_ptr decompression_function(enum cbfs_compression algo)
  90 {
  91         decomp_func_ptr decompress;
  92         switch (algo) {
  93         case CBFS_COMPRESS_NONE:
  94                 decompress = none_decompress;
  95                 break;
  96         case CBFS_COMPRESS_LZMA:
  97                 decompress = lzma_decompress;
  98                 break;
  99         case CBFS_COMPRESS_LZ4:
 100                 decompress = lz4_decompress;
 101                 break;
 102         default:
 103                 ERROR("Unknown compression algorithm %d!\n", algo);
 104                 return NULL;
 105         }
 106         return decompress;
 107 }