File Coverage

blib/lib/Finnigan/OLE2Header.pm

Criterion	Covered	Total	%
statement	34	34	100.0
branch			n/a
condition			n/a
subroutine	16	16	100.0
pod	11	11	100.0
total	61	61	100.0

package Finnigan::OLE2Header;

use strict;
use warnings FATAL => qw( all );
our $VERSION = 0.0206;

use Finnigan;
use base 'Finnigan::Decoder';

use overload ('""' => 'stringify');

sub decode {
  my ($class, $stream, $version) = @_;

  my @fields = (
                "guid"            => ['a16',   'RawBytes'], # used by some apps
                "minor version"   => ['v',     'UInt16'],
                "major version"   => ['v',     'UInt16'],
                "endian"          => ['a2',    'RawBytes'], # 0xFFFE for Intel
                "bb log"          => ['v',     'UInt16'],   # log2-size of big blocks
                "sb log"          => ['v',     'UInt16'],   # log2-size of small blocks (minisectors)
                "reserved"        => ['a6',    'RawBytes'],
                "csectdir"        => ['V',     'UInt32'],   # Number of sector pointers in directory chain (sector size 4 kb)
                "bb count"        => ['V',     'UInt32'],   # number of blocks in Big Block Depot (number of SECTs in the FAT chain)
                "bb start"        => ['V',     'UInt32'],   # the first block in Big Block Depot (first SECT in the Directory chain)
                "transaction"     => ['a4',    'RawBytes'], # transaction signature
                "ministream max"  => ['V',     'UInt32'],   # max. size of a ministream (4096)
                "sb start"        => ['V',     'UInt32'],   # the first block in Small Block Depot (first SECT in the mini-FAT chain)
                "sb count"        => ['V',     'UInt32'],   # number of blocks in Small Block Depot (number of SECTs in the mini-FAT chain)
                "dif start"       => ['V',     'UInt32'],   # the first SECT in the DIF chain (should be 0xfffffffe if the file is smaller than 7Mb)
                "dif count"       => ['V',     'UInt32'],   # number of SECTs in the DIF chain (should be 0 if the file is smaller than 7Mb)
               );

  my $self = Finnigan::Decoder->read($stream, \@fields, $version);
  return bless $self, $class;
}

sub stringify {
  my $self = shift;

  my $version = $self->{data}->{"major version"}->{value} . "." . $self->{data}->{"minor version"}->{value};
  my $fat_blocks = $self->bb_count;
  my $minifat_blocks = $self->sb_count;
  my $dif_blocks = $self->dif_count;
  return "Version $version; block(s) in FAT chain: $fat_blocks; in mini-FAT chain: $minifat_blocks; in DIF chain: $dif_blocks";
}

sub ministream_max {
  shift->{data}->{"ministream max"}->{value};
}

sub bb_log {
  shift->{data}->{"bb log"}->{value};
}

sub sb_log {
  shift->{data}->{"sb log"}->{value};
}

sub bb_start {
  shift->{data}->{"bb start"}->{value};
}

sub bb_count {
  shift->{data}->{"bb count"}->{value};
}

sub sb_start {
  shift->{data}->{"sb start"}->{value};
}

sub sb_count {
  shift->{data}->{"sb count"}->{value};
}

sub dif_start {
  shift->{data}->{"dif start"}->{value};
}

sub dif_count {
  shift->{data}->{"dif count"}->{value};
}

1;
__END__