Root/tools/squashfs4/patches/160-expose_lzma_xz_options.patch

1--- /dev/null
2+++ b/squashfs-tools/lzma_xz_options.h
3@@ -0,0 +1,112 @@
4+#ifndef LZMA_XZ_OPTIONS_H
5+#define LZMA_XZ_OPTIONS_H
6+/*
7+ * Copyright (c) 2011
8+ * Jonas Gorski <jonas.gorski@gmail.com>
9+ *
10+ * This program is free software; you can redistribute it and/or
11+ * modify it under the terms of the GNU General Public License
12+ * as published by the Free Software Foundation; either version 2,
13+ * or (at your option) any later version.
14+ *
15+ * This program is distributed in the hope that it will be useful,
16+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
17+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18+ * GNU General Public License for more details.
19+ *
20+ * You should have received a copy of the GNU General Public License
21+ * along with this program; if not, write to the Free Software
22+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23+ *
24+ * lzma_options.h
25+ */
26+
27+#include <stdint.h>
28+
29+#ifndef linux
30+#define __BYTE_ORDER BYTE_ORDER
31+#define __BIG_ENDIAN BIG_ENDIAN
32+#define __LITTLE_ENDIAN LITTLE_ENDIAN
33+#else
34+#include <endian.h>
35+#endif
36+
37+
38+
39+struct lzma_opts {
40+ uint32_t flags;
41+#define LZMA_OPT_FLT_MASK 0xffff
42+#define LZMA_OPT_PRE_OFF 16
43+#define LZMA_OPT_PRE_MASK (0xf << LZMA_OPT_PRE_OFF)
44+#define LZMA_OPT_EXTREME 20
45+ uint16_t bit_opts;
46+#define LZMA_OPT_LC_OFF 0
47+#define LZMA_OPT_LC_MASK (0x7 << LZMA_OPT_LC_OFF)
48+#define LZMA_OPT_LP_OFF 3
49+#define LZMA_OPT_LP_MASK (0x7 << LZMA_OPT_LP_OFF)
50+#define LZMA_OPT_PB_OFF 6
51+#define LZMA_OPT_PB_MASK (0x7 << LZMA_OPT_PB_OFF)
52+ uint16_t fb;
53+ uint32_t dict_size;
54+};
55+
56+#if __BYTE_ORDER == __BIG_ENDIAN
57+extern unsigned int inswap_le32(unsigned int);
58+
59+#define SQUASHFS_INSWAP_LZMA_COMP_OPTS(s) { \
60+ (s)->flags = inswap_le32((s)->flags); \
61+ (s)->bit_opts = inswap_le16((s)->bit_opts); \
62+ (s)->fb = inswap_le16((s)->fb); \
63+ (s)->dict_size = inswap_le32((s)->dict_size); \
64+}
65+#else
66+#define SQUASHFS_INSWAP_LZMA_COMP_OPTS(s)
67+#endif
68+
69+#define MEMLIMIT (32 * 1024 * 1024)
70+
71+#define LZMA_OPT_LC_MIN 0
72+#define LZMA_OPT_LC_MAX 4
73+#define LZMA_OPT_LC_DEFAULT 3
74+
75+#define LZMA_OPT_LP_MIN 0
76+#define LZMA_OPT_LP_MAX 4
77+#define LZMA_OPT_LP_DEFAULT 0
78+
79+#define LZMA_OPT_PB_MIN 0
80+#define LZMA_OPT_PB_MAX 4
81+#define LZMA_OPT_PB_DEFAULT 2
82+
83+#define LZMA_OPT_FB_MIN 5
84+#define LZMA_OPT_FB_MAX 273
85+#define LZMA_OPT_FB_DEFAULT 64
86+
87+enum {
88+ LZMA_OPT_LZMA = 1,
89+ LZMA_OPT_XZ
90+};
91+
92+struct lzma_xz_options {
93+ int preset;
94+ int extreme;
95+ int lc;
96+ int lp;
97+ int pb;
98+ int fb;
99+ int dict_size;
100+ int flags;
101+};
102+
103+struct lzma_xz_options *lzma_xz_get_options(void);
104+
105+int lzma_xz_options(char *argv[], int argc, int lzmaver);
106+
107+int lzma_xz_options_post(int block_size, int lzmaver);
108+
109+void *lzma_xz_dump_options(int block_size, int *size, int flags);
110+
111+int lzma_xz_extract_options(int block_size, void *buffer, int size, int lzmaver);
112+
113+void lzma_xz_usage(int lzmaver);
114+
115+#endif
116--- /dev/null
117+++ b/squashfs-tools/lzma_xz_options.c
118@@ -0,0 +1,365 @@
119+/*
120+ * Copyright (c) 2011
121+ * Jonas Gorski <jonas.gorski@gmail.com>
122+ *
123+ * This program is free software; you can redistribute it and/or
124+ * modify it under the terms of the GNU General Public License
125+ * as published by the Free Software Foundation; either version 2,
126+ * or (at your option) any later version.
127+ *
128+ * This program is distributed in the hope that it will be useful,
129+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
130+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
131+ * GNU General Public License for more details.
132+ *
133+ * You should have received a copy of the GNU General Public License
134+ * along with this program; if not, write to the Free Software
135+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
136+ *
137+ * lzma_options.c
138+ *
139+ * Common options for LZMA1 and 2 compressors. Based on xz_wrapper.c
140+ */
141+
142+#include <stdio.h>
143+#include <string.h>
144+#include <stdlib.h>
145+
146+#include <lzma.h>
147+
148+#include "lzma_xz_options.h"
149+
150+static const char const *lzmaver_str[] = { "", "lzma", "xz" };
151+
152+static struct lzma_xz_options options = {
153+ .flags = 0,
154+ .preset = 6,
155+ .extreme = 0,
156+ .lc = LZMA_OPT_LC_DEFAULT,
157+ .lp = LZMA_OPT_LP_DEFAULT,
158+ .pb = LZMA_OPT_PB_DEFAULT,
159+ .fb = LZMA_OPT_FB_DEFAULT,
160+ .dict_size = 0,
161+};
162+
163+static float lzma_dict_percent = 0;
164+
165+struct lzma_xz_options *lzma_xz_get_options(void)
166+{
167+ return &options;
168+}
169+
170+
171+int lzma_xz_options(char *argv[], int argc, int lzmaver)
172+{
173+ const char *comp_name = lzmaver_str[lzmaver];
174+
175+ if(strcmp(argv[0], "-Xpreset") == 0) {
176+ int preset;
177+
178+ if(argc < 2) {
179+ fprintf(stderr, "%s: -Xpreset missing preset\n", comp_name);
180+ goto failed;
181+ }
182+
183+ preset = atoi(argv[1]);
184+
185+ if (preset < 0 || preset > 9) {
186+ fprintf(stderr, "%s: -Xpreset invalid value\n", comp_name);
187+ goto failed;
188+ }
189+ options.preset = preset;
190+ return 1;
191+ } else if(strcmp(argv[0], "-Xe") == 0) {
192+ options.extreme = 1;
193+ return 0;
194+ } else if(strcmp(argv[0], "-Xlc") == 0) {
195+ int lc;
196+
197+ if(argc < 2) {
198+ fprintf(stderr, "%s: -Xlc missing lc\n", comp_name);
199+ goto failed;
200+ }
201+
202+ lc = atoi(argv[1]);
203+
204+ if (lc < LZMA_OPT_LC_MIN || lc > LZMA_OPT_LC_MAX) {
205+ fprintf(stderr, "%s: -Xlc invalid value\n", comp_name);
206+ goto failed;
207+ }
208+ options.lc = lc;
209+ return 1;
210+ } else if(strcmp(argv[0], "-Xlp") == 0) {
211+ int lp;
212+
213+ if(argc < 2) {
214+ fprintf(stderr, "%s: -Xlp missing lp\n", comp_name);
215+ goto failed;
216+ }
217+
218+ lp = atoi(argv[1]);
219+
220+ if (lp < LZMA_OPT_LP_MIN || lp > LZMA_OPT_LP_MAX) {
221+ fprintf(stderr, "%s: -Xlp invalid value\n", comp_name);
222+ goto failed;
223+ }
224+ options.lp = lp;
225+ return 1;
226+ } else if(strcmp(argv[0], "-Xpb") == 0) {
227+ int pb;
228+
229+ if(argc < 2) {
230+ fprintf(stderr, "%s: -Xpb missing pb\n", comp_name);
231+ goto failed;
232+ }
233+
234+ pb = atoi(argv[1]);
235+
236+ if (pb < LZMA_OPT_PB_MIN || pb > LZMA_OPT_PB_MAX) {
237+ fprintf(stderr, "%s: -Xbp invalid value\n", comp_name);
238+ goto failed;
239+ }
240+ options.pb = pb;
241+ return 1;
242+ } else if(strcmp(argv[0], "-Xfb") == 0) {
243+ int fb;
244+
245+ if(argc < 2) {
246+ fprintf(stderr, "%s: -Xfb missing fb\n", comp_name);
247+ goto failed;
248+ }
249+
250+ fb = atoi(argv[1]);
251+
252+ if (fb < LZMA_OPT_FB_MIN || fb > LZMA_OPT_FB_MAX) {
253+ fprintf(stderr, "%s: -Xfb invalid value\n", comp_name);
254+ goto failed;
255+ }
256+ options.fb = fb;
257+ return 1;
258+ } else if(strcmp(argv[0], "-Xdict-size") == 0) {
259+ char *b;
260+ float size;
261+
262+ if(argc < 2) {
263+ fprintf(stderr, "%s: -Xdict-size missing dict-size\n", comp_name);
264+ goto failed;
265+ }
266+
267+ size = strtof(argv[1], &b);
268+ if(*b == '%') {
269+ if(size <= 0 || size > 100) {
270+ fprintf(stderr, "%s: -Xdict-size percentage "
271+ "should be 0 < dict-size <= 100\n", comp_name);
272+ goto failed;
273+ }
274+
275+ lzma_dict_percent = size;
276+ options.dict_size = 0;
277+ } else {
278+ if((float) ((int) size) != size) {
279+ fprintf(stderr, "%s: -Xdict-size can't be "
280+ "fractional unless a percentage of the"
281+ " block size\n", comp_name);
282+ goto failed;
283+ }
284+
285+ lzma_dict_percent = 0;
286+ options.dict_size = (int) size;
287+
288+ if(*b == 'k' || *b == 'K')
289+ options.dict_size *= 1024;
290+ else if(*b == 'm' || *b == 'M')
291+ options.dict_size *= 1024 * 1024;
292+ else if(*b != '\0') {
293+ fprintf(stderr, "%s: -Xdict-size invalid "
294+ "dict-size\n", comp_name);
295+ goto failed;
296+ }
297+ }
298+
299+ return 1;
300+ }
301+
302+ return -1;
303+
304+failed:
305+ return -2;
306+
307+}
308+
309+int lzma_xz_options_post(int block_size, int lzmaver)
310+{
311+ const char *comp_name = lzmaver_str[lzmaver];
312+ /*
313+ * if -Xdict-size has been specified use this to compute the datablock
314+ * dictionary size
315+ */
316+ if(options.dict_size || lzma_dict_percent) {
317+ int dict_size_min = (lzmaver == 1 ? 4096 : 8192);
318+ int n;
319+
320+ if(options.dict_size) {
321+ if(options.dict_size > block_size) {
322+ fprintf(stderr, "%s: -Xdict-size is larger than"
323+ " block_size\n", comp_name);
324+ goto failed;
325+ }
326+ } else
327+ options.dict_size = block_size * lzma_dict_percent / 100;
328+
329+ if(options.dict_size < dict_size_min) {
330+ fprintf(stderr, "%s: -Xdict-size should be %i bytes "
331+ "or larger\n", comp_name, dict_size_min);
332+ goto failed;
333+ }
334+
335+ /*
336+ * dictionary_size must be storable in xz header as either
337+ * 2^n or as 2^n+2^(n+1)
338+ */
339+ n = ffs(options.dict_size) - 1;
340+ if(options.dict_size != (1 << n) &&
341+ options.dict_size != ((1 << n) + (1 << (n + 1)))) {
342+ fprintf(stderr, "%s: -Xdict-size is an unsupported "
343+ "value, dict-size must be storable in %s "
344+ "header\n", comp_name, comp_name);
345+ fprintf(stderr, "as either 2^n or as 2^n+2^(n+1). "
346+ "Example dict-sizes are 75%%, 50%%, 37.5%%, "
347+ "25%%,\n");
348+ fprintf(stderr, "or 32K, 16K, 8K etc.\n");
349+ goto failed;
350+ }
351+
352+ } else
353+ /* No -Xdict-size specified, use defaults */
354+ options.dict_size = block_size;
355+
356+ return 0;
357+
358+failed:
359+ return -1;
360+}
361+
362+static struct lzma_opts lzma_comp_opts;
363+
364+void *lzma_xz_dump_options(int block_size, int *size, int flags)
365+{
366+ /* No need to store default options */
367+ if (options.preset == 6 &&
368+ options.extreme == 0 &&
369+ options.lc == LZMA_OPT_LC_DEFAULT &&
370+ options.lp == LZMA_OPT_LC_DEFAULT &&
371+ options.pb == LZMA_OPT_PB_DEFAULT &&
372+ options.fb == 0 &&
373+ options.dict_size == block_size &&
374+ flags == 0)
375+ return NULL;
376+
377+ *size = sizeof(struct lzma_opts);
378+
379+ lzma_comp_opts.flags |= flags;
380+
381+ if (options.extreme)
382+ lzma_comp_opts.flags |= LZMA_OPT_EXTREME;
383+
384+ lzma_comp_opts.flags |= ((options.preset << LZMA_OPT_PRE_OFF) & LZMA_OPT_PRE_MASK);
385+
386+ lzma_comp_opts.bit_opts =
387+ ((options.lc << LZMA_OPT_LC_OFF) & LZMA_OPT_LC_MASK) |
388+ ((options.lp << LZMA_OPT_LP_OFF) & LZMA_OPT_LP_MASK) |
389+ ((options.pb << LZMA_OPT_PB_OFF) & LZMA_OPT_PB_MASK);
390+ lzma_comp_opts.fb = options.fb;
391+ lzma_comp_opts.dict_size = options.dict_size;
392+
393+ SQUASHFS_INSWAP_LZMA_COMP_OPTS(&lzma_comp_opts);
394+
395+ return &lzma_comp_opts;
396+}
397+
398+int lzma_xz_extract_options(int block_size, void *buffer, int size, int lzmaver)
399+{
400+ if (size == 0) {
401+ /* default options */
402+ options.preset = 6;
403+ options.extreme = 0;
404+ options.lc = LZMA_OPT_LC_DEFAULT;
405+ options.lp = LZMA_OPT_LC_DEFAULT;
406+ options.pb = LZMA_OPT_PB_DEFAULT;
407+ options.fb = LZMA_OPT_FB_DEFAULT;
408+ options.dict_size = block_size;
409+ options.flags = 0;
410+ } else {
411+ struct lzma_opts *comp_opts = buffer;
412+ int n;
413+
414+ if (size != sizeof(struct lzma_opts))
415+ goto failed;
416+
417+ SQUASHFS_INSWAP_LZMA_COMP_OPTS(&comp_opts);
418+
419+ options.flags = comp_opts->flags & LZMA_OPT_FLT_MASK;
420+ options.preset = (comp_opts->flags & LZMA_OPT_PRE_MASK) >> LZMA_OPT_PRE_OFF;
421+ options.extreme = !!(comp_opts->flags & LZMA_OPT_EXTREME);
422+
423+ options.lc = (comp_opts->bit_opts & LZMA_OPT_LC_MASK) >> LZMA_OPT_LC_OFF;
424+ options.lp = (comp_opts->bit_opts & LZMA_OPT_LP_MASK) >> LZMA_OPT_LP_OFF;
425+ options.pb = (comp_opts->bit_opts & LZMA_OPT_PB_MASK) >> LZMA_OPT_PB_OFF;
426+ options.fb = comp_opts->fb;
427+ options.dict_size = comp_opts->dict_size;
428+
429+ /* check that the LZMA bit options are in range */
430+ if (options.lc < LZMA_OPT_LC_MIN || options.lc > LZMA_OPT_LC_MAX ||
431+ options.lp < LZMA_OPT_LP_MIN || options.lp > LZMA_OPT_LP_MAX ||
432+ options.pb < LZMA_OPT_PB_MIN || options.pb > LZMA_OPT_PB_MAX ||
433+ options.fb < LZMA_OPT_FB_MIN || options.fb > LZMA_OPT_FB_MAX)
434+ goto failed;
435+
436+ /*
437+ * check that the dictionary size seems correct - the dictionary
438+ * size should 2^n or 2^n+2^(n+1)
439+ */
440+ n = ffs(options.dict_size) - 1;
441+ if(options.dict_size != (1 << n) &&
442+ options.dict_size != ((1 << n) + (1 << (n + 1))))
443+ goto failed;
444+
445+ }
446+
447+ return 0;
448+
449+failed:
450+ fprintf(stderr, "%s: error reading stored compressor options from "
451+ "filesystem!\n", lzmaver_str[lzmaver]);
452+ return -1;
453+}
454+
455+void lzma_xz_usage(int lzmaver)
456+{
457+ fprintf(stderr, "\t -Xpreset <preset>\n");
458+ fprintf(stderr, "\t\tcompression preset (0-9, default 6)\n");
459+ fprintf(stderr, "\t -Xe\n");
460+ fprintf(stderr, "\t\tTry to improve compression ratio by using more ");
461+ fprintf(stderr, "CPU time.\n");
462+ fprintf(stderr, "\t -Xlc <lc>\n");
463+ fprintf(stderr, "\t\tNumber of literal context bits (0-4, default 3)\n");
464+ fprintf(stderr, "\t -Xlp <lp>\n");
465+ fprintf(stderr, "\t\tNumber of literal position bits (0-4, default 0)\n");
466+ fprintf(stderr, "\t -Xpb <pb>\n");
467+ fprintf(stderr, "\t\tNumber of position bits (0-4, default 2)\n");
468+ fprintf(stderr, "\t -Xnice <nice>\n");
469+ fprintf(stderr, "\t\tNice length of a match (5-273, default 64)\n");
470+ fprintf(stderr, "\t -Xdict-size <dict-size>\n");
471+ fprintf(stderr, "\t\tUse <dict-size> as the %s dictionary size. The",
472+ lzmaver == LZMA_OPT_LZMA ? "LZMA" : "XZ");
473+ fprintf(stderr, " dictionary size\n\t\tcan be specified as a");
474+ fprintf(stderr, " percentage of the block size, or as an\n\t\t");
475+ fprintf(stderr, "absolute value. The dictionary size must be less");
476+ fprintf(stderr, " than or equal\n\t\tto the block size and %d bytes",
477+ lzmaver == LZMA_OPT_LZMA ? 4096 : 8192);
478+ fprintf(stderr, " or larger. It must also be\n\t\tstorable in the lzma");
479+ fprintf(stderr, " header as either 2^n or as 2^n+2^(n+1).\n\t\t");
480+ fprintf(stderr, "Example dict-sizes are 75%%, 50%%, 37.5%%, 25%%, or");
481+ fprintf(stderr, " 32K, 16K, 8K\n\t\tetc.\n");
482+
483+}
484--- a/squashfs-tools/lzma_xz_wrapper.c
485+++ b/squashfs-tools/lzma_xz_wrapper.c
486@@ -27,6 +27,7 @@
487 
488 #include "squashfs_fs.h"
489 #include "compressor.h"
490+#include "lzma_xz_options.h"
491 
492 #define LZMA_PROPS_SIZE 5
493 #define LZMA_UNCOMP_SIZE 8
494@@ -38,13 +39,27 @@
495 static int lzma_compress(void *dummy, void *dest, void *src, int size,
496     int block_size, int *error)
497 {
498+ uint32_t preset;
499     unsigned char *d = (unsigned char *) dest;
500+ struct lzma_xz_options *opts = lzma_xz_get_options();
501+
502     lzma_options_lzma opt;
503     lzma_stream strm = LZMA_STREAM_INIT;
504     int res;
505 
506- lzma_lzma_preset(&opt, LZMA_OPTIONS);
507- opt.dict_size = block_size;
508+ preset = opts->preset;
509+
510+ if (opts->extreme)
511+ preset |= LZMA_PRESET_EXTREME;
512+
513+ lzma_lzma_preset(&opt, opts->preset);
514+ opt.lc = opts->lc;
515+ opt.lp = opts->lp;
516+ opt.pb = opts->pb;
517+ if (opts->fb)
518+ opt.nice_len = opts->fb;
519+
520+ opt.dict_size = opts->dict_size;
521 
522     res = lzma_alone_encoder(&strm, &opt);
523     if(res != LZMA_OK) {
524@@ -143,13 +158,45 @@ failed:
525     return -1;
526 }
527 
528+static int lzma_options(char *argv[], int argc)
529+{
530+ return lzma_xz_options(argv, argc, LZMA_OPT_LZMA);
531+}
532+
533+
534+static int lzma_options_post(int block_size)
535+{
536+ return lzma_xz_options_post(block_size, LZMA_OPT_LZMA);
537+}
538+
539+
540+static void *lzma_dump_options(int block_size, int *size)
541+{
542+ return lzma_xz_dump_options(block_size, size, 0);
543+}
544+
545+
546+static int lzma_extract_options(int block_size, void *buffer, int size)
547+{
548+ return lzma_xz_extract_options(block_size, buffer, size, LZMA_OPT_LZMA);
549+}
550+
551+
552+void lzma_usage()
553+{
554+ lzma_xz_usage(LZMA_OPT_LZMA);
555+}
556+
557 
558 struct compressor lzma_comp_ops = {
559     .init = NULL,
560     .compress = lzma_compress,
561     .uncompress = lzma_uncompress,
562- .options = NULL,
563- .usage = NULL,
564+ .options = lzma_options,
565+ .options_post = lzma_options_post,
566+ .dump_options = lzma_dump_options,
567+ .extract_options = lzma_extract_options,
568+ .usage = lzma_usage,
569     .id = LZMA_COMPRESSION,
570     .name = "lzma",
571     .supported = 1
572--- a/squashfs-tools/xz_wrapper.h
573+++ b/squashfs-tools/xz_wrapper.h
574@@ -24,25 +24,6 @@
575  *
576  */
577 
578-#ifndef linux
579-#define __BYTE_ORDER BYTE_ORDER
580-#define __BIG_ENDIAN BIG_ENDIAN
581-#define __LITTLE_ENDIAN LITTLE_ENDIAN
582-#else
583-#include <endian.h>
584-#endif
585-
586-#if __BYTE_ORDER == __BIG_ENDIAN
587-extern unsigned int inswap_le32(unsigned int);
588-
589-#define SQUASHFS_INSWAP_COMP_OPTS(s) { \
590- (s)->dictionary_size = inswap_le32((s)->dictionary_size); \
591- (s)->flags = inswap_le32((s)->flags); \
592-}
593-#else
594-#define SQUASHFS_INSWAP_COMP_OPTS(s)
595-#endif
596-
597 #define MEMLIMIT (32 * 1024 * 1024)
598 
599 struct bcj {
600--- a/squashfs-tools/xz_wrapper.c
601+++ b/squashfs-tools/xz_wrapper.c
602@@ -30,6 +30,7 @@
603 #include "squashfs_fs.h"
604 #include "xz_wrapper.h"
605 #include "compressor.h"
606+#include "lzma_xz_options.h"
607 
608 static struct bcj bcj[] = {
609     { "x86", LZMA_FILTER_X86, 0 },
610@@ -41,22 +42,18 @@ static struct bcj bcj[] = {
611     { NULL, LZMA_VLI_UNKNOWN, 0 }
612 };
613 
614-static struct comp_opts comp_opts;
615-
616 static int filter_count = 1;
617-static int dictionary_size = 0;
618-static float dictionary_percent = 0;
619 
620 
621 static int xz_options(char *argv[], int argc)
622 {
623- int i;
624- char *name;
625-
626     if(strcmp(argv[0], "-Xbcj") == 0) {
627+ int i;
628+ char *name;
629+
630         if(argc < 2) {
631             fprintf(stderr, "xz: -Xbcj missing filter\n");
632- goto failed;
633+ return -2;
634         }
635 
636         name = argv[1];
637@@ -76,190 +73,50 @@ static int xz_options(char *argv[], int
638             }
639             if(bcj[i].name == NULL) {
640                 fprintf(stderr, "xz: -Xbcj unrecognised "
641- "filter\n");
642- goto failed;
643- }
644- }
645-
646- return 1;
647- } else if(strcmp(argv[0], "-Xdict-size") == 0) {
648- char *b;
649- float size;
650-
651- if(argc < 2) {
652- fprintf(stderr, "xz: -Xdict-size missing dict-size\n");
653- goto failed;
654- }
655-
656- size = strtof(argv[1], &b);
657- if(*b == '%') {
658- if(size <= 0 || size > 100) {
659- fprintf(stderr, "xz: -Xdict-size percentage "
660- "should be 0 < dict-size <= 100\n");
661- goto failed;
662- }
663-
664- dictionary_percent = size;
665- dictionary_size = 0;
666- } else {
667- if((float) ((int) size) != size) {
668- fprintf(stderr, "xz: -Xdict-size can't be "
669- "fractional unless a percentage of the"
670- " block size\n");
671- goto failed;
672- }
673-
674- dictionary_percent = 0;
675- dictionary_size = (int) size;
676-
677- if(*b == 'k' || *b == 'K')
678- dictionary_size *= 1024;
679- else if(*b == 'm' || *b == 'M')
680- dictionary_size *= 1024 * 1024;
681- else if(*b != '\0') {
682- fprintf(stderr, "xz: -Xdict-size invalid "
683- "dict-size\n");
684- goto failed;
685+ "filter\n");
686+ return -2;
687             }
688         }
689-
690         return 1;
691+ } else {
692+ return lzma_xz_options(argv, argc, LZMA_OPT_XZ);
693     }
694-
695- return -1;
696-
697-failed:
698- return -2;
699 }
700 
701 
702 static int xz_options_post(int block_size)
703 {
704- /*
705- * if -Xdict-size has been specified use this to compute the datablock
706- * dictionary size
707- */
708- if(dictionary_size || dictionary_percent) {
709- int n;
710-
711- if(dictionary_size) {
712- if(dictionary_size > block_size) {
713- fprintf(stderr, "xz: -Xdict-size is larger than"
714- " block_size\n");
715- goto failed;
716- }
717- } else
718- dictionary_size = block_size * dictionary_percent / 100;
719-
720- if(dictionary_size < 8192) {
721- fprintf(stderr, "xz: -Xdict-size should be 8192 bytes "
722- "or larger\n");
723- goto failed;
724- }
725-
726- /*
727- * dictionary_size must be storable in xz header as either
728- * 2^n or as 2^n+2^(n+1)
729- */
730- n = ffs(dictionary_size) - 1;
731- if(dictionary_size != (1 << n) &&
732- dictionary_size != ((1 << n) + (1 << (n + 1)))) {
733- fprintf(stderr, "xz: -Xdict-size is an unsupported "
734- "value, dict-size must be storable in xz "
735- "header\n");
736- fprintf(stderr, "as either 2^n or as 2^n+2^(n+1). "
737- "Example dict-sizes are 75%%, 50%%, 37.5%%, "
738- "25%%,\n");
739- fprintf(stderr, "or 32K, 16K, 8K etc.\n");
740- goto failed;
741- }
742-
743- } else
744- /* No -Xdict-size specified, use defaults */
745- dictionary_size = block_size;
746-
747- return 0;
748-
749-failed:
750- return -1;
751+ return lzma_xz_options_post(block_size, LZMA_OPT_XZ);
752 }
753 
754 
755 static void *xz_dump_options(int block_size, int *size)
756 {
757- int flags = 0, i;
758-
759- /*
760- * don't store compressor specific options in file system if the
761- * default options are being used - no compressor options in the
762- * file system means the default options are always assumed
763- *
764- * Defaults are:
765- * metadata dictionary size: SQUASHFS_METADATA_SIZE
766- * datablock dictionary size: block_size
767- * 1 filter
768- */
769- if(dictionary_size == block_size && filter_count == 1)
770- return NULL;
771+ int i, flags = 0;
772 
773     for(i = 0; bcj[i].name; i++)
774         flags |= bcj[i].selected << i;
775 
776- comp_opts.dictionary_size = dictionary_size;
777- comp_opts.flags = flags;
778-
779- SQUASHFS_INSWAP_COMP_OPTS(&comp_opts);
780-
781- *size = sizeof(comp_opts);
782- return &comp_opts;
783+ return lzma_xz_dump_options(block_size, size, flags);
784 }
785 
786 
787 static int xz_extract_options(int block_size, void *buffer, int size)
788 {
789- struct comp_opts *comp_opts = buffer;
790- int flags, i, n;
791-
792- if(size == 0) {
793- /* set defaults */
794- dictionary_size = block_size;
795- flags = 0;
796- } else {
797- /* check passed comp opts struct is of the correct length */
798- if(size != sizeof(struct comp_opts))
799- goto failed;
800-
801- SQUASHFS_INSWAP_COMP_OPTS(comp_opts);
802-
803- dictionary_size = comp_opts->dictionary_size;
804- flags = comp_opts->flags;
805-
806- /*
807- * check that the dictionary size seems correct - the dictionary
808- * size should 2^n or 2^n+2^(n+1)
809- */
810- n = ffs(dictionary_size) - 1;
811- if(dictionary_size != (1 << n) &&
812- dictionary_size != ((1 << n) + (1 << (n + 1))))
813- goto failed;
814- }
815+ int ret = lzma_xz_extract_options(block_size, buffer, size, LZMA_OPT_XZ);
816 
817- filter_count = 1;
818- for(i = 0; bcj[i].name; i++) {
819- if((flags >> i) & 1) {
820- bcj[i].selected = 1;
821- filter_count ++;
822- } else
823- bcj[i].selected = 0;
824+ if (!ret) {
825+ int i;
826+ struct lzma_xz_options *opts = lzma_xz_get_options();
827+ for(i = 0; bcj[i].name; i++) {
828+ if((opts->flags >> i) & 1) {
829+ bcj[i].selected = 1;
830+ filter_count ++;
831+ } else
832+ bcj[i].selected = 0;
833+ }
834     }
835-
836- return 0;
837-
838-failed:
839- fprintf(stderr, "xz: error reading stored compressor options from "
840- "filesystem!\n");
841-
842- return -1;
843+ return ret;
844 }
845 
846 
847@@ -268,6 +125,7 @@ static int xz_init(void **strm, int bloc
848     int i, j, filters = datablock ? filter_count : 1;
849     struct filter *filter = malloc(filters * sizeof(struct filter));
850     struct xz_stream *stream;
851+ struct lzma_xz_options *opts = lzma_xz_get_options();
852 
853     if(filter == NULL)
854         goto failed;
855@@ -281,7 +139,7 @@ static int xz_init(void **strm, int bloc
856 
857     memset(filter, 0, filters * sizeof(struct filter));
858 
859- stream->dictionary_size = datablock ? dictionary_size :
860+ stream->dictionary_size = datablock ? opts->dict_size :
861         SQUASHFS_METADATA_SIZE;
862 
863     filter[0].filter[0].id = LZMA_FILTER_LZMA2;
864@@ -323,14 +181,25 @@ static int xz_compress(void *strm, void
865         lzma_ret res = 0;
866     struct xz_stream *stream = strm;
867     struct filter *selected = NULL;
868+ struct lzma_xz_options *opts = lzma_xz_get_options();
869 
870     stream->filter[0].buffer = dest;
871 
872     for(i = 0; i < stream->filters; i++) {
873+ uint32_t preset = opts->preset;
874         struct filter *filter = &stream->filter[i];
875 
876- if(lzma_lzma_preset(&stream->opt, LZMA_PRESET_DEFAULT))
877- goto failed;
878+ if (opts->extreme)
879+ preset |= LZMA_PRESET_EXTREME;
880+
881+ if(lzma_lzma_preset(&stream->opt, preset))
882+ goto failed;
883+
884+ stream->opt.lc = opts->lc;
885+ stream->opt.lp = opts->lp;
886+ stream->opt.pb = opts->pb;
887+ if (opts->fb)
888+ stream->opt.nice_len = opts->fb;
889 
890         stream->opt.dict_size = stream->dictionary_size;
891 
892@@ -384,22 +253,13 @@ static int xz_uncompress(void *dest, voi
893 
894 void xz_usage()
895 {
896+ lzma_xz_usage(LZMA_OPT_XZ);
897     fprintf(stderr, "\t -Xbcj filter1,filter2,...,filterN\n");
898     fprintf(stderr, "\t\tCompress using filter1,filter2,...,filterN in");
899     fprintf(stderr, " turn\n\t\t(in addition to no filter), and choose");
900     fprintf(stderr, " the best compression.\n");
901     fprintf(stderr, "\t\tAvailable filters: x86, arm, armthumb,");
902     fprintf(stderr, " powerpc, sparc, ia64\n");
903- fprintf(stderr, "\t -Xdict-size <dict-size>\n");
904- fprintf(stderr, "\t\tUse <dict-size> as the XZ dictionary size. The");
905- fprintf(stderr, " dictionary size\n\t\tcan be specified as a");
906- fprintf(stderr, " percentage of the block size, or as an\n\t\t");
907- fprintf(stderr, "absolute value. The dictionary size must be less");
908- fprintf(stderr, " than or equal\n\t\tto the block size and 8192 bytes");
909- fprintf(stderr, " or larger. It must also be\n\t\tstorable in the xz");
910- fprintf(stderr, " header as either 2^n or as 2^n+2^(n+1).\n\t\t");
911- fprintf(stderr, "Example dict-sizes are 75%%, 50%%, 37.5%%, 25%%, or");
912- fprintf(stderr, " 32K, 16K, 8K\n\t\tetc.\n");
913 }
914 
915 
916--- a/squashfs-tools/Makefile
917+++ b/squashfs-tools/Makefile
918@@ -140,6 +140,8 @@ COMPRESSORS += xz
919 endif
920 
921 ifneq ($(LZMA_XZ_SUPPORT)$(XZ_SUPPORT),)
922+MKSQUASHFS_OBJS += lzma_xz_options.o
923+UNSQUASHFS_OBJS += lzma_xz_options.o
924 ifneq ($(LZMA_LIB),)
925 MKSQUASHFS_OBJS += $(LZMA_LIB)
926 UNSQUASHFS_OBJS += $(LZMA_LIB)
927

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive