exiftool_vendored 10.31.0 → 10.40.0

data/bin/Image-ExifTool-10.40/lib/Image/ExifTool/DJI.pm

@@ -0,0 +1,71 @@
+#------------------------------------------------------------------------------
+# File:         DJI.pm
+#
+# Description:  DJI Phantom maker notes tags
+#
+# Revisions:    2016-07-25 - P. Harvey Created
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::DJI;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool::Exif;
+
+$VERSION = '1.00';
+
+my %convFloat2 = (
+    PrintConv => 'sprintf("%+.2f", $val)',
+    PrintConvInv => '$val',
+);
+
+# DJI maker notes (ref PH, mostly educated guesses based on DJI QuickTime::UserData tags)
+%Image::ExifTool::DJI::Main = (
+    WRITE_PROC => \&Image::ExifTool::Exif::WriteExif,
+    CHECK_PROC => \&Image::ExifTool::Exif::CheckExif,
+    GROUPS => { 0 => 'MakerNotes', 2 => 'Camera' },
+    NOTES => q{
+        This table lists tags found in the maker notes of images from some DJI
+        Phantom drones.
+    },
+    0x01 => { Name => 'Make',       Writable => 'string' },
+  # 0x02 - int8u[4]: "1 0 0 0", "1 1 0 0"
+    0x03 => { Name => 'SpeedX',     Writable => 'float', %convFloat2 }, # (guess)
+    0x04 => { Name => 'SpeedY',     Writable => 'float', %convFloat2 }, # (guess)
+    0x05 => { Name => 'SpeedZ',     Writable => 'float', %convFloat2 }, # (guess)
+    0x06 => { Name => 'Pitch',      Writable => 'float', %convFloat2 },
+    0x07 => { Name => 'Yaw',        Writable => 'float', %convFloat2 },
+    0x08 => { Name => 'Roll',       Writable => 'float', %convFloat2 },
+    0x09 => { Name => 'CameraPitch',Writable => 'float', %convFloat2 },
+    0x0a => { Name => 'CameraYaw',  Writable => 'float', %convFloat2 },
+    0x0b => { Name => 'CameraRoll', Writable => 'float', %convFloat2 },
+);
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::DJI - DJI Phantom maker notes tags
+
+=head1 SYNOPSIS
+
+This module is loaded automatically by Image::ExifTool when required.
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to interpret
+the maker notes in images from some DJI Phantom drones.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, 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::TagNames/DJI Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut

data/bin/Image-ExifTool-10.40/lib/Image/ExifTool/DNG.pm

@@ -0,0 +1,835 @@
+#------------------------------------------------------------------------------
+# File:         DNG.pm
+#
+# Description:  Read DNG-specific information
+#
+# Revisions:    01/09/2006 - P. Harvey Created
+#
+# References:   1) http://www.adobe.com/products/dng/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::DNG;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::Exif;
+use Image::ExifTool::MakerNotes;
+use Image::ExifTool::CanonRaw;
+
+$VERSION = '1.22';
+
+sub ProcessOriginalRaw($$$);
+sub ProcessAdobeData($$$);
+sub ProcessAdobeMakN($$$);
+sub ProcessAdobeCRW($$$);
+sub ProcessAdobeRAF($$$);
+sub ProcessAdobeMRW($$$);
+sub ProcessAdobeSR2($$$);
+sub ProcessAdobeIFD($$$);
+sub WriteAdobeStuff($$$);
+
+# data in OriginalRawFileData
+%Image::ExifTool::DNG::OriginalRaw = (
+    GROUPS => { 2 => 'Image' },
+    PROCESS_PROC => \&ProcessOriginalRaw,
+    NOTES => q{
+        This table defines tags extracted from the DNG OriginalRawFileData
+        information.
+    },
+    0 => { Name => 'OriginalRawImage',    Binary => 1 },
+    1 => { Name => 'OriginalRawResource', Binary => 1 },
+    2 => 'OriginalRawFileType',
+    3 => 'OriginalRawCreator',
+    4 => { Name => 'OriginalTHMImage',    Binary => 1 },
+    5 => { Name => 'OriginalTHMResource', Binary => 1 },
+    6 => 'OriginalTHMFileType',
+    7 => 'OriginalTHMCreator',
+);
+
+%Image::ExifTool::DNG::AdobeData = ( #PH
+    GROUPS => { 0 => 'MakerNotes', 1 => 'AdobeDNG', 2 => 'Image' },
+    PROCESS_PROC => \&ProcessAdobeData,
+    WRITE_PROC => \&WriteAdobeStuff,
+    NOTES => q{
+        This information is found in the "Adobe" DNGPrivateData.
+
+        The maker notes ('MakN') are processed by ExifTool, but some information may
+        have been lost by the Adobe DNG Converter.  This is because the Adobe DNG
+        Converter (as of version 6.3) doesn't properly handle information referenced
+        from inside the maker notes that lies outside the original maker notes
+        block.  This information is lost when only the maker note block is copied to
+        the DNG image.   While this doesn't effect all makes of cameras, it is a
+        problem for some major brands such as Olympus and Sony.
+
+        Other entries in this table represent proprietary information that is
+        extracted from the original RAW image and restructured to a different (but
+        still proprietary) Adobe format.
+    },
+    MakN  => [ ],   # (filled in later)
+   'CRW ' => {
+        Name => 'AdobeCRW',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::CanonRaw::Main',
+            ProcessProc => \&ProcessAdobeCRW,
+            WriteProc => \&WriteAdobeStuff,
+        },
+    },
+   'MRW ' => {
+        Name => 'AdobeMRW',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::MinoltaRaw::Main',
+            ProcessProc => \&ProcessAdobeMRW,
+            WriteProc => \&WriteAdobeStuff,
+        },
+    },
+   'SR2 ' => {
+        Name => 'AdobeSR2',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Sony::SR2Private',
+            ProcessProc => \&ProcessAdobeSR2,
+        },
+    },
+   'RAF ' => {
+        Name => 'AdobeRAF',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FujiFilm::RAF',
+            ProcessProc => \&ProcessAdobeRAF,
+        },
+    },
+    'Pano' => {
+        Name => 'AdobePano',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::PanasonicRaw::Main',
+            ProcessProc => \&ProcessAdobeIFD,
+        },
+    },
+    'Koda' => {
+        Name => 'AdobeKoda',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Kodak::IFD',
+            ProcessProc => \&ProcessAdobeIFD,
+        },
+    },
+    'Leaf' => {
+        Name => 'AdobeLeaf',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::Leaf::SubIFD',
+            ProcessProc => \&ProcessAdobeIFD,
+        },
+    },
+);
+
+# fill in maker notes
+{
+    my $tagInfo;
+    my $list = $Image::ExifTool::DNG::AdobeData{MakN};
+    foreach $tagInfo (@Image::ExifTool::MakerNotes::Main) {
+        unless (ref $tagInfo eq 'HASH') {
+            push @$list, $tagInfo;
+            next;
+        }
+        my %copy = %$tagInfo;
+        delete $copy{Groups};
+        delete $copy{GotGroups};
+        delete $copy{Table};
+        push @$list, \%copy;
+    }
+}
+
+#------------------------------------------------------------------------------
+# Process DNG OriginalRawFileData information
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+sub ProcessOriginalRaw($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $start = $$dirInfo{DirStart};
+    my $end = $start + $$dirInfo{DirLen};
+    my $pos = $start;
+    my ($index, $err);
+
+    SetByteOrder('MM'); # pointers are always big-endian in this structure
+    for ($index=0; $index<8; ++$index) {
+        last if $pos + 4 > $end;
+        my $val = Get32u($dataPt, $pos);
+        $val or $pos += 4, next; # ignore zero values
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $index);
+        $tagInfo or $err = "Missing DNG tag $index", last;
+        if ($index & 0x02) {
+            # extract a simple file type (tags 2, 3, 6 and 7)
+            $val = substr($$dataPt, $pos, 4);
+            $pos += 4;
+        } else {
+            # extract a compressed data block (tags 0, 1, 4 and 5)
+            my $n = int(($val + 65535) / 65536);
+            my $hdrLen = 4 * ($n + 2);
+            $pos + $hdrLen > $end and $err = '', last;
+            my $tag = $$tagInfo{Name};
+            # only extract this information if requested (because it takes time)
+            my $lcTag = lc $tag;
+            if (($$et{OPTIONS}{Binary} and not $$et{EXCL_TAG_LOOKUP}{$lcTag}) or
+                $$et{REQ_TAG_LOOKUP}{$lcTag})
+            {
+                unless (eval { require Compress::Zlib }) {
+                    $err = 'Install Compress::Zlib to extract compressed images';
+                    last;
+                }
+                my $i;
+                $val = '';
+                my $p2 = $pos + Get32u($dataPt, $pos + 4);
+                for ($i=0; $i<$n; ++$i) {
+                    # inflate this compressed block
+                    my $p1 = $p2;
+                    $p2 = $pos + Get32u($dataPt, $pos + ($i + 2) * 4);
+                    if ($p1 >= $p2 or $p2 > $end) {
+                        $err = 'Bad compressed RAW image';
+                        last;
+                    }
+                    my $buff = substr($$dataPt, $p1, $p2 - $p1);
+                    my ($v2, $stat);
+                    my $inflate = Compress::Zlib::inflateInit();
+                    $inflate and ($v2, $stat) = $inflate->inflate($buff);
+                    if ($inflate and $stat == Compress::Zlib::Z_STREAM_END()) {
+                        $val .= $v2;
+                    } else {
+                        $err = 'Error inflating compressed RAW image';
+                        last;
+                    }
+                }
+                $pos = $p2;
+            } else {
+                $pos + $hdrLen > $end and $err = '', last;
+                my $len = Get32u($dataPt, $pos + $hdrLen - 4);
+                $pos + $len > $end and $err = '', last;
+                $val = substr($$dataPt, $pos + $hdrLen, $len - $hdrLen);
+                $val = "Binary data $len bytes";
+                $pos += $len;   # skip over this block
+            }
+        }
+        $et->FoundTag($tagInfo, $val);
+    }
+    $et->Warn($err || 'Bad OriginalRawFileData') if defined $err;
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe DNGPrivateData directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessAdobeData($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dataPos = $$dirInfo{DataPos};
+    my $pos = $$dirInfo{DirStart};
+    my $end = $$dirInfo{DirLen} + $pos;
+    my $outfile = $$dirInfo{OutFile};
+    my $verbose = $et->Options('Verbose');
+    my $htmlDump = $et->Options('HtmlDump');
+
+    return 0 unless $$dataPt =~ /^Adobe\0/;
+    unless ($outfile) {
+        $et->VerboseDir($dirInfo);
+        # don't parse makernotes if FastScan > 1
+        my $fast = $et->Options('FastScan');
+        return 1 if $fast and $fast > 1;
+    }
+    $htmlDump and $et->HDump($dataPos, 6, 'Adobe DNGPrivateData header');
+    SetByteOrder('MM'); # always big endian
+    $pos += 6;
+    while ($pos + 8 <= $end) {
+        my ($tag, $size) = unpack("x${pos}a4N", $$dataPt);
+        $pos += 8;
+        last if $pos + $size > $end;
+        my $tagInfo = $$tagTablePtr{$tag};
+        if ($htmlDump) {
+            my $name = "Adobe$tag";
+            $name =~ tr/ //d;
+            $et->HDump($dataPos + $pos - 8, 8, "$name header", "Data Size: $size bytes");
+            # dump non-EXIF format data
+            unless ($tag =~ /^(MakN|SR2 )$/) {
+                $et->HDump($dataPos + $pos, $size, "$name data");
+            }
+        }
+        if ($verbose and not $outfile) {
+            $tagInfo or $et->VPrint(0, "$$et{INDENT}Unsupported DNGAdobeData record: ($tag)\n");
+            $et->VerboseInfo($tag,
+                ref $tagInfo eq 'HASH' ? $tagInfo : undef,
+                DataPt => $dataPt,
+                DataPos => $dataPos,
+                Start => $pos,
+                Size => $size,
+            );
+        }
+        my $value;
+        while ($tagInfo) {
+            my ($subTable, $subName, $processProc);
+            if (ref $tagInfo eq 'HASH') {
+                unless ($$tagInfo{SubDirectory}) {
+                    if ($outfile) {
+                        # copy value across to outfile
+                        $value = substr($$dataPt, $pos, $size);
+                    } else {
+                        $et->HandleTag($tagTablePtr, $tag, substr($$dataPt, $pos, $size));
+                    }
+                    last;
+                }
+                $subTable = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
+                $subName = $$tagInfo{Name};
+                $processProc = $tagInfo->{SubDirectory}->{ProcessProc};
+            } else {
+                $subTable = $tagTablePtr;
+                $subName = 'AdobeMakN';
+                $processProc = \&ProcessAdobeMakN;
+            }
+            my %dirInfo = (
+                Base     => $$dirInfo{Base},
+                DataPt   => $dataPt,
+                DataPos  => $dataPos,
+                DataLen  => $$dirInfo{DataLen},
+                DirStart => $pos,
+                DirLen   => $size,
+                DirName  => $subName,
+            );
+            if ($outfile) {
+                $dirInfo{Proc} = $processProc;  # WriteAdobeStuff() calls this to do the actual writing
+                $value = $et->WriteDirectory(\%dirInfo, $subTable, \&WriteAdobeStuff);
+                # use old directory if an error occurred
+                defined $value or $value = substr($$dataPt, $pos, $size);
+            } else {
+                # override process proc for MakN
+                $et->ProcessDirectory(\%dirInfo, $subTable, $processProc);
+            }
+            last;
+        }
+        if (defined $value and length $value) {
+            # add "Adobe" header if necessary
+            $$outfile = "Adobe\0" unless $$outfile and length $$outfile;
+            $$outfile .= $tag . pack('N', length $value) . $value;
+            $$outfile .= "\0" if length($value) & 0x01; # pad if necessary
+        }
+        $pos += $size;
+        ++$pos if $size & 0x01; # (darn padding)
+    }
+    $pos == $end or $et->Warn("$pos $end Adobe private data is corrupt");
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe CRW directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+# Notes: data has 4 byte header (2 for byte order and 2 for entry count)
+# - this routine would be as simple as ProcessAdobeMRW() below if Adobe hadn't
+#   pulled the bonehead move of reformatting the CRW information
+sub ProcessAdobeCRW($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $start = $$dirInfo{DirStart};
+    my $end = $start + $$dirInfo{DirLen};
+    my $verbose = $et->Options('Verbose');
+    my $buildMakerNotes = $et->Options('MakerNotes');
+    my $outfile = $$dirInfo{OutFile};
+    my ($newTags, $oldChanged);
+
+    SetByteOrder('MM'); # always big endian
+    return 0 if $$dirInfo{DirLen} < 4;
+    my $byteOrder = substr($$dataPt, $start, 2);
+    return 0 unless $byteOrder =~ /^(II|MM)$/;
+
+    # initialize maker note data if building maker notes
+    $buildMakerNotes and Image::ExifTool::CanonRaw::InitMakerNotes($et);
+
+    my $entries = Get16u($dataPt, $start + 2);
+    my $pos = $start + 4;
+    $et->VerboseDir($dirInfo, $entries) unless $outfile;
+    if ($outfile) {
+        # get hash of new tags
+        $newTags = $et->GetNewTagInfoHash($tagTablePtr);
+        $$outfile = substr($$dataPt, $start, 4);
+        $oldChanged = $$et{CHANGED};
+    }
+    # loop through entries in Adobe CRW information
+    my $index;
+    for ($index=0; $index<$entries; ++$index) {
+        last if $pos + 6 > $end;
+        my $tag = Get16u($dataPt, $pos);
+        my $size = Get32u($dataPt, $pos + 2);
+        $pos += 6;
+        last if $pos + $size > $end;
+        my $value = substr($$dataPt, $pos, $size);
+        my $tagID = $tag & 0x3fff;
+        my $tagType = ($tag >> 8) & 0x38;   # get tag type
+        my $format = $Image::ExifTool::CanonRaw::crwTagFormat{$tagType};
+        my $count;
+        my $tagInfo = $et->GetTagInfo($tagTablePtr, $tagID, \$value);
+        if ($tagInfo) {
+            $format = $$tagInfo{Format} if $$tagInfo{Format};
+            $count = $$tagInfo{Count};
+        }
+        # set count to 1 by default for values that were in the directory entry
+        if (not defined $count and $tag & 0x4000 and $format and $format ne 'string') {
+            $count = 1;
+        }
+        # 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);
+        }
+        $format or $format = 'undef';
+        SetByteOrder($byteOrder);
+        my $val = ReadValue(\$value, 0, $format, $count, $size);
+        if ($outfile) {
+            if ($tagInfo) {
+                my $subdir = $$tagInfo{SubDirectory};
+                if ($subdir and $$subdir{TagTable}) {
+                    my $name = $$tagInfo{Name};
+                    my $newTagTable = 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,
+                        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}) {
+                    my $nvHash = $et->GetNewValueHash($tagInfo);
+                    if ($et->IsOverwriting($nvHash, $val)) {
+                        my $newVal = $et->GetNewValue($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) {
+                            $et->VerboseValue("- CanonRaw:$$tagInfo{Name}", $value);
+                            $et->VerboseValue("+ CanonRaw:$$tagInfo{Name}", $verboseVal);
+                            $value = $newVal;
+                            ++$$et{CHANGED};
+                        }
+                    }
+                }
+            }
+            # write out new value (always big-endian)
+            SetByteOrder('MM');
+            # (verified that there is no padding here)
+            $$outfile .= Set16u($tag) . Set32u(length($value)) . $value;
+        } else {
+            $et->HandleTag($tagTablePtr, $tagID, $val,
+                Index   => $index,
+                DataPt  => $dataPt,
+                DataPos => $$dirInfo{DataPos},
+                Start   => $pos,
+                Size    => $size,
+                TagInfo => $tagInfo,
+            );
+            if ($buildMakerNotes) {
+                # build maker notes information if requested
+                Image::ExifTool::CanonRaw::BuildMakerNotes($et, $tagID, $tagInfo,
+                                                           \$value, $format, $count);
+            }
+        }
+        # (we lost the directory structure, but the second tag 0x0805
+        # should be in the ImageDescription directory)
+        $$et{DIR_NAME} = 'ImageDescription' if $tagID == 0x0805;
+        SetByteOrder('MM');
+        $pos += $size;
+    }
+    if ($outfile and (not defined $$outfile or $index != $entries or
+        $$et{CHANGED} ==  $oldChanged))
+    {
+        $$et{CHANGED} = $oldChanged; # nothing changed
+        undef $$outfile;    # rewrite old directory
+    }
+    if ($index != $entries) {
+        $et->Warn('Truncated CRW notes');
+    } elsif ($pos < $end) {
+        $et->Warn($end-$pos . ' extra bytes at end of CRW notes');
+    }
+    # finish building maker notes if necessary
+    if ($buildMakerNotes) {
+        SetByteOrder($byteOrder);
+        Image::ExifTool::CanonRaw::SaveMakerNotes($et);
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe MRW directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+# Notes: data has 4 byte header (2 for byte order and 2 for entry count)
+sub ProcessAdobeMRW($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirLen = $$dirInfo{DirLen};
+    my $dirStart = $$dirInfo{DirStart};
+    my $outfile = $$dirInfo{OutFile};
+
+    # construct fake MRW file
+    my $buff = "\0MRM" . pack('N', $dirLen - 4);
+    # ignore leading byte order and directory count words
+    $buff .= substr($$dataPt, $dirStart + 4, $dirLen - 4);
+    my $raf = new File::RandomAccess(\$buff);
+    my %dirInfo = ( RAF => $raf, OutFile => $outfile );
+    my $rtnVal = Image::ExifTool::MinoltaRaw::ProcessMRW($et, \%dirInfo);
+    if ($outfile and defined $$outfile and length $$outfile) {
+        # remove MRW header and add Adobe header
+        $$outfile = substr($$dataPt, $dirStart, 4) . substr($$outfile, 8);
+    }
+    return $rtnVal;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe RAF directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+sub ProcessAdobeRAF($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    return 0 if $$dirInfo{OutFile}; # (can't write this yet)
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = $$dirInfo{DirStart};
+    my $dirEnd = $$dirInfo{DirLen} + $pos;
+    my ($readIt, $warn);
+
+    # set byte order according to first 2 bytes of Adobe RAF data
+    if ($pos + 2 <= $dirEnd and SetByteOrder(substr($$dataPt, $pos, 2))) {
+        $pos += 2;
+    } else {
+        $et->Warn('Invalid DNG RAF data');
+        return 0;
+    }
+    $et->VerboseDir($dirInfo);
+    # make fake RAF object for processing (same acronym, different meaning)
+    my $raf = new File::RandomAccess($dataPt);
+    my $num = '';
+    # loop through all records in Adobe RAF data:
+    # 0 - RAF table (not processed)
+    # 1 - first RAF directory
+    # 2 - second RAF directory (if available)
+    for (;;) {
+        last if $pos + 4 > $dirEnd;
+        my $len = Get32u($dataPt, $pos);
+        $pos += 4 + $len;   # step to next entry in Adobe RAF record
+        $len or last;       # ends with an empty entry
+        $readIt or $readIt = 1, next;   # ignore first entry (RAF table)
+        my %dirInfo = (
+            RAF      => $raf,
+            DirStart => $pos - $len,
+        );
+        $$et{SET_GROUP1} = "RAF$num";
+        $et->ProcessDirectory(\%dirInfo, $tagTablePtr) or $warn = 1;
+        delete $$et{SET_GROUP1};
+        $num = ($num || 1) + 1;
+    }
+    $warn and $et->Warn('Possibly corrupt RAF information');
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe SR2 directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+# Notes: data has 6 byte header (2 for byte order and 4 for original offset)
+sub ProcessAdobeSR2($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    return 0 if $$dirInfo{OutFile}; # (can't write this yet)
+    my $dataPt = $$dirInfo{DataPt};
+    my $start = $$dirInfo{DirStart};
+    my $len = $$dirInfo{DirLen};
+
+    return 0 if $len < 6;
+    SetByteOrder('MM');
+    my $originalPos = Get32u($dataPt, $start + 2);
+    return 0 unless SetByteOrder(substr($$dataPt, $start, 2));
+
+    $et->VerboseDir($dirInfo);
+    my $dataPos = $$dirInfo{DataPos};
+    my $dirStart = $start + 6;  # pointer to maker note directory
+    my $dirLen = $len - 6;
+
+    # initialize subdirectory information
+    my $fix = $dataPos + $dirStart - $originalPos;
+    my %subdirInfo = (
+        DirName   => 'AdobeSR2',
+        Base      => $$dirInfo{Base} + $fix,
+        DataPt    => $dataPt,
+        DataPos   => $dataPos - $fix,
+        DataLen   => $$dirInfo{DataLen},
+        DirStart  => $dirStart,
+        DirLen    => $dirLen,
+        Parent    => $$dirInfo{DirName},
+    );
+    if ($et->Options('HtmlDump')) {
+        $et->HDump($dataPos + $start, 6, 'Adobe SR2 data');
+    }
+    # parse the SR2 directory
+    $et->ProcessDirectory(\%subdirInfo, $tagTablePtr);
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe-mutilated IFD directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+# Notes: data has 2 byte header (byte order of the data)
+sub ProcessAdobeIFD($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    return 0 if $$dirInfo{OutFile}; # (can't write this yet)
+    my $dataPt = $$dirInfo{DataPt};
+    my $pos = $$dirInfo{DirStart};
+    my $dataPos = $$dirInfo{DataPos};
+
+    return 0 if $$dirInfo{DirLen} < 4;
+    my $dataOrder = substr($$dataPt, $pos, 2);
+    return 0 unless SetByteOrder($dataOrder);   # validate byte order of data
+
+    # parse the mutilated IFD.  This is similar to a TIFF IFD, except:
+    # - data follows directly after Count entry in IFD
+    # - byte order of IFD entires is always big-endian, but byte order of data changes
+    SetByteOrder('MM');     # IFD structure is always big-endian
+    my $entries = Get16u($dataPt, $pos + 2);
+    $et->VerboseDir($dirInfo, $entries);
+    $pos += 4;
+
+    my $end = $pos + $$dirInfo{DirLen};
+    my $index;
+    for ($index=0; $index<$entries; ++$index) {
+        last if $pos + 8 > $end;
+        SetByteOrder('MM'); # directory entries always big-endian (doh!)
+        my $tagID = Get16u($dataPt, $pos);
+        my $format = Get16u($dataPt, $pos+2);
+        my $count = Get32u($dataPt, $pos+4);
+        if ($format < 1 or $format > 13) {
+            # warn unless the IFD was just padded with zeros
+            $format and $et->Warn(
+                sprintf("Unknown format ($format) for $$dirInfo{DirName} tag 0x%x",$tagID));
+            return 0; # must be corrupted
+        }
+        my $size = $Image::ExifTool::Exif::formatSize[$format] * $count;
+        last if $pos + 8 + $size > $end;
+        my $formatStr = $Image::ExifTool::Exif::formatName[$format];
+        SetByteOrder($dataOrder);   # data stored in native order
+        my $val = ReadValue($dataPt, $pos + 8, $formatStr, $count, $size);
+        $et->HandleTag($tagTablePtr, $tagID, $val,
+            Index   => $index,
+            DataPt  => $dataPt,
+            DataPos => $dataPos,
+            Start   => $pos + 8,
+            Size    => $size
+        );
+        $pos += 8 + $size;
+    }
+    if ($index < $entries) {
+        $et->Warn("Truncated $$dirInfo{DirName} directory");
+        return 0;
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process Adobe MakerNotes directory
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success, otherwise returns 0 and sets a Warning
+# Notes: data has 6 byte header (2 for byte order and 4 for original offset)
+sub ProcessAdobeMakN($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $start = $$dirInfo{DirStart};
+    my $len = $$dirInfo{DirLen};
+    my $outfile = $$dirInfo{OutFile};
+
+    return 0 if $len < 6;
+    SetByteOrder('MM');
+    my $originalPos = Get32u($dataPt, $start + 2);
+    return 0 unless SetByteOrder(substr($$dataPt, $start, 2));
+
+    $et->VerboseDir($dirInfo) unless $outfile;
+    my $dataPos = $$dirInfo{DataPos};
+    my $dirStart = $start + 6;  # pointer to maker note directory
+    my $dirLen = $len - 6;
+
+    my $hdr = substr($$dataPt, $dirStart, $dirLen < 48 ? $dirLen : 48);
+    my $tagInfo = $et->GetTagInfo($tagTablePtr, 'MakN', \$hdr);
+    return 0 unless $tagInfo and $$tagInfo{SubDirectory};
+    my $subdir = $$tagInfo{SubDirectory};
+    my $subTable = GetTagTable($$subdir{TagTable});
+    # initialize subdirectory information
+    my %subdirInfo = (
+        DirName   => 'MakerNotes',
+        Name      => $$tagInfo{Name},   # needed for maker notes verbose dump
+        Base      => $$dirInfo{Base},
+        DataPt    => $dataPt,
+        DataPos   => $dataPos,
+        DataLen   => $$dirInfo{DataLen},
+        DirStart  => $dirStart,
+        DirLen    => $dirLen,
+        TagInfo   => $tagInfo,
+        FixBase   => $$subdir{FixBase},
+        EntryBased=> $$subdir{EntryBased},
+        Parent    => $$dirInfo{DirName},
+    );
+    # look for start of maker notes IFD
+    my $loc = Image::ExifTool::MakerNotes::LocateIFD($et,\%subdirInfo);
+    unless (defined $loc) {
+        $et->Warn('Maker notes could not be parsed');
+        return 0;
+    }
+    if ($et->Options('HtmlDump')) {
+        $et->HDump($dataPos + $start, 6, 'Adobe MakN data');
+        $et->HDump($dataPos + $dirStart, $loc, "$$tagInfo{Name} header") if $loc;
+    }
+
+    my $fix = 0;
+    unless ($$subdir{Base}) {
+        # adjust base offset for current maker note position
+        $fix = $dataPos + $dirStart - $originalPos;
+        $subdirInfo{Base} += $fix;
+        $subdirInfo{DataPos} -= $fix;
+    }
+    if ($outfile) {
+        # rewrite the maker notes directory
+        my $fixup = $subdirInfo{Fixup} = new Image::ExifTool::Fixup;
+        my $oldChanged = $$et{CHANGED};
+        my $buff = $et->WriteDirectory(\%subdirInfo, $subTable);
+        # nothing to do if error writing directory or nothing changed
+        unless (defined $buff and $$et{CHANGED} != $oldChanged) {
+            $$et{CHANGED} = $oldChanged;
+            return 1;
+        }
+        # deleting maker notes if directory is empty
+        unless (length $buff) {
+            $$outfile = '';
+            return 1;
+        }
+        # apply a one-time fixup to offsets
+        if ($subdirInfo{Relative}) {
+            # shift all offsets to be relative to new base
+            my $baseShift = $dataPos + $dirStart + $$dirInfo{Base} - $subdirInfo{Base};
+            $fixup->{Shift} += $baseShift;
+        } else {
+            # shift offsets to position of original maker notes
+            $fixup->{Shift} += $originalPos;
+        }
+        # if we wrote the directory as a block the header is already included
+        $loc = 0 if $subdirInfo{BlockWrite};
+        $fixup->{Shift} += $loc;    # adjust for makernotes header
+        $fixup->ApplyFixup(\$buff); # fix up pointer offsets
+        # get copy of original Adobe header (6) and makernotes header ($loc)
+        my $header = substr($$dataPt, $start, 6 + $loc);
+        # add Adobe and makernotes headers to new directory
+        $$outfile = $header . $buff;
+    } else {
+        # parse the maker notes directory
+        $et->ProcessDirectory(\%subdirInfo, $subTable, $$subdir{ProcessProc});
+        # extract maker notes as a block if specified
+        if ($et->Options('MakerNotes') or
+            $$et{REQ_TAG_LOOKUP}{lc($$tagInfo{Name})})
+        {
+            my $val;
+            if ($$tagInfo{MakerNotes}) {
+                $subdirInfo{Base}     = $$dirInfo{Base} + $fix;
+                $subdirInfo{DataPos}  = $dataPos - $fix;
+                $subdirInfo{DirStart} = $dirStart;
+                $subdirInfo{DirLen}   = $dirLen;
+                # rebuild the maker notes to identify all offsets that require fixing up
+                $val = Image::ExifTool::Exif::RebuildMakerNotes($et, $subTable, \%subdirInfo);
+                if (not defined $val and $dirLen > 4) {
+                    $et->Warn('Error rebuilding maker notes (may be corrupt)');
+                }
+            } else {
+                # extract this directory as a block if specified
+                return 1 unless $$tagInfo{Writable};
+            }
+            $val = substr($$dataPt, 20) unless defined $val;
+            $et->FoundTag($tagInfo, $val);
+        }
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Write Adobe information (calls appropriate ProcessProc to do the actual work)
+# Inputs: 0) ExifTool object ref, 1) source dirInfo ref, 2) tag table ref
+# Returns: new data block (may be empty if directory is deleted) or undef on error
+sub WriteAdobeStuff($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access
+    my $proc = $$dirInfo{Proc} || \&ProcessAdobeData;
+    my $buff;
+    $$dirInfo{OutFile} = \$buff;
+    &$proc($et, $dirInfo, $tagTablePtr) or undef $buff;
+    return $buff;
+}
+
+1; # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::DNG.pm - Read DNG-specific information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains routines required by Image::ExifTool to process
+information in DNG (Digital Negative) images.
+
+=head1 AUTHOR
+
+Copyright 2003-2017, 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.adobe.com/products/dng/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/DNG Tags>,
+L<Image::ExifTool::TagNames/EXIF Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut