release/src-rt-6.x.4708/tools/misc/xz/debug/known_sizes.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       known_sizes.c
   4 /// \brief      Encodes .lzma Stream with sizes known in Block Header
   5 ///
   6 /// The input file is encoded in RAM, and the known Compressed Size
   7 /// and/or Uncompressed Size values are stored in the Block Header.
   8 /// As of writing there's no such Stream encoder in liblzma.
   9 //
  10 //  Author:     Lasse Collin
  11 //
  12 //  This file has been put into the public domain.
  13 //  You can do whatever you want with this file.
  14 //
  15 ///////////////////////////////////////////////////////////////////////////////
  16
  17 #include "sysdefs.h"
  18 #include "lzma.h"
  19 #include <sys/types.h>
  20 #include <sys/stat.h>
  21 #include <sys/unistd.h>
  22 #include <stdio.h>
  23
  24
  25 // Support file sizes up to 1 MiB. We use this for output space too, so files
  26 // close to 1 MiB had better compress at least a little or we have a buffer
  27 // overflow.
  28 #define BUFFER_SIZE (1U << 20)
  29
  30
  31 int
  32 main(void)
  33 {
  34         // Allocate the buffers.
  35         uint8_t *in = malloc(BUFFER_SIZE);
  36         uint8_t *out = malloc(BUFFER_SIZE);
  37         if (in == NULL || out == NULL)
  38                 return 1;
  39
  40         // Fill the input buffer.
  41         const size_t in_size = fread(in, 1, BUFFER_SIZE, stdin);
  42
  43         // Filter setup
  44         lzma_options_lzma opt_lzma;
  45         if (lzma_lzma_preset(&opt_lzma, 1))
  46                 return 1;
  47
  48         lzma_filter filters[] = {
  49                 {
  50                         .id = LZMA_FILTER_LZMA2,
  51                         .options = &opt_lzma
  52                 },
  53                 {
  54                         .id = LZMA_VLI_UNKNOWN
  55                 }
  56         };
  57
  58         lzma_block block = {
  59                 .check = LZMA_CHECK_CRC32,
  60                 .compressed_size = BUFFER_SIZE, // Worst case reserve
  61                 .uncompressed_size = in_size,
  62                 .filters = filters,
  63         };
  64
  65         lzma_stream strm = LZMA_STREAM_INIT;
  66         if (lzma_block_encoder(&strm, &block) != LZMA_OK)
  67                 return 1;
  68
  69         // Reserve space for Stream Header and Block Header. We need to
  70         // calculate the size of the Block Header first.
  71         if (lzma_block_header_size(&block) != LZMA_OK)
  72                 return 1;
  73
  74         size_t out_size = LZMA_STREAM_HEADER_SIZE + block.header_size;
  75
  76         strm.next_in = in;
  77         strm.avail_in = in_size;
  78         strm.next_out = out + out_size;
  79         strm.avail_out = BUFFER_SIZE - out_size;
  80
  81         if (lzma_code(&strm, LZMA_FINISH) != LZMA_STREAM_END)
  82                 return 1;
  83
  84         out_size += strm.total_out;
  85
  86         if (lzma_block_header_encode(&block, out + LZMA_STREAM_HEADER_SIZE)
  87                         != LZMA_OK)
  88                 return 1;
  89
  90         lzma_index *idx = lzma_index_init(NULL);
  91         if (idx == NULL)
  92                 return 1;
  93
  94         if (lzma_index_append(idx, NULL, block.header_size + strm.total_out,
  95                         strm.total_in) != LZMA_OK)
  96                 return 1;
  97
  98         if (lzma_index_encoder(&strm, idx) != LZMA_OK)
  99                 return 1;
 100
 101         if (lzma_code(&strm, LZMA_RUN) != LZMA_STREAM_END)
 102                 return 1;
 103
 104         out_size += strm.total_out;
 105
 106         lzma_end(&strm);
 107
 108         lzma_index_end(idx, NULL);
 109
 110         // Encode the Stream Header and Stream Footer. backwards_size is
 111         // needed only for the Stream Footer.
 112         lzma_stream_flags sf = {
 113                 .backward_size = strm.total_out,
 114                 .check = block.check,
 115         };
 116
 117         if (lzma_stream_header_encode(&sf, out) != LZMA_OK)
 118                 return 1;
 119
 120         if (lzma_stream_footer_encode(&sf, out + out_size) != LZMA_OK)
 121                 return 1;
 122
 123         out_size += LZMA_STREAM_HEADER_SIZE;
 124
 125         // Write out the file.
 126         fwrite(out, 1, out_size, stdout);
 127
 128         return 0;
 129 }