exiftool_vendored 10.04.0 → 10.23.0

data/bin/Image-ExifTool-10.04/lib/Image/ExifTool/Vorbis.pm

@@ -1,238 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         Vorbis.pm
-#
-# Description:  Read Ogg Vorbis audio meta information
-#
-# Revisions:    2006/11/10 - P. Harvey Created
-#               2011/07/12 - PH Moved Ogg to a separate module and added Theora
-#
-# References:   1) http://www.xiph.org/vorbis/doc/
-#               2) http://flac.sourceforge.net/ogg_mapping.html
-#               3) http://www.theora.org/doc/Theora.pdf
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::Vorbis;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.08';
-
-sub ProcessComments($$$);
-
-# Vorbis header types
-%Image::ExifTool::Vorbis::Main = (
-    NOTES => q{
-        Information extracted from Ogg Vorbis files.  See
-        L<http://www.xiph.org/vorbis/doc/> for the Vorbis specification.
-    },
-    1 => {
-        Name => 'Identification',
-        SubDirectory => { TagTable => 'Image::ExifTool::Vorbis::Identification' },
-    },
-    3 => {
-        Name => 'Comments',
-        SubDirectory => { TagTable => 'Image::ExifTool::Vorbis::Comments' },
-    },
-);
-
-%Image::ExifTool::Vorbis::Identification = (
-    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
-    GROUPS => { 2 => 'Audio' },
-    0 => {
-        Name => 'VorbisVersion',
-        Format => 'int32u',
-    },
-    4 => 'AudioChannels',
-    5 => {
-        Name => 'SampleRate',
-        Format => 'int32u',
-    },
-    9 => {
-        Name => 'MaximumBitrate',
-        Format => 'int32u',
-        RawConv => '$val || undef',
-        PrintConv => 'ConvertBitrate($val)',
-    },
-    13 => {
-        Name => 'NominalBitrate',
-        Format => 'int32u',
-        RawConv => '$val || undef',
-        PrintConv => 'ConvertBitrate($val)',
-    },
-    17 => {
-        Name => 'MinimumBitrate',
-        Format => 'int32u',
-        RawConv => '$val || undef',
-        PrintConv => 'ConvertBitrate($val)',
-    },
-);
-
-%Image::ExifTool::Vorbis::Comments = (
-    PROCESS_PROC => \&ProcessComments,
-    GROUPS => { 2 => 'Audio' },
-    NOTES => q{
-        The tags below are only some common tags found in the Vorbis comments of Ogg
-        Vorbis and Ogg FLAC audio files, however ExifTool will extract values from
-        any tag found, even if not listed here.
-    },
-    vendor    => { Notes => 'from comment header' },
-    TITLE     => { Name => 'Title' },
-    VERSION   => { Name => 'Version' },
-    ALBUM     => { Name => 'Album' },
-    TRACKNUMBER=>{ Name => 'TrackNumber' },
-    ARTIST    => { Name => 'Artist',       Groups => { 2 => 'Author' }, List => 1 },
-    PERFORMER => { Name => 'Performer',    Groups => { 2 => 'Author' }, List => 1 },
-    COPYRIGHT => { Name => 'Copyright',    Groups => { 2 => 'Author' } },
-    LICENSE   => { Name => 'License',      Groups => { 2 => 'Author' } },
-    ORGANIZATION=>{Name => 'Organization', Groups => { 2 => 'Author' } },
-    DESCRIPTION=>{ Name => 'Description' },
-    GENRE     => { Name => 'Genre' },
-    DATE      => { Name => 'Date',         Groups => { 2 => 'Time' } },
-    LOCATION  => { Name => 'Location',     Groups => { 2 => 'Location' } },
-    CONTACT   => { Name => 'Contact',      Groups => { 2 => 'Author' }, List => 1 },
-    ISRC      => { Name => 'ISRCNumber' },
-    COVERARTMIME => { Name => 'CoverArtMIMEType' },
-    COVERART  => {
-        Name => 'CoverArt',
-        Groups => { 2 => 'Preview' },
-        Notes => 'base64-encoded image',
-        ValueConv => q{
-            require Image::ExifTool::XMP;
-            Image::ExifTool::XMP::DecodeBase64($val);
-        },
-    },
-    REPLAYGAIN_TRACK_PEAK => { Name => 'ReplayGainTrackPeak' },
-    REPLAYGAIN_TRACK_GAIN => { Name => 'ReplayGainTrackGain' },
-    REPLAYGAIN_ALBUM_PEAK => { Name => 'ReplayGainAlbumPeak' },
-    REPLAYGAIN_ALBUM_GAIN => { Name => 'ReplayGainAlbumGain' },
-    # observed in "Xiph.Org libVorbis I 20020717" ogg:
-    ENCODED_USING => { Name => 'EncodedUsing' },
-    ENCODED_BY  => { Name => 'EncodedBy' },
-    COMMENT     => { Name => 'Comment' },
-    # in Theora documentation (ref 3)
-    DIRECTOR    => { Name => 'Director' },
-    PRODUCER    => { Name => 'Producer' },
-    COMPOSER    => { Name => 'Composer' },
-    ACTOR       => { Name => 'Actor' },
-);
-
-# Vorbis composite tags
-%Image::ExifTool::Vorbis::Composite = (
-    Duration => {
-        Require => {
-            0 => 'Vorbis:NominalBitrate',
-            1 => 'FileSize',
-        },
-        RawConv => '$val[0] ? $val[1] * 8 / $val[0] : undef',
-        PrintConv => 'ConvertDuration($val) . " (approx)"', # (only approximate)
-    },
-);
-
-# add our composite tags
-Image::ExifTool::AddCompositeTags('Image::ExifTool::Vorbis');
-
-
-#------------------------------------------------------------------------------
-# Process Vorbis Comments
-# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
-# Returns: 1 on success, otherwise returns 0 and sets a Warning
-sub ProcessComments($$$)
-{
-    my ($et, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt = $$dirInfo{DataPt};
-    my $dataPos = $$dirInfo{DataPos};
-    my $pos = $$dirInfo{DirStart} || 0;
-    my $end = $$dirInfo{DirLen} ? $pos + $$dirInfo{DirLen} : length $$dataPt;
-    my ($num, $index);
-
-    SetByteOrder('II');
-    for (;;) {
-        last if $pos + 4 > $end;
-        my $len = Get32u($dataPt, $pos);
-        last if $pos + 4 + $len > $end;
-        my $start = $pos + 4;
-        my $buff = substr($$dataPt, $start, $len);
-        $pos = $start + $len;
-        my ($tag, $val);
-        if (defined $num) {
-            $buff =~ /(.*?)=(.*)/s or last;
-            ($tag, $val) = ($1, $2);
-            # Vorbis tag ID's are all capitals, so they may conflict with our internal tags
-            # --> protect against this by adding a trailing underline if necessary
-            $tag .= '_' if $Image::ExifTool::specialTags{$tag};
-        } else {
-            $tag = 'vendor';
-            $val = $buff;
-            $num = ($pos + 4 < $end) ? Get32u($dataPt, $pos) : 0;
-            $et->VPrint(0, "  + [Vorbis comments with $num entries]\n");
-            $pos += 4;
-        }
-        # add tag to table unless it exists already
-        unless ($$tagTablePtr{$tag}) {
-            my $name = ucfirst(lc($tag));
-            # remove invalid characters in tag name and capitalize following letters
-            $name =~ s/[^\w-]+(.?)/\U$1/sg;
-            $name =~ s/([a-z0-9])_([a-z])/$1\U$2/g;
-            AddTagToTable($tagTablePtr, $tag, { Name => $name });
-        }
-        $et->HandleTag($tagTablePtr, $tag, $et->Decode($val, 'UTF8'),
-            Index   => $index,
-            DataPt  => $dataPt,
-            DataPos => $dataPos,
-            Start   => $start,
-            Size    => $len,
-        );
-        # all done if this was our last tag
-        $num-- or return 1;
-        $index = (defined $index) ? $index + 1 : 0;
-    }
-    $et->Warn('Format error in Vorbis comments');
-    return 0;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::Vorbis - Read Ogg Vorbis audio meta information
-
-=head1 SYNOPSIS
-
-This module is used by Image::ExifTool
-
-=head1 DESCRIPTION
-
-This module contains definitions required by Image::ExifTool to extract meta
-information from Ogg Vorbis audio headers.
-
-=head1 AUTHOR
-
-Copyright 2003-2015, Phil Harvey (phil at owl.phy.queensu.ca)
-
-This library is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-=head1 REFERENCES
-
-=over 4
-
-=item L<http://www.xiph.org/vorbis/doc/>
-
-=item L<http://flac.sourceforge.net/ogg_mapping.html>
-
-=item L<http://www.theora.org/doc/Theora.pdf>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/Vorbis Tags>,
-L<Image::ExifTool::TagNames/Ogg Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-

data/bin/Image-ExifTool-10.04/lib/Image/ExifTool/WriteCanonRaw.pl

@@ -1,637 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         WriteCanonRaw.pl
-#
-# Description:  Write Canon RAW (CRW and CR2) meta information
-#
-# Revisions:    01/25/2005 - P. Harvey Created
-#               09/16/2010 - PH Added ability to write XMP in CRW images
-#------------------------------------------------------------------------------
-package Image::ExifTool::CanonRaw;
-
-use strict;
-use vars qw($VERSION $AUTOLOAD %crwTagFormat);
-use Image::ExifTool::Fixup;
-
-# map for adding directories to CRW
-my %crwMap = (
-    XMP      => 'CanonVRD',
-    CanonVRD => 'Trailer',
-);
-
-# mappings to from RAW tagID to MakerNotes tagID
-# (Note: upper two bits of RawTagID are zero)
-my %mapRawTag = (
-  # RawTagID => Canon TagID
-    0x080b => 0x07, # CanonFirmwareVersion
-    0x0810 => 0x09, # OwnerName
-    0x0815 => 0x06, # CanonImageType
-    0x1028 => 0x03, # (unknown if no tag name specified)
-    0x1029 => 0x02, # FocalLength
-    0x102a => 0x04, # CanonShotInfo
-    0x102d => 0x01, # CanonCameraSettings
-    0x1033 => 0x0f, # CanonCustomFunctions (only verified for 10D)
-    0x1038 => 0x12, # CanonAFInfo
-    0x1039 => 0x13,
-    0x1093 => 0x93,
-    0x10a8 => 0xa8,
-    0x10a9 => 0xa9, # WhiteBalanceTable
-    0x10aa => 0xaa,
-    0x10ae => 0xae, # ColorTemperature
-    0x10b4 => 0xb4, # ColorSpace
-    0x10b5 => 0xb5,
-    0x10c0 => 0xc0,
-    0x10c1 => 0xc1,
-    0x180b => 0x0c, # SerialNumber
-    0x1817 => 0x08, # FileNumber
-    0x1834 => 0x10,
-    0x183b => 0x15,
-);
-# translation from Rotation to Orientation values
-my %mapRotation = (
-    0 => 1,
-    90 => 6,
-    180 => 3,
-    270 => 8,
-);
-
-
-#------------------------------------------------------------------------------
-# Initialize buffers for building MakerNotes from RAW data
-# Inputs: 0) ExifTool object reference
-sub InitMakerNotes($)
-{
-    my $et = shift;
-    $$et{MAKER_NOTE_INFO} = {
-        Entries => { },     # directory entries keyed by tagID
-        ValBuff => "\0\0\0\0", # value data buffer (start with zero nextIFD pointer)
-        FixupTags => { },   # flags for tags with data in value buffer
-    };
-}
-
-#------------------------------------------------------------------------------
-# Build maker notes from CanonRaw information
-# Inputs: 0) ExifTool object reference, 1) raw tag ID, 2) reference to tagInfo
-#         3) reference to value, 4) format name, 5) count
-# Notes: This will build the directory in the order the tags are found in the CRW
-# file, which isn't sequential (but Canon's version isn't sequential either...)
-sub BuildMakerNotes($$$$$$)
-{
-    my ($et, $rawTag, $tagInfo, $valuePt, $formName, $count) = @_;
-
-    my $tagID = $mapRawTag{$rawTag} || return;
-    $formName or warn(sprintf "No format for tag 0x%x!\n",$rawTag), return;
-    # special case: ignore user comment because it gets saved in EXIF
-    # (and has the same raw tagID as CanonFileDescription)
-    return if $tagInfo and $$tagInfo{Name} eq 'UserComment';
-    my $format = $Image::ExifTool::Exif::formatNumber{$formName};
-    my $fsiz = $Image::ExifTool::Exif::formatSize[$format];
-    my $size = length($$valuePt);
-    my $value;
-    if ($count and $size != $count * $fsiz) {
-        if ($size < $count * $fsiz) {
-            warn sprintf("Value too short for raw tag 0x%x\n",$rawTag);
-            return;
-        }
-        # shorten value appropriately
-        $size = $count * $fsiz;
-        $value = substr($$valuePt, 0, $size);
-    } else {
-        $count = $size / $fsiz;
-        $value = $$valuePt;
-    }
-    my $offsetVal;
-    my $makerInfo = $$et{MAKER_NOTE_INFO};
-    if ($size > 4) {
-        my $len = length $makerInfo->{ValBuff};
-        $offsetVal = Set32u($len);
-        $makerInfo->{ValBuff} .= $value;
-        # pad to an even number of bytes
-        $size & 0x01 and $makerInfo->{ValBuff} .= "\0";
-        # set flag indicating that this tag needs a fixup
-        $makerInfo->{FixupTags}->{$tagID} = 1;
-    } else {
-        $offsetVal = $value;
-        $size < 4 and $offsetVal .= "\0" x (4 - $size);
-    }
-    $makerInfo->{Entries}->{$tagID} = Set16u($tagID) . Set16u($format) .
-                                      Set32u($count) . $offsetVal;
-}
-
-#------------------------------------------------------------------------------
-# Finish building and save MakerNotes
-# Inputs: 0) ExifTool object reference
-sub SaveMakerNotes($)
-{
-    my $et = shift;
-    # save maker notes
-    my $makerInfo = $$et{MAKER_NOTE_INFO};
-    delete $$et{MAKER_NOTE_INFO};
-    my $dirEntries = $makerInfo->{Entries};
-    my $numEntries = scalar(keys %$dirEntries);
-    my $fixup = new Image::ExifTool::Fixup;
-    return unless $numEntries;
-    # build the MakerNotes directory
-    my $makerNotes = Set16u($numEntries);
-    my $tagID;
-    # write the entries in proper tag order (even though Canon doesn't do this...)
-    foreach $tagID (sort { $a <=> $b } keys %$dirEntries) {
-        $makerNotes .= $$dirEntries{$tagID};
-        next unless $makerInfo->{FixupTags}->{$tagID};
-        # add fixup for this pointer
-        $fixup->AddFixup(length($makerNotes) - 4);
-    }
-    # save position of maker notes for pointer fixups
-    $fixup->{Shift} += length($makerNotes);
-    $$et{MAKER_NOTE_FIXUP} = $fixup;
-    $$et{MAKER_NOTE_BYTE_ORDER} = GetByteOrder();
-    # add value data
-    $makerNotes .= $makerInfo->{ValBuff};
-    # get MakerNotes tag info
-    my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::Exif::Main');
-    my $tagInfo = $et->GetTagInfo($tagTablePtr, 0x927c, \$makerNotes);
-    # save the MakerNotes
-    $et->FoundTag($tagInfo, $makerNotes);
-    # save the garbage collection some work later
-    delete $makerInfo->{Entries};
-    delete $makerInfo->{ValBuff};
-    delete $makerInfo->{FixupTags};
-    # also generate Orientation tag since Rotation isn't transferred from RAW info
-    my $rotation = $et->GetValue('Rotation', 'ValueConv');
-    if (defined $rotation and defined $mapRotation{$rotation}) {
-        $tagInfo = $et->GetTagInfo($tagTablePtr, 0x112);
-        $et->FoundTag($tagInfo, $mapRotation{$rotation});
-    }
-}
-
-#------------------------------------------------------------------------------
-# Check CanonRaw information
-# Inputs: 0) ExifTool object reference, 1) tagInfo hash reference,
-#         2) raw value reference
-# Returns: error string or undef (and may change value) on success
-sub CheckCanonRaw($$$)
-{
-    my ($et, $tagInfo, $valPtr) = @_;
-    my $tagName = $$tagInfo{Name};
-    if ($tagName eq 'JpgFromRaw' or $tagName eq 'ThumbnailImage') {
-        unless ($$valPtr =~ /^\xff\xd8/ or $et->Options('IgnoreMinorErrors')) {
-            return '[minor] Not a valid image';
-        }
-    } else {
-        my $format = $$tagInfo{Format};
-        my $count = $$tagInfo{Count};
-        unless ($format) {
-            my $tagType = ($$tagInfo{TagID} >> 8) & 0x38;
-            $format = $crwTagFormat{$tagType};
-        }
-        $format and return Image::ExifTool::CheckValue($valPtr, $format, $count);
-    }
-    return undef;
-}
-
-#------------------------------------------------------------------------------
-# Write CR2 file
-# Inputs: 0) ExifTool ref, 1) dirInfo reference (must have read first 16 bytes)
-#         2) tag table reference
-# Returns: true on success
-sub WriteCR2($$$)
-{
-    my ($et, $dirInfo, $tagTablePtr) = @_;
-    my $dataPt = $$dirInfo{DataPt} or return 0;
-    my $outfile = $$dirInfo{OutFile} or return 0;
-    $$dirInfo{RAF} or return 0;
-
-    # check CR2 signature
-    if ($$dataPt !~ /^.{8}CR\x02\0/s) {
-        my ($msg, $minor);
-        if ($$dataPt =~ /^.{8}CR/s) {
-            $msg = 'Unsupported Canon RAW file. May cause problems if rewritten';
-            $minor = 1;
-        } elsif ($$dataPt =~ /^.{8}\xba\xb0\xac\xbb/s) {
-            $msg = 'Can not currently write Canon 1D RAW images';
-        } else {
-            $msg = 'Unrecognized Canon RAW file';
-        }
-        return 0 if $et->Error($msg, $minor);
-    }
-
-    # CR2 has a 16-byte header
-    $$dirInfo{NewDataPos} = 16;
-    my $newData = $et->WriteDirectory($dirInfo, $tagTablePtr);
-    return 0 unless defined $newData;
-    unless ($$dirInfo{LastIFD}) {
-        $et->Error("CR2 image IFD may not be deleted");
-        return 0;
-    }
-
-    if (length($newData)) {
-        # build 16 byte header for Canon RAW file
-        my $header = substr($$dataPt, 0, 16);
-        # set IFD0 pointer (may not be 16 if edited by PhotoMechanic)
-        Set32u(16, \$header, 4);
-        # last 4 bytes of header is pointer to last IFD
-        Set32u($$dirInfo{LastIFD}, \$header, 12);
-        Write($outfile, $header, $newData) or return 0;
-        undef $newData;     # free memory
-
-        # copy over image data now if necessary
-        if (ref $$dirInfo{ImageData}) {
-            $et->CopyImageData($$dirInfo{ImageData}, $outfile) or return 0;
-            delete $$dirInfo{ImageData};
-        }
-    }
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Write CanonRaw (CRW) information
-# Inputs: 0) ExifTool object reference, 1) source dirInfo reference,
-#         2) tag table reference
-# Returns: true on success
-# Notes: Increments ExifTool CHANGED flag for each tag changed This routine is
-# different from all of the other write routines because Canon RAW files are
-# designed well!  So it isn't necessary to buffer the data in memory before
-# writing it out.  Therefore this routine doesn't return the directory data as
-# the rest of the Write routines do.  Instead, it writes to the dirInfo
-# OutFile on the fly --> much faster, efficient, and less demanding on memory!
-sub WriteCanonRaw($$$)
-{
-    my ($et, $dirInfo, $tagTablePtr) = @_;
-    $et or return 1;    # allow dummy access to autoload this package
-    my $blockStart = $$dirInfo{DirStart};
-    my $blockSize = $$dirInfo{DirLen};
-    my $raf = $$dirInfo{RAF} or return 0;
-    my $outfile = $$dirInfo{OutFile} or return 0;
-    my $outPos = $$dirInfo{OutPos} or return 0;
-    my $outBase = $outPos;
-    my $verbose = $et->Options('Verbose');
-    my $out = $et->Options('TextOut');
-    my ($buff, $tagInfo);
-
-    # 4 bytes at end of block give directory position within block
-    $raf->Seek($blockStart+$blockSize-4, 0) or return 0;
-    $raf->Read($buff, 4) == 4 or return 0;
-    my $dirOffset = Get32u(\$buff,0) + $blockStart;
-    $raf->Seek($dirOffset, 0) or return 0;
-    $raf->Read($buff, 2) == 2 or return 0;
-    my $entries = Get16u(\$buff,0);             # get number of entries in directory
-    # read the directory (10 bytes per entry)
-    $raf->Read($buff, 10 * $entries) == 10 * $entries or return 0;
-    my $newDir = '';
-
-    # get hash of new information keyed by tagID
-    my $newTags = $et->GetNewTagInfoHash($tagTablePtr);
-
-    # generate list of tags to add or delete (currently, we only allow JpgFromRaw
-    # and ThumbnailImage, to be added or deleted from the root CanonRaw directory)
-    my (@addTags, %delTag);
-    if ($$dirInfo{Nesting} == 0) {
-        my $tagID;
-        foreach $tagID (keys %$newTags) {
-            my $permanent = $newTags->{$tagID}->{Permanent};
-            push(@addTags, $tagID) if defined($permanent) and not $permanent;
-        }
-    }
-
-    my $index;
-    for ($index=0; ; ++$index) {
-        my ($pt, $tag, $size, $valuePtr, $ptr, $value);
-        if ($index<$entries) {
-            $pt = 10 * $index;
-            $tag = Get16u(\$buff, $pt);
-            $size = Get32u(\$buff, $pt+2);
-            $valuePtr = Get32u(\$buff, $pt+6);
-            $ptr = $valuePtr + $blockStart;        # all pointers relative to block start
-        }
-        # add any required new tags
-        # NOTE: can't currently add tags where value is stored in directory
-        if (@addTags and (not defined($tag) or $tag >= $addTags[0])) {
-            my $addTag = shift @addTags;
-            $tagInfo = $$newTags{$addTag};
-            my $newVal = $et->GetNewValues($tagInfo);
-            if (defined $newVal) {
-                # pad value to an even length (Canon ImageBrowser and ZoomBrowser
-                # version 6.1.1 have problems with odd-sized embedded JPEG images
-                # even if the value is padded to maintain alignment, so do this
-                # before calculating the size for the directory entry)
-                $newVal .= "\0" if length($newVal) & 0x01;
-                # add new directory entry
-                $newDir .= Set16u($addTag) . Set32u(length($newVal)) .
-                           Set32u($outPos - $outBase);
-                # write new value data
-                Write($outfile, $newVal) or return 0;
-                $outPos += length($newVal);     # update current position
-                $verbose > 1 and print $out "    + CanonRaw:$$tagInfo{Name}\n";
-                ++$$et{CHANGED};
-            }
-            # set flag to delete this tag if found later
-            $delTag{$addTag} = 1;
-        }
-        last unless defined $tag;           # all done if no more directory entries
-        return 0 if $tag & 0x8000;          # top bit should not be set
-        my $tagID = $tag & 0x3fff;          # get tag ID
-        my $tagType = ($tag >> 8) & 0x38;   # get tag type
-        my $valueInDir = ($tag & 0x4000);   # flag for value in directory
-
-        my $tagInfo = $et->GetTagInfo($tagTablePtr,$tagID);
-        my $format = $crwTagFormat{$tagType};
-        my ($count, $subdir);
-        if ($tagInfo) {
-            $subdir = $$tagInfo{SubDirectory};
-            $format = $$tagInfo{Format} if $$tagInfo{Format};
-            $count = $$tagInfo{Count};
-        }
-        if ($valueInDir) {
-            $size = 8;
-            $value = substr($buff, $pt+2, $size);
-            # set count to 1 by default for normal values in directory
-            $count = 1 if not defined $count and $format and
-                          $format ne 'string' and not $subdir;
-        } else {
-            if ($tagType==0x28 or $tagType==0x30) {
-                # this type of tag specifies a raw subdirectory
-                my $name;
-                $tagInfo and $name = $$tagInfo{Name};
-                $name or $name = sprintf("CanonRaw_0x%.4x", $tagID);
-                my %subdirInfo = (
-                    DirName  => $name,
-                    DataLen  => 0,
-                    DirStart => $ptr,
-                    DirLen   => $size,
-                    Nesting  => $$dirInfo{Nesting} + 1,
-                    RAF      => $raf,
-                    Parent   => $$dirInfo{DirName},
-                    OutFile  => $outfile,
-                    OutPos   => $outPos,
-                );
-                my $result = $et->WriteDirectory(\%subdirInfo, $tagTablePtr);
-                return 0 unless $result;
-                # set size and pointer for this new directory
-                $size = $subdirInfo{OutPos} - $outPos;
-                $valuePtr = $outPos - $outBase;
-                $outPos = $subdirInfo{OutPos};
-            } else {
-                # verify that the value data is within this block
-                $valuePtr + $size <= $blockSize or return 0;
-                # read value from file
-                $raf->Seek($ptr, 0) or return 0;
-                $raf->Read($value, $size) == $size or return 0;
-            }
-        }
-        # set count from tagInfo count if necessary
-        if ($format and not $count) {
-            # set count according to format and size
-            my $fnum = $Image::ExifTool::Exif::formatNumber{$format};
-            my $fsiz = $Image::ExifTool::Exif::formatSize[$fnum];
-            $count = int($size / $fsiz);
-        }
-        # edit subdirectory if necessary
-        if ($tagInfo) {
-            if ($subdir and $$subdir{TagTable}) {
-                my $name = $$tagInfo{Name};
-                my $newTagTable = Image::ExifTool::GetTagTable($$subdir{TagTable});
-                return 0 unless $newTagTable;
-                my $subdirStart = 0;
-                #### eval Start ()
-                $subdirStart = eval $$subdir{Start} if $$subdir{Start};
-                my $dirData = \$value;
-                my %subdirInfo = (
-                    Name     => $name,
-                    DataPt   => $dirData,
-                    DataLen  => $size,
-                    DirStart => $subdirStart,
-                    DirLen   => $size - $subdirStart,
-                    Nesting  => $$dirInfo{Nesting} + 1,
-                    RAF      => $raf,
-                    Parent   => $$dirInfo{DirName},
-                );
-                #### eval Validate ($dirData, $subdirStart, $size)
-                if (defined $$subdir{Validate} and not eval $$subdir{Validate}) {
-                    $et->Warn("Invalid $name data");
-                } else {
-                    $subdir = $et->WriteDirectory(\%subdirInfo, $newTagTable);
-                    if (defined $subdir and length $subdir) {
-                        if ($subdirStart) {
-                            # add header before data directory
-                            $value = substr($value, 0, $subdirStart) . $subdir;
-                        } else {
-                            $value = $subdir;
-                        }
-                    }
-                }
-            } elsif ($$newTags{$tagID}) {
-                if ($delTag{$tagID}) {
-                    $verbose > 1 and print $out "    - CanonRaw:$$tagInfo{Name}\n";
-                    ++$$et{CHANGED};
-                    next;   # next since we already added this tag
-                }
-                my $oldVal;
-                if ($format) {
-                    $oldVal = ReadValue(\$value, 0, $format, $count, $size);
-                } else {
-                    $oldVal = $value;
-                }
-                my $nvHash = $et->GetNewValueHash($tagInfo);
-                if ($et->IsOverwriting($nvHash, $oldVal)) {
-                    my $newVal = $et->GetNewValues($nvHash);
-                    my $verboseVal;
-                    $verboseVal = $newVal if $verbose > 1;
-                    # convert to specified format if necessary
-                    if (defined $newVal and $format) {
-                        $newVal = WriteValue($newVal, $format, $count);
-                    }
-                    if (defined $newVal) {
-                        $value = $newVal;
-                        ++$$et{CHANGED};
-                        $et->VerboseValue("- CanonRaw:$$tagInfo{Name}", $oldVal);
-                        $et->VerboseValue("+ CanonRaw:$$tagInfo{Name}", $verboseVal);
-                    }
-                }
-            }
-        }
-        if ($valueInDir) {
-            my $len = length $value;
-            if ($len < 8) {
-                # pad with original garbage in case it contained something useful
-                $value .= substr($buff, $pt+2+8-$len, 8-$len);
-            } elsif ($len > 8) {   # this shouldn't happen
-                warn "Value too long! -- trucated\n";
-                $value = substr($value, 0, 8);
-            }
-            # create new directory entry
-            $newDir .= Set16u($tag) . $value;
-            next;   # all done this entry
-        }
-        if (defined $value) {
-            # don't allow value to change length unless Writable is 'resize'
-            my $writable = $$tagInfo{Writable};
-            my $diff = length($value) - $size;
-            if ($diff) {
-                if ($writable and $writable eq 'resize') {
-                    $size += $diff; # allow size to change
-                } elsif ($diff > 0) {
-                    $value .= ("\0" x $diff);
-                } else {
-                    $value = substr($value, 0, $size);
-                }
-            }
-            # pad value if necessary to align on even-byte boundary (as per CIFF spec)
-            $value .= "\0" if $size & 0x01;
-            $valuePtr = $outPos - $outBase;
-            # write out value data
-            Write($outfile, $value) or return 0;
-            $outPos += length($value);  # update current position in outfile
-        }
-        # create new directory entry
-        $newDir .= Set16u($tag) . Set32u($size) . Set32u($valuePtr);
-    }
-    # add the directory counts and offset to the directory start,
-    $entries = length($newDir) / 10;
-    $newDir = Set16u($entries) . $newDir . Set32u($outPos - $outBase);
-    # write directory data
-    Write($outfile, $newDir) or return 0;
-
-    # update current output file position in dirInfo
-    $$dirInfo{OutPos} = $outPos + length($newDir);
-    # save outfile directory start (needed for rewriting VRD trailer)
-    $$dirInfo{OutDirStart} = $outPos - $outBase;
-
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# write Canon RAW (CRW) file
-# Inputs: 0) ExifTool object reference, 1) dirInfo reference
-# Returns: 1 on success, 0 if this wasn't a valid CRW file,
-#          or -1 if a write error occurred
-sub WriteCRW($$)
-{
-    my ($et, $dirInfo) = @_;
-    my $outfile = $$dirInfo{OutFile};
-    my $raf = $$dirInfo{RAF};
-    my $rtnVal = 0;
-    my ($buff, $err, $sig);
-
-    $raf->Read($buff,2) == 2    or return 0;
-    SetByteOrder($buff)         or return 0;
-    $raf->Read($buff,4) == 4    or return 0;
-    $raf->Read($sig,8) == 8     or return 0;   # get file signature
-    $sig =~ /^HEAP(CCDR|JPGM)/  or return 0;   # validate signature
-    my $type = $1;
-    my $hlen = Get32u(\$buff, 0);   # get header length
-
-    if ($$et{DEL_GROUP}{MakerNotes}) {
-        if ($type eq 'CCDR') {
-            $et->Error("Can't delete MakerNotes group in CRW file");
-            return 0;
-        } else {
-            ++$$et{CHANGED};
-            return 1;
-        }
-    }
-    # make XMP the preferred group for CRW files
-    if ($$et{FILE_TYPE} eq 'CRW') {
-        $et->InitWriteDirs(\%crwMap, 'XMP');
-    }
-
-    # write header
-    $raf->Seek(0, 0)            or return 0;
-    $raf->Read($buff, $hlen) == $hlen or return 0;
-    Write($outfile, $buff) or $err = 1;
-
-    $raf->Seek(0, 2)            or return 0;   # seek to end of file
-    my $filesize = $raf->Tell() or return 0;
-
-    # build directory information for main raw directory
-    my %dirInfo = (
-        DataLen  => 0,
-        DirStart => $hlen,
-        DirLen   => $filesize - $hlen,
-        Nesting  => 0,
-        RAF      => $raf,
-        Parent   => 'CRW',
-        OutFile  => $outfile,
-        OutPos   => $hlen,
-    );
-    # process the raw directory
-    my $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::CanonRaw::Main');
-    my $success = $et->WriteDirectory(\%dirInfo, $tagTablePtr);
-
-    my $trailPt;
-    while ($success) {
-        # check to see if trailer(s) exist(s)
-        my $trailInfo = Image::ExifTool::IdentifyTrailer($raf) or last;
-        # rewrite the trailer(s)
-        $buff = '';
-        $$trailInfo{OutFile} = \$buff;
-        $success = $et->ProcessTrailers($trailInfo) or last;
-        $trailPt = $$trailInfo{OutFile};
-        # nothing to write if trailers were deleted
-        undef $trailPt if length($$trailPt) < 4;
-        last;
-    }
-    if ($success) {
-        # add CanonVRD trailer if writing as a block
-        $trailPt = $et->AddNewTrailers($trailPt,'CanonVRD');
-        if (not $trailPt and $$et{ADD_DIRS}{CanonVRD}) {
-            # create CanonVRD from scratch if necessary
-            my $outbuff = '';
-            my $saveOrder = GetByteOrder();
-            require Image::ExifTool::CanonVRD;
-            if (Image::ExifTool::CanonVRD::ProcessCanonVRD($et, { OutFile => \$outbuff }) > 0) {
-                $trailPt = \$outbuff;
-            }
-            SetByteOrder($saveOrder);
-        }
-        # write trailer
-        if ($trailPt) {
-            # must append DirStart pointer to end of trailer
-            my $newDirStart = Set32u($dirInfo{OutDirStart});
-            my $len = length $$trailPt;
-            my $pad = ($len & 0x01) ? ' ' : ''; # add pad byte if necessary
-            Write($outfile, $pad, substr($$trailPt,0,$len-4), $newDirStart) or $err = 1;
-        }
-        $rtnVal = $err ? -1 : 1;
-    } else {
-        $et->Error('Error rewriting CRW file');
-    }
-    return $rtnVal;
-}
-
-1; # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::WriteCanonRaw.pl - Write Canon RAW (CRW and CR2) information
-
-=head1 SYNOPSIS
-
-These routines are autoloaded by Image::ExifTool::CanonRaw.
-
-=head1 DESCRIPTION
-
-This file contains routines used by ExifTool to write Canon CRW and CR2
-files and metadata.
-
-=head1 NOTES
-
-The CRW format is a pleasure to work with.  All pointer offsets are relative
-to the start of the data for each directory.  If TIFF/EXIF had implemented
-pointers in this way, it would be MUCH easier to read and write TIFF/JPEG
-files, and would lead to far fewer problems with corrupted metadata.
-
-=head1 AUTHOR
-
-Copyright 2003-2015, Phil Harvey (phil at owl.phy.queensu.ca)
-
-This library is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::CanonRaw(3pm)|Image::ExifTool::CanonRaw>,
-L<Image::ExifTool(3pm)|Image::ExifTool>,
-L<http://owl.phy.queensu.ca/~phil/exiftool/canon_raw.html>
-
-=cut