git.zerfleddert.de Git - proxmark3-svn/blob

1 //-----------------------------------------------------------------------------

2 // This code is licensed to you under the terms of the GNU GPL, version 2 or,

3 // at your option, any later version. See the LICENSE.txt file for the text of

4 // the license.

5 //-----------------------------------------------------------------------------

6 // Compression tool for FPGA config files. Compress several *.bit files at

7 // compile time. Decompression is done at run time (see fpgaloader.c).

8 // This uses the zlib library tuned to this specific case. The small file sizes

9 // allow to use "insane" parameters for optimum compression ratio.

10 //-----------------------------------------------------------------------------

12 #include <stdio.h>

13 #include <stdlib.h>

14 #include <string.h>

15 #include <stdint.h>

16 #include <stdbool.h>

17 #include "zlib.h"

19 #define MAX(a,b) ((a)>(b)?(a):(b))

21 // zlib configuration

22 #define COMPRESS_LEVEL 9 // use best possible compression

23 #define COMPRESS_WINDOW_BITS 15 // default = max = 15 for a window of 2^15 = 32KBytes

24 #define COMPRESS_MEM_LEVEL 9 // determines the amount of memory allocated during compression. Default = 8.

25 /* COMPRESS_STRATEGY can be

26 Z_DEFAULT_STRATEGY (the default),

27 Z_FILTERED (more huffmann, less string matching),

28 Z_HUFFMAN_ONLY (huffman only, no string matching)

29 Z_RLE (distances limited to one)

30 Z_FIXED (prevents the use of dynamic Huffman codes)

31 */

33 #define COMPRESS_STRATEGY Z_DEFAULT_STRATEGY

34 // zlib tuning parameters:

35 #define COMPRESS_GOOD_LENGTH 258

36 #define COMPRESS_MAX_LAZY 258

37 #define COMPRESS_MAX_NICE_LENGTH 258

38 #define COMPRESS_MAX_CHAIN 8192

40 #define FPGA_INTERLEAVE_SIZE 288 // (the FPGA's internal config frame size is 288 bits. Interleaving with 288 bytes should give best compression)

41 #define FPGA_CONFIG_SIZE 42336 // our current fpga_[lh]f.bit files are 42175 bytes. Rounded up to next multiple of FPGA_INTERLEAVE_SIZE

 static void usage(void)

44 {

         fprintf(stderr, "Usage: fpga_compress <infile1> <infile2> ... <infile_n> <outfile>\n");

         fprintf(stderr, "          Combine n FPGA bitstream files and compress them into one.\n\n");

         fprintf(stderr, "       fpga_compress -d <infile> <outfile>");

         fprintf(stderr, "          Decompress <infile>. Write result to <outfile>");

49 }

 static voidpf fpga_deflate_malloc(voidpf opaque, uInt items, uInt size)

53 {

         return malloc(items*size);

55 }

 static void fpga_deflate_free(voidpf opaque, voidpf address)

59 {

60 return free(address);

61 }

 static bool all_feof(FILE *infile[], uint8_t num_infiles)

65 {

         for (uint16_t i = 0; i < num_infiles; i++) {

                 if (!feof(infile[i])) {

68 return false;

69 }

70 }

72 return true;

73 }

 int zlib_compress(FILE *infile[], uint8_t num_infiles, FILE *outfile)

77 {

78 uint8_t *fpga_config;

79 uint32_t i;

80 int32_t ret;

81 uint8_t c;

82 z_stream compressed_fpga_stream;

         fpga_config = malloc(num_infiles * FPGA_CONFIG_SIZE);

86 // read the input files. Interleave them into fpga_config[]

87 i = 0;

88 do {

                 if (i >= num_infiles * FPGA_CONFIG_SIZE) {

                         fprintf(stderr, "Input files too big (total > %u bytes). These are probably not PM3 FPGA config files.\n", num_infiles*FPGA_CONFIG_SIZE);

                         for(uint16_t j = 0; j < num_infiles; j++) {

93 fclose(infile[j]);

94 }

95 free(fpga_config);

96 return(EXIT_FAILURE);

97 }

                 for(uint16_t j = 0; j < num_infiles; j++) {

                         for(uint16_t k = 0; k < FPGA_INTERLEAVE_SIZE; k++) {

                                 c = fgetc(infile[j]);

                                 if (!feof(infile[j])) {

103 fpga_config[i++] = c;

                                 } else if (num_infiles > 1) {

105 fpga_config[i++] = '\0';

106 }

107 }

108 }

109

         } while (!all_feof(infile, num_infiles));

111

112 // initialize zlib structures

113 compressed_fpga_stream.next_in = fpga_config;

114 compressed_fpga_stream.avail_in = i;

115 compressed_fpga_stream.zalloc = fpga_deflate_malloc;

116 compressed_fpga_stream.zfree = fpga_deflate_free;

117 compressed_fpga_stream.opaque = Z_NULL;

118 ret = deflateInit2(&compressed_fpga_stream,

119 COMPRESS_LEVEL,

120 Z_DEFLATED,

121 COMPRESS_WINDOW_BITS,

122 COMPRESS_MEM_LEVEL,

123 COMPRESS_STRATEGY);

124

125 // estimate the size of the compressed output

         uint32_t outsize_max = deflateBound(&compressed_fpga_stream, compressed_fpga_stream.avail_in);

         uint8_t *outbuf = malloc(outsize_max);

128 compressed_fpga_stream.next_out = outbuf;

129 compressed_fpga_stream.avail_out = outsize_max;

130

131 if (ret == Z_OK) {

132 ret = deflateTune(&compressed_fpga_stream,

133 COMPRESS_GOOD_LENGTH,

134 COMPRESS_MAX_LAZY,

135 COMPRESS_MAX_NICE_LENGTH,

136 COMPRESS_MAX_CHAIN);

137 }

138

139 if (ret == Z_OK) {

                 ret = deflate(&compressed_fpga_stream, Z_FINISH);

141 }

142

         fprintf(stderr, "compressed %u input bytes to %lu output bytes\n", i, compressed_fpga_stream.total_out);

144

145 if (ret != Z_STREAM_END) {

                 fprintf(stderr, "Error in deflate(): %i %s\n", ret, compressed_fpga_stream.msg);

147 free(outbuf);

148 deflateEnd(&compressed_fpga_stream);

                 for(uint16_t j = 0; j < num_infiles; j++) {

150 fclose(infile[j]);

151 }

152 fclose(outfile);

153 free(infile);

154 free(fpga_config);

155 return(EXIT_FAILURE);

156 }

157

         for (i = 0; i < compressed_fpga_stream.total_out; i++) {

                 fputc(outbuf[i], outfile);

160 }

161

162 free(outbuf);

163 deflateEnd(&compressed_fpga_stream);

         for(uint16_t j = 0; j < num_infiles; j++) {

165 fclose(infile[j]);

166 }

167 fclose(outfile);

168 free(infile);

169 free(fpga_config);

170

171 return(EXIT_SUCCESS);

172

173 }

174

175

 int zlib_decompress(FILE *infile, FILE *outfile)

177 {

178 #define DECOMPRESS_BUF_SIZE 1024

179 uint8_t outbuf[DECOMPRESS_BUF_SIZE];

180 uint8_t inbuf[DECOMPRESS_BUF_SIZE];

181 int32_t ret;

182

183 z_stream compressed_fpga_stream;

184

185 // initialize zlib structures

186 compressed_fpga_stream.next_in = inbuf;

187 compressed_fpga_stream.avail_in = 0;

188 compressed_fpga_stream.next_out = outbuf;

189 compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;

190 compressed_fpga_stream.zalloc = fpga_deflate_malloc;

191 compressed_fpga_stream.zfree = fpga_deflate_free;

192 compressed_fpga_stream.opaque = Z_NULL;

193

         ret = inflateInit2(&compressed_fpga_stream, 0);

195

196 do {

                 if (compressed_fpga_stream.avail_in == 0) {

198 compressed_fpga_stream.next_in = inbuf;

199 uint16_t i = 0;

200 do {

                                 int32_t c = fgetc(infile);

                                 if (!feof(infile)) {

                                         inbuf[i++] = c & 0xFF;

204 compressed_fpga_stream.avail_in++;

205 } else {

206 break;

207 }

                         } while (i < DECOMPRESS_BUF_SIZE);

209 }

210

                 ret = inflate(&compressed_fpga_stream, Z_SYNC_FLUSH);

212

                 if (ret != Z_OK && ret != Z_STREAM_END) {

214 break;

215 }

216

                 if (compressed_fpga_stream.avail_out == 0) {

                         for (uint16_t i = 0; i < DECOMPRESS_BUF_SIZE; i++) {

                                 fputc(outbuf[i], outfile);

220 }

221 compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;

222 compressed_fpga_stream.next_out = outbuf;

223 }

         } while (ret == Z_OK);

225

         if (ret == Z_STREAM_END) {  // reached end of input

227 uint16_t i = 0;

                 while (compressed_fpga_stream.avail_out < DECOMPRESS_BUF_SIZE) {

                         fputc(outbuf[i++], outfile);

230 compressed_fpga_stream.avail_out++;

231 }

232 fclose(outfile);

233 fclose(infile);

234 return(EXIT_SUCCESS);

235 } else {

                 fprintf(stderr, "Error. Inflate() returned error %i, %s", ret, compressed_fpga_stream.msg);

237 fclose(outfile);

238 fclose(infile);

239 return(EXIT_FAILURE);

240 }

241

242 }

243

244

 int main(int argc, char **argv)

246 {

247 FILE **infiles;

248 FILE *outfile;

249

         if (argc == 1 || argc == 2) {

251 usage();

252 return(EXIT_FAILURE);

253 }

254

         if (!strcmp(argv[1], "-d")) { // Decompress

                 infiles = calloc(1, sizeof(FILE*));

                 if (argc != 4) {

258 usage();

259 return(EXIT_FAILURE);

260 }

                 infiles[0] = fopen(argv[2], "rb");

                 if (infiles[0] == NULL) {

                         fprintf(stderr, "Error. Cannot open input file %s", argv[2]);

264 return(EXIT_FAILURE);

265 }

                 outfile = fopen(argv[3], "wb");

267 if (outfile == NULL) {

                         fprintf(stderr, "Error. Cannot open output file %s", argv[3]);

269 return(EXIT_FAILURE);

270 }

                 return zlib_decompress(infiles[0], outfile);

272

273 } else { // Compress

274

                 infiles = calloc(argc-2, sizeof(FILE*));

                 for (uint16_t i = 0; i < argc-2; i++) { 

                         infiles[i] = fopen(argv[i+1], "rb");

                         if (infiles[i] == NULL) {

                                 fprintf(stderr, "Error. Cannot open input file %s", argv[i+1]);

280 return(EXIT_FAILURE);

281 }

282 }

                 outfile = fopen(argv[argc-1], "wb");

284 if (outfile == NULL) {

                         fprintf(stderr, "Error. Cannot open output file %s", argv[argc-1]);

286 return(EXIT_FAILURE);

287 }

                 return zlib_compress(infiles, argc-2, outfile);

289 }

290 }