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 */

32 #define COMPRESS_STRATEGY Z_DEFAULT_STRATEGY

33 // zlib tuning parameters:

34 #define COMPRESS_GOOD_LENGTH 258

35 #define COMPRESS_MAX_LAZY 258

36 #define COMPRESS_MAX_NICE_LENGTH 258

37 #define COMPRESS_MAX_CHAIN 8192

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

40 #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)

43 {

         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>");

48 }

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

52 {

         return malloc(items*size);

54 }

 static void fpga_deflate_free(voidpf opaque, voidpf address)

58 {

59 return free(address);

60 }

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

64 {

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

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

67 return false;

68 }

69 }

71 return true;

72 }

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

76 {

77 uint8_t *fpga_config;

78 uint32_t i;

79 int ret;

80 uint8_t c;

81 z_stream compressed_fpga_stream;

         fpga_config = malloc(num_infiles * FPGA_CONFIG_SIZE);

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

86 i = 0;

87 do {

                 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])) {

92 fpga_config[i++] = c;

                                 } else if (num_infiles > 1) {

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

95 }

96 }

97 }

                 if (i >= num_infiles * FPGA_CONFIG_SIZE) {

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

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

102 fclose(infile[j]);

103 }

104 return -1;

105 }

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

107

108 // initialize zlib structures

109 compressed_fpga_stream.next_in = fpga_config;

110 compressed_fpga_stream.avail_in = i;

111 compressed_fpga_stream.zalloc = fpga_deflate_malloc;

112 compressed_fpga_stream.zfree = fpga_deflate_free;

113

114 ret = deflateInit2(&compressed_fpga_stream,

115 COMPRESS_LEVEL,

116 Z_DEFLATED,

117 COMPRESS_WINDOW_BITS,

118 COMPRESS_MEM_LEVEL,

119 COMPRESS_STRATEGY);

120

121 // estimate the size of the compressed output

         unsigned int outsize_max = deflateBound(&compressed_fpga_stream, compressed_fpga_stream.avail_in);

         uint8_t *outbuf = malloc(outsize_max);

124 compressed_fpga_stream.next_out = outbuf;

125 compressed_fpga_stream.avail_out = outsize_max;

126

127 if (ret == Z_OK) {

128 ret = deflateTune(&compressed_fpga_stream,

129 COMPRESS_GOOD_LENGTH,

130 COMPRESS_MAX_LAZY,

131 COMPRESS_MAX_NICE_LENGTH,

132 COMPRESS_MAX_CHAIN);

133 }

134

135 if (ret == Z_OK) {

                 ret = deflate(&compressed_fpga_stream, Z_FINISH);

137 }

138

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

140

141 if (ret != Z_STREAM_END) {

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

143 free(outbuf);

144 deflateEnd(&compressed_fpga_stream);

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

146 fclose(infile[j]);

147 }

148 fclose(outfile);

149 free(infile);

150 free(fpga_config);

151 return -1;

152 }

153

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

                 fputc(outbuf[i], outfile);

156 }

157

158 free(outbuf);

159 deflateEnd(&compressed_fpga_stream);

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

161 fclose(infile[j]);

162 }

163 fclose(outfile);

164 free(infile);

165 free(fpga_config);

166

167 return 0;

168

169 }

170

171

 int zlib_decompress(FILE *infile, FILE *outfile)

173 {

174 #define DECOMPRESS_BUF_SIZE 1024

175 uint8_t outbuf[DECOMPRESS_BUF_SIZE];

176 uint8_t inbuf[DECOMPRESS_BUF_SIZE];

177 int ret;

178

179 z_stream compressed_fpga_stream;

180

181 // initialize zlib structures

182 compressed_fpga_stream.next_in = inbuf;

183 compressed_fpga_stream.avail_in = 0;

184 compressed_fpga_stream.next_out = outbuf;

185 compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;

186 compressed_fpga_stream.zalloc = fpga_deflate_malloc;

187 compressed_fpga_stream.zfree = fpga_deflate_free;

188

         ret = inflateInit2(&compressed_fpga_stream, 0);

190

191 do {

                 if (compressed_fpga_stream.avail_in == 0) {

193 compressed_fpga_stream.next_in = inbuf;

194 uint16_t i = 0;

195 do {

                                 uint8_t c = fgetc(infile);

                                 if (!feof(infile)) {

198 inbuf[i++] = c;

199 compressed_fpga_stream.avail_in++;

200 } else {

201 break;

202 }

                         } while (i < DECOMPRESS_BUF_SIZE);

204 }

205

                 ret = inflate(&compressed_fpga_stream, Z_SYNC_FLUSH);

207

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

209 break;

210 }

211

                 if (compressed_fpga_stream.avail_out == 0) {

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

                                 fputc(outbuf[i], outfile);

215 }

216 compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;

217 compressed_fpga_stream.next_out = outbuf;

218 }

         } while (ret == Z_OK);

220

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

222 uint16_t i = 0;

                 while (compressed_fpga_stream.avail_out < DECOMPRESS_BUF_SIZE) {

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

225 compressed_fpga_stream.avail_out++;

226 }

227 fclose(outfile);

228 fclose(infile);

229 return 0;

230 } else {

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

232 fclose(outfile);

233 fclose(infile);

234 return -1;

235 }

236

237 }

238

239

 int main(int argc, char **argv)

241 {

242 FILE **infiles;

243 FILE *outfile;

244

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

246 usage();

247 return -1;

248 }

249

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

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

                 if (argc != 4) {

253 usage();

254 return -1;

255 }

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

                 if (infiles[0] == NULL) {

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

259 return -1;

260 }

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

262 if (outfile == NULL) {

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

264 return -1;

265 }

                 return zlib_decompress(infiles[0], outfile);

267

268 } else { // Compress

269

                 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]);

275 return -1;

276 }

277 }

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

279 if (outfile == NULL) {

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

281 return -1;

282 }

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

284 }

285 }