pristine-xz: Detect pixz compression

The delta file is a compressed tarball, containing the following files:

type

	Type of file this is a delta for ("tar", "gz", or "bz2").

	Type of file this is a delta for ("tar", "gz", "bz2", or "xz").

version

	The meaning depends on the "type" value.

sha256sum

version

	Currently only "2.0".

params

	Typically, only the compression level is needed.

	Typically, only the compression level is needed.  May also contain

	integrity check type, block size, and/or pixz tarball mode.  Also

	multi-threading, which affects xz block header flags and block size.

program

	Program used to compress. Almost every time, it is xz.

	Program used to compress. Almost every time, it is xz (or another

	implementation producing bit-identical results).  pixz may also be

	used in a mode which differs from xz (e.g. due to -t or block header

	padding differences).

use File::Basename qw/basename/;

use IO::Handle;

my @supported_xz_programs = qw(xz);

my @supported_xz_programs = qw(xz pixz);

my $try = 0;

}

sub predict_xz_args {

  my ($xz)       = @_;

  my ($xz, $program) = @_;

  my $presets    = undef;

  my $block_list = undef;

  my $blocks     = $xz->{blocks};

  if (scalar(@$blocks)) {

    # There is at least one block. We assume the same compression

      die "Unknown dict size: $dict_size\n"

        if (!defined($presets));

    }

    if (scalar(@$blocks) > 1) {

      # Gather the block uncompressed sizes

      $block_list = join(',', map { $_->{uncompressed_size} } @$blocks);

  }

  my $check_name = $xz->{stream}->{check_name};

  my $common = [$program];

  if ($program eq 'pixz') {

    # pixz only supports CRC32

    return [] if ($check_name ne 'CRC32');

    # pixz writes sizes in all block headers except tar index block

    # Note: tar index also recognizable by PIXZ_INDEX_MAGIC in block data

    my $last_block = $blocks->[-1];

    my @data_blocks = @$blocks;

    if (scalar(@$blocks) > 1 and $last_block->{size_present_flags} ne 'cu') {

      # last block is probably a tar index

      pop @data_blocks;

    } else {

      # last block is not a tar index, force non-tarball mode

      push @$common, '-t';

    }

    return [] if (grep { $_->{size_present_flags} ne 'cu' } @data_blocks);

  } else {

    my %check_kwd_of = (

      None      => 'none',

      CRC32     => 'crc32',

      CRC64     => 'crc64',

      'SHA-256' => 'sha256',

    );

  my $check_name = $xz->{stream}->{check_name};

    my $check_kwd  = $check_kwd_of{$check_name};

    die "Unknown xz check: $check_name\n" if (!defined($check_kwd));

  my $possible_args = [];

  my $common = [ "--check=$check_kwd", "-z" ];

  if (defined($block_list)) {

    push @$common, "--check=$check_kwd", '-z';

    if (scalar(@$blocks) > 1) {

      # Gather the block uncompressed sizes

      my $block_list = join(',', map { $_->{uncompressed_size} } @$blocks);

      unshift @$common, "--block-list=$block_list";

    }

    # xz writes sizes in block headers if and only if run with multiple threads

      # Note: All values other than 1 produce the same output.  Use 0 for speed.

      push @$common, '-T0'

    }

  }

  my $possible_args = [];

  foreach my $preset (@$presets) {

    push @$possible_args, [ @$common, "-$preset" ];

    push @$possible_args, [ @$common, "-${preset}e" ];

  # lzma2_presets_from_dict_size_of in predict_xz_args) or if --extreme

  # was used. We output possible args for each combination in this case.

  my $xz            = scan_xz_lvv_robot($filename);

  my $possible_args = predict_xz_args($xz);

  my $possible_args = [];

  foreach my $program (@supported_xz_programs) {

    push @$possible_args, @{ predict_xz_args($xz, $program) };

  }

  return $possible_args;

}

  # If we get an error we fallback to guessing, otherwise, we should

  # succeed with one of the proposed combinations

  if (!$@) {

    foreach my $program (@supported_xz_programs) {

    foreach my $args (@$possible_args) {

      my $program = shift @$args;

      testvariant($orig, $tmpin, $program, @$args)

        && return $program, @$args;

    }

    }

  } else {

    # Fallback to guessing

    my ($possible_levels) = predictxzlevels($orig);

    my $param = shift @params;

    next if $param =~ /^(-[0-9]e?)$/;

    if ($delta->{program} eq 'xz') {

      next if $param eq '-z';

      next if $param eq '--check=none';

      next if $param eq '--check=crc32';

      next if $param eq '--check=sha256';

      next if $param =~ /^(--block-list=[0-9,]+)$/;

      next if $param =~ /^-T[0-9]+$/;

    } elsif ($delta->{program} eq 'pixz') {

      next if $param eq '-t';

    }

    die "paranoia check failed on params from delta ($param)";

  }

  @params = split(' ', $delta->{params});