exiftool_vendored 12.73.0 → 12.75.0

data/bin/lib/Image/ExifTool/Jpeg2000.pm

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.37';
+$VERSION = '1.39';
 
 sub ProcessJpeg2000Box($$$);
 sub ProcessJUMD($$$);
@@ -141,10 +141,13 @@ my %j2cMarker = (
         Authenticity Initiative) JUMBF (JPEG Universal Metadata Box Format) metdata
         is currently extracted from JPEG, PNG, TIFF-based (eg. TIFF, DNG),
         QuickTime-based (eg. MP4, MOV, HEIF, AVIF), RIFF-based (eg. WAV, AVI, WebP),
-        GIF files and ID3v2 metadata.  The suggested ExifTool command-line arguments
-        for reading C2PA metadata are C<-jumbf:all -G3 -b -j -u -struct>.  This
-        metadata may be deleted from writable JPEG, PNG, WebP, TIFF-based, and
-        QuickTime-based files by deleting the JUMBF group with C<-jumbf:all=>.
+        PDF, SVG and GIF files, and ID3v2 metadata.  The suggested ExifTool
+        command-line arguments for reading C2PA metadata are C<-jumbf:all -G3 -b -j
+        -u -struct>.  This metadata may be deleted from writable JPEG, PNG, WebP,
+        TIFF-based, and QuickTime-based files by deleting the JUMBF group with
+        C<-jumbf:all=>.  The C2PA JUMBF metadata may be extracted as a block via the
+        JUMBF tag.  See L<https://c2pa.org/specifications/> for the C2PA
+        specification.
     },
 #
 # NOTE: ONLY TAGS WITH "Format" DEFINED ARE EXTRACTED!
@@ -419,7 +422,7 @@ my %j2cMarker = (
         Flags => [ 'Binary', 'Protected' ],
         SubDirectory => { TagTable => 'Image::ExifTool::CBOR::Main' },
     },
-    bfdb => { # used in JUMBF (see  # (used when tag is renamed according to JUMDLabel)
+    bfdb => { # used in JUMBF
         Name => 'BinaryDataType',
         Notes => 'JUMBF, MIME type and optional file name',
         Format => 'undef',
@@ -748,6 +751,7 @@ my %j2cMarker = (
         },
         # seen:
         # cacb/cast/caas/cacl/casg/json-00110010800000aa00389b71
+        #   (also brob- but not yet tested)
         # 6579d6fbdba2446bb2ac1b82feeb89d1 - JPEG image
     },
     'label' => { Name => 'JUMDLabel' },
@@ -821,6 +825,7 @@ sub ProcessJUMD($$$)
             $name =~ tr/-_a-zA-Z0-9//dc;    # remove other illegal characters
             $name =~ s/__/_/;               # collapse double underlines
             $name = ucfirst $name;          # capitalize first letter
+            $name =~ s/C2pa/C2PA/;          # capitalize C2PA
             $name = "Tag$name" if length($name) < 2; # must at least 2 characters long
             $$et{JUMBFLabel} = $name;
         }
@@ -1017,11 +1022,23 @@ sub ProcessJpeg2000Box($$$)
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $base = $$dirInfo{Base} || 0;
     my $outfile = $$dirInfo{OutFile};
+    my $dirName = $$dirInfo{DirName} || '';
     my $dirEnd = $dirStart + $dirLen;
     my ($err, $outBuff, $verbose, $doColour, $hash, $raf);
 
-    # read from RAF unless reading from buffer
-    $raf = $$dirInfo{RAF} unless $dataPt;
+    if ($dataPt) {
+        # save C2PA JUMBF as a block if requested
+        if ($dirName eq 'JUMBF' and $$et{REQ_TAG_LOOKUP}{jumbf} and not $$dirInfo{NoBlockSave}) {
+            if ($dirStart or $dirLen ne length($$dataPt)) {
+                my $dat = substr($$dataPt, $dirStart, $dirLen);
+                $et->FoundTag(JUMBF => \$dat);
+            } else {
+                $et->FoundTag(JUMBF => $dataPt);
+            }
+        }
+    } else {
+        $raf = $$dirInfo{RAF};  # read from RAF
+    }
 
     if ($outfile) {
         unless ($raf) {
@@ -1030,7 +1047,7 @@ sub ProcessJpeg2000Box($$$)
             $outfile = \$outBuff;
         }
         # determine if we will be writing colr box
-        if ($$dirInfo{DirName} and $$dirInfo{DirName} eq 'JP2Header') {
+        if ($dirName eq 'JP2Header') {
             $doColour = 2 if defined $et->GetNewValue('ColorSpecMethod') or $et->GetNewValue('ICC_Profile') or
                              defined $et->GetNewValue('ColorSpecPrecedence') or defined $et->GetNewValue('ColorSpace') or
                              defined $et->GetNewValue('ColorSpecApproximation') or defined $et->GetNewValue('ColorSpecData');
@@ -1038,7 +1055,7 @@ sub ProcessJpeg2000Box($$$)
     } else {
         # (must not set verbose flag when writing!)
         $verbose = $$et{OPTIONS}{Verbose};
-        $et->VerboseDir($$dirInfo{DirName}) if $verbose;
+        $et->VerboseDir($dirName) if $verbose;
         # do hash if requested, but only for top-level image data
         $hash = $$et{ImageDataHash} if $raf;
     }
@@ -1187,7 +1204,7 @@ sub ProcessJpeg2000Box($$$)
         # create new tag for JUMBF data values with name corresponding to JUMBFLabel
         if ($tagInfo and $$et{JUMBFLabel} and (not $$tagInfo{SubDirectory} or $$tagInfo{BlockExtract})) {
             $tagInfo = { %$tagInfo, Name => $$et{JUMBFLabel} . ($$tagInfo{JUMBF_Suffix} || '') };
-            delete $$tagInfo{Description};
+            ($$tagInfo{Description} = Image::ExifTool::MakeDescription($$tagInfo{Name})) =~ s/C2 PA/C2PA/;
             AddTagToTable($tagTablePtr, '_JUMBF_' . $$et{JUMBFLabel}, $tagInfo);
             delete $$tagInfo{Protected}; # (must do this so -j -b returns JUMBF binary data)
             $$tagInfo{TagID} = $boxID;
@@ -1491,6 +1508,28 @@ sub ProcessJXLCodestream($$)
     return 1;
 }
 
+#------------------------------------------------------------------------------
+# Read/write meta information from a C2PA/JUMBF file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid JUMBF file
+sub ProcessJUMBF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $hdr;
+
+    # check to be sure this is a valid JPG2000 file
+    return 0 unless $raf->Read($hdr,20) == 20 and $raf->Seek(0,0);
+    return 0 unless $hdr =~ /^.{4}jumb\0.{3}jumd(.{4})/;
+    $et->SetFileType($1 eq 'c2pa' ? 'C2PA' : 'JUMBF');
+    my %dirInfo = (
+        RAF => $raf,
+        DirName => 'JUMBF',
+    );
+    my $tagTablePtr = GetTagTable('Image::ExifTool::Jpeg2000::Main');
+    return $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
+}
+
 #------------------------------------------------------------------------------
 # Read/write meta information from a JPEG 2000 image
 # Inputs: 0) ExifTool object reference, 1) dirInfo reference
@@ -1583,7 +1622,7 @@ sub ProcessJXL($$)
             $$et{IsJXL} = 2;
             my $buff = "\0\0\0\x0cJXL \x0d\x0a\x87\x0a\0\0\0\x14ftypjxl \0\0\0\0jxl ";
             # add metadata to empty ISO BMFF container
-            $$dirInfo{RAF} = new File::RandomAccess(\$buff);
+            $$dirInfo{RAF} = File::RandomAccess->new(\$buff);
         } else {
             $et->SetFileType('JXL Codestream','image/jxl', 'jxl');
             if ($$et{ImageDataHash} and $raf->Seek(0,0)) {

data/bin/lib/Image/ExifTool/MIE.pm

@@ -14,7 +14,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 
-$VERSION = '1.52';
+$VERSION = '1.54';
 
 sub ProcessMIE($$);
 sub ProcessMIEGroup($$$);
@@ -1077,7 +1077,7 @@ sub WriteMIEGroup($$$)
                         $newVal = '';
                         %subdirInfo = (
                             OutFile => \$newVal,
-                            RAF => new File::RandomAccess(\$oldVal),
+                            RAF => File::RandomAccess->new(\$oldVal),
                         );
                     } elsif ($optCompress and not $$dirInfo{IsCompressed}) {
                         # write to memory so we can compress the new MIE group
@@ -1585,7 +1585,7 @@ sub ProcessMIEGroup($$$)
                 WasCompressed => $wasCompressed,
             );
             # read from uncompressed data instead if necessary
-            $subdirInfo{RAF} = new File::RandomAccess(\$value) if $valLen;
+            $subdirInfo{RAF} = File::RandomAccess->new(\$value) if $valLen;
 
             my $oldOrder = GetByteOrder();
             SetByteOrder($format & 0x08 ? 'II' : 'MM');

data/bin/lib/Image/ExifTool/MinoltaRaw.pm

@@ -17,7 +17,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Minolta;
 
-$VERSION = '1.19';
+$VERSION = '1.20';
 
 sub ProcessMRW($$;$);
 sub WriteMRW($$;$);
@@ -400,7 +400,7 @@ sub ProcessMRW($$;$)
 
     if ($$dirInfo{DataPt}) {
         # make a RAF object for MRW information extracted from other file types
-        $raf = new File::RandomAccess($$dirInfo{DataPt});
+        $raf = File::RandomAccess->new($$dirInfo{DataPt});
         # MRW information in DNG images may not start at beginning of data block
         $raf->Seek($$dirInfo{DirStart}, 0) if $$dirInfo{DirStart};
     }

data/bin/lib/Image/ExifTool/Nikon.pm

@@ -65,7 +65,7 @@ use Image::ExifTool::Exif;
 use Image::ExifTool::GPS;
 use Image::ExifTool::XMP;
 
-$VERSION = '4.29';
+$VERSION = '4.30';
 
 sub LensIDConv($$$);
 sub ProcessNikonAVI($$$);
@@ -677,6 +677,7 @@ sub GetAFPointGrid($$;$);
     '71 48 64 64 24 24 00 00' => 'Voigtlander APO-Skopar 90mm F2.8 SL IIs', #30
     'FD 00 50 50 18 18 DF 00' => 'Voigtlander APO-Lanthar 50mm F2 Aspherical', #35
     'FD 00 44 44 18 18 DF 00' => 'Voigtlander APO-Lanthar 35mm F2', #30
+    'FD 00 59 59 18 18 DF 00' => 'Voigtlander Macro APO-Lanthar 65mm F2', #30
 #
     '00 40 2D 2D 2C 2C 00 00' => 'Carl Zeiss Distagon T* 3.5/18 ZF.2',
     '00 48 27 27 24 24 00 00' => 'Carl Zeiss Distagon T* 2.8/15 ZF.2', #MykytaKozlov
@@ -690,6 +691,7 @@ sub GetAFPointGrid($$;$);
     '00 54 62 62 0C 0C 00 00' => 'Carl Zeiss Planar T* 1.4/85 ZF.2',
     '00 54 68 68 18 18 00 00' => 'Carl Zeiss Makro-Planar T* 2/100 ZF.2',
     '00 54 72 72 18 18 00 00' => 'Carl Zeiss Apo Sonnar T* 2/135 ZF.2',
+    '02 54 3C 3C 0C 0C 00 00' => 'Zeiss Otus 1.4/28 ZF.2', #30
     '00 54 53 53 0C 0C 00 00' => 'Zeiss Otus 1.4/55', #IB
     '01 54 62 62 0C 0C 00 00' => 'Zeiss Otus 1.4/85',
     '03 54 68 68 0C 0C 00 00' => 'Zeiss Otus 1.4/100', #IB

data/bin/lib/Image/ExifTool/NikonCustom.pm

@@ -9852,7 +9852,7 @@ my %noYes = ( 0 => 'No', 1 => 'Yes' );
     85 => { Name => 'HighSpeedSync',          PrintConv => \%offOn }, # CSe1-b
     87 => { # CSe2
         Name => 'FlashShutterSpeed',
-        ValueConv => 'my $t = ($val - 16) % 24; $t ? $val / 24  : 2 + ($val - 16) / 24',     #unusual decode perhaps due to need to accomodate 4 new values?
+        ValueConv => 'my $t = ($val - 16) % 24; $t ? $val / 24  : 2 + ($val - 16) / 24',     #unusual decode perhaps due to need to accommodate 4 new values?
         PrintConv => {
             0 => '1 s',
             1 => '1/2 s',
@@ -10242,7 +10242,7 @@ my %noYes = ( 0 => 'No', 1 => 'Yes' );
     85 => { Name => 'HighSpeedSync',          PrintConv => \%offOn }, # CSe1-b
     87 => { # CSe2
         Name => 'FlashShutterSpeed',
-        ValueConv => 'my $t = ($val - 16) % 24; $t ? $val / 24  : 2 + ($val - 16) / 24',     #unusual decode perhaps due to need to accomodate 4 new values?
+        ValueConv => 'my $t = ($val - 16) % 24; $t ? $val / 24  : 2 + ($val - 16) / 24',     #unusual decode perhaps due to need to accommodate 4 new values?
         PrintConv => {
             0 => '1 s',
             1 => '1/2 s',
@@ -10652,7 +10652,7 @@ my %noYes = ( 0 => 'No', 1 => 'Yes' );
     85 => { Name => 'HighSpeedSync',          PrintConv => \%offOn }, # CSe1-b
     87 => { # CSe2
         Name => 'FlashShutterSpeed',
-        ValueConv => 'my $t = ($val - 16) % 24; $t ? $val / 24  : 2 + ($val - 16) / 24',     #unusual decode perhaps due to need to accomodate 4 new values?
+        ValueConv => 'my $t = ($val - 16) % 24; $t ? $val / 24  : 2 + ($val - 16) / 24',     #unusual decode perhaps due to need to accommodate 4 new values?
         PrintConv => {
             0 => '1 s',
             1 => '1/2 s',

data/bin/lib/Image/ExifTool/Ogg.pm

@@ -17,7 +17,7 @@ use strict;
 use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.02';
+$VERSION = '1.03';
 
 my $MAX_PACKETS = 2;    # maximum packets to scan from each stream at start of file
 
@@ -189,7 +189,7 @@ sub ProcessOGG($$)
     if (defined $numFlac and defined $val{$stream}) {
         # process FLAC headers as if it was a complete FLAC file
         require Image::ExifTool::FLAC;
-        my %dirInfo = ( RAF => new File::RandomAccess(\$val{$stream}) );
+        my %dirInfo = ( RAF => File::RandomAccess->new(\$val{$stream}) );
         Image::ExifTool::FLAC::ProcessFLAC($et, \%dirInfo);
     }
     return $success;

data/bin/lib/Image/ExifTool/PDF.pm

@@ -21,7 +21,7 @@ use vars qw($VERSION $AUTOLOAD $lastFetched);
 use Image::ExifTool qw(:DataAccess :Utils);
 require Exporter;
 
-$VERSION = '1.57';
+$VERSION = '1.58';
 
 sub FetchObject($$$$);
 sub ExtractObject($$;$$);
@@ -178,6 +178,9 @@ my %supportedFilter = (
     AcroForm => {
         SubDirectory => { TagTable => 'Image::ExifTool::PDF::AcroForm' },
     },
+    AF => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::AF' },
+    },
     Lang       => 'Language',
     PageLayout => { },
     PageMode   => { },
@@ -251,6 +254,37 @@ my %supportedFilter = (
     },
 );
 
+# tags extracted from AF dictionary
+%Image::ExifTool::PDF::AF = (
+    PROCESS_PROC => \&ProcessAF,
+    NOTES => 'Processed only for C2PA information if AFRelationship is "/C2PA_Manifest".',
+    EF => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::EF' },
+    },
+);
+
+# tags extracted from EF dictionary
+%Image::ExifTool::PDF::EF = (
+    F => {
+        Name => 'F_', # (don't want single-letter tag names)
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::F' },
+    },
+);
+
+# tags extracted from F dictionary
+%Image::ExifTool::PDF::F = (
+    NOTES => 'C2PA JUMBF metadata extracted from "/C2PA_Manifest" file.',
+    _stream => {
+        Name => 'JUMBF',
+        Condition => '$$self{AFRelationship} eq "/C2PA_Manifest"',
+        SubDirectory => {
+            TagTable  => 'Image::ExifTool::Jpeg2000::Main',
+            DirName   => 'JUMBF',
+            ByteOrder => 'BigEndian',
+        },
+    },
+);
+
 # tags in PDF Kids dictionary
 %Image::ExifTool::PDF::Kids = (
     Metadata => {
@@ -1739,6 +1773,19 @@ sub ProcessAcroForm($$$$;$$)
 {
     my ($et, $tagTablePtr, $dict, $xref, $nesting, $type) = @_;
     $et->HandleTag($tagTablePtr, '_has_xfa', $$dict{XFA} ? 'true' : 'false');
+    return 1 unless $et->Options('Verbose');
+    return ProcessDict($et, $tagTablePtr, $dict, $xref, $nesting, $type);
+}
+
+#------------------------------------------------------------------------------
+# Process AF dictionary to extract C2PA manifest
+# Inputs: Same as ProcessDict
+sub ProcessAF($$$$;$$)
+{
+    my ($et, $tagTablePtr, $dict, $xref, $nesting, $type) = @_;
+    $$et{AFRelationship} = $$dict{AFRelationship} || '';
+    # go no further unless Verbose or this is the C2PA_Manifest item
+    return 1 unless $et->Options('Verbose') or $$et{AFRelationship} eq '/C2PA_Manifest';
     return ProcessDict($et, $tagTablePtr, $dict, $xref, $nesting, $type);
 }
 
@@ -1987,7 +2034,8 @@ sub ProcessDict($$$$;$$)
                     $$et{INDENT} .= '| ';
                     $$et{DIR_NAME} = $tag;
                     $et->VerboseDir($tag, scalar(@{$$subDict{_tags}}));
-                    ProcessDict($et, $subTablePtr, $subDict, $xref, $nesting);
+                    my $proc = $$subTablePtr{PROCESS_PROC} || \&ProcessDict;
+                    &$proc($et, $subTablePtr, $subDict, $xref, $nesting);
                     $$et{INDENT} = $oldIndent;
                     $$et{DIR_NAME} = $oldDir;
                 }
@@ -2087,7 +2135,8 @@ sub ProcessDict($$$$;$$)
         ($tag = $$dict{Subtype} . $tag) =~ s/^\/// if $$dict{Subtype};
         last unless $$tagTablePtr{$tag};
         my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag) or last;
-        unless ($$tagInfo{SubDirectory}) {
+        my $subdir = $$tagInfo{SubDirectory};
+        unless ($subdir) {
             # don't build filter lists across different images
             delete $$et{LIST_TAGS}{$$tagTablePtr{Filter}};
             # we arrive here only when extracting embedded images
@@ -2120,8 +2169,9 @@ sub ProcessDict($$$$;$$)
             DirStart => 0,
             DirLen   => length $$dict{_stream},
             Parent   => 'PDF',
+            DirName  => $$subdir{DirName},
         );
-        my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
+        my $subTablePtr = GetTagTable($$subdir{TagTable});
         unless ($et->ProcessDirectory(\%dirInfo, $subTablePtr)) {
             $et->Warn("Error processing $$tagInfo{Name} information");
         }

data/bin/lib/Image/ExifTool/PLIST.pm

@@ -21,7 +21,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::XMP;
 use Image::ExifTool::GPS;
 
-$VERSION = '1.11';
+$VERSION = '1.12';
 
 sub ExtractObject($$;$);
 sub Get24u($$);
@@ -351,9 +351,9 @@ sub ProcessBinaryPLIST($$;$)
         my $start = $$dirInfo{DirStart};
         if ($start or ($$dirInfo{DirLen} and $$dirInfo{DirLen} != length $$dataPt)) {
             my $buf2 = substr($$dataPt, $start || 0, $$dirInfo{DirLen});
-            $$dirInfo{RAF} = new File::RandomAccess(\$buf2);
+            $$dirInfo{RAF} = File::RandomAccess->new(\$buf2);
         } else {
-            $$dirInfo{RAF} = new File::RandomAccess($dataPt);
+            $$dirInfo{RAF} = File::RandomAccess->new($dataPt);
         }
         my $strt = $$dirInfo{DirStart} || 0;
     }

data/bin/lib/Image/ExifTool/PanasonicRaw.pm

@@ -21,7 +21,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.28';
+$VERSION = '1.29';
 
 sub ProcessJpgFromRaw($$$);
 sub WriteJpgFromRaw($$$);
@@ -839,7 +839,7 @@ sub WriteJpgFromRaw($$$)
         my $buff = substr($$dataPt, $dirStart, $dirLen);
         $dataPt = \$buff;
     }
-    my $raf = new File::RandomAccess($dataPt);
+    my $raf = File::RandomAccess->new($dataPt);
     my $outbuff;
     my %dirInfo = (
         RAF => $raf,
@@ -890,7 +890,7 @@ sub ProcessJpgFromRaw($$$)
     # extract information from embedded JPEG
     my %dirInfo = (
         Parent => 'RAF',
-        RAF    => new File::RandomAccess($dataPt),
+        RAF    => File::RandomAccess->new($dataPt),
     );
     if ($verbose) {
         my $indent = $$et{INDENT};

data/bin/lib/Image/ExifTool/PhaseOne.pm

@@ -15,7 +15,7 @@ use vars qw($VERSION);
 use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 
-$VERSION = '1.09';
+$VERSION = '1.10';
 
 sub WritePhaseOne($$$);
 sub ProcessPhaseOne($$$);
@@ -473,7 +473,7 @@ sub WritePhaseOne($$$)
     return undef if $numEntries < 2 or $numEntries > 300 or $ifdEnd > $dirLen;
     my $hdrBuff = $hdr;
     my $valBuff = '';   # buffer for value data
-    my $fixup = new Image::ExifTool::Fixup;
+    my $fixup = Image::ExifTool::Fixup->new;
     my $index;
     for ($index=0; $index<$numEntries; ++$index) {
         my $entry = $dirStart + $ifdStart + 8 + $entrySize * $index;

data/bin/lib/Image/ExifTool/Photoshop.pm

@@ -28,7 +28,7 @@ use strict;
 use vars qw($VERSION $AUTOLOAD $iptcDigestInfo %printFlags);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.69';
+$VERSION = '1.70';
 
 sub ProcessPhotoshop($$$);
 sub WritePhotoshop($$$);
@@ -70,7 +70,7 @@ my %thumbnailInfo = (
     Protected => 1,
     RawConv => 'my $img=substr($val,0x1c); $self->ValidateImage(\$img,$tag)',
     ValueConvInv => q{
-        my $et = new Image::ExifTool;
+        my $et = Image::ExifTool->new;
         my @tags = qw{ImageWidth ImageHeight FileType};
         my $info = $et->ImageInfo(\$val, @tags);
         my ($w, $h, $type) = @$info{@tags};
@@ -892,7 +892,7 @@ sub ProcessDocumentData($$$)
     unless ($raf) {
         my $dataPt = $$dirInfo{DataPt};
         my $start = $$dirInfo{DirStart} || 0;
-        $raf = new File::RandomAccess($dataPt);
+        $raf = File::RandomAccess->new($dataPt);
         $raf->Seek($start, 0) if $start;
         $dirLen = length $$dataPt - $start unless defined $dirLen;
         $et->VerboseDump($dataPt, Start => $start, Len => $dirLen, Base => $$dirInfo{Base});

data/bin/lib/Image/ExifTool/PostScript.pm

@@ -16,7 +16,7 @@ use strict;
 use vars qw($VERSION $AUTOLOAD);
 use Image::ExifTool qw(:DataAccess :Utils);
 
-$VERSION = '1.44';
+$VERSION = '1.45';
 
 sub WritePS($$);
 sub ProcessPS($$;$);
@@ -430,7 +430,7 @@ sub ProcessPS($$;$)
 
     # allow read from data
     unless ($raf) {
-        $raf = new File::RandomAccess($$dirInfo{DataPt});
+        $raf = File::RandomAccess->new($$dirInfo{DataPt});
         $et->VerboseDir('PostScript');
     }
 #