tools/squashfs4/patches/160-expose_lzma_xz_options.patch

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