exiftool_vendored 9.37.0 → 9.41.0

data/bin/{Image-ExifTool-9.37 → Image-ExifTool-9.41}/lib/Image/ExifTool.pm

@@ -27,7 +27,7 @@ use vars qw($VERSION $RELEASE @ISA @EXPORT_OK %EXPORT_TAGS $AUTOLOAD @fileTypes
             %mimeType $swapBytes $swapWords $currentByteOrder %unpackStd
             %jpegMarker %specialTags);
 
-$VERSION = '9.37';
+$VERSION = '9.41';
 $RELEASE = '';
 @ISA = qw(Exporter);
 %EXPORT_TAGS = (
@@ -123,8 +123,8 @@ sub ReadValue($$$$$;$);
 # unless tweaked in BuildTagLookup::GetTableOrder().
 @loadAllTables = qw(
     PhotoMechanic Exif GeoTiff CanonRaw KyoceraRaw MinoltaRaw PanasonicRaw
-    SigmaRaw JPEG GIMP Jpeg2000 GIF BMP BMP::OS2 PICT PNG MNG DjVu OpenEXR MIFF
-    PGF PSP PhotoCD Radiance PDF PostScript Photoshop::Header FujiFilm::RAF
+    SigmaRaw JPEG GIMP Jpeg2000 GIF BMP BMP::OS2 PICT PNG MNG DjVu DPX OpenEXR
+    MIFF PGF PSP PhotoCD Radiance PDF PostScript Photoshop::Header FujiFilm::RAF
     FujiFilm::IFD Sony::SRF2 Sony::SR2SubIFD Sony::PMP ITC ID3 Vorbis Ogg APE
     APE::NewHeader APE::OldHeader MPC MPEG::Audio MPEG::Video MPEG::Xing M2TS
     QuickTime QuickTime::ImageFile Matroska MXF DV Flash Flash::FLV Real::Media
@@ -167,16 +167,16 @@ $defaultLang = 'en';    # default language
                 BMP PPM RIFF AIFF ASF MOV MPEG Real SWF PSP FLV OGG FLAC APE MPC
                 MKV MXF DV PMP IND PGF ICC ITC FLIR FPF HTML VRD RTF XCF QTIF
                 FPX PICT ZIP GZIP PLIST RAR BZ2 TAR RWZ EXE EXR HDR CHM LNK WMF
-                AVC DEX RAW Font RSRC M2TS PHP Torrent MP3 DICM PCD);
+                AVC DEX DPX RAW Font RSRC M2TS PHP Torrent MP3 DICM PCD);
 
 # file types that we can write (edit)
 my @writeTypes = qw(JPEG TIFF GIF CRW MRW ORF RAF RAW PNG MIE PSD XMP PPM
-                    EPS X3F PS PDF ICC VRD JP2 EXIF AI AIT IND);
+                    EPS X3F PS PDF ICC VRD JP2 EXIF AI AIT IND MOV);
 my %writeTypes; # lookup for writable file types (hash filled if required)
 
 # file extensions that we can't write for various base types
 %noWriteFile = (
-    TIFF => [ qw(3FR DCR K25 KDC SRF) ],
+    TIFF => [ qw(3FR DCR K25 KDC ) ],
     XMP  => [ 'SVG' ],
     JP2  => [ 'J2C', 'JPC' ],
 );
@@ -240,6 +240,7 @@ my %fileTypeLookup = (
     DOT  => ['FPX',  'Microsoft Word Template'],
     DOTM => [['ZIP','FPX'], 'Office Open XML Document Template Macro-enabled'],
     DOTX => [['ZIP','FPX'], 'Office Open XML Document Template'],
+    DPX  => ['DPX',  'Digital Picture Exchange' ],
     DV   => ['DV',   'Digital Video'],
     DVB  => ['MOV',  'Digital Video Broadcasting'],
     DYLIB=> ['EXE',  'Mach-O Dynamic Link Library'],
@@ -489,6 +490,7 @@ my %fileDescription = (
     DOT  => 'application/msword',
     DOTM => 'application/vnd.ms-word.template.macroEnabledTemplate',
     DOTX => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+    DPX  => 'image/x-dpx',
     DV   => 'video/x-dv',
     EIP  => 'application/x-captureone', #(NC)
     EPS  => 'application/postscript',
@@ -693,6 +695,7 @@ my %moduleName = (
     DEX  => "dex\n035\0",
     DICM => '(.{128}DICM|\0[\x02\x04\x06\x08]\0[\0-\x20]|[\x02\x04\x06\x08]\0[\0-\x20]\0)',
     DOCX => 'PK\x03\x04',
+    DPX  => '(SDPX|XPDS)',
     DV   => '\x1f\x07\0[\x3f\xbf]', # (not tested if extension recognized)
     EPS  => '(%!PS|%!Ad|\xc5\xd0\xd3\xc6)',
     EXE  => '(MZ|\xca\xfe\xba\xbe|\xfe\xed\xfa[\xce\xcf]|[\xce\xcf]\xfa\xed\xfe|Joy!peff|\x7fELF|#!\s*/\S*bin/|!<arch>\x0a)',
@@ -719,7 +722,7 @@ my %moduleName = (
     MIE  => '~[\x10\x18]\x04.0MIE',
     MIFF => 'id=ImageMagick',
     MKV  => '\x1a\x45\xdf\xa3',
-    MOV  => '.{4}(free|skip|wide|ftyp|pnot|PICT|pict|moov|mdat|junk|uuid)',
+    MOV  => '.{4}(free|skip|wide|ftyp|pnot|PICT|pict|moov|mdat|junk|uuid)', # (duplicated in WriteQuickTime.pl !!)
   # MP3  =>  difficult to rule out
     MPC  => '(MP\+|ID3)',
     MPEG => '\0\0\x01[\xb0-\xbf]',
@@ -843,8 +846,26 @@ sub DummyWriteProc { return 1; }
     GROUPS => { 0 => 'File', 1 => 'File', 2 => 'Image' },
     VARS => { NO_ID => 1 }, # tag ID's aren't meaningful for these tags
     WRITE_PROC => \&DummyWriteProc,
-    Error   => { Priority => 0, Groups => \%allGroupsExifTool },
-    Warning => { Priority => 0, Groups => \%allGroupsExifTool },
+    Error   => {
+        Priority => 0,
+        Groups => \%allGroupsExifTool,
+        Notes => q{
+            returns errors that may have occurred while reading or writing a file.  Any
+            Error will prevent the file from being processed.  Minor errors may be
+            downgraded to warnings with the -m or IgnoreMinorErrors option
+        },
+    },
+    Warning => {
+        Priority => 0,
+        Groups => \%allGroupsExifTool,
+        Notes => q{
+            returns warnings that may have occurred while reading or writing a file. 
+            Use the -a or Duplicates option to see all warnings if more than one
+            occurred. Minor warnings may be ignored with the -m or IgnoreMinorErrors
+            option.  Minor warnings with a capital "M" in the "[Minor]" designation
+            indicate that the processing is affected by ignoring the warning
+        },
+    },
     Comment => {
         Notes => 'comment embedded in JPEG, GIF89a or PPM/PGM/PBM image',
         Writable => 1,
@@ -901,7 +922,12 @@ sub DummyWriteProc { return 1; }
         },
         PrintConv => \&ConvertFileSize,
     },
-    FileType    => { },
+    FileType => {
+        Notes => q{
+            a short description of the file type.  As a general rule, this is the
+            extension commonly used for the file, but there are exceptions to this rule
+        },
+    },
     FileModifyDate => {
         Description => 'File Modification Date/Time',
         Notes => q{
@@ -986,7 +1012,7 @@ sub DummyWriteProc { return 1; }
             return $str;
         },
     },
-    MIMEType    => { },
+    MIMEType    => { Notes => 'the MIME type of the source file' },
     ImageWidth  => { },
     ImageHeight => { },
     XResolution => { },
@@ -1098,6 +1124,7 @@ sub DummyWriteProc { return 1; }
     ExifToolVersion => {
         Description => 'ExifTool Version Number',
         Groups => \%allGroupsExifTool,
+        Notes => 'the version of ExifTool currently running',
     },
     RAFVersion => { },
     JPEGDigest => {
@@ -1346,10 +1373,10 @@ sub new
     GetTagTable("Image::ExifTool::Exif::Main");
 
     $self->ClearOptions();      # create default options hash
-    $self->{VALUE} = { };       # must initialize this for warning messages
-    $self->{DEL_GROUP} = { };   # lookup for groups to delete when writing
-    $self->{SAVE_COUNT} = 0;    # count calls to SaveNewValues()
-    $self->{FILE_SEQUENCE} = 0; # sequence number for files when reading
+    $$self{VALUE} = { };        # must initialize this for warning messages
+    $$self{DEL_GROUP} = { };    # lookup for groups to delete when writing
+    $$self{SAVE_COUNT} = 0;     # count calls to SaveNewValues()
+    $$self{FILE_SEQUENCE} = 0;  # sequence number for files when reading
 
     # initialize our new groups for writing
     $self->SetNewGroups(@defaultWriteGroups);
@@ -1375,8 +1402,8 @@ sub new
 #   use Image::ExifTool 'ImageInfo';
 #   my $info = ImageInfo($file, 'DateTimeOriginal', 'ImageSize');
 #    - or -
-#   my $exifTool = new Image::ExifTool;
-#   my $info = $exifTool->ImageInfo($file, \@tagList, {Sort=>'Group0'} );
+#   my $et = new Image::ExifTool;
+#   my $info = $et->ImageInfo($file, \@tagList, {Sort=>'Group0'} );
 sub ImageInfo($;@)
 {
     local $_;
@@ -1387,16 +1414,16 @@ sub ImageInfo($;@)
     } else {
         $self = new Image::ExifTool;
     }
-    my %saveOptions = %{$self->{OPTIONS}};  # save original options
+    my %saveOptions = %{$$self{OPTIONS}};   # save original options
 
     # initialize file information
-    $self->{FILENAME} = $self->{RAF} = undef;
+    $$self{FILENAME} = $$self{RAF} = undef;
 
     $self->ParseArguments(@_);              # parse our function arguments
     $self->ExtractInfo(undef);              # extract meta information from image
     my $info = $self->GetInfo(undef);       # get requested information
 
-    $self->{OPTIONS} = \%saveOptions;       # restore original options
+    $$self{OPTIONS} = \%saveOptions;        # restore original options
 
     return $info;   # return requested information
 }
@@ -1475,7 +1502,7 @@ sub Options($$;@)
                     delete $$self{ESCAPE_PROC};
                 }
                 # must forget saved values since they depend on Escape method
-                $self->{BOTH} = { };
+                $$self{BOTH} = { };
             }
             $$options{$param} = $newVal;
         }
@@ -1497,7 +1524,7 @@ sub ClearOptions($)
     # ! DON'T FORGET!!  When adding any new option, must    !
     # ! decide how it is handled in SetNewValuesFromFile()  !
     # +-----------------------------------------------------+
-    $self->{OPTIONS} = {
+    $$self{OPTIONS} = {
     #   Binary      => undef,   # flag to extract binary values even if tag not specified
     #   ByteOrder   => undef,   # default byte order when creating EXIF information
         Charset     => 'UTF8',  # character set for converting Unicode characters
@@ -1570,7 +1597,7 @@ sub ExtractInfo($;@)
 {
     local $_;
     my $self = shift;
-    my $options = $self->{OPTIONS};     # pointer to current options
+    my $options = $$self{OPTIONS};      # pointer to current options
     my (%saveOptions, $reEntry, $rsize, $type);
 
     # check for internal ReEntry option to allow recursive calls to ExtractInfo
@@ -1585,21 +1612,21 @@ sub ExtractInfo($;@)
             EXIF_POS  => $$self{EXIF_POS},
             FILE_TYPE => $$self{FILE_TYPE},
         };
-        $self->{RAF} = new File::RandomAccess($_[0]);
+        $$self{RAF} = new File::RandomAccess($_[0]);
         $$self{PROCESSED} = { };
         delete $$self{EXIF_DATA};
         delete $$self{EXIF_POS};
     } else {
-        if (defined $_[0] or $options->{HtmlDump}) {
+        if (defined $_[0] or $$options{HtmlDump}) {
             %saveOptions = %$options;       # save original options
 
             # require duplicates for html dump
-            $self->Options(Duplicates => 1) if $options->{HtmlDump};
+            $self->Options(Duplicates => 1) if $$options{HtmlDump};
 
             if (defined $_[0]) {
                 # only initialize filename if called with arguments
-                $self->{FILENAME} = undef;  # name of file (or '' if we didn't open it)
-                $self->{RAF} = undef;       # RandomAccess object reference
+                $$self{FILENAME} = undef;   # name of file (or '' if we didn't open it)
+                $$self{RAF} = undef;        # RandomAccess object reference
 
                 $self->ParseArguments(@_);  # initialize from our arguments
             }
@@ -1607,22 +1634,22 @@ sub ExtractInfo($;@)
         # initialize ExifTool object members
         $self->Init();
 
-        delete $self->{MAKER_NOTE_FIXUP};   # fixup information for extracted maker notes
-        delete $self->{MAKER_NOTE_BYTE_ORDER};
+        delete $$self{MAKER_NOTE_FIXUP};    # fixup information for extracted maker notes
+        delete $$self{MAKER_NOTE_BYTE_ORDER};
 
         # return our version number
-        my $reqAll = $self->{OPTIONS}{RequestAll};
+        my $reqAll = $$self{OPTIONS}{RequestAll};
         $self->FoundTag('ExifToolVersion', "$VERSION$RELEASE");
-        $self->FoundTag('Now', TimeNow()) if $self->{REQ_TAG_LOOKUP}{now} or $reqAll;
-        $self->FoundTag('NewGUID', NewGUID()) if $self->{REQ_TAG_LOOKUP}{newguid} or $reqAll;
+        $self->FoundTag('Now', TimeNow()) if $$self{REQ_TAG_LOOKUP}{now} or $reqAll;
+        $self->FoundTag('NewGUID', NewGUID()) if $$self{REQ_TAG_LOOKUP}{newguid} or $reqAll;
         # generate sequence number if necessary
-        if ($self->{REQ_TAG_LOOKUP}{filesequence} or $reqAll) {
+        if ($$self{REQ_TAG_LOOKUP}{filesequence} or $reqAll) {
             $self->FoundTag('FileSequence', $$self{FILE_SEQUENCE});
         }
         ++$$self{FILE_SEQUENCE};        # count files read
     }
-    my $filename = $self->{FILENAME};   # image file name ('' if already open)
-    my $raf = $self->{RAF};             # RandomAccess object
+    my $filename = $$self{FILENAME};    # image file name ('' if already open)
+    my $raf = $$self{RAF};              # RandomAccess object
 
     local *EXIFTOOL_FILE;   # avoid clashes with global namespace
 
@@ -1653,8 +1680,8 @@ sub ExtractInfo($;@)
                 $raf = new File::RandomAccess(\*EXIFTOOL_FILE);
                 # patch to force pipe to be buffered because seek returns success
                 # in Windows cmd shell pipe even though it really failed
-                $raf->{TESTED} = -1 if $filename eq '-' or $filename =~ /\|$/;
-                $self->{RAF} = $raf;
+                $$raf{TESTED} = -1 if $filename eq '-' or $filename =~ /\|$/;
+                $$self{RAF} = $raf;
             } else {
                 $self->Error('Error opening file');
             }
@@ -1666,10 +1693,10 @@ sub ExtractInfo($;@)
     if ($raf) {
         if ($reEntry) {
             # we already set these tags
-        } elsif (not $raf->{FILE_PT}) {
+        } elsif (not $$raf{FILE_PT}) {
             # get file size from image in memory
-            $self->FoundTag('FileSize', length ${$raf->{BUFF_PT}});
-        } elsif (-f $raf->{FILE_PT}) {
+            $self->FoundTag('FileSize', length ${$$raf{BUFF_PT}});
+        } elsif (-f $$raf{FILE_PT}) {
             # get file size and last modified time if this is a plain file
             my $fileSize = -s _;
             my $fileTime = -M _;
@@ -1728,7 +1755,7 @@ sub ExtractInfo($;@)
                 $self->Warn("Skipped unknown $skip byte header");
             }
             # save file type in member variable
-            $self->{FILE_TYPE} = $type;
+            $$self{FILE_TYPE} = $type;
             $dirInfo{Parent} = ($type eq 'TIFF') ? $tiffType : $type;
             my $module = $moduleName{$type};
             $module = $type unless defined $module;
@@ -1783,35 +1810,35 @@ sub ExtractInfo($;@)
             $self->Error($err);
         }
         # extract binary EXIF data block only if requested
-        if (defined $self->{EXIF_DATA} and length $$self{EXIF_DATA} > 16 and
-            ($self->{REQ_TAG_LOOKUP}{exif} or
+        if (defined $$self{EXIF_DATA} and length $$self{EXIF_DATA} > 16 and
+            ($$self{REQ_TAG_LOOKUP}{exif} or
             # (not extracted normally, so check TAGS_FROM_FILE)
-            ($self->{TAGS_FROM_FILE} and not $self->{EXCL_TAG_LOOKUP}{exif})))
+            ($$self{TAGS_FROM_FILE} and not $$self{EXCL_TAG_LOOKUP}{exif})))
         {
-            $self->FoundTag('EXIF', $self->{EXIF_DATA});
+            $self->FoundTag('EXIF', $$self{EXIF_DATA});
         }
         unless ($reEntry) {
-            $self->{PATH} = [ ];    # reset PATH
+            $$self{PATH} = [ ];     # reset PATH
             # calculate Composite tags
-            $self->BuildCompositeTags() if $options->{Composite};
+            $self->BuildCompositeTags() if $$options{Composite};
             # do our HTML dump if requested
-            if ($self->{HTML_DUMP}) {
+            if ($$self{HTML_DUMP}) {
                 $raf->Seek(0, 2);   # seek to end of file
-                $self->{HTML_DUMP}->FinishTiffDump($self, $raf->Tell());
-                my $pos = $options->{HtmlDumpBase};
-                $pos = ($self->{FIRST_EXIF_POS} || 0) unless defined $pos;
-                my $dataPt = defined $self->{EXIF_DATA} ? \$self->{EXIF_DATA} : undef;
-                undef $dataPt if defined $self->{EXIF_POS} and $pos != $self->{EXIF_POS};
-                my $success = $self->{HTML_DUMP}->Print($raf, $dataPt, $pos,
-                    $options->{TextOut}, $options->{HtmlDump},
-                    $self->{FILENAME} ? "HTML Dump ($self->{FILENAME})" : 'HTML Dump');
-                $self->Warn("Error reading $self->{HTML_DUMP}{ERROR}") if $success < 0;
+                $$self{HTML_DUMP}->FinishTiffDump($self, $raf->Tell());
+                my $pos = $$options{HtmlDumpBase};
+                $pos = ($$self{FIRST_EXIF_POS} || 0) unless defined $pos;
+                my $dataPt = defined $$self{EXIF_DATA} ? \$$self{EXIF_DATA} : undef;
+                undef $dataPt if defined $$self{EXIF_POS} and $pos != $$self{EXIF_POS};
+                my $success = $$self{HTML_DUMP}->Print($raf, $dataPt, $pos,
+                    $$options{TextOut}, $$options{HtmlDump},
+                    $$self{FILENAME} ? "HTML Dump ($$self{FILENAME})" : 'HTML Dump');
+                $self->Warn("Error reading $$self{HTML_DUMP}{ERROR}") if $success < 0;
             }
         }
         if ($filename) {
             $raf->Close();  # close the file if we opened it
             # process the resource fork as an embedded file on Mac filesystems
-            if ($rsize and $options->{ExtractEmbedded}) {
+            if ($rsize and $$options{ExtractEmbedded}) {
                 local *RESOURCE_FILE;
                 if (Open(\*RESOURCE_FILE, "$filename/..namedfork/rsrc")) {
                     $$self{DOC_NUM} = $$self{DOC_COUNT} + 1;
@@ -1827,7 +1854,7 @@ sub ExtractInfo($;@)
     }
 
     # restore original options
-    %saveOptions and $self->{OPTIONS} = \%saveOptions;
+    %saveOptions and $$self{OPTIONS} = \%saveOptions;
 
     if ($reEntry) {
         # restore necessary members when exiting re-entrant code
@@ -1835,7 +1862,7 @@ sub ExtractInfo($;@)
     }
 
     # ($type may be undef without an Error when processing sub-documents)
-    return 0 if not defined $type or exists $self->{VALUE}{Error};
+    return 0 if not defined $type or exists $$self{VALUE}{Error};
     return 1;
 }
 
@@ -1855,9 +1882,9 @@ sub GetInfo($;@)
     my %saveOptions;
 
     unless (@_ and not defined $_[0]) {
-        %saveOptions = %{$self->{OPTIONS}}; # save original options
+        %saveOptions = %{$$self{OPTIONS}}; # save original options
         # must set FILENAME so it isn't parsed from the arguments
-        $self->{FILENAME} = '' unless defined $self->{FILENAME};
+        $$self{FILENAME} = '' unless defined $$self{FILENAME};
         $self->ParseArguments(@_);
     }
 
@@ -1866,7 +1893,7 @@ sub GetInfo($;@)
 
     # build hash of tag information
     my (%info, %ignored);
-    my $conv = $self->{OPTIONS}{PrintConv} ? 'PrintConv' : 'ValueConv';
+    my $conv = $$self{OPTIONS}{PrintConv} ? 'PrintConv' : 'ValueConv';
     foreach (@$rtnTags) {
         my $val = $self->GetValue($_, $conv);
         defined $val or $ignored{$_} = 1, next;
@@ -1901,14 +1928,14 @@ sub GetInfo($;@)
     }
 
     # remove ignored tags from the list
-    my $reqTags = $self->{REQUESTED_TAGS} || [ ];
+    my $reqTags = $$self{REQUESTED_TAGS} || [ ];
     if (%ignored) {
         if (not @$reqTags) {
             my @goodTags;
             foreach (@$rtnTags) {
                 push @goodTags, $_ unless $ignored{$_};
             }
-            $rtnTags = $self->{FOUND_TAGS} = \@goodTags;
+            $rtnTags = $$self{FOUND_TAGS} = \@goodTags;
         } elsif (@$wildTags) {
             # only remove tags specified by wildcard
             my @goodTags;
@@ -1922,22 +1949,22 @@ sub GetInfo($;@)
                 }
                 ++$i;
             }
-            $rtnTags = $self->{FOUND_TAGS} = \@goodTags;
+            $rtnTags = $$self{FOUND_TAGS} = \@goodTags;
         }
     }
 
     # return sorted tag list if provided with a list reference
-    if ($self->{IO_TAG_LIST}) {
+    if ($$self{IO_TAG_LIST}) {
         # use file order by default if no tags specified
         # (no such thing as 'Input' order in this case)
-        my $sort = $self->{OPTIONS}{Sort};
+        my $sort = $$self{OPTIONS}{Sort};
         $sort = 'File' unless @$reqTags or ($sort and $sort ne 'Input');
         # return tags in specified sort order
-        @{$self->{IO_TAG_LIST}} = $self->GetTagList($rtnTags, $sort, $self->{OPTIONS}{Sort2});
+        @{$$self{IO_TAG_LIST}} = $self->GetTagList($rtnTags, $sort, $$self{OPTIONS}{Sort2});
     }
 
     # restore original options
-    %saveOptions and $self->{OPTIONS} = \%saveOptions;
+    %saveOptions and $$self{OPTIONS} = \%saveOptions;
 
     return \%info;
 }
@@ -1953,7 +1980,7 @@ sub CombineInfo($;@)
     my $self = shift;
     my (%combinedInfo, $info, $tag, %haveInfo);
 
-    if ($self->{OPTIONS}{Duplicates}) {
+    if ($$self{OPTIONS}{Duplicates}) {
         while ($info = shift) {
             foreach $tag (keys %$info) {
                 $combinedInfo{$tag} = $$info{$tag};
@@ -1990,7 +2017,7 @@ sub GetTagList($;$$$)
     } elsif (ref $info eq 'ARRAY') {
         $foundTags = $info;
     }
-    my $fileOrder = $self->{FILE_ORDER};
+    my $fileOrder = $$self{FILE_ORDER};
 
     if ($foundTags) {
         # make sure a FILE_ORDER entry exists for all tags
@@ -2001,9 +2028,9 @@ sub GetTagList($;$$$)
         }
     } else {
         $sort = $info if $info and not $sort;
-        $foundTags = $self->{FOUND_TAGS} || $self->SetFoundTags() or return undef;
+        $foundTags = $$self{FOUND_TAGS} || $self->SetFoundTags() or return undef;
     }
-    $sort or $sort = $self->{OPTIONS}{Sort};
+    $sort or $sort = $$self{OPTIONS}{Sort};
 
     # return original list if no sort order specified
     return @$foundTags unless $sort and $sort ne 'Input';
@@ -2023,7 +2050,7 @@ sub GetTagList($;$$$)
             $num or $num = $groupCount{$group} = ++$numGroups;
             $groupOrder{$tag} = $num;
         }
-        $sort2 or $sort2 = $self->{OPTIONS}{Sort2};
+        $sort2 or $sort2 = $$self{OPTIONS}{Sort2};
         if ($sort2) {
             if ($sort2 eq 'Tag' or $sort2 eq 'Alpha') {
                 return sort { $groupOrder{$a} <=> $groupOrder{$b} or $a cmp $b } @$foundTags;
@@ -2053,7 +2080,7 @@ sub GetFoundTags($;$$)
 {
     local $_;
     my ($self, $sort, $sort2) = @_;
-    my $foundTags = $self->{FOUND_TAGS} || $self->SetFoundTags() or return undef;
+    my $foundTags = $$self{FOUND_TAGS} || $self->SetFoundTags() or return undef;
     return $self->GetTagList($foundTags, $sort, $sort2);
 }
 
@@ -2084,13 +2111,13 @@ sub GetValue($$;$)
 
     # figure out what conversions to do
     if ($type) {
-        return $self->{RATIONAL}{$tag} if $type eq 'Rational';
+        return $$self{RATIONAL}{$tag} if $type eq 'Rational';
     } else {
-        $type = $self->{OPTIONS}{PrintConv} ? 'PrintConv' : 'ValueConv';
+        $type = $$self{OPTIONS}{PrintConv} ? 'PrintConv' : 'ValueConv';
     }
 
     # start with the raw value
-    my $value = $self->{VALUE}{$tag};
+    my $value = $$self{VALUE}{$tag};
     if (not defined $value) {
         return wantarray ? () : undef unless ref $tag;
         # get the value of a structure field
@@ -2103,7 +2130,7 @@ sub GetValue($$;$)
             push @convTypes, 'PrintConv' unless $type eq 'ValueConv';
         }
     } else {
-        $tagInfo = $self->{TAG_INFO}{$tag};
+        $tagInfo = $$self{TAG_INFO}{$tag};
         if ($$tagInfo{Struct} and ref $value) {
             # must load XMPStruct.pl just in case (should already be loaded if
             # a structure was extracted, but we could also arrive here if a simple
@@ -2121,7 +2148,7 @@ sub GetValue($$;$)
         }
         if ($type ne 'Raw') {
             # use values we calculated already if we stored them
-            $both = $self->{BOTH}{$tag};
+            $both = $$self{BOTH}{$tag};
             if ($both) {
                 if ($type eq 'PrintConv') {
                     $value = $$both[1];
@@ -2150,7 +2177,7 @@ sub GetValue($$;$)
                 $conv = '\$val';  # return scalar reference for binary values
             } else {
                 # use PRINT_CONV from tag table if PrintConv doesn't exist
-                next unless defined($conv = $tagInfo->{Table}{PRINT_CONV});
+                next unless defined($conv = $$tagInfo{Table}{PRINT_CONV});
                 next if exists $$tagInfo{$convType};
             }
         }
@@ -2206,9 +2233,9 @@ sub GetValue($$;$)
                     my $oldEscape = $$self{ESCAPE_PROC};
                     delete $$self{ESCAPE_PROC};
                     foreach (keys %$val) {
-                        $raw[$_] = $self->{VALUE}{$$val{$_}};
+                        $raw[$_] = $$self{VALUE}{$$val{$_}};
                         ($val[$_], $prt[$_]) = $self->GetValue($$val{$_}, 'Both');
-                        next if defined $val[$_] or not $tagInfo->{Require}{$_};
+                        next if defined $val[$_] or not $$tagInfo{Require}{$_};
                         $$self{ESCAPE_PROC} = $oldEscape;
                         return wantarray ? () : undef;
                     }
@@ -2223,7 +2250,7 @@ sub GetValue($$;$)
                         # override with our localized language PrintConv if available
                         if ($$self{CUR_LANG} and $convType eq 'PrintConv' and
                             # (no need to check for lang-alt tag names -- they won't have a PrintConv)
-                            ref($lc = $self->{CUR_LANG}{$$tagInfo{Name}}) eq 'HASH' and
+                            ref($lc = $$self{CUR_LANG}{$$tagInfo{Name}}) eq 'HASH' and
                             ($lc = $$lc{PrintConv}) and ($lc = $$lc{$value}))
                         {
                             $value = $self->Decode($lc, 'UTF8');
@@ -2233,7 +2260,7 @@ sub GetValue($$;$)
                             $value = DecodeBits($val, $$conv{BITMASK});
                             # override with localized language strings
                             if (defined $value and $$self{CUR_LANG} and $convType eq 'PrintConv' and
-                                ref($lc = $self->{CUR_LANG}{$$tagInfo{Name}}) eq 'HASH' and
+                                ref($lc = $$self{CUR_LANG}{$$tagInfo{Name}}) eq 'HASH' and
                                 ($lc = $$lc{PrintConv}))
                             {
                                 my @vals = split ', ', $value;
@@ -2296,7 +2323,7 @@ sub GetValue($$;$)
     if ($type eq 'Both') {
         # save both (unescaped) values because we often need them again
         # (Composite tags need "Both" and often Require one tag for various Composite tags)
-        $self->{BOTH}{$tag} = [ $valueConv, $value ] unless $both;
+        $$self{BOTH}{$tag} = [ $valueConv, $value ] unless $both;
         # escape values if necessary
         if ($$self{ESCAPE_PROC}) {
             DoEscape($value, $$self{ESCAPE_PROC});
@@ -2319,9 +2346,9 @@ sub GetValue($$;$)
         # return array if requested
         return @$value if wantarray;
         # return list reference for Raw, ValueConv or if List or not a list of scalars
-        return $value if $type ne 'PrintConv' or $self->{OPTIONS}{List} or ref $$value[0];
+        return $value if $type ne 'PrintConv' or $$self{OPTIONS}{List} or ref $$value[0];
         # otherwise join in comma-separated string
-        $value = join $self->{OPTIONS}{ListSep}, @$value;
+        $value = join $$self{OPTIONS}{ListSep}, @$value;
     }
     return $value;
 }
@@ -2334,7 +2361,7 @@ sub GetValue($$;$)
 sub GetTagID($$)
 {
     my ($self, $tag) = @_;
-    my $tagInfo = $self->{TAG_INFO}{$tag};
+    my $tagInfo = $$self{TAG_INFO}{$tag};
     return '' unless $tagInfo and defined $$tagInfo{TagID};
     return ($$tagInfo{TagID}, $$tagInfo{LangCode}) if wantarray;
     return $$tagInfo{TagID};
@@ -2347,8 +2374,8 @@ sub GetTagID($$)
 sub GetTableName($$)
 {
     my ($self, $tag) = @_;
-    my $tagInfo = $self->{TAG_INFO}{$tag} or return '';
-    return $tagInfo->{Table}{SHORT_NAME};
+    my $tagInfo = $$self{TAG_INFO}{$tag} or return '';
+    return $$tagInfo{Table}{SHORT_NAME};
 }
 
 #------------------------------------------------------------------------------
@@ -2358,7 +2385,7 @@ sub GetTableName($$)
 sub GetTagIndex($$)
 {
     my ($self, $tag) = @_;
-    my $tagInfo = $self->{TAG_INFO}{$tag} or return undef;
+    my $tagInfo = $$self{TAG_INFO}{$tag} or return undef;
     return $$tagInfo{Index};
 }
 
@@ -2372,12 +2399,12 @@ sub GetDescription($$)
     local $_;
     my ($self, $tag) = @_;
     my ($desc, $name);
-    my $tagInfo = $self->{TAG_INFO}{$tag};
+    my $tagInfo = $$self{TAG_INFO}{$tag};
     # ($tagInfo won't be defined for missing tags extracted with -f)
     if ($tagInfo) {
         # use alternate language description if available
         while ($$self{CUR_LANG}) {
-            $desc = $self->{CUR_LANG}{$$tagInfo{Name}};
+            $desc = $$self{CUR_LANG}{$$tagInfo{Name}};
             if ($desc) {
                 # must look up Description if this tag also has a PrintConv
                 $desc = $$desc{Description} or last if ref $desc;
@@ -2385,7 +2412,7 @@ sub GetDescription($$)
                 # look up default language of lang-alt tag
                 last unless $$tagInfo{LangCode} and
                     ($name = $$tagInfo{Name}) =~ s/-$$tagInfo{LangCode}$// and
-                    $desc = $self->{CUR_LANG}{$name};
+                    $desc = $$self{CUR_LANG}{$name};
                 $desc = $$desc{Description} or last if ref $desc;
                 $desc .= " ($$tagInfo{LangCode})";
             }
@@ -2409,7 +2436,8 @@ sub GetDescription($$)
 # Get group name for specified tag
 # Inputs: 0) ExifTool object reference
 #         1) tag key (or reference to tagInfo hash, not part of the public API)
-#         2) [optional] group family (-1 to get extended group list)
+#         2) [optional] group family (-1 to get extended group list, or multiple
+#            families separated by colons to return multiple groups as a string)
 # Returns: Scalar context: Group name (for family 0 if not otherwise specified)
 #          Array context: Group name if family specified, otherwise list of
 #          group names for each family.  Returns '' for undefined tag.
@@ -2418,32 +2446,30 @@ sub GetGroup($$;$)
 {
     local $_;
     my ($self, $tag, $family) = @_;
-    my ($tagInfo, @groups, @families, $simplify, $byTagInfo);
+    my ($tagInfo, @groups, @families, $simplify, $byTagInfo, $ex);
     if (ref $tag eq 'HASH') {
         $tagInfo = $tag;
         $tag = $$tagInfo{Name};
         # set flag so we don't get extra information for an extracted tag
         $byTagInfo = 1;
     } else {
-        $tagInfo = $self->{TAG_INFO}{$tag} or return '';
+        $tagInfo = $$self{TAG_INFO}{$tag} || { };
+        $ex = $$self{TAG_EXTRA}{$tag};
     }
     my $groups = $$tagInfo{Groups};
     # fill in default groups unless already done
     # (after this, Groups 0-2 in tagInfo are guaranteed to be defined)
     unless ($$tagInfo{GotGroups}) {
-        my $tagTablePtr = $$tagInfo{Table};
-        if ($tagTablePtr) {
-            # construct our group list
-            $groups or $groups = $$tagInfo{Groups} = { };
-            # fill in default groups
-            foreach (keys %{$$tagTablePtr{GROUPS}}) {
-                $$groups{$_} or $$groups{$_} = $tagTablePtr->{GROUPS}{$_};
-            }
+        my $tagTablePtr = $$tagInfo{Table} || { GROUPS => { } };
+        # construct our group list
+        $groups or $groups = $$tagInfo{Groups} = { };
+        # fill in default groups
+        foreach (0..2) {
+            $$groups{$_} = $$tagTablePtr{GROUPS}{$_} || '' unless $$groups{$_};
         }
         # set flag indicating group list was built
         $$tagInfo{GotGroups} = 1;
     }
-    my $ex = $self->{TAG_EXTRA}{$tag};
     if (defined $family and $family ne '-1') {
         if ($family =~ /[^\d]/) {
             @families = ($family =~ /\d+/g);
@@ -2511,7 +2537,7 @@ sub GetGroups($;$$)
     # figure out our arguments
     if (ref $info ne 'HASH') {
         $family = $info;
-        $info = $self->{VALUE};
+        $info = $$self{VALUE};
     } else {
         $family = shift;
     }
@@ -2542,8 +2568,8 @@ sub SetNewGroups($;@)
     $priority{file} = 10;       # 'File' group is always written (Comment)
     $priority{composite} = 10;  # 'Composite' group is always written
     # set write priority (higher # is higher priority)
-    $self->{WRITE_PRIORITY} = \%priority;
-    $self->{WRITE_GROUPS} = \@groups;
+    $$self{WRITE_PRIORITY} = \%priority;
+    $$self{WRITE_GROUPS} = \@groups;
 }
 
 #------------------------------------------------------------------------------
@@ -2566,7 +2592,7 @@ sub BuildCompositeTags($)
     my @tagList = sort keys %Image::ExifTool::Composite;
     my %tagsUsed;
 
-    my $rawValue = $self->{VALUE};
+    my $rawValue = $$self{VALUE};
     for (;;) {
         my %notBuilt;
         $notBuilt{$_} = 1 foreach @tagList;
@@ -2634,11 +2660,11 @@ COMPOSITE_TAG:
                 }
                 if ($doc) {
                     if ($found) {
-                        $self->{DOC_NUM} = $doc;
+                        $$self{DOC_NUM} = $doc;
                         $self->FoundTag($tagInfo, \%tagKey);
-                        delete $self->{DOC_NUM};
+                        delete $$self{DOC_NUM};
                     }
-                    next if ++$doc <= $self->{DOC_COUNT};
+                    next if ++$doc <= $$self{DOC_COUNT};
                     last;
                 } elsif ($found) {
                     delete $notBuilt{$tag}; # this tag is OK to build now
@@ -2657,7 +2683,7 @@ COMPOSITE_TAG:
                     # check to see if we just replaced one of the tag keys we Require'd
                     if (defined $key and $tagsUsed{$key}) {
                         foreach (@{$tagsUsed{$key}}) {
-                            $$_ = $self->{MOVED_KEY};   # replace with new tag key
+                            $$_ = $$self{MOVED_KEY};    # replace with new tag key
                         }
                         delete $tagsUsed{$key};         # can't be replaced again
                     }
@@ -2798,46 +2824,46 @@ sub Init($)
     my $self = shift;
     # delete all DataMember variables (lower-case names)
     foreach (keys %$self) {
-        /[a-z]/ and delete $self->{$_};
-    }
-    delete $self->{FOUND_TAGS};     # list of found tags
-    delete $self->{EXIF_DATA};      # the EXIF data block
-    delete $self->{EXIF_POS};       # EXIF position in file
-    delete $self->{FIRST_EXIF_POS}; # position of first EXIF in file
-    delete $self->{HTML_DUMP};      # html dump information
-    delete $self->{SET_GROUP0};     # group0 name override
-    delete $self->{SET_GROUP1};     # group1 name override
-    delete $self->{DOC_NUM};        # current embedded document number
-    $self->{DOC_COUNT}  = 0;        # count of embedded documents processed
-    $self->{BASE}       = 0;        # base for offsets from start of file
-    $self->{FILE_ORDER} = { };      # * hash of tag order in file ('*' = based on tag key)
-    $self->{VALUE}      = { };      # * hash of raw tag values
-    $self->{BOTH}       = { };      # * hash for Value/PrintConv values of Require'd tags
-    $self->{RATIONAL}   = { };      # * hash of original rational components
-    $self->{TAG_INFO}   = { };      # * hash of tag information
-    $self->{TAG_EXTRA}  = { };      # * hash of extra tag information (dynamic group names)
-    $self->{PRIORITY}   = { };      # * priority of current tags
-    $self->{LIST_TAGS}  = { };      # hash of tagInfo refs for active List-type tags
-    $self->{PROCESSED}  = { };      # hash of processed directory start positions
-    $self->{DIR_COUNT}  = { };      # count various types of directories
-    $self->{DUPL_TAG}   = { };      # last-used index for duplicate-tag keys
-    $self->{WARNED_ONCE}= { };      # WarnOnce() warnings already issued
-    $self->{PATH}       = [ ];      # current subdirectory path in file when reading
-    $self->{NUM_FOUND}  = 0;        # total number of tags found (incl. duplicates)
-    $self->{CHANGED}    = 0;        # number of tags changed (writer only)
-    $self->{INDENT}     = '  ';     # initial indent for verbose messages
-    $self->{PRIORITY_DIR} = '';     # the priority directory name
-    $self->{LOW_PRIORITY_DIR} = { PreviewIFD => 1 }; # names of priority 0 directories
-    $self->{TIFF_TYPE}  = '';       # type of TIFF data (APP1, TIFF, NEF, etc...)
-    $self->{Make}       = '';       # camera make
-    $self->{Model}      = '';       # camera model
-    $self->{CameraType} = '';       # Olympus camera type
+        /[a-z]/ and delete $$self{$_};
+    }
+    delete $$self{FOUND_TAGS};      # list of found tags
+    delete $$self{EXIF_DATA};       # the EXIF data block
+    delete $$self{EXIF_POS};        # EXIF position in file
+    delete $$self{FIRST_EXIF_POS};  # position of first EXIF in file
+    delete $$self{HTML_DUMP};       # html dump information
+    delete $$self{SET_GROUP0};      # group0 name override
+    delete $$self{SET_GROUP1};      # group1 name override
+    delete $$self{DOC_NUM};         # current embedded document number
+    $$self{DOC_COUNT}  = 0;         # count of embedded documents processed
+    $$self{BASE}       = 0;         # base for offsets from start of file
+    $$self{FILE_ORDER} = { };       # * hash of tag order in file ('*' = based on tag key)
+    $$self{VALUE}      = { };       # * hash of raw tag values
+    $$self{BOTH}       = { };       # * hash for Value/PrintConv values of Require'd tags
+    $$self{RATIONAL}   = { };       # * hash of original rational components
+    $$self{TAG_INFO}   = { };       # * hash of tag information
+    $$self{TAG_EXTRA}  = { };       # * hash of extra tag information (dynamic group names)
+    $$self{PRIORITY}   = { };       # * priority of current tags
+    $$self{LIST_TAGS}  = { };       # hash of tagInfo refs for active List-type tags
+    $$self{PROCESSED}  = { };       # hash of processed directory start positions
+    $$self{DIR_COUNT}  = { };       # count various types of directories
+    $$self{DUPL_TAG}   = { };       # last-used index for duplicate-tag keys
+    $$self{WARNED_ONCE}= { };       # WarnOnce() warnings already issued
+    $$self{PATH}       = [ ];       # current subdirectory path in file when reading
+    $$self{NUM_FOUND}  = 0;         # total number of tags found (incl. duplicates)
+    $$self{CHANGED}    = 0;         # number of tags changed (writer only)
+    $$self{INDENT}     = '  ';      # initial indent for verbose messages
+    $$self{PRIORITY_DIR} = '';      # the priority directory name
+    $$self{LOW_PRIORITY_DIR} = { PreviewIFD => 1 }; # names of priority 0 directories
+    $$self{TIFF_TYPE}  = '';        # type of TIFF data (APP1, TIFF, NEF, etc...)
+    $$self{Make}       = '';        # camera make
+    $$self{Model}      = '';        # camera model
+    $$self{CameraType} = '';        # Olympus camera type
     if ($self->Options('HtmlDump')) {
         require Image::ExifTool::HtmlDump;
-        $self->{HTML_DUMP} = new Image::ExifTool::HtmlDump;
+        $$self{HTML_DUMP} = new Image::ExifTool::HtmlDump;
     }
     # make sure our TextOut is a file reference
-    $self->{OPTIONS}{TextOut} = \*STDOUT unless ref $self->{OPTIONS}{TextOut};
+    $$self{OPTIONS}{TextOut} = \*STDOUT unless ref $$self{OPTIONS}{TextOut};
 }
 
 #------------------------------------------------------------------------------
@@ -2885,27 +2911,27 @@ sub Open(*$;$)
 sub ParseArguments($;@)
 {
     my $self = shift;
-    my $options = $self->{OPTIONS};
+    my $options = $$self{OPTIONS};
     my @exclude;
-    my @oldGroupOpts = grep /^Group/, keys %{$self->{OPTIONS}};
+    my @oldGroupOpts = grep /^Group/, keys %{$$self{OPTIONS}};
     my $wasExcludeOpt;
 
-    $self->{REQUESTED_TAGS}  = [ ];
-    $self->{REQ_TAG_LOOKUP}  = { };
-    $self->{EXCL_TAG_LOOKUP} = { };
-    $self->{IO_TAG_LIST} = undef;
+    $$self{REQUESTED_TAGS}  = [ ];
+    $$self{REQ_TAG_LOOKUP}  = { };
+    $$self{EXCL_TAG_LOOKUP} = { };
+    $$self{IO_TAG_LIST} = undef;
 
     # handle our input arguments
     while (@_) {
         my $arg = shift;
         if (ref $arg) {
             if (ref $arg eq 'ARRAY') {
-                $self->{IO_TAG_LIST} = $arg;
+                $$self{IO_TAG_LIST} = $arg;
                 foreach (@$arg) {
                     if (/^-(.*)/) {
                         push @exclude, $1;
                     } else {
-                        push @{$self->{REQUESTED_TAGS}}, $_;
+                        push @{$$self{REQUESTED_TAGS}}, $_;
                     }
                 }
             } elsif (ref $arg eq 'HASH') {
@@ -2914,7 +2940,7 @@ sub ParseArguments($;@)
                     # a single new group option overrides all old group options
                     if (@oldGroupOpts and $opt =~ /^Group/) {
                         foreach (@oldGroupOpts) {
-                            delete $options->{$_};
+                            delete $$options{$_};
                         }
                         undef @oldGroupOpts;
                     }
@@ -2922,7 +2948,7 @@ sub ParseArguments($;@)
                     $opt eq 'Exclude' and $wasExcludeOpt = 1;
                 }
             } elsif (ref $arg eq 'SCALAR' or UNIVERSAL::isa($arg,'GLOB')) {
-                next if defined $self->{RAF};
+                next if defined $$self{RAF};
                 # convert image data from UTF-8 to character stream if necessary
                 # (patches RHEL 3 UTF8 LANG problem)
                 if (ref $arg eq 'SCALAR' and $] >= 5.006 and
@@ -2932,45 +2958,45 @@ sub ParseArguments($;@)
                     my $buff = $@ ? pack('C*',unpack('U0C*',$$arg)) : Encode::encode('utf8',$$arg);
                     $arg = \$buff;
                 }
-                $self->{RAF} = new File::RandomAccess($arg);
+                $$self{RAF} = new File::RandomAccess($arg);
                 # set filename to empty string to indicate that
                 # we have a file but we didn't open it
-                $self->{FILENAME} = '';
+                $$self{FILENAME} = '';
             } elsif (UNIVERSAL::isa($arg, 'File::RandomAccess')) {
-                $self->{RAF} = $arg;
-                $self->{FILENAME} = '';
+                $$self{RAF} = $arg;
+                $$self{FILENAME} = '';
             } else {
                 warn "Don't understand ImageInfo argument $arg\n";
             }
-        } elsif (defined $self->{FILENAME}) {
+        } elsif (defined $$self{FILENAME}) {
             if ($arg =~ /^-(.*)/) {
                 push @exclude, $1;
             } else {
-                push @{$self->{REQUESTED_TAGS}}, $arg;
+                push @{$$self{REQUESTED_TAGS}}, $arg;
             }
         } else {
-            $self->{FILENAME} = $arg;
+            $$self{FILENAME} = $arg;
         }
     }
     # expand shortcuts in tag arguments if provided
-    if (@{$self->{REQUESTED_TAGS}}) {
-        ExpandShortcuts($self->{REQUESTED_TAGS});
+    if (@{$$self{REQUESTED_TAGS}}) {
+        ExpandShortcuts($$self{REQUESTED_TAGS});
         # initialize lookup for requested tags
-        foreach (@{$self->{REQUESTED_TAGS}}) {
-            /([-\w]+)#?$/ and $self->{REQ_TAG_LOOKUP}{lc($1)} = 1;
+        foreach (@{$$self{REQUESTED_TAGS}}) {
+            /([-\w]+)#?$/ and $$self{REQ_TAG_LOOKUP}{lc($1)} = 1;
         }
     }
     if (@exclude or $wasExcludeOpt) {
         # must add existing excluded tags
-        push @exclude, @{$options->{Exclude}} if $options->{Exclude};
-        $options->{Exclude} = \@exclude;
+        push @exclude, @{$$options{Exclude}} if $$options{Exclude};
+        $$options{Exclude} = \@exclude;
         # expand shortcuts in new exclude list
-        ExpandShortcuts($options->{Exclude}, 1); # (also remove '#' suffix)
+        ExpandShortcuts($$options{Exclude}, 1); # (also remove '#' suffix)
     }
     # generate lookup for excluded tags
-    if ($options->{Exclude}) {
-        foreach (@{$options->{Exclude}}) {
-            /([-\w]+)#?$/ and $self->{EXCL_TAG_LOOKUP}{lc($1)} = 1;
+    if ($$options{Exclude}) {
+        foreach (@{$$options{Exclude}}) {
+            /([-\w]+)#?$/ and $$self{EXCL_TAG_LOOKUP}{lc($1)} = 1;
         }
     }
 }
@@ -3033,11 +3059,11 @@ sub GroupMatches($$$)
 sub SetFoundTags($)
 {
     my $self = shift;
-    my $options = $self->{OPTIONS};
-    my $reqTags = $self->{REQUESTED_TAGS} || [ ];
-    my $duplicates = $options->{Duplicates};
-    my $exclude = $options->{Exclude};
-    my $fileOrder = $self->{FILE_ORDER};
+    my $options = $$self{OPTIONS};
+    my $reqTags = $$self{REQUESTED_TAGS} || [ ];
+    my $duplicates = $$options{Duplicates};
+    my $exclude = $$options{Exclude};
+    my $fileOrder = $$self{FILE_ORDER};
     my @groupOptions = sort grep /^Group/, keys %$options;
     my $doDups = $duplicates || $exclude || @groupOptions;
     my ($tag, $rtnTags, @byValue, @wildTags);
@@ -3062,7 +3088,7 @@ sub SetFoundTags($)
                 $tag = $reqTag;
             }
             $byValue = 1 if $tag =~ s/#$// and $$options{PrintConv};
-            if (defined $tagHash->{$reqTag} and not $doDups) {
+            if (defined $$tagHash{$reqTag} and not $doDups) {
                 $matches[0] = $tag;
             } elsif ($tag =~ /^(\*|all)$/i) {
                 # tag name of '*' or 'all' matches all tags
@@ -3104,9 +3130,9 @@ sub SetFoundTags($)
                 # return only the highest priority tag unless duplicates wanted
                 unless ($doDups or $allTag or $allGrp) {
                     $tag = shift @matches;
-                    my $oldPriority = $self->{PRIORITY}{$tag} || 1;
+                    my $oldPriority = $$self{PRIORITY}{$tag} || 1;
                     foreach (@matches) {
-                        my $priority = $self->{PRIORITY}{$_};
+                        my $priority = $$self{PRIORITY}{$_};
                         $priority = 1 unless defined $priority;
                         next unless $priority >= $oldPriority;
                         $tag = $_;
@@ -3118,7 +3144,7 @@ sub SetFoundTags($)
                 # put entry in return list even without value (value is undef)
                 $matches[0] = $byValue ? "$tag #(0)" : "$tag (0)";
                 # bogus file order entry to avoid warning if sorting in file order
-                $self->{FILE_ORDER}{$matches[0]} = 9999;
+                $$self{FILE_ORDER}{$matches[0]} = 9999;
             }
             # save indices of tags extracted by value
             push @byValue, scalar(@$rtnTags) .. (scalar(@$rtnTags)+scalar(@matches)-1) if $byValue;
@@ -3185,10 +3211,10 @@ sub SetFoundTags($)
             $family = $1 || 0;
             $wantGroup{$family} or $wantGroup{$family} = { };
             my $groupList;
-            if (ref $options->{$groupOpt} eq 'ARRAY') {
-                $groupList = $options->{$groupOpt};
+            if (ref $$options{$groupOpt} eq 'ARRAY') {
+                $groupList = $$options{$groupOpt};
             } else {
-                $groupList = [ $options->{$groupOpt} ];
+                $groupList = [ $$options{$groupOpt} ];
             }
             foreach (@$groupList) {
                 # groups have priority in order they were specified
@@ -3250,7 +3276,7 @@ GR_TAG: foreach $tag (@$rtnTags) {
         $rtnTags = \@tags;
         last;
     }
-    $self->{FOUND_TAGS} = $rtnTags;     # save found tags
+    $$self{FOUND_TAGS} = $rtnTags;      # save found tags
 
     # return reference to found tag keys (and list of indices of tags to extract by value)
     return wantarray ? ($rtnTags, \@byValue, \@wildTags) : $rtnTags;
@@ -3302,7 +3328,7 @@ sub Warn($$;$)
 {
     my ($self, $str, $ignorable) = @_;
     if ($ignorable) {
-        return 0 if $self->{OPTIONS}{IgnoreMinorErrors};
+        return 0 if $$self{OPTIONS}{IgnoreMinorErrors};
         $str = $ignorable eq '2' ? "[Minor] $str" : "[minor] $str";
     }
     $self->FoundTag('Warning', $str);
@@ -3316,7 +3342,7 @@ sub Warn($$;$)
 sub WarnOnce($$;$)
 {
     my ($self, $str, $ignorable) = @_;
-    return 0 if $ignorable and $self->{OPTIONS}{IgnoreMinorErrors};
+    return 0 if $ignorable and $$self{OPTIONS}{IgnoreMinorErrors};
     unless ($$self{WARNED_ONCE}{$str}) {
         $self->Warn($str, $ignorable);
         $$self{WARNED_ONCE}{$str} = 1;
@@ -3331,11 +3357,11 @@ sub WarnOnce($$;$)
 sub Error($$;$)
 {
     my ($self, $str, $ignorable) = @_;
-    if ($ignorable) {
-        if ($self->{OPTIONS}{IgnoreMinorErrors}) {
-            $self->Warn($str);
-            return 0;
-        }
+    if ($$self{DemoteErrors}) {
+        $self->Warn($str) and ++$$self{DemoteErrors};
+        return 1;
+    } elsif ($ignorable) {
+        $$self{OPTIONS}{IgnoreMinorErrors} and $self->Warn($str), return 0;
         $str = "[minor] $str";
     }
     $self->FoundTag('Error', $str);
@@ -3461,9 +3487,9 @@ sub AddCompositeTags($;$)
 
     # make sure default groups are defined in families 0 and 1
     if ($defaultGroups) {
-        $defaultGroups->{0} or $defaultGroups->{0} = 'Composite';
-        $defaultGroups->{1} or $defaultGroups->{1} = 'Composite';
-        $defaultGroups->{2} or $defaultGroups->{2} = 'Other';
+        $$defaultGroups{0} or $$defaultGroups{0} = 'Composite';
+        $$defaultGroups{1} or $$defaultGroups{1} = 'Composite';
+        $$defaultGroups{2} or $$defaultGroups{2} = 'Other';
     } else {
         $defaultGroups = $$add{GROUPS} = { 0 => 'Composite', 1 => 'Composite', 2 => 'Other' };
     }
@@ -4059,7 +4085,7 @@ sub ValidateImage($$$)
             $self->Options('IgnoreMinorErrors'))
     {
         # issue warning only if the tag was specifically requested
-        if ($self->{REQ_TAG_LOOKUP}{lc GetTagName($tag)}) {
+        if ($$self{REQ_TAG_LOOKUP}{lc GetTagName($tag)}) {
             $self->Warn("$tag is not a valid JPEG image",1);
             return undef;
         }
@@ -4118,7 +4144,7 @@ sub Printable($;$)
     return '(undef)' unless defined $outStr;
     $outStr =~ tr/\x01-\x1f\x7f-\xff/./;
     $outStr =~ s/\x00//g;
-    my $verbose = $self->{OPTIONS}{Verbose};
+    my $verbose = $$self{OPTIONS}{Verbose};
     if ($verbose < 4) {
         if ($maxLen) {
             $maxLen = 20 if $maxLen < 20;   # minimum length is 20
@@ -4145,8 +4171,8 @@ sub Printable($;$)
 sub ConvertDateTime($$)
 {
     my ($self, $date) = @_;
-    my $dateFormat = $self->{OPTIONS}{DateFormat};
-    my $shift = $self->{OPTIONS}{GlobalTimeShift};
+    my $dateFormat = $$self{OPTIONS}{DateFormat};
+    my $shift = $$self{OPTIONS}{GlobalTimeShift};
     if ($shift) {
         my $dir = ($shift =~ s/^([-+])// and $1 eq '-') ? -1 : 1;
         require 'Image/ExifTool/Shift.pl';
@@ -4165,7 +4191,7 @@ sub ConvertDateTime($$)
         if (@a and $a[0] >= 1000 and $a[0] < 3000 and eval 'require POSIX') {
             $date = POSIX::strftime($dateFormat, $a[5]||0, $a[4]||0, $a[3]||0,
                                                  $a[2]||1, ($a[1]||1)-1, $a[0]-1900);
-        } elsif ($self->{OPTIONS}{StrictDate}) {
+        } elsif ($$self{OPTIONS}{StrictDate}) {
             undef $date;
         }
     }
@@ -4327,6 +4353,11 @@ sub ConvertDuration($)
     $time -= $h * 3600;
     my $m = int($time / 60);
     $time -= $m * 60;
+    if ($h > 24) {
+        my $d = int($h / 24);
+        $h -= $d * 24;
+        $sign = "$sign$d days ";
+    }
     return sprintf("$sign%d:%.2d:%.2d", $h, $m, int($time));
 }
 
@@ -4358,7 +4389,7 @@ sub HDump($$$$;$$)
     if ($$self{HTML_DUMP}) {
         my $pos = shift;
         $pos += $$self{BASE} if $$self{BASE};
-        $self->{HTML_DUMP}->Add($pos, @_);
+        $$self{HTML_DUMP}->Add($pos, @_);
     }
 }
 
@@ -4555,11 +4586,11 @@ sub ProcessJPEG($$)
     local $_;
     my ($self, $dirInfo) = @_;
     my ($ch, $s, $length);
-    my $verbose = $self->{OPTIONS}{Verbose};
-    my $out = $self->{OPTIONS}{TextOut};
-    my $fast = $self->{OPTIONS}{FastScan};
+    my $verbose = $$self{OPTIONS}{Verbose};
+    my $out = $$self{OPTIONS}{TextOut};
+    my $fast = $$self{OPTIONS}{FastScan};
     my $raf = $$dirInfo{RAF};
-    my $htmlDump = $self->{HTML_DUMP};
+    my $htmlDump = $$self{HTML_DUMP};
     my %dumpParms = ( Out => $out );
     my ($success, $wantTrailer, $trailInfo);
     my (@iccChunk, $iccChunkCount, $iccChunksTotal, @flirChunk, $flirCount, $flirTotal);
@@ -4697,7 +4728,7 @@ sub ProcessJPEG($$)
                     # (and Minolta and Sony previews can have a random first byte...)
                     my $scanLen = $$self{Make} =~ /Sony/i ? 65536 : 1024;
                     if ($raf->Read($buff, $scanLen) and ($buff =~ /\xff\xd8\xff./g or
-                        ($self->{Make} =~ /(Minolta|Sony)/i and $buff =~ /.\xd8\xff\xdb/g)))
+                        ($$self{Make} =~ /(Minolta|Sony)/i and $buff =~ /.\xd8\xff\xdb/g)))
                     {
                         # adjust PreviewImageStart to this location
                         my $actual = $pos + pos($buff) - 4;
@@ -4705,7 +4736,7 @@ sub ProcessJPEG($$)
                             print $out "(Fixed PreviewImage location: $start -> $actual)\n";
                         }
                         # update preview image offsets
-                        $self->{VALUE}{PreviewImageStart} = $actual if $self->{VALUE}{PreviewImageStart};
+                        $$self{VALUE}{PreviewImageStart} = $actual if $$self{VALUE}{PreviewImageStart};
                         $$self{PreviewImageStart} = $actual;
                         # load preview now if we tried and failed earlier
                         if ($$self{PreviewError} and $$self{PreviewImageLength}) {
@@ -4799,7 +4830,7 @@ sub ProcessJPEG($$)
             #  because we aren't checking the RequestAll API option here.
             #  The reason is that there is too much overhead involved in
             #  the calculation of this tag to make this worth the CPU time.)
-            $self->{REQ_TAG_LOOKUP}{jpegdigest})
+            $$self{REQ_TAG_LOOKUP}{jpegdigest})
         {
             my $num = unpack('C',$$segDataPt) & 0x0f;   # get table index
             $dqt[$num] = $$segDataPt if $num < 4;       # save for MD5 calculation
@@ -4836,12 +4867,12 @@ sub ProcessJPEG($$)
                 next if $fast and $fast > 1;    # skip processing for very fast
                 $dumpType = 'CIFF';
                 my %dirInfo = ( RAF => new File::RandomAccess($segDataPt) );
-                $self->{SET_GROUP1} = 'CIFF';
-                push @{$self->{PATH}}, 'CIFF';
+                $$self{SET_GROUP1} = 'CIFF';
+                push @{$$self{PATH}}, 'CIFF';
                 require Image::ExifTool::CanonRaw;
                 Image::ExifTool::CanonRaw::ProcessCRW($self, \%dirInfo);
-                pop @{$self->{PATH}};
-                delete $self->{SET_GROUP1};
+                pop @{$$self{PATH}};
+                delete $$self{SET_GROUP1};
             } elsif ($$segDataPt =~ /^(AVI1|Ocad)/) {
                 $dumpType = $1;
                 SetByteOrder('MM');
@@ -4892,10 +4923,10 @@ sub ProcessJPEG($$)
                     $plen = $$self{PreviewImageLength};
                 }
                 if ($start and $plen and IsInt($start) and IsInt($plen) and
-                    $start + $plen > $self->{EXIF_POS} + length($self->{EXIF_DATA}) and
-                    ($self->{REQ_TAG_LOOKUP}{previewimage} or
+                    $start + $plen > $$self{EXIF_POS} + length($$self{EXIF_DATA}) and
+                    ($$self{REQ_TAG_LOOKUP}{previewimage} or
                     # (extracted normally, so check Binary option)
-                    ($self->{OPTIONS}{Binary} and not $self->{EXCL_TAG_LOOKUP}{previewimage})))
+                    ($$self{OPTIONS}{Binary} and not $$self{EXCL_TAG_LOOKUP}{previewimage})))
                 {
                     $$self{PreviewImageStart} = $start;
                     $$self{PreviewImageLength} = $plen;
@@ -5248,8 +5279,29 @@ sub ProcessJPEG($$)
                 );
                 $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
             }
-        } elsif ($marker == 0xe7) {         # APP7 (Qualcomm)
-            if ($$segDataPt =~ /^\x1aQualcomm Camera Attributes/) {
+        } elsif ($marker == 0xe7) {         # APP7 (Pentax, Qualcomm)
+            if ($$segDataPt =~ /^PENTAX \0(II|MM)/) {
+                # found in K-3 images (is this multi-segment??)
+                SetByteOrder($1);
+                undef $dumpType; # (dump this ourself)
+                my $hdrLen = 10;
+                my $tagTablePtr = GetTagTable('Image::ExifTool::Pentax::Main');
+                my %dirInfo = (
+                    Parent   => $markerName,
+                    DataPt   => $segDataPt,
+                    DataLen  => $length,
+                    DataPos  => 0, # (remember: relative to Base!)
+                    DirStart => $hdrLen,
+                    Base     => $segPos,
+                    DirName  => 'Pentax APP7',
+                );
+                if ($htmlDump) {
+                    $self->HDump($segPos-4, 4, 'APP7 header', "Data size: $length bytes");
+                    $self->HDump($segPos, $hdrLen, 'Pentax header', 'APP7 data type: Pentax');
+                    $dumpEnd = $segPos + $length;
+                }
+                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            } elsif ($$segDataPt =~ /^\x1aQualcomm Camera Attributes/) {
                 # found in HP iPAQ_VoiceMessenger
                 $dumpType = 'Qualcomm';
                 my $tagTablePtr = GetTagTable('Image::ExifTool::Qualcomm::Main');
@@ -5386,7 +5438,7 @@ sub ProcessJPEG($$)
             undef $dumpType;    # only dump unknown APP segments
         }
         if (defined $dumpType) {
-            if (not $dumpType and $self->{OPTIONS}{Unknown}) {
+            if (not $dumpType and $$self{OPTIONS}{Unknown}) {
                 $self->Warn("Unknown $markerName segment", 1);
             }
             if ($htmlDump) {
@@ -5454,7 +5506,7 @@ sub DoProcessTIFF($$;$)
     my ($err, $canonSig, $otherSig);
 
     # attempt to read TIFF header
-    $self->{EXIF_DATA} = '';
+    $$self{EXIF_DATA} = '';
     if ($raf) {
         if ($outfile) {
             $raf->Seek(0, 0) or return 0;
@@ -5467,17 +5519,17 @@ sub DoProcessTIFF($$;$)
         }
         # extract full EXIF block (for block copy) from EXIF file
         my $amount = $fileType eq 'EXIF' ? 65536 * 8 : 8;
-        my $n = $raf->Read($self->{EXIF_DATA}, $amount);
+        my $n = $raf->Read($$self{EXIF_DATA}, $amount);
         if ($n < 8) {
             return 0 if $n or not $outfile or $fileType ne 'EXIF';
             # create EXIF file from scratch
-            delete $self->{EXIF_DATA};
+            delete $$self{EXIF_DATA};
             undef $raf;
         }
         if ($n > 8) {
             $raf->Seek(8, 0);
             if ($n == $amount) {
-                $self->{EXIF_DATA} = substr($self->{EXIF_DATA}, 0, 8);
+                $$self{EXIF_DATA} = substr($$self{EXIF_DATA}, 0, 8);
                 $self->Warn('EXIF too large to extract as a block'); #(shouldn't happen)
             }
         }
@@ -5485,24 +5537,24 @@ sub DoProcessTIFF($$;$)
         # save a copy of the EXIF data
         my $dirStart = $$dirInfo{DirStart} || 0;
         my $dirLen = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
-        $self->{EXIF_DATA} = substr($$dataPt, $dirStart, $dirLen);
-        $self->VerboseDir('TIFF') if $self->{OPTIONS}{Verbose} and length($$self{INDENT}) > 2;
+        $$self{EXIF_DATA} = substr($$dataPt, $dirStart, $dirLen);
+        $self->VerboseDir('TIFF') if $$self{OPTIONS}{Verbose} and length($$self{INDENT}) > 2;
     } elsif ($outfile) {
-        delete $self->{EXIF_DATA};  # create from scratch
+        delete $$self{EXIF_DATA};  # create from scratch
     } else {
-        $self->{EXIF_DATA} = '';
+        $$self{EXIF_DATA} = '';
     }
-    unless (defined $self->{EXIF_DATA}) {
+    unless (defined $$self{EXIF_DATA}) {
         # create TIFF information from scratch
         if ($self->SetPreferredByteOrder() eq 'MM') {
-            $self->{EXIF_DATA} = "MM\0\x2a\0\0\0\x08";
+            $$self{EXIF_DATA} = "MM\0\x2a\0\0\0\x08";
         } else {
-            $self->{EXIF_DATA} = "II\x2a\0\x08\0\0\0";
+            $$self{EXIF_DATA} = "II\x2a\0\x08\0\0\0";
         }
     }
     $$self{FIRST_EXIF_POS} = $base + $$self{BASE} unless defined $$self{FIRST_EXIF_POS};
     $$self{EXIF_POS} = $base + $$self{BASE};
-    $dataPt = \$self->{EXIF_DATA};
+    $dataPt = \$$self{EXIF_DATA};
 
     # set byte ordering
     my $byteOrder = substr($$dataPt,0,2);
@@ -5527,7 +5579,7 @@ sub DoProcessTIFF($$;$)
             $$dataPt .= $canonSig;
             if ($canonSig =~ /^(CR\x02\0|\xba\xb0\xac\xbb)/) {
                 $fileType = $canonSig =~ /^CR/ ? 'CR2' : 'Canon 1D RAW';
-                $self->HDump($base+8, 8, "[$fileType header]") if $self->{HTML_DUMP};
+                $self->HDump($base+8, 8, "[$fileType header]") if $$self{HTML_DUMP};
             } else {
                 undef $canonSig;
             }
@@ -5567,7 +5619,7 @@ sub DoProcessTIFF($$;$)
             }
         }
         # we have a valid TIFF (or whatever) file
-        if ($fileType and not $self->{VALUE}{FileType}) {
+        if ($fileType and not $$self{VALUE}{FileType}) {
             my $lookup = $fileTypeLookup{$fileType};
             $lookup = $fileTypeLookup{$lookup} unless ref $lookup or not $lookup;
             # use file extension to pre-determine type if extension is TIFF-based or type is RAW
@@ -5582,13 +5634,13 @@ sub DoProcessTIFF($$;$)
     } else {
         $ifdName = $$tagTablePtr{GROUPS}{1};
     }
-    if ($self->{HTML_DUMP}) {
+    if ($$self{HTML_DUMP}) {
         my $tip = sprintf("Byte order: %s endian\nIdentifier: 0x%.4x\n$ifdName offset: 0x%.4x",
                           ($byteOrder eq 'II') ? 'Little' : 'Big', $identifier, $offset);
         $self->HDump($base, 8, 'TIFF header', $tip, 0);
     }
     # remember where we found the TIFF data (APP1, APP3, TIFF, NEF, etc...)
-    $self->{TIFF_TYPE} = $fileType;
+    $$self{TIFF_TYPE} = $fileType;
 
     # get reference to the main EXIF table
     $tagTablePtr or $tagTablePtr = GetTagTable('Image::ExifTool::Exif::Main');
@@ -5613,7 +5665,7 @@ sub DoProcessTIFF($$;$)
         # process the directory
         $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
         # process GeoTiff information if available
-        if ($self->{VALUE}{GeoTiffDirectory}) {
+        if ($$self{VALUE}{GeoTiffDirectory}) {
             require Image::ExifTool::GeoTiff;
             Image::ExifTool::GeoTiff::ProcessGeoTiff($self);
         }
@@ -5634,7 +5686,7 @@ sub DoProcessTIFF($$;$)
            }
         }
         # update FileType if necessary now that we know more about the file
-        if ($$self{DNGVersion} and $self->{VALUE}{FileType} ne 'DNG') {
+        if ($$self{DNGVersion} and $$self{VALUE}{FileType} ne 'DNG') {
             # override whatever FileType we set since we now know it is DNG
             $self->OverrideFileType('DNG');
         }
@@ -5644,10 +5696,10 @@ sub DoProcessTIFF($$;$)
 # rewrite the image
 #
     if ($$dirInfo{NoTiffEnd}) {
-        delete $self->{TIFF_END};
+        delete $$self{TIFF_END};
     } else {
         # initialize TIFF_END so it will be updated by WriteExif()
-        $self->{TIFF_END} = 0;
+        $$self{TIFF_END} = 0;
     }
     if ($canonSig) {
         # write Canon CR2 specially because it has a header we want to preserve,
@@ -5697,8 +5749,8 @@ sub DoProcessTIFF($$;$)
         }
     }
     # make local copy of TIFF_END now (it may be reset when processing trailers)
-    my $tiffEnd = $self->{TIFF_END};
-    delete $self->{TIFF_END};
+    my $tiffEnd = $$self{TIFF_END};
+    delete $$self{TIFF_END};
 
     # rewrite trailers if they exist
     if ($raf and $tiffEnd and not $err) {
@@ -5732,9 +5784,9 @@ sub DoProcessTIFF($$;$)
         }
         if ($extra > 0) {
             my $known = $$self{KnownTrailer};
-            if ($self->{DEL_GROUP}{Trailer} and not $known) {
+            if ($$self{DEL_GROUP}{Trailer} and not $known) {
                 $self->VPrint(0, "  Deleting unknown trailer ($extra bytes)\n");
-                ++$self->{CHANGED};
+                ++$$self{CHANGED};
             } elsif ($known) {
                 $self->VPrint(0, "  Copying $$known{Name} ($extra bytes)\n");
                 $raf->Seek($tiffEnd, 0) or $err = 1;
@@ -5913,26 +5965,26 @@ sub ProcessDirectory($$$;$)
         ($$dirInfo{DirLen} or not defined $$dirInfo{DirLen}))
     {
         my $addr = $$dirInfo{DirStart} + $$dirInfo{DataPos} + ($$dirInfo{Base}||0);
-        if ($self->{PROCESSED}{$addr}) {
-            $self->Warn("$dirName pointer references previous $self->{PROCESSED}{$addr} directory");
+        if ($$self{PROCESSED}{$addr}) {
+            $self->Warn("$dirName pointer references previous $$self{PROCESSED}{$addr} directory");
             return 0;
         }
-        $self->{PROCESSED}{$addr} = $dirName;
+        $$self{PROCESSED}{$addr} = $dirName;
     }
     my $oldOrder = GetByteOrder();
-    my $oldIndent = $self->{INDENT};
-    my $oldDir = $self->{DIR_NAME};
-    $self->{LIST_TAGS} = { };  # don't build lists across different directories
-    $self->{INDENT} .= '| ';
-    $self->{DIR_NAME} = $dirName;
-    push @{$self->{PATH}}, $dirName;
+    my $oldIndent = $$self{INDENT};
+    my $oldDir = $$self{DIR_NAME};
+    $$self{LIST_TAGS} = { };    # don't build lists across different directories
+    $$self{INDENT} .= '| ';
+    $$self{DIR_NAME} = $dirName;
+    push @{$$self{PATH}}, $dirName;
 
     # process the directory
     my $rtnVal = &$proc($self, $dirInfo, $tagTablePtr);
 
-    pop @{$self->{PATH}};
-    $self->{INDENT} = $oldIndent;
-    $self->{DIR_NAME} = $oldDir;
+    pop @{$$self{PATH}};
+    $$self{INDENT} = $oldIndent;
+    $$self{DIR_NAME} = $oldDir;
     SetByteOrder($oldOrder);
     return $rtnVal;
 }
@@ -6074,8 +6126,8 @@ sub AddTagToTable($$;$$)
     if ($$tagInfo{Groups}) {
         # fill in default groups from table GROUPS
         foreach (keys %{$$tagTablePtr{GROUPS}}) {
-            next if $tagInfo->{Groups}{$_};
-            $tagInfo->{Groups}{$_} = $tagTablePtr->{GROUPS}{$_};
+            next if $$tagInfo{Groups}{$_};
+            $$tagInfo{Groups}{$_} = $$tagTablePtr{GROUPS}{$_};
         }
     } else {
         $$tagInfo{Groups} = { %{$$tagTablePtr{GROUPS}} };
@@ -6122,7 +6174,7 @@ sub AddTagToTable($$;$$)
 sub HandleTag($$$$;%)
 {
     my ($self, $tagTablePtr, $tag, $val, %parms) = @_;
-    my $verbose = $self->{OPTIONS}{Verbose};
+    my $verbose = $$self{OPTIONS}{Verbose};
     my $tagInfo = $parms{TagInfo} || $self->GetTagInfo($tagTablePtr, $tag, \$val);
     my $dataPt = $parms{DataPt};
     my ($subdir, $format, $count, $size, $noTagInfo, $rational);
@@ -6228,15 +6280,15 @@ sub FoundTag($$$)
         # make temporary hash if tag doesn't exist in Extra
         # (not advised to do this since the tag won't show in list)
         $tagInfo or $tagInfo = { Name => $tag, Groups => \%allGroupsExifTool };
-        $self->{OPTIONS}{Verbose} and $self->VerboseInfo(undef, $tagInfo, Value => $value);
+        $$self{OPTIONS}{Verbose} and $self->VerboseInfo(undef, $tagInfo, Value => $value);
     }
     # get tag priority
     my $priority = $$tagInfo{Priority};
     unless (defined $priority) {
-        $priority = $tagInfo->{Table}{PRIORITY};
+        $priority = $$tagInfo{Table}{PRIORITY};
         $priority = 0 if not defined $priority and $$tagInfo{Avoid};
     }
-    my $valueHash = $self->{VALUE};
+    my $valueHash = $$self{VALUE};
     if ($$tagInfo{RawConv}) {
         # initialize @val for use in Composite RawConv expressions
         my @val;
@@ -6261,14 +6313,14 @@ sub FoundTag($$$)
     # handle duplicate tag names
     if (defined $$valueHash{$tag}) {
         # add to list if there is an active list for this tag
-        if ($self->{LIST_TAGS}{$tagInfo}) {
-            $tag = $self->{LIST_TAGS}{$tagInfo};  # use key from previous list tag
+        if ($$self{LIST_TAGS}{$tagInfo}) {
+            $tag = $$self{LIST_TAGS}{$tagInfo}; # use key from previous list tag
             if (defined $$self{NO_LIST}) {
                 # accumulate list in TAG_EXTRA "NoList" element
-                if (defined $self->{TAG_EXTRA}{$tag}{NoList}) {
-                    push @{$self->{TAG_EXTRA}{$tag}{NoList}}, $value;
+                if (defined $$self{TAG_EXTRA}{$tag}{NoList}) {
+                    push @{$$self{TAG_EXTRA}{$tag}{NoList}}, $value;
                 } else {
-                    $self->{TAG_EXTRA}{$tag}{NoList} = [ $$valueHash{$tag}, $value ];
+                    $$self{TAG_EXTRA}{$tag}{NoList} = [ $$valueHash{$tag}, $value ];
                 }
                 $noListDel = 1; # set flag to delete this tag if re-listed
             } else {
@@ -6280,17 +6332,17 @@ sub FoundTag($$$)
             }
         }
         # get next available tag key
-        my $nextInd = $self->{DUPL_TAG}{$tag} = ($self->{DUPL_TAG}{$tag} || 0) + 1;
+        my $nextInd = $$self{DUPL_TAG}{$tag} = ($$self{DUPL_TAG}{$tag} || 0) + 1;
         my $nextTag = "$tag ($nextInd)";
 #
 # take tag with highest priority
 #
         # promote existing 0-priority tag so it takes precedence over a new 0-tag
         # (unless old tag was a sub-document and new tag isn't)
-        my $oldPriority = $self->{PRIORITY}{$tag};
+        my $oldPriority = $$self{PRIORITY}{$tag};
         unless ($oldPriority) {
-            if ($self->{DOC_NUM} or not $self->{TAG_EXTRA}{$tag} or
-                                    not $self->{TAG_EXTRA}{$tag}{G3})
+            if ($$self{DOC_NUM} or not $$self{TAG_EXTRA}{$tag} or
+                                   not $$self{TAG_EXTRA}{$tag}{G3})
             {
                 $oldPriority = 1;
             } else {
@@ -6307,55 +6359,55 @@ sub FoundTag($$$)
         } else {
             $priority = 1;  # the normal default
         }
-        if ($priority >= $oldPriority and not $self->{DOC_NUM} and not $noListDel) {
+        if ($priority >= $oldPriority and not $$self{DOC_NUM} and not $noListDel) {
             # move existing tag out of the way since this tag is higher priority
             # (NOTE: any new members added here must also be added to DeleteTag())
-            $self->{MOVED_KEY} = $nextTag;  # used in BuildCompositeTags()
-            $self->{PRIORITY}{$nextTag} = $self->{PRIORITY}{$tag};
+            $$self{MOVED_KEY} = $nextTag;  # used in BuildCompositeTags()
+            $$self{PRIORITY}{$nextTag} = $$self{PRIORITY}{$tag};
             $$valueHash{$nextTag} = $$valueHash{$tag};
-            $self->{FILE_ORDER}{$nextTag} = $self->{FILE_ORDER}{$tag};
-            my $oldInfo = $self->{TAG_INFO}{$nextTag} = $self->{TAG_INFO}{$tag};
+            $$self{FILE_ORDER}{$nextTag} = $$self{FILE_ORDER}{$tag};
+            my $oldInfo = $$self{TAG_INFO}{$nextTag} = $$self{TAG_INFO}{$tag};
             foreach ('TAG_EXTRA','RATIONAL') {
-                if ($self->{$_}{$tag}) {
-                    $self->{$_}{$nextTag} = $self->{$_}{$tag};
-                    delete $self->{$_}{$tag};
+                if ($$self{$_}{$tag}) {
+                    $$self{$_}{$nextTag} = $$self{$_}{$tag};
+                    delete $$self{$_}{$tag};
                 }
             }
-            delete $self->{BOTH}{$tag};
+            delete $$self{BOTH}{$tag};
             # update tag key for list if necessary
-            $self->{LIST_TAGS}{$oldInfo} = $nextTag if $self->{LIST_TAGS}{$oldInfo};
+            $$self{LIST_TAGS}{$oldInfo} = $nextTag if $$self{LIST_TAGS}{$oldInfo};
         } else {
             $tag = $nextTag;        # don't override the existing tag
         }
-        $self->{PRIORITY}{$tag} = $priority;
-        $self->{TAG_EXTRA}{$tag}{NoListDel} = 1 if $noListDel;
+        $$self{PRIORITY}{$tag} = $priority;
+        $$self{TAG_EXTRA}{$tag}{NoListDel} = 1 if $noListDel;
     } elsif ($priority) {
         # set tag priority (only if exists and is non-zero)
-        $self->{PRIORITY}{$tag} = $priority;
+        $$self{PRIORITY}{$tag} = $priority;
     }
 
     # save the raw value, file order, tagInfo ref, group1 name,
     # and tag key for lists if necessary
     $$valueHash{$tag} = $value;
-    $self->{FILE_ORDER}{$tag} = ++$self->{NUM_FOUND};
-    $self->{TAG_INFO}{$tag} = $tagInfo;
+    $$self{FILE_ORDER}{$tag} = ++$$self{NUM_FOUND};
+    $$self{TAG_INFO}{$tag} = $tagInfo;
     # set dynamic groups 0, 1 and 3 if necessary
-    $self->{TAG_EXTRA}{$tag}{G0} = $self->{SET_GROUP0} if $self->{SET_GROUP0};
-    $self->{TAG_EXTRA}{$tag}{G1} = $self->{SET_GROUP1} if $self->{SET_GROUP1};
-    if ($self->{DOC_NUM}) {
-        $self->{TAG_EXTRA}{$tag}{G3} = $self->{DOC_NUM};
-        if ($self->{DOC_NUM} =~ /^(\d+)/) {
+    $$self{TAG_EXTRA}{$tag}{G0} = $$self{SET_GROUP0} if $$self{SET_GROUP0};
+    $$self{TAG_EXTRA}{$tag}{G1} = $$self{SET_GROUP1} if $$self{SET_GROUP1};
+    if ($$self{DOC_NUM}) {
+        $$self{TAG_EXTRA}{$tag}{G3} = $$self{DOC_NUM};
+        if ($$self{DOC_NUM} =~ /^(\d+)/) {
             # keep track of maximum 1st-level sub-document number
-            $self->{DOC_COUNT} = $1 unless $self->{DOC_COUNT} >= $1;
+            $$self{DOC_COUNT} = $1 unless $$self{DOC_COUNT} >= $1;
         }
     }
     # save path if requested
-    $self->{TAG_EXTRA}{$tag}{G5} = $self->MetadataPath() if $self->{OPTIONS}{SavePath};
+    $$self{TAG_EXTRA}{$tag}{G5} = $self->MetadataPath() if $$self{OPTIONS}{SavePath};
 
     # remember this tagInfo if we will be accumulating values in a list
     # (but don't override earlier list if this may be deleted by NoListDel flag)
     if ($$tagInfo{List} and not $$self{NO_LIST} and not $noListDel) {
-        $self->{LIST_TAGS}{$tagInfo} = $tag;
+        $$self{LIST_TAGS}{$tagInfo} = $tag;
     }
 
     return $tag;
@@ -6367,7 +6419,7 @@ sub FoundTag($$$)
 sub SetPriorityDir($)
 {
     my $self = shift;
-    $self->{PRIORITY_DIR} = $self->{DIR_NAME} unless $self->{PRIORITY_DIR};
+    $$self{PRIORITY_DIR} = $$self{DIR_NAME} unless $$self{PRIORITY_DIR};
 }
 
 #------------------------------------------------------------------------------
@@ -6376,7 +6428,7 @@ sub SetPriorityDir($)
 sub SetGroup($$$;$)
 {
     my ($self, $tagKey, $extra, $fam) = @_;
-    $self->{TAG_EXTRA}{$tagKey}{defined $fam ? "G$fam" : 'G1'} = $extra;
+    $$self{TAG_EXTRA}{$tagKey}{defined $fam ? "G$fam" : 'G1'} = $extra;
 }
 
 #------------------------------------------------------------------------------
@@ -6385,13 +6437,13 @@ sub SetGroup($$$;$)
 sub DeleteTag($$)
 {
     my ($self, $tag) = @_;
-    delete $self->{VALUE}{$tag};
-    delete $self->{FILE_ORDER}{$tag};
-    delete $self->{TAG_INFO}{$tag};
-    delete $self->{TAG_EXTRA}{$tag};
-    delete $self->{PRIORITY}{$tag};
-    delete $self->{RATIONAL}{$tag};
-    delete $self->{BOTH}{$tag};
+    delete $$self{VALUE}{$tag};
+    delete $$self{FILE_ORDER}{$tag};
+    delete $$self{TAG_INFO}{$tag};
+    delete $$self{TAG_EXTRA}{$tag};
+    delete $$self{PRIORITY}{$tag};
+    delete $$self{RATIONAL}{$tag};
+    delete $$self{BOTH}{$tag};
 }
 
 #------------------------------------------------------------------------------
@@ -6422,8 +6474,8 @@ sub DoEscape($$)
 sub SetFileType($;$$)
 {
     my ($self, $fileType, $mimeType) = @_;
-    unless ($self->{VALUE}{FileType} and not $$self{DOC_NUM}) {
-        my $baseType = $self->{FILE_TYPE};
+    unless ($$self{VALUE}{FileType} and not $$self{DOC_NUM}) {
+        my $baseType = $$self{FILE_TYPE};
         $fileType or $fileType = $baseType;
         $mimeType or $mimeType = $mimeType{$fileType};
         # use base file type if necessary (except if 'TIFF', which is a special case)
@@ -6459,12 +6511,12 @@ sub ModifyMimeType($;$)
 {
     my ($self, $mime) = @_;
     $mime =~ m{/} or $mime = $mimeType{$mime} or return;
-    my $old = $self->{VALUE}{MIMEType};
+    my $old = $$self{VALUE}{MIMEType};
     if (defined $old) {
         my ($a, $b) = split '/', $old;
         my ($c, $d) = split '/', $mime;
         $d =~ s/^x-//;
-        $self->{VALUE}{MIMEType} = "$c/$b-$d";
+        $$self{VALUE}{MIMEType} = "$c/$b-$d";
         $self->VPrint(0, "  Modified MIMEType = $c/$b-$d\n");
     } else {
         $self->FoundTag('MIMEType', $mime);
@@ -6478,9 +6530,10 @@ sub VPrint($$@)
 {
     my $self = shift;
     my $level = shift;
-    if ($self->{OPTIONS}{Verbose} and $self->{OPTIONS}{Verbose} > $level) {
-        my $out = $self->{OPTIONS}{TextOut};
+    if ($$self{OPTIONS}{Verbose} and $$self{OPTIONS}{Verbose} > $level) {
+        my $out = $$self{OPTIONS}{TextOut};
         print $out @_;
+        print $out "\n" unless $_[-1] =~ /\n$/;
     }
 }
 
@@ -6491,11 +6544,11 @@ sub VerboseDump($$;%)
 {
     my $self = shift;
     my $dataPt = shift;
-    if ($self->{OPTIONS}{Verbose} and $self->{OPTIONS}{Verbose} > 2) {
+    if ($$self{OPTIONS}{Verbose} and $$self{OPTIONS}{Verbose} > 2) {
         my %parms = (
-            Prefix => $self->{INDENT},
-            Out    => $self->{OPTIONS}{TextOut},
-            MaxLen => $self->{OPTIONS}{Verbose} < 4 ? 96 : undef,
+            Prefix => $$self{INDENT},
+            Out    => $$self{OPTIONS}{TextOut},
+            MaxLen => $$self{OPTIONS}{Verbose} < 4 ? 96 : undef,
         );
         HexDump($dataPt, undef, %parms, @_);
     }
@@ -6531,14 +6584,14 @@ sub ExtractBinary($$$;$)
             $isPreview = 1;
         }
         my $lcTag = lc $tag;
-        if ((not $self->{OPTIONS}{Binary} or $self->{EXCL_TAG_LOOKUP}{$lcTag}) and
-             not $self->{OPTIONS}{Verbose} and not $self->{REQ_TAG_LOOKUP}{$lcTag})
+        if ((not $$self{OPTIONS}{Binary} or $$self{EXCL_TAG_LOOKUP}{$lcTag}) and
+             not $$self{OPTIONS}{Verbose} and not $$self{REQ_TAG_LOOKUP}{$lcTag})
         {
             return "Binary data $length bytes";
         }
     }
-    unless ($self->{RAF}->Seek($offset,0)
-        and $self->{RAF}->Read($buff, $length) == $length)
+    unless ($$self{RAF}->Seek($offset,0)
+        and $$self{RAF}->Read($buff, $length) == $length)
     {
         $tag or $tag = 'binary data';
         if ($isPreview and not $$self{BuildingComposite}) {
@@ -6564,8 +6617,8 @@ sub ProcessBinaryData($$$)
     my $offset = $$dirInfo{DirStart} || 0;
     my $size = $$dirInfo{DirLen} || (length($$dataPt) - $offset);
     my $base = $$dirInfo{Base} || 0;
-    my $verbose = $self->{OPTIONS}{Verbose};
-    my $unknown = $self->{OPTIONS}{Unknown};
+    my $verbose = $$self{OPTIONS}{Verbose};
+    my $unknown = $$self{OPTIONS}{Unknown};
     my $dataPos = $$dirInfo{DataPos} || 0;
 
     # get default format ('int8u' unless specified)
@@ -6589,6 +6642,9 @@ sub ProcessBinaryData($$$)
     } elsif ($$dirInfo{DataMember}) {
         @tags = @{$$dirInfo{DataMember}};
         $verbose = 0;   # no verbose output of extracted values when writing
+    } elsif ($$dirInfo{MixedTags}) {
+        # process sorted integer-ID tags only
+        @tags = sort { $a <=> $b } grep /^\d+$/, TagTableKeys($tagTablePtr);
     } else {
         # extract known tags in numerical order
         @tags = sort { $a <=> $b } TagTableKeys($tagTablePtr);
@@ -6655,7 +6711,7 @@ sub ProcessBinaryData($$$)
                     $wasVar = 1;
                     # save variable size data if required for writing
                     if ($$dirInfo{VarFormatData}) {
-                        push @{$$dirInfo{VarFormatData}}, $index, $varSize;
+                        push @{$$dirInfo{VarFormatData}}, [ $index, $varSize, $format ];
                     }
                 }
             } elsif ($format =~ /^var_/) {
@@ -6692,7 +6748,7 @@ sub ProcessBinaryData($$$)
                 $wasVar = 1;
                 # save variable size data if required for writing
                 if ($$dirInfo{VarFormatData}) {
-                    push @{$$dirInfo{VarFormatData}}, $index, $varSize;
+                    push @{$$dirInfo{VarFormatData}}, [ $index, $varSize, $format ];
                 }
             }
         }
@@ -6702,8 +6758,8 @@ sub ProcessBinaryData($$$)
             eval $$tagInfo{Hook};
             # save variable size data if required for writing (in case changed by Hook)
             if ($$dirInfo{VarFormatData}) {
-                $#{$$dirInfo{VarFormatData}} -= 2 if $wasVar; # remove previous entries for this tag
-                push @{$$dirInfo{VarFormatData}}, $index, $varSize;
+                $#{$$dirInfo{VarFormatData}} -= 1 if $wasVar; # remove previous entry for this tag
+                push @{$$dirInfo{VarFormatData}}, [ $index, $varSize, $format ];
             }
         }
         if ($unknown > 1) {
@@ -6774,8 +6830,8 @@ sub ProcessBinaryData($$$)
             next;
         }
         if ($$tagInfo{IsOffset} and $$tagInfo{IsOffset} ne '3') {
-            my $exifTool = $self;
-            #### eval IsOffset ($val, $exifTool)
+            my $et = $self;
+            #### eval IsOffset ($val, $et)
             $val += $base + $$self{BASE} if eval $$tagInfo{IsOffset};
         }
         $val{$index} = $val;