Changeset 24107 for main/trunk/greenstone2/perllib/cpan/Image/ExifTool/PDF.pm

Timestamp:

2011-06-01T12:33:42+12:00 (13 years ago)

Author:

sjm84

Message:

Updating the ExifTool perl modules

File:

• main/trunk/greenstone2/perllib/cpan/Image/ExifTool/PDF.pm (modified) (64 diffs)

main/trunk/greenstone2/perllib/cpan/Image/ExifTool/PDF.pm

@@ -4 +4 @@
 # Description:  Read PDF meta information
 #
-# Revisions:    07/11/05 - P. Harvey Created
-#               07/25/05 - P. Harvey Add support for encrypted documents
-#
-# References:   1) http://partners.adobe.com/public/developer/pdf/index_reference.html
-#               2) http://www.cr0.net:8040/code/crypto/rc4/
+# Revisions:    07/11/2005 - P. Harvey Created
+#               07/25/2005 - P. Harvey Add support for encrypted documents
+#
+# References:   1) http://www.adobe.com/devnet/pdf/pdf_reference.html
+#               2) http://search.cpan.org/dist/Crypt-RC4/
+#               3) http://www.adobe.com/devnet/acrobat/pdfs/PDF32000_2008.pdf
+#               4) http://www.adobe.com/content/dam/Adobe/en/devnet/pdf/pdfs/adobe_supplement_iso32000.pdf
+#               5) http://tools.ietf.org/search/rfc3454
+#               6) http://www.armware.dk/RFC/rfc/rfc4013.html
 #------------------------------------------------------------------------------
 
@@ -14 +18 @@
 
 use strict;
-use vars qw($VERSION);
+use vars qw($VERSION $AUTOLOAD $lastFetched);
 use Image::ExifTool qw(:DataAccess :Utils);
 require Exporter;
 
-$VERSION = '1.10';
-
-sub LocateObject($$);
+$VERSION = '1.29';
+
 sub FetchObject($$$$);
 sub ExtractObject($$;$$);
 sub ReadToNested($;$);
-sub ProcessDict($$$$;$);
-
-my %warnedOnce;     # hash of warnings we issued
+sub ProcessDict($$$$;$$);
+sub ReadPDFValue($);
+sub CheckPDF($$$);
+
+# $lastFetched - last fetched object reference (used for decryption)
+#                (undefined if fetched object was already decrypted, ie. object from stream)
+
+my $cryptInfo;      # encryption object reference (plus additional information)
+my $cryptString;    # flag that strings are encrypted
+my $cryptStream;    # flag that streams are encrypted
+my $lastOffset;     # last fetched object offset
 my %streamObjs;     # hash of stream objects
 my %fetched;        # dicts fetched in verbose mode (to avoid cyclical recursion)
-my $lastFetched;    # last fetched object reference (used for decryption)
-my $cryptInfo;      # encryption object reference (plus additional information)
+my $pdfVer;         # version of PDF file being processed
 
 # tags in main PDF directories
 %Image::ExifTool::PDF::Main = (
+    GROUPS => { 2 => 'Document' },
+    VARS => { CAPTURE => ['Main','Prev'] },
     Info => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Info',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Info' },
     },
     Root => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Root',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Root' },
+    },
+    Encrypt => {
+        NoProcess => 1, # don't process normally (processed in advance)
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Encrypt' },
+    },
+    _linearized => {
+        Name => 'Linearized',
+        Notes => 'flag set if document is linearized for fast web display; not a real Tag ID',
+        PrintConv => { 'true' => 'Yes', 'false' => 'No' },
     },
 );
@@ -48 +65 @@
 # tags in PDF Info directory
 %Image::ExifTool::PDF::Info = (
-    GROUPS => { 2 => 'Image' },
+    GROUPS => { 2 => 'Document' },
+    VARS => { CAPTURE => ['Info'] },
     EXTRACT_UNKNOWN => 1, # extract all unknown tags in this directory
+    WRITE_PROC => \&Image::ExifTool::DummyWriteProc,
+    CHECK_PROC => \&CheckPDF,
+    WRITABLE => 'string',
     NOTES => q{
         As well as the tags listed below, the PDF specification allows for
         user-defined tags to exist in the Info dictionary.  These tags, which should
-        have corresponding XMP-pdfx entries in the PDF Metadata, are also extracted
-        by ExifTool.
+        have corresponding XMP-pdfx entries in the XMP of the PDF XML Metadata
+        object, are also extracted by ExifTool.
+
+        B<Writable> specifies the value format, and may be C<string>, C<date>,
+        C<integer>, C<real>, C<boolean> or C<name> for PDF tags.
     },
     Title       => { },
     Author      => { Groups => { 2 => 'Author' } },
     Subject     => { },
-    Keywords    => { List => 1 },  # this is a list of tokens
+    Keywords    => { List => 'string' },  # this is a string list
     Creator     => { },
     Producer    => { },
     CreationDate => {
         Name => 'CreateDate',
+        Writable => 'date',
         Groups => { 2 => 'Time' },
-        ValueConv => 'Image::ExifTool::PDF::ConvertPDFDate($self, $val)',
+        Shift => 'Time',
+        PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val)',
     },
     ModDate => {
         Name => 'ModifyDate',
+        Writable => 'date',
         Groups => { 2 => 'Time' },
-        ValueConv => 'Image::ExifTool::PDF::ConvertPDFDate($self, $val)',
+        Shift => 'Time',
+        PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val)',
     },
     Trapped => {
+        Protected => 1,
         # remove leading '/' from '/True' or '/False'
         ValueConv => '$val=~s{^/}{}; $val',
+        ValueConvInv => '"/$val"',
+    },
+    'AAPL:Keywords' => { #PH
+        Name => 'AppleKeywords',
+        List => 'array', # this is an array of values
+        Notes => q{
+            keywords written by Apple utilities, although they seem to use PDF:Keywords
+            when reading
+        },
     },
 );
@@ -80 +120 @@
 # tags in the PDF Root document catalog
 %Image::ExifTool::PDF::Root = (
+    GROUPS => { 2 => 'Document' },
+    # note: can't capture previous versions of Root since they are not parsed
+    VARS => { CAPTURE => ['Root'] },
     NOTES => 'This is the PDF document catalog.',
+    MarkInfo => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::MarkInfo' },
+    },
     Metadata => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Metadata',
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Metadata' },
+    },
+    Pages => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Pages' },
+    },
+    Perms => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Perms' },
+    },
+    Lang       => 'Language',
+    PageLayout => { },
+    PageMode   => { },
+    Version    => 'PDFVersion',
+);
+
+# tags extracted from the PDF Encrypt dictionary
+%Image::ExifTool::PDF::Encrypt = (
+    GROUPS => { 2 => 'Document' },
+    NOTES => 'Tags extracted from the document Encrypt dictionary.',
+    Filter => {
+        Name => 'Encryption',
+        Notes => q{
+            extracted value is actually a combination of the Filter, SubFilter, V, R and
+            Length information from the Encrypt dictionary
         },
     },
-    Pages => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Pages',
-        },
+    P => {
+        Name => 'UserAccess',
+        ValueConv => '$val & 0x0f3c',  # ignore reserved bits
+        PrintConvColumns => 2,
+        PrintConv => { BITMASK => {
+            2 => 'Print',
+            3 => 'Modify',
+            4 => 'Copy',
+            5 => 'Annotate',
+            8 => 'Fill forms',
+            9 => 'Extract',
+            10 => 'Assemble',
+            11 => 'Print high-res',
+        }},
     },
 );
@@ -95 +172 @@
 # tags in PDF Pages directory
 %Image::ExifTool::PDF::Pages = (
-    GROUPS => { 2 => 'Image' },
+    GROUPS => { 2 => 'Document' },
     Count => 'PageCount',
     Kids => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Kids',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Kids' },
+    },
+);
+
+# tags in PDF Perms directory
+%Image::ExifTool::PDF::Perms = (
+    NOTES => 'Additional document permissions imposed by digital signatures.',
+    DocMDP => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Signature' },
+    },
+    FieldMDP => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Signature' },
+    },
+    UR3 => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Signature' },
     },
 );
@@ -107 +196 @@
 %Image::ExifTool::PDF::Kids = (
     Metadata => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Metadata',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Metadata' },
     },
     PieceInfo => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::PieceInfo',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::PieceInfo' },
     },
     Resources => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Resources',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Resources' },
     },
 );
@@ -126 +209 @@
 %Image::ExifTool::PDF::Resources = (
     ColorSpace => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::ColorSpace',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::ColorSpace' },
     },
 );
@@ -135 +216 @@
 %Image::ExifTool::PDF::ColorSpace = (
     DefaultRGB => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::DefaultRGB',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::DefaultRGB' },
     },
 );
@@ -144 +223 @@
 %Image::ExifTool::PDF::DefaultRGB = (
     ICCBased => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::ICCBased',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::ICCBased' },
     },
 );
@@ -152 +229 @@
 # tags in PDF ICCBased directory
 %Image::ExifTool::PDF::ICCBased = (
-    stream => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::ICC_Profile::Main',
-        },
+    _stream => {
+        SubDirectory => { TagTable => 'Image::ExifTool::ICC_Profile::Main' },
     },
 );
@@ -162 +237 @@
 %Image::ExifTool::PDF::PieceInfo = (
     AdobePhotoshop => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::AdobePhotoshop',
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::AdobePhotoshop' },
+    },
+    Illustrator => {
+        # assume this is an illustrator file if it contains this directory
+        # and doesn't have a ".PDF" extension
+        Condition => q{
+            $self->OverrideFileType("AI") unless $$self{FILE_EXT} and $$self{FILE_EXT} eq 'PDF';
+            return 1;
         },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Illustrator' },
     },
 );
@@ -171 +253 @@
 %Image::ExifTool::PDF::AdobePhotoshop = (
     Private => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::Private',
-        },
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Private' },
+    },
+);
+
+# tags in PDF Illustrator directory
+%Image::ExifTool::PDF::Illustrator = (
+    Private => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::AIPrivate' },
     },
 );
@@ -180 +267 @@
 %Image::ExifTool::PDF::Private = (
     ImageResources => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::PDF::ImageResources',
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::ImageResources' },
+    },
+);
+
+# tags in PDF AI Private directory
+%Image::ExifTool::PDF::AIPrivate = (
+    GROUPS => { 2 => 'Document' },
+    EXTRACT_UNKNOWN => 0,   # extract known but numbered tags
+    AIMetaData => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::AIMetaData' },
+    },
+    AIPrivateData => {
+        Notes => q{
+            the ExtractEmbedded option enables information to be extracted from embedded
+            PostScript documents in the AIPrivateData stream
         },
+        SubDirectory => { TagTable => 'Image::ExifTool::PostScript::Main' },
+    },
+    RoundTripVersion => { },
+    ContainerVersion => { },
+    CreatorVersion => { },
+);
+
+# tags in PDF AIMetaData directory
+%Image::ExifTool::PDF::AIMetaData = (
+    _stream => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PostScript::Main' },
     },
 );
@@ -188 +299 @@
 # tags in PDF ImageResources directory
 %Image::ExifTool::PDF::ImageResources = (
-    stream => {
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::Photoshop::Main',
-        },
+    _stream => {
+        SubDirectory => { TagTable => 'Image::ExifTool::Photoshop::Main' },
+    },
+);
+
+# tags in PDF MarkInfo directory
+%Image::ExifTool::PDF::MarkInfo = (
+    GROUPS => { 2 => 'Document' },
+    Marked => {
+        Name => 'TaggedPDF',
+        Notes => "not a Tagged PDF if this tag is missing",
+        PrintConv => { 'true' => 'Yes', 'false' => 'No' },
     },
 );
@@ -197 +316 @@
 # tags in PDF Metadata directory
 %Image::ExifTool::PDF::Metadata = (
-    GROUPS => { 2 => 'Image' },
+    GROUPS => { 2 => 'Document' },
     XML_stream => { # this is the stream for a Subtype /XML dictionary (not a real tag)
         Name => 'XMP',
-        SubDirectory => {
-            TagTable => 'Image::ExifTool::XMP::Main',
+        SubDirectory => { TagTable => 'Image::ExifTool::XMP::Main' },
+    },
+);
+
+# tags in PDF signature directories (DocMDP, FieldMDP or UR3)
+%Image::ExifTool::PDF::Signature = (
+    GROUPS => { 2 => 'Document' },
+    ContactInfo => 'SignerContactInfo',
+    Location => 'SigningLocation',
+    M => {
+        Name => 'SigningDate',
+        Format => 'date',
+        Groups => { 2 => 'Time' },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    Name     => 'SigningAuthority',
+    Reason   => 'SigningReason',
+    Reference => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::Reference' },
+    },
+    Prop_AuthTime => {
+        Name => 'AuthenticationTime',
+        PrintConv => 'ConvertTimeSpan($val) . " ago"',
+    },
+    Prop_AuthType => 'AuthenticationType',
+);
+
+# tags in PDF Reference directory
+%Image::ExifTool::PDF::Reference = (
+    TransformParams => {
+        SubDirectory => { TagTable => 'Image::ExifTool::PDF::TransformParams' },
+    },
+);
+
+# tags in PDF TransformParams directory
+%Image::ExifTool::PDF::TransformParams = (
+    GROUPS => { 2 => 'Document' },
+    Annots => {
+        Name => 'AnnotationUsageRights',
+        Notes => 'UR3 signatures only',
+        List => 1,
+    },
+    Document => {
+        Name => 'DocumentUsageRights',
+        Notes => 'UR3 signatures only',
+        List => 1,
+    },
+    Form => {
+        Name => 'FormUsageRights',
+        Notes => 'UR3 signatures only',
+        List => 1,
+    },
+    Signature => {
+        Name => 'SignatureUsageRights',
+        Notes => 'UR3 signatures only',
+        List => 1,
+    },
+    EF => {
+        Name => 'EmbeddedFileUsageRights',
+        Notes => 'UR3 signatures only',
+        List => 1,
+    },
+    Msg => {
+        Name => 'UsageRightsMessage',
+        Notes => 'UR3 signatures only',
+    },
+    P => {
+        Name => 'ModificationPermissions',
+        Notes => q{
+            1-3 for DocMDP signatures, default 2; true/false for UR3 signatures, default
+            false
         },
+        PrintConv => {
+            1 => 'No changes permitted',
+            2 => 'Fill forms, Create page templates, Sign',
+            3 => 'Fill forms, Create page templates, Sign, Create/Delete/Edit annotations',
+            'true' => 'Restrict al applications to reader permissions',
+            'false' => 'Do not restrict applications to reader permissions',
+        },
+    },
+    Action => {
+        Name => 'FieldPermissions',
+        Notes => 'FieldMDP signatures only',
+        PrintConv => {
+            'All' => 'Disallow changes to all form fields',
+            'Include' => 'Disallow changes to specified form fields',
+            'Exclude' => 'Allow changes to specified form fields',
+        },
+    },
+    Fields => {
+        Notes => 'FieldMDP signatures only',
+        Name => 'FormFields',
+        List => 1,
     },
 );
@@ -212 +421 @@
 
 #------------------------------------------------------------------------------
-# Issue one warning of each type
-# Inputs: 0) ExifTool object reference, 1) warning
-sub WarnOnce($$)
+# AutoLoad our writer routines when necessary
+#
+sub AUTOLOAD
 {
-    my ($exifTool, $warn) = @_;
-    unless ($warnedOnce{$warn}) {
-        $warnedOnce{$warn} = 1;
-        $exifTool->Warn($warn);
-    }
+    return Image::ExifTool::DoAutoLoad($AUTOLOAD, @_);
 }
 
 #------------------------------------------------------------------------------
-# Set PDF format error warning
-# Inputs: 0) ExifTool object reference, 1) error string
-# Returns: 1
-sub PDFErr($$)
+# Convert from PDF to EXIF-style date/time
+# Inputs: 0) PDF date/time string (D:YYYYmmddHHMMSS+HH'MM')
+# Returns: EXIF date string (YYYY:mm:dd HH:MM:SS+HH:MM)
+sub ConvertPDFDate($)
 {
-    my ($exifTool, $str) = @_;
-    $exifTool->Warn("PDF format error ($str)");
-    return 1;
-}
-
-#------------------------------------------------------------------------------
-# Convert from PDF to EXIF-style date/time
-# Inputs: 0) ExifTool object reference,
-#         1) PDF date/time string (D:yyyymmddhhmmss+hh'mm')
-# Returns: EXIF date string (yyyy:mm:dd hh:mm:ss+hh:mm)
-sub ConvertPDFDate($$)
-{
-    my ($exifTool, $date) = @_;
+    my $date = shift;
     # remove optional 'D:' prefix
     $date =~ s/^D://;
     # fill in default values if necessary
-    #              yyyymmddhhmmss
+    #              YYYYmmddHHMMSS
     my $default = '00000101000000';
     if (length $date < length $default) {
@@ -253 +446 @@
     $date = "$1:$2:$3 $4:$5:$6";
     if ($7) {
-        my @t = split /'/, $7;
-        $date .= $t[0];
-        $date .= ':' . ($t[1] || 0) if $t[0] ne 'Z';
-    }
-    return $exifTool->ConvertDateTime($date);
+        my $tz = $7;
+        if ($tz =~ /^\s*Z/i) {
+            # ignore any "HH'mm'" after the Z (OS X 10.6 does this)
+            $date .= 'Z';
+        # tolerate some improper formatting in timezone specification
+        } elsif ($tz =~ /^\s*([-+])\s*(\d+)[': ]+(\d*)/) {
+            $date .= $1 . $2 . ':' . ($3 || '00');
+        }
+    }
+    return $date;
 }
 
 #------------------------------------------------------------------------------
-# Locate an object in the XRref tables
-# Inputs: 0) XRef reference, 1) object reference string
-# Returns: offset to object in file, or undefined on error
-sub LocateObject($$)
+# Locate any object in the XRef tables (including compressed objects)
+# Inputs: 0) XRef reference, 1) object reference string (or free object number)
+# Returns: offset to object in file or compressed object reference string,
+#          0 if object is free, or undefined on error
+sub LocateAnyObject($$)
 {
     my ($xref, $ref) = @_;
     return undef unless $xref;
-    return $$xref{$ref} if $$xref{$ref};
+    return $$xref{$ref} if exists $$xref{$ref};
     # get the object number
     return undef unless $ref =~ /^(\d+)/;
     my $objNum = $1;
+    # return 0 if the object number has been reused (old object is free)
+    return 0 if defined $$xref{$objNum};
 #
 # scan our XRef stream dictionaries for this object
@@ -283 +484 @@
         next if $objNum < $$index[0];
         # scan the tables for the specified object
-        my $size = $$dict{entry_size};
+        my $size = $$dict{_entry_size};
         my $num = scalar(@$index) / 2;
         my $tot = 0;
@@ -291 +492 @@
             my $count = $$index[$i*2+1];
             # table is in ascending order, so quit if we have passed the object
-            last if $objNum >= $start + $count;
-            if ($objNum >= $start) {
+            last if $objNum < $start;
+            if ($objNum < $start + $count) {
                 my $offset = $size * ($objNum - $start + $tot);
-                last if $offset + $size > length $$dict{stream};
-                my @c = unpack("x$offset C$size", $$dict{stream});
+                last if $offset + $size > length $$dict{_stream};
+                my @c = unpack("x$offset C$size", $$dict{_stream});
                 # extract values from this table entry
                 # (can be 1, 2, 3, 4, etc.. bytes per value)
-                my (@t, $j, $k, $ref2);
+                my (@t, $j, $k);
                 my $w = $$dict{W};
                 for ($j=0; $j<3; ++$j) {
                     # use default value if W entry is 0 (as per spec)
-                    $$w[$j] or $t[$j] = ($j ? 1 : 0), next;
+                    # - 0th element defaults to 1, others default to 0
+                    $$w[$j] or $t[$j] = ($j ? 0 : 1), next;
                     $t[$j] = shift(@c);
                     for ($k=1; $k < $$w[$j]; ++$k) {
@@ -308 +510 @@
                     }
                 }
+                # by default, use "o g R" as the xref key
+                # (o = object number, g = generation number)
+                my $ref2 = "$objNum $t[2] R";
                 if ($t[0] == 1) {
-                    # normal object reference: use "o g R" as hash ref
-                    # (o = object number, g = generation number)
-                    $ref2 = "$objNum $t[2] R";
-                    # xref is offset of object from start
+                    # normal object reference:
+                    # $t[1]=offset of object from start, $t[2]=generation number
                     $$xref{$ref2} = $t[1];
                 } elsif ($t[0] == 2) {
                     # compressed object reference:
+                    # $t[1]=stream object number, $t[2]=index of object in stream
                     $ref2 = "$objNum 0 R";
-                    # xref is object index and stream object reference
                     $$xref{$ref2} = "I$t[2] $t[1] 0 R";
+                } elsif ($t[0] == 0) {
+                    # free object:
+                    # $t[1]=next free object in linked list, $t[2]=generation number
+                    $$xref{$ref2} = 0;
                 } else {
-                    last;
+                    # treat as a null object
+                    $$xref{$ref2} = undef;
                 }
+                $$xref{$objNum} = $t[1];    # remember offsets by object number too
                 return $$xref{$ref} if $ref eq $ref2;
+                return 0;   # object is free or was reused
             }
             $tot += $count;
@@ -331 +541 @@
 
 #------------------------------------------------------------------------------
+# Locate a regular object in the XRef tables (does not include compressed objects)
+# Inputs: 0) XRef reference, 1) object reference string (or free object number)
+# Returns: offset to object in file, 0 if object is free,
+#          or undef on error or if object was compressed
+sub LocateObject($$)
+{
+    my ($xref, $ref) = @_;
+    my $offset = LocateAnyObject($xref, $ref);
+    return undef if $offset and $offset =~ /^I/;
+    return $offset;
+}
+
+#------------------------------------------------------------------------------
 # Fetch indirect object from file (from inside a stream if required)
-# Inputs: 0) ExifTool object reference, 1) object reference string, 2) xref lookup,
+# Inputs: 0) ExifTool object reference, 1) object reference string,
+#         2) xref lookup, 3) object name (for warning messages)
 # Returns: object data or undefined on error
+# Notes: sets $lastFetched to the object reference, or undef if the object
+#        was extracted from an encrypted stream
 sub FetchObject($$$$)
 {
     my ($exifTool, $ref, $xref, $tag) = @_;
     $lastFetched = $ref;    # save this for decoding if necessary
-    my $offset = LocateObject($xref, $ref);
+    my $offset = LocateAnyObject($xref, $ref);
+    $lastOffset = $offset;
     unless ($offset) {
-        $exifTool->Warn("Bad $tag reference");
+        $exifTool->Warn("Bad $tag reference") unless defined $offset;
         return undef;
     }
@@ -348 +575 @@
         my ($objNum) = split ' ', $ref; # save original object number
         $ref = $offset; # now a reference to the containing stream object
-        my $obj = $streamObjs{$ref};
+        $obj = $streamObjs{$ref};
         unless ($obj) {
             # don't try to load the same object stream twice
@@ -359 +586 @@
             return undef unless $$obj{First} and $$obj{N};
             return undef unless DecodeStream($exifTool, $obj);
-            # add a special 'table' entry to this dictionary which contains
+            # add a special '_table' entry to this dictionary which contains
             # the list of object number/offset pairs from the stream header
             my $num = $$obj{N} * 2;
-            my @table = split ' ', $$obj{stream}, $num;
+            my @table = split ' ', $$obj{_stream}, $num;
             return undef unless @table == $num;
             # remove everything before first object in stream
-            $$obj{stream} = substr($$obj{stream}, $$obj{First});
-            $table[$num-1] =~ s/^(\d+).*/$1/;  # trim excess from last number
-            $$obj{table} = \@table;
+            $$obj{_stream} = substr($$obj{_stream}, $$obj{First});
+            $table[$num-1] =~ s/^(\d+).*/$1/s;  # trim excess from last number
+            $$obj{_table} = \@table;
             # save the object stream so we don't have to re-load it later
             $streamObjs{$ref} = $obj;
@@ -373 +600 @@
         # verify that we have the specified object
         my $i = 2 * $index;
-        my $table = $$obj{table};
+        my $table = $$obj{_table};
         unless ($index < $$obj{N} and $$table[$i] == $objNum) {
             $exifTool->Warn("Bad index for stream object $tag");
@@ -382 +609 @@
         #  the next offset to get the object length)
         $offset = $$table[$i + 1];
-        my $len = ($$table[$i + 3] || length($$obj{stream})) - $offset;
-        $data = substr($$obj{stream}, $offset, $len);
+        my $len = ($$table[$i + 3] || length($$obj{_stream})) - $offset;
+        $data = substr($$obj{_stream}, $offset, $len);
+        # avoid re-decrypting data in already decrypted streams
+        undef $lastFetched if $cryptStream;
         return ExtractObject($exifTool, \$data);
     }
@@ -396 +625 @@
     }
     return ExtractObject($exifTool, \$data, $raf, $xref);
+}
+
+#------------------------------------------------------------------------------
+# Convert PDF value to something readable
+# Inputs: 0) PDF object data
+# Returns: converted object
+sub ReadPDFValue($)
+{
+    my $str = shift;
+    # decode all strings in an array
+    if (ref $str eq 'ARRAY') {
+        # create new list to not alter the original data when rewriting
+        my ($val, @vals);
+        foreach $val (@$str) {
+            push @vals, ReadPDFValue($val);
+        }
+        return \@vals;
+    }
+    length $str or return $str;
+    my $delim = substr($str, 0, 1);
+    if ($delim eq '(') {    # literal string
+        $str = $1 if $str =~ /.*?\((.*)\)/s;    # remove brackets
+        # decode escape sequences in literal strings
+        while ($str =~ /\\(.)/sg) {
+            my $n = pos($str) - 2;
+            my $c = $1;
+            my $r;
+            if ($c =~ /[0-7]/) {
+                # get up to 2 more octal digits
+                $c .= $1 if $str =~ /\G([0-7]{1,2})/g;
+                # convert octal escape code
+                $r = chr(oct($c) & 0xff);
+            } elsif ($c eq "\x0d") {
+                # the string is continued if the line ends with '\'
+                # (also remove "\x0d\x0a")
+                $c .= $1 if $str =~ /\G(\x0a)/g;
+                $r = '';
+            } elsif ($c eq "\x0a") {
+                $r = '';
+            } else {
+                # convert escaped characters
+                ($r = $c) =~ tr/nrtbf/\n\r\t\b\f/;
+            }
+            substr($str, $n, length($c)+1) = $r;
+            # continue search after this character
+            pos($str) = $n + length($r);
+        }
+        Crypt(\$str, $lastFetched) if $cryptString;
+    } elsif ($delim eq '<') {   # hex string
+        # decode hex data
+        $str =~ tr/0-9A-Fa-f//dc;
+        $str .= '0' if length($str) & 0x01; # (by the spec)
+        $str = pack('H*', $str);
+        Crypt(\$str, $lastFetched) if $cryptString;
+    } elsif ($delim eq '/') {   # name
+        $str = substr($str, 1);
+        # convert escape codes (PDF 1.2 or later)
+        $str =~ s/#([0-9a-f]{2})/chr(hex($1))/sgei if $pdfVer >= 1.2;
+    }
+    return $str;
 }
 
@@ -408 +697 @@
 #          d) string, name, integer, boolean, null --> scalar value
 # - updates $$dataPt on return to contain unused data
-# - creates two bogus entries ('stream' and 'tags') in dictionaries to represent
-#   the stream data and a list of the tags (not including 'stream' and 'tags')
+# - creates two bogus entries ('_stream' and '_tags') in dictionaries to represent
+#   the stream data and a list of the tags (not including '_stream' and '_tags')
 #   in their original order
 sub ExtractObject($$;$$)
@@ -419 +708 @@
 
     for (;;) {
-        if ($$dataPt =~ /^\s*(<{1,2}|\[|\()/) {
+        if ($$dataPt =~ /^\s*(<{1,2}|\[|\()/s) {
             $delim = $1;
+            $$dataPt =~ s/^\s+//;   # remove leading white space
             $objData = ReadToNested($dataPt, $raf);
             return undef unless defined $objData;
             last;
-        } elsif ($$dataPt =~ s{^\s*(\S[^[(/<>\s]*)\s*}{}) {
+        } elsif ($$dataPt =~ s{^\s*(\S[^[(/<>\s]*)\s*}{}s) {
 #
 # extract boolean, numerical, string, name, null object or indirect reference
@@ -430 +720 @@
             $objData = $1;
             # look for an indirect reference
-            if ($objData =~ /^\d+$/ and $$dataPt =~ s/^(\d+)\s+R//) {
+            if ($objData =~ /^\d+$/ and $$dataPt =~ s/^(\d+)\s+R//s) {
                 $objData .= "$1 R";
                 $objData = \$objData;   # return scalar reference
@@ -440 +730 @@
     }
 #
-# extract literal string
-#
-    if ($delim eq '(') {
-        $objData = $1 if $objData =~ /.*?\((.*)\)/s;    # remove brackets
-        # decode escape sequences in literal strings
-        while ($objData =~ /\\(.)/sg) {
-            my $n = pos($objData) - 2;
-            my $c = $1;
-            my $r;
-            if ($c =~ /[0-7]/) {
-                # get up to 2 more octal digits
-                $c .= $1 if $objData =~ /\G([0-7]{1,2})/g;
-                # convert octal escape code
-                $r = chr(oct($c) & 0xff);
-            } elsif ($c eq "\x0d") {
-                # the string is continued if the line ends with '\'
-                # (also remove "\x0d\x0a")
-                $c .= $1 if $objData =~ /\G(\x0a)/g;
-                $r = '';
-            } elsif ($c eq "\x0a") {
-                # (also remove "\x0a\x0d")
-                $c .= $1 if $objData =~ /\G(\x0d)/g;
-                $r = '';
-            } else {
-                # convert escaped characters
-                ($r = $c) =~ tr/nrtbf/\n\r\t\b\f/;
-            }
-            substr($objData, $n, length($c)+1) = $r;
-            # contine search after this character
-            pos($objData) = $n + length($r);
-        }
-        Decrypt(\$objData) if $cryptInfo;
-        # convert from UTF-16 (big endian) to UTF-8 or Latin if necessary
-        if ($objData =~ s/^\xfe\xff//) {
-            $objData = $exifTool->Unicode2Charset($objData, 'MM');
-        }
+# return literal string or hex string without parsing
+#
+    if ($delim eq '(' or $delim eq '<') {
         return $objData;
 #
-# extract hex string
-#
-    } elsif ($delim eq '<') {
-        # decode hex data
-        $objData =~ tr/0-9A-Fa-f//dc;
-        $objData .= '0' if length($objData) & 0x01; # (by the spec)
-        $objData = pack('H*', $objData);
-        Decrypt(\$objData) if $cryptInfo;
-        return $objData;
-#
 # extract array
 #
     } elsif ($delim eq '[') {
-        $objData =~ /.*?\[(.*)\]/s or return;    # remove brackets
-        my $data = $1;
+        $objData =~ /.*?\[(.*)\]/s or return undef;
+        my $data = $1;    # brackets removed
         my @list;
         for (;;) {
@@ -536 +783 @@
         } elsif ($val =~ /^\d/) {
             my $pos = pos($objData);
-            if ($objData =~ /\G\s+(\d+)\s+R/g) {
+            if ($objData =~ /\G\s+(\d+)\s+R/sg) {
                 $val = \ "$val $1 R";   # make a reference
             } else {
@@ -544 +791 @@
         if ($$dict{$tag}) {
             # duplicate dictionary entries are not allowed
-            $exifTool->Warn("Duplicate $tag entry in dictionary (ignored)");
+            $exifTool->Warn('Duplicate $tag entry in dictionary (ignored)');
         } else {
             # save the entry
@@ -552 +799 @@
     }
     return undef unless @tags;
-    $$dict{tags} = \@tags;
+    $$dict{_tags} = \@tags;
     return $dict unless $raf;   # direct objects can not have streams
 #
@@ -563 +810 @@
         my $oldpos = $raf->Tell();
         # get the location of the object specifying the length
+        # (compressed objects are not allowed)
         my $offset = LocateObject($xref, $length) or return $dict;
-        $raf->Seek($offset, 0) or $exifTool->Warn("Bad Length offset"), return $dict;
+        $offset or $exifTool->Warn('Bad Length object'), return $dict;
+        $raf->Seek($offset, 0) or $exifTool->Warn('Bad Length offset'), return $dict;
         # verify that we are reading the expected object
-        $raf->ReadLine($data) or $exifTool->Warn("Error reading Length data"), return $dict;
+        $raf->ReadLine($data) or $exifTool->Warn('Error reading Length data'), return $dict;
         $length =~ s/R/obj/;
         unless ($data =~ /^$length/) {
@@ -572 +821 @@
             return $dict;
         }
-        $raf->ReadLine($data) or $exifTool->Warn("Error reading stream Length"), return $dict;
-        $data =~ /(\d+)/ or $exifTool->Warn("Stream length not found"), return $dict;
+        $raf->ReadLine($data) or $exifTool->Warn('Error reading stream Length'), return $dict;
+        $data =~ /(\d+)/ or $exifTool->Warn('Stream length not found'), return $dict;
         $length = $1;
         $raf->Seek($oldpos, 0); # restore position to start of stream
@@ -585 +834 @@
             $$dataPt .= $data if $raf->ReadLine($data);
             # remove our stream header
-            $$dataPt =~ s/^.*stream(\x0a|\x0d\x0a)//s;
+            $$dataPt =~ s/^\s*stream(\x0a|\x0d\x0a)//s;
             my $more = $length - length($$dataPt);
             if ($more > 0) {
                 unless ($raf->Read($data, $more) == $more) {
-                    $exifTool->Warn("Error reading stream data");
+                    $exifTool->Warn('Error reading stream data');
                     $$dataPt = '';
                     return $dict;
                 }
-                $$dict{stream} = $$dataPt . $data;
+                $$dict{_stream} = $$dataPt . $data;
                 $$dataPt = '';
             } elsif ($more < 0) {
-                $$dict{stream} = substr($$dataPt, 0, $length);
+                $$dict{_stream} = substr($$dataPt, 0, $length);
                 $$dataPt = substr($$dataPt, $length);
             } else {
-                $$dict{stream} = $$dataPt;
+                $$dict{_stream} = $$dataPt;
                 $$dataPt = '';
             }
@@ -616 +865 @@
 # - updates data reference with trailing data
 # - unescapes characters in literal strings
+my %closingDelim = (    # lookup for matching delimiter
+    '(' => ')',
+    '[' => ']',
+    '<' => '>',
+   '<<' => '>>',
+);
 sub ReadToNested($;$)
 {
     my ($dataPt, $raf) = @_;
-    # matching closing delimiters
-    my %closingDelim = (
-        '<<' => '>>',
-        '('  => ')',
-        '['  => ']',
-        '<'  => '>',
-    );
     my @delim = ('');   # closing delimiter list, most deeply nested first
     pos($$dataPt) = 0;  # begin at start of data
@@ -664 +912 @@
             pos($$dataPt) = pos($$dataPt) - 1;
         }
-        my $delim = shift @delim;   # remove from nesting list
+        shift @delim;               # remove from nesting list
         next if $delim[0];          # keep going if we have more nested delimiters
         my $pos = pos($$dataPt);
@@ -682 +930 @@
     my ($exifTool, $dict) = @_;
 
-    return 0 unless $$dict{stream}; # no stream to decode
-    # apply decryption first if required
-    if ($cryptInfo and not $$dict{decrypted}) {
-        $$dict{decrypted} = 1;
-        if ($$cryptInfo{meta} or ($$dict{Type} and $$dict{Type} ne '/Metadata')) {
-            Decrypt(\$$dict{stream});
-        }
-    }
-    return 1 unless $$dict{Filter};
-    if ($$dict{Filter} eq '/FlateDecode') {
-        if (eval 'require Compress::Zlib') {
-            my $inflate = Compress::Zlib::inflateInit();
-            my ($buff, $stat);
-            $inflate and ($buff, $stat) = $inflate->inflate($$dict{stream});
-            if ($inflate and $stat == Compress::Zlib::Z_STREAM_END()) {
-                $$dict{stream} = $buff;
-                # move Filter to prevent double decoding
-                $$dict{oldFilter} = $$dict{Filter};
-                $$dict{Filter} = '';
+    return 0 unless $$dict{_stream}; # no stream to decode
+
+    # get list of filters
+    my (@filters, @decodeParms, $filter);
+    if (ref $$dict{Filter} eq 'ARRAY') {
+        @filters = @{$$dict{Filter}};
+    } elsif (defined $$dict{Filter}) {
+        @filters = ($$dict{Filter});
+    }
+    # apply decryption first if required (and if the default encryption
+    # has not been overridden by a Crypt filter. Note: the Crypt filter
+    # must be first in the Filter array: ref 3, page 38)
+    unless (defined $$dict{_decrypted} or ($filters[0] and $filters[0] eq '/Crypt')) {
+        CryptStream($dict, $lastFetched);
+    }
+    return 1 unless $$dict{Filter};         # Filter entry is mandatory
+    return 0 if defined $$dict{_filtered};  # avoid double-filtering
+    $$dict{_filtered} = 1;                  # set flag to prevent double-filtering
+
+    # get array of DecodeParms dictionaries
+    if (ref $$dict{DecodeParms} eq 'ARRAY') {
+        @decodeParms = @{$$dict{DecodeParms}};
+    } else {
+        @decodeParms = ($$dict{DecodeParms});
+    }
+    foreach $filter (@filters) {
+        my $decodeParms = shift @decodeParms;
+
+        if ($filter eq '/FlateDecode') {
+            if (eval 'require Compress::Zlib') {
+                my $inflate = Compress::Zlib::inflateInit();
+                my ($buff, $stat);
+                $inflate and ($buff, $stat) = $inflate->inflate($$dict{_stream});
+                if ($inflate and $stat == Compress::Zlib::Z_STREAM_END()) {
+                    $$dict{_stream} = $buff;
+                } else {
+                    $exifTool->Warn('Error inflating stream');
+                    return 0;
+                }
             } else {
-                $exifTool->Warn('Error inflating stream');
+                $exifTool->WarnOnce('Install Compress::Zlib to process filtered streams');
                 return 0;
             }
-        } else {
-            WarnOnce($exifTool,'Install Compress::Zlib to decode filtered streams');
+            # apply anti-predictor if necessary
+            next unless ref $decodeParms eq 'HASH';
+            my $pre = $$decodeParms{Predictor};
+            next unless $pre and $pre != 1;
+            if ($pre != 12) {
+                # currently only support 'up' prediction
+                $exifTool->WarnOnce("FlateDecode Predictor $pre not currently supported");
+                return 0;
+            }
+            my $cols = $$decodeParms{Columns};
+            unless ($cols) {
+                # currently only support 'up' prediction
+                $exifTool->WarnOnce('No Columns for decoding stream');
+                return 0;
+            }
+            my @bytes = unpack('C*', $$dict{_stream});
+            my @pre = (0) x $cols;  # initialize predictor array
+            my $buff = '';
+            while (@bytes > $cols) {
+                unless (($_ = shift @bytes) == 2) {
+                    $exifTool->WarnOnce("Unsupported PNG filter $_"); # (yes, PNG)
+                    return 0;
+                }
+                foreach (@pre) {
+                    $_ = ($_ + shift(@bytes)) & 0xff;
+                }
+                $buff .= pack('C*', @pre);
+            }
+            $$dict{_stream} = $buff;
+
+        } elsif ($filter eq '/Crypt') {
+
+            # (we shouldn't have to check the _decrypted flag since we
+            #  already checked the _filtered flag, but what the heck...)
+            next if defined $$dict{_decrypted};
+            # assume Identity filter (the default) if DecodeParms are missing
+            next unless ref $decodeParms eq 'HASH';
+            my $name = $$decodeParms{Name};
+            next unless defined $name or $name eq 'Identity';
+            if ($name ne 'StdCF') {
+                $exifTool->WarnOnce("Unsupported Crypt Filter $name");
+                return 0;
+            }
+            unless ($cryptInfo) {
+                $exifTool->WarnOnce('Missing Encrypt StdCF entry');
+                return 0;
+            }
+            # decrypt the stream manually because we want to:
+            # 1) ignore $cryptStream (StmF) setting
+            # 2) ignore EncryptMetadata setting (I can't find mention of how to
+            #    reconcile this in the spec., but this would make sense)
+            # 3) avoid adding the crypt key extension (ref 3, page 58, Algorithm 1b)
+            # 4) set _decrypted flag so we will recrypt according to StmF when
+            #    writing (since we don't yet write Filter'd streams)
+            Crypt(\$$dict{_stream}, 'none');
+            $$dict{_decrypted} = ($cryptStream ? 1 : 0);
+
+        } elsif ($filter ne '/Identity') {
+
+            $exifTool->WarnOnce("Unsupported Filter $filter");
             return 0;
         }
-#
-# apply anti-predictor if necessary
-#
-        return 1 unless $$dict{DecodeParms};
-        my $pre = $dict->{DecodeParms}->{Predictor};
-        return 1 unless $pre and $pre != 1;
-        if ($pre != 12) {
-            # currently only support 'up' prediction
-            WarnOnce($exifTool,"FlateDecode Predictor $pre not currently supported");
-            return 0;
-        }
-        my $cols = $dict->{DecodeParms}->{Columns};
-        unless ($cols) {
-            # currently only support 'up' prediction
-            WarnOnce($exifTool,'No Columns for decoding stream');
-            return 0;
-        }
-        my @bytes = unpack('C*', $$dict{stream});
-        my @pre = (0) x $cols;  # initialize predictor array
-        my $buff = '';
-        while (@bytes > $cols) {
-            unless (($_ = shift @bytes) == 2) {
-                WarnOnce($exifTool, "Unsupported PNG filter $_");
-                return 0;
-            }
-            foreach (@pre) {
-                $_ = ($_ + shift(@bytes)) & 0xff;
-            }
-            $buff .= pack('C*', @pre);
-        }
-        $$dict{stream} = $buff;
-    } else {
-        WarnOnce($exifTool, "Unsupported Filter $$dict{Filter}");
-        return 0;
     }
     return 1;
@@ -795 +1087 @@
 # Inputs: 0) ExifTool object reference, 1) Encrypt dictionary reference,
 #         2) ID from file trailer dictionary
-# Returns: error string or undef on success
+# Returns: error string or undef on success (and sets $cryptInfo)
 sub DecryptInit($$$)
 {
+    local $_;
     my ($exifTool, $encrypt, $id) = @_;
+
+    undef $cryptInfo;
     unless ($encrypt and ref $encrypt eq 'HASH') {
         return 'Error loading Encrypt object';
@@ -806 +1101 @@
         return 'Encrypt dictionary has no Filter!';
     }
+    # extract some interesting tags
     my $ver = $$encrypt{V} || 0;
     my $rev = $$encrypt{R} || 0;
-    $exifTool->FoundTag('Encryption', "$filt v$ver.$rev");
-    unless ($$encrypt{Filter} eq '/Standard') {
-        $$encrypt{Filter} =~ s/^\///;
-        return "PDF '$$encrypt{Filter}' encryption not currently supported";
+    my $enc = "$filt V$ver";
+    $enc .= ".$rev" if $filt eq 'Standard';
+    $enc .= " ($1)" if $$encrypt{SubFilter} and $$encrypt{SubFilter} =~ /^\/(.*)/;
+    $enc .= ' (' . ($$encrypt{Length} || 40) . '-bit)' if $filt eq 'Standard';
+    my $tagTablePtr = GetTagTable('Image::ExifTool::PDF::Encrypt');
+    $exifTool->HandleTag($tagTablePtr, 'Filter', $enc);
+    if ($filt ne 'Standard') {
+        return "Encryption filter $filt not currently supported";
+    } elsif (not defined $$encrypt{R}) {
+        return 'Standard security handler missing revision';
     }
     unless ($$encrypt{O} and $$encrypt{P} and $$encrypt{U}) {
         return 'Incomplete Encrypt specification';
     }
-    unless ($ver == 1 or $ver == 2) {
-        return "Encryption algorithm $ver currently not supported";
+    $exifTool->HandleTag($tagTablePtr, 'P', $$encrypt{P});
+
+    my %parm;   # optional parameters extracted from Encrypt dictionary
+
+    if ($ver == 1 or $ver == 2) {
+        $cryptString = $cryptStream = 1;
+    } elsif ($ver == 4 or $ver == 5) {
+        # initialize our $cryptString and $cryptStream flags
+        foreach ('StrF', 'StmF') {
+            my $flagPt = $_ eq 'StrF' ? \$cryptString : \$cryptStream;
+            $$flagPt = $$encrypt{$_};
+            undef $$flagPt if $$flagPt and $$flagPt eq '/Identity';
+            return "Unsupported $_ encryption $$flagPt" if $$flagPt and $$flagPt ne '/StdCF';
+        }
+        if ($cryptString or $cryptStream) {
+            return 'Missing or invalid Encrypt StdCF entry' unless ref $$encrypt{CF} eq 'HASH' and
+                ref $$encrypt{CF}{StdCF} eq 'HASH' and $$encrypt{CF}{StdCF}{CFM};
+            my $cryptMeth = $$encrypt{CF}{StdCF}{CFM};
+            unless ($cryptMeth =~ /^\/(V2|AESV2|AESV3)$/) {
+                return "Unsupported encryption method $cryptMeth";
+            }
+            # set "_aesv2" or "_aesv3" flag in %$encrypt hash if AES encryption was used
+            $$encrypt{'_' . lc($1)} = 1 if $cryptMeth =~ /^\/(AESV2|AESV3)$/;
+        }
+        if ($ver == 5) {
+            # validate OE and UE entries
+            foreach ('OE', 'UE') {
+                return "Missing Encrypt $_ entry" unless $$encrypt{$_};
+                $parm{$_} = ReadPDFValue($$encrypt{$_});
+                return "Invalid Encrypt $_ entry" unless length $parm{$_} == 32;
+            }
+            require Image::ExifTool::AES;   # will need this later
+        }
+    } else {
+        return "Encryption version $ver not currently supported";
     }
     $id or return "Can't decrypt (no document ID)";
-    unless (eval 'require Digest::MD5') {
-        return 'Install Digest::MD5 to extract encrypted information';
-    }
+
+    # make sure we have the necessary libraries available
+    if ($ver < 5) {
+        unless (eval 'require Digest::MD5') {
+            return "Install Digest::MD5 to process encrypted PDF";
+        }
+    } else {
+        unless (eval 'require Digest::SHA') {
+            return "Install Digest::SHA to process AES-256 encrypted PDF";
+        }
+    }
+
     # calculate file-level en/decryption key
     my $pad = "\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08".
               "\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A";
-    my $key = $pad . $$encrypt{O} . pack('V', $$encrypt{P}) . $id;
-    my $rep = 1;
-    $$encrypt{meta} = 1; # set flag that Metadata is encrypted
-    if ($rev >= 3) {
-        # in rev 4 (not yet supported), metadata streams may not be encrypted
-        if ($$encrypt{EncryptMetadata} and $$encrypt{EncryptMetadata} =~ /false/i) {
-            delete $$encrypt{meta};     # Meta data isn't encrypted after all
-            $key .= "\xff\xff\xff\xff"; # must add this if metadata not encrypted
-        }
-        $rep += 50; # repeat MD5 50 more times if revision is 3 or greater
-    }
-    my ($len, $i);
-    if ($ver == 1) {
-        $len = 5;
-    } else {
-        $len = $$encrypt{Length} || 40;
-        $len >= 40 or return 'Bad Encrypt Length';
-        $len = int($len / 8);
-    }
-    for ($i=0; $i<$rep; ++$i) {
-        $key = substr(Digest::MD5::md5($key), 0, $len);
-    }
-    # decrypt U to see if a user password is required
-    my $dat;
-    if ($rev >= 3) {
-        $dat = Digest::MD5::md5($pad . $id);
-        RC4Crypt(\$dat, $key);
-        for ($i=1; $i<=19; ++$i) {
-            my @key = unpack('C*', $key);
-            foreach (@key) { $_ ^= $i; }
-            RC4Crypt(\$dat, pack('C*', @key));
-        }
-        $dat .= substr($$encrypt{U}, 16);
-    } else {
-        $dat = $pad;
-        RC4Crypt(\$dat, $key);
-    }
-    $dat eq $$encrypt{U} or return 'Document is password encrypted';
-    $$encrypt{key} = $key;  # save the file-level encryption key
-    $cryptInfo = $encrypt;  # save a reference to the Encrypt object
+    my $o = ReadPDFValue($$encrypt{O});
+    my $u = ReadPDFValue($$encrypt{U});
+
+    # set flag indicating whether metadata is encrypted
+    # (in version 4 and higher, metadata streams may not be encrypted)
+    if ($ver < 4 or not $$encrypt{EncryptMetadata} or $$encrypt{EncryptMetadata} !~ /false/i) {
+        $$encrypt{_meta} = 1;
+    }
+    # try no password first, then try provided password if available
+    my ($try, $key);
+    for ($try=0; ; ++$try) {
+        my $password;
+        if ($try == 0) {
+            $password = '';
+        } elsif ($try == 1) {
+            $password = $exifTool->Options('Password');
+            return 'Document is password protected (use Password option)' unless defined $password;
+            # make sure there is no UTF-8 flag on the password
+            if ($] >= 5.006 and (eval 'require Encode; Encode::is_utf8($password)' or $@)) {
+                # repack by hand if Encode isn't available
+                $password = $@ ? pack('C*',unpack('U0C*',$password)) : Encode::encode('utf8',$password);
+            }
+        } else {
+            return 'Incorrect password';
+        }
+        if ($ver < 5) {
+            if (length $password) {
+                # password must be encoding in PDFDocEncoding (ref iso32000)
+                $password = $exifTool->Encode($password, 'PDFDoc');
+                # truncate or pad the password to exactly 32 bytes
+                if (length($password) > 32) {
+                    $password = substr($password, 0, 32);
+                } elsif (length($password) < 32) {
+                    $password .= substr($pad, 0, 32-length($password));
+                }
+            } else {
+                $password = $pad;
+            }
+            $key = $password . $o . pack('V', $$encrypt{P}) . $id;
+            my $rep = 1;
+            if ($rev == 3 or $rev == 4) {
+                # must add this if metadata not encrypted
+                $key .= "\xff\xff\xff\xff" unless $$encrypt{_meta};
+                $rep += 50; # repeat MD5 50 more times if revision is 3 or greater
+            }
+            my ($len, $i, $dat);
+            if ($ver == 1) {
+                $len = 5;
+            } else {
+                $len = $$encrypt{Length} || 40;
+                $len >= 40 or return 'Bad Encrypt Length';
+                $len = int($len / 8);
+            }
+            for ($i=0; $i<$rep; ++$i) {
+                $key = substr(Digest::MD5::md5($key), 0, $len);
+            }
+            # decrypt U to see if a user password is required
+            if ($rev >= 3) {
+                $dat = Digest::MD5::md5($pad . $id);
+                RC4Crypt(\$dat, $key);
+                for ($i=1; $i<=19; ++$i) {
+                    my @key = unpack('C*', $key);
+                    foreach (@key) { $_ ^= $i; }
+                    RC4Crypt(\$dat, pack('C*', @key));
+                }
+                $dat .= substr($u, 16);
+            } else {
+                $dat = $pad;
+                RC4Crypt(\$dat, $key);
+            }
+            last if $dat eq $u; # all done if this was the correct key
+        } else {
+            return 'Invalid O or U Encrypt entries' if length($o) < 48 or length($u) < 48;
+            if (length $password) {
+                # Note: this should be good for passwords containing reasonable characters,
+                # but to be bullet-proof we need to apply the SASLprep (IETF RFC 4013) profile
+                # of stringprep (IETF RFC 3454) to the password before encoding in UTF-8
+                $password = $exifTool->Encode($password, 'UTF8');
+                $password = substr($password, 0, 127) if length($password) > 127;
+            }
+            # test for the owner password
+            my $sha = Digest::SHA::sha256($password, substr($o,32,8), substr($u,0,48));
+            if ($sha eq substr($o, 0, 32)) {
+                $key = Digest::SHA::sha256($password, substr($o,40,8), substr($u,0,48));
+                my $dat = ("\0" x 16) . $parm{OE};
+                # decrypt with no padding
+                my $err = Image::ExifTool::AES::Crypt(\$dat, $key, 0, 1);
+                return $err if $err;
+                $key = $dat;    # use this as the file decryption key
+                last;
+            }
+            # test for the user password
+            $sha = Digest::SHA::sha256($password, substr($u,32,8));
+            if ($sha eq substr($u, 0, 32)) {
+                $key = Digest::SHA::sha256($password, substr($u,40,8));
+                my $dat = ("\0" x 16) . $parm{UE};
+                my $err = Image::ExifTool::AES::Crypt(\$dat, $key, 0, 1);
+                return $err if $err;
+                $key = $dat;    # use this as the file decryption key
+                last;
+            }
+        }
+    }
+    $$encrypt{_key} = $key; # save the file-level encryption key
+    $cryptInfo = $encrypt;  # save reference to the file-level Encrypt object
     return undef;           # success!
 }
 
 #------------------------------------------------------------------------------
-# Decrypt data
-# Inputs: 0) data reference
-sub Decrypt($)
+# Decrypt/Encrypt data
+# Inputs: 0) data ref
+#         1) PDF object reference to use as crypt key extension (may be 'none' to
+#            avoid extending the encryption key, as for streams with Crypt Filter)
+#         2) encrypt flag (false for decryption)
+sub Crypt($$;$)
 {
-    my $dataPt = shift;
-    my $key = $$cryptInfo{key};
-    my $len = length($key) + 5;
-    return unless $lastFetched =~ /^(I\d+ )?(\d+) (\d+)/;
-    $key .= substr(pack('V', $2), 0, 3) . substr(pack('V', $3), 0, 2);
-    $len = 16 if $len > 16;
-    $key = substr(Digest::MD5::md5($key), 0, $len);
-    RC4Crypt($dataPt, $key);
+    return unless $cryptInfo;
+    my ($dataPt, $keyExt, $encrypt) = @_;
+    # do not decrypt if the key extension object is undefined
+    # (this doubles as a flag to disable decryption/encryption)
+    return unless defined $keyExt;
+    my $key = $$cryptInfo{_key};
+    # apply the necessary crypt key extension
+    unless ($$cryptInfo{_aesv3}) {
+        unless ($keyExt eq 'none') {
+            # extend crypt key using object and generation number
+            unless ($keyExt =~ /^(I\d+ )?(\d+) (\d+)/) {
+                $$cryptInfo{_error} = 'Invalid object reference for encryption';
+                return;
+            }
+            $key .= substr(pack('V', $2), 0, 3) . substr(pack('V', $3), 0, 2);
+        }
+        # add AES-128 salt if necessary (this little gem is conveniently
+        # omitted from the Adobe PDF 1.6 documentation, causing me to
+        # waste 12 hours trying to figure out why this wasn't working --
+        # it appears in ISO32000 though, so I should have been using that)
+        $key .= 'sAlT' if $$cryptInfo{_aesv2};
+        my $len = length($key);
+        $key = Digest::MD5::md5($key);              # get 16-byte MD5 digest
+        $key = substr($key, 0, $len) if $len < 16;  # trim if necessary
+    }
+    # perform the decryption/encryption
+    if ($$cryptInfo{_aesv2} or $$cryptInfo{_aesv3}) {
+        require Image::ExifTool::AES;
+        my $err = Image::ExifTool::AES::Crypt($dataPt, $key, $encrypt);
+        $err and $$cryptInfo{_error} = $err;
+    } else {
+        RC4Crypt($dataPt, $key);
+    }
+}
+
+#------------------------------------------------------------------------------
+# Decrypt/Encrypt stream data
+# Inputs: 0) dictionary ref, 1) PDF object reference to use as crypt key extension
+sub CryptStream($$)
+{
+    return unless $cryptStream;
+    my ($dict, $keyExt) = @_;
+    my $type = $$dict{Type} || '';
+    # XRef streams are not encrypted (ref 3, page 50),
+    # and Metadata may or may not be encrypted
+    if ($cryptInfo and $type ne '/XRef' and
+        ($$cryptInfo{_meta} or $type ne '/Metadata'))
+    {
+        Crypt(\$$dict{_stream}, $keyExt, $$dict{_decrypted});
+        # toggle _decrypted flag
+        $$dict{_decrypted} = ($$dict{_decrypted} ? undef : 1);
+    } else {
+        $$dict{_decrypted} = 0; # stream should never be encrypted
+    }
+}
+
+#------------------------------------------------------------------------------
+# Generate a new PDF tag (based on its ID) and add it to a tag table
+# Inputs: 0) tag table ref, 1) tag ID
+# Returns: tag info ref
+sub NewPDFTag($$)
+{
+    my ($tagTablePtr, $tag) = @_;
+    my $name = $tag;
+    # translate URL-like escape sequences
+    $name =~ s/#([0-9a-f]{2})/chr(hex($1))/ige;
+    $name =~ s/[^-\w]+/_/g;         # translate invalid characters to an underline
+    $name =~ s/(^|_)([a-z])/\U$2/g; # start words with upper case
+    my $tagInfo = { Name => $name };
+    Image::ExifTool::AddTagToTable($tagTablePtr, $tag, $tagInfo);
+    return $tagInfo;
 }
 
@@ -888 +1363 @@
 # Inputs: 0) ExifTool object reference, 1) tag table reference
 #         2) dictionary reference, 3) cross-reference table reference,
-#         4) nesting depth
-sub ProcessDict($$$$;$)
+#         4) nesting depth, 5) dictionary capture type
+sub ProcessDict($$$$;$$)
 {
-    my ($exifTool, $tagTablePtr, $dict, $xref, $nesting) = @_;
+    my ($exifTool, $tagTablePtr, $dict, $xref, $nesting, $type) = @_;
     my $verbose = $exifTool->Options('Verbose');
-    my @tags = @{$$dict{tags}};
+    my $unknown = $$tagTablePtr{EXTRACT_UNKNOWN};
+    my $embedded = (defined $unknown and not $unknown and $exifTool->Options('ExtractEmbedded'));
+    my @tags = @{$$dict{_tags}};
+    my ($next, %join);
     my $index = 0;
-    my $next;
 
     $nesting = ($nesting || 0) + 1;
     if ($nesting > 50) {
-        WarnOnce($exifTool, 'Nesting too deep (directory ignored)');
+        $exifTool->WarnOnce('Nesting too deep (directory ignored)');
         return;
+    }
+    # save entire dictionary for rewriting if specified
+    if ($$exifTool{PDF_CAPTURE} and $$tagTablePtr{VARS} and
+        $tagTablePtr->{VARS}->{CAPTURE})
+    {
+        my $name;
+        foreach $name (@{$tagTablePtr->{VARS}->{CAPTURE}}) {
+            next if $exifTool->{PDF_CAPTURE}->{$name};
+            # make sure we load the right type if indicated
+            next if $type and $type ne $name;
+            $exifTool->{PDF_CAPTURE}->{$name} = $dict;
+            last;
+        }
     }
 #
@@ -915 +1405 @@
             last;
         }
+        my $val = $$dict{$tag};
         if ($$tagTablePtr{$tag}) {
             $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
-        }
-        my $val = $$dict{$tag};
+            undef $tagInfo if $$tagInfo{NoProcess};
+        } elsif ($embedded and $tag =~ /^(.*?)(\d+)$/ and
+            $$tagTablePtr{$1} and ref $val eq 'SCALAR' and not $fetched{$$val})
+        {
+            my ($name, $num) = ($1, $2);
+            $join{$name} = [] unless $join{$name};
+            $fetched{$$val} = 1;
+            my $obj = FetchObject($exifTool, $$val, $xref, $tag);
+            next unless ref $obj eq 'HASH' and $$obj{_stream};
+            # save all the stream data to join later
+            $join{$name}->[$num] = $$obj{_stream};
+        }
         if ($verbose) {
             my ($val2, $extra);
@@ -932 +1433 @@
                     $fetched{$$val} = 1;
                     $val = FetchObject($exifTool, $$val, $xref, $tag);
-                    $val2 = '<err>' unless defined $val;
+                    unless (defined $val) {
+                        my $str;
+                        if (defined $lastOffset) {
+                            $val2 = '<free>';
+                            $str = 'Object was freed';
+                        } else {
+                            $val2 = '<err>';
+                            $str = 'Error reading object';
+                        }
+                        $exifTool->VPrint(0, "$$exifTool{INDENT}${str}:\n");
+                    }
                 }
             } elsif (ref $val eq 'HASH') {
@@ -962 +1473 @@
                     },
                 };
-            } elsif (ref $val eq 'ARRAY') {
-                my @list = @$val;
-                foreach (@list) {
-                    $_ = "ref($$_)" if ref $_ eq 'SCALAR';
+            } else {
+                if (ref $val eq 'ARRAY') {
+                    my @list = @$val;
+                    foreach (@list) {
+                        $_ = "ref($$_)" if ref $_ eq 'SCALAR';
+                    }
+                    $val2 = '[' . join(',',@list) . ']';
                 }
-                $val2 = '[' . join(',',@list) . ']';
+                # generate tag info if we will use it later
+                if (not $tagInfo and defined $val and $unknown) {
+                    $tagInfo = NewPDFTag($tagTablePtr, $tag);
+                }
             }
             $exifTool->VerboseInfo($tag, $tagInfo,
@@ -974 +1491 @@
                 Index => $index++,
             );
+            next unless defined $val;
         }
         unless ($tagInfo) {
             # add any tag found in Info directory to table
-            next unless $$tagTablePtr{EXTRACT_UNKNOWN};
-            $tagInfo = { Name => $tag };
-            Image::ExifTool::AddTagToTable($tagTablePtr, $tag, $tagInfo);
+            next unless $unknown;
+            $tagInfo = NewPDFTag($tagTablePtr, $tag);
         }
         unless ($$tagInfo{SubDirectory}) {
+            # fetch object if necessary
+            # (OS X 10.6 writes indirect objects in the Info dictionary!)
+            if (ref $val eq 'SCALAR') {
+                my $prevFetched = $lastFetched;
+                # (note: fetching the same object multiple times is OK here)
+                $val = FetchObject($exifTool, $$val, $xref, $tag);
+                next unless defined $val;
+                $val = ReadPDFValue($val);
+                # set flag to re-encrypt if necessary if rewritten
+                $$dict{_needCrypt}{$tag} = ($lastFetched ? 0 : 1) if $cryptString;
+                $lastFetched = $prevFetched; # restore last fetched object reference
+            } else {
+                $val = ReadPDFValue($val);
+            }
+            my $format = $$tagInfo{Format} || $$tagInfo{Writable} || 'string';
+            $val = ConvertPDFDate($val) if $format eq 'date';
             # convert from UTF-16 (big endian) to UTF-8 or Latin if necessary
             # unless this is binary data (hex-encoded strings would not have been converted)
-            if ($val =~ s/^\xfe\xff// and not $$tagInfo{Binary}) {
-                $val = $exifTool->Unicode2Charset($val, 'MM');
-            }
-            if ($$tagInfo{List}) {
-                # separate tokens in comma or whitespace delimited lists
-                my @values = ($val =~ /,/) ? split /,+\s*/, $val : split ' ', $val;
-                foreach $val (@values) {
+            if (ref $val) {
+                next if ref $val ne 'ARRAY';
+                my $v;
+                foreach $v (@$val) {
+                    $exifTool->FoundTag($tagInfo, $v);
+                }
+            } else {
+                if (not $$tagInfo{Binary} and $val =~ /[\x18-\x1f\x80-\xff]/) {
+                    # text string is already in Unicode if it starts with "\xfe\xff",
+                    # otherwise we must first convert from PDFDocEncoding
+                    $val = $exifTool->Decode($val, ($val=~s/^\xfe\xff// ? 'UCS2' : 'PDFDoc'), 'MM');
+                }
+                if ($$tagInfo{List}) {
+                    # separate tokens in comma or whitespace delimited lists
+                    my @values = ($val =~ /,/) ? split /,+\s*/, $val : split ' ', $val;
+                    foreach $val (@values) {
+                        $exifTool->FoundTag($tagInfo, $val);
+                    }
+                } else {
+                    # a simple tag value
                     $exifTool->FoundTag($tagInfo, $val);
                 }
-            } else {
-                # a tag value
-                $exifTool->FoundTag($tagInfo, $val);
             }
             next;
@@ -1009 +1552 @@
         for (;;) {
             my $subDict = shift @subDicts or last;
+            # save last fetched object in case we fetch another one here
+            my $prevFetched = $lastFetched;
             if (ref $subDict eq 'SCALAR') {
+                # only fetch once (other copies are obsolete)
+                next if $fetched{$$subDict};
                 # load dictionary via an indirect reference
                 $fetched{$$subDict} = 1;
-                $subDict = FetchObject($exifTool, $$subDict, $xref, $tag);
-                $subDict or $exifTool->Warn("Error reading $tag object"), next;
+                my $obj = FetchObject($exifTool, $$subDict, $xref, $tag);
+                unless (defined $obj) {
+                    unless (defined $lastOffset) {
+                        $exifTool->Warn("Error reading $tag object ($$subDict)");
+                    }
+                    next;
+                }
+                $subDict = $obj;
             }
             if (ref $subDict eq 'ARRAY') {
                 # convert array of key/value pairs to a hash
                 next if @$subDict < 2;
-                my %hash = ( tags => [] );
+                my %hash = ( _tags => [] );
                 while (@$subDict >= 2) {
                     my $key = shift @$subDict;
                     $key =~ s/^\///;
-                    push @{$hash{tags}}, $key;
+                    push @{$hash{_tags}}, $key;
                     $hash{$key} = shift @$subDict;
                 }
@@ -1029 +1582 @@
                 next unless ref $subDict eq 'HASH';
             }
+            # set flag to re-crypt all strings when rewriting if the dictionary
+            # came from an encrypted stream
+            $$subDict{_needCrypt}{'*'} = 1 unless $lastFetched;
             my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
             if (not $verbose) {
-                ProcessDict($exifTool, $subTablePtr, $subDict, $xref, $nesting);
+                my $proc = $$subTablePtr{PROCESS_PROC} || \&ProcessDict;
+                &$proc($exifTool, $subTablePtr, $subDict, $xref, $nesting);
             } elsif ($next) {
                 # handle 'Next' links at this level to avoid deep recursion
@@ -1038 +1595 @@
                 $tagTablePtr = $subTablePtr;
                 $dict = $subDict;
-                @tags = @{$$subDict{tags}};
+                @tags = @{$$subDict{_tags}};
                 $exifTool->VerboseDir($tag, scalar(@tags));
             } else {
@@ -1045 +1602 @@
                 $exifTool->{INDENT} .= '| ';
                 $exifTool->{DIR_NAME} = $tag;
-                $exifTool->VerboseDir($tag, scalar(@{$$subDict{tags}}));
+                $exifTool->VerboseDir($tag, scalar(@{$$subDict{_tags}}));
                 ProcessDict($exifTool, $subTablePtr, $subDict, $xref, $nesting);
                 $exifTool->{INDENT} = $oldIndent;
                 $exifTool->{DIR_NAME} = $oldDir;
             }
-        }
-    }
-#
-# extract information from stream object if it exists
-#
-    return unless $$dict{stream};
-    my $tag = 'stream';
+            $lastFetched = $prevFetched;
+        }
+    }
+#
+# extract information from joined streams if necessary
+#
+
+    if (%join) {
+        my ($tag, $i);
+        foreach $tag (sort keys %join) {
+            my $list = $join{$tag};
+            last unless defined $$list[1] and $$list[1] =~ /^%.*?([\x0d\x0a]*)/;
+            my $buff = "%!PS-Adobe-3.0$1";  # add PS header with same line break
+            for ($i=1; defined $$list[$i]; ++$i) {
+                $buff .= $$list[$i];
+                undef $$list[$i];   # free memory
+            }
+            $exifTool->HandleTag($tagTablePtr, $tag, $buff);
+        }
+    }
+#
+# extract information from stream object if it exists (ie. Metadata stream)
+#
+    return unless $$dict{_stream};
+    my $tag = '_stream';
     # add Subtype (if it exists) to stream name and remove leading '/'
-    ($tag = "$$dict{Subtype}_$tag") =~ s/^\/// if $$dict{Subtype};
+    ($tag = $$dict{Subtype} . $tag) =~ s/^\/// if $$dict{Subtype};
     return unless $$tagTablePtr{$tag};
     my $tagInfo = $exifTool->GetTagInfo($tagTablePtr, $tag);
@@ -1065 +1640 @@
     # extract information from stream
     my %dirInfo = (
-        DataPt => \$$dict{stream},
-        DataLen => length $$dict{stream},
+        DataPt   => \$$dict{_stream},
+        DataLen  => length $$dict{_stream},
         DirStart => 0,
-        DirLen => length $$dict{stream},
-        Parent => 'PDF',
+        DirLen   => length $$dict{_stream},
+        Parent   => 'PDF',
     );
     my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}->{TagTable});
@@ -1086 +1661 @@
     my $raf = $$dirInfo{RAF};
     my $verbose = $exifTool->Options('Verbose');
-    my ($data, $encrypt, $id);
+    my ($buff, $encrypt, $id);
 #
 # validate PDF file
 #
-    $raf->Read($data, 4) == 4 or return 0;
-    $data eq '%PDF' or return 0;
+    # (linearization dictionary must be in the first 1024 bytes of the file)
+    $raf->Read($buff, 1024) >= 8 or return 0;
+    $buff =~ /^%PDF-(\d+\.\d+)/ or return 0;
+    $pdfVer = $1;
     $exifTool->SetFileType();   # set the FileType tag
-    my $tagTablePtr = GetTagTable('Image::ExifTool::PDF::Main');
+    $exifTool->Warn("May not be able to read a PDF version $pdfVer file") if $pdfVer >= 2.0;
+    # store PDFVersion tag
+    my $tagTablePtr = GetTagTable('Image::ExifTool::PDF::Root');
+    $exifTool->HandleTag($tagTablePtr, 'Version', $pdfVer);
+    $tagTablePtr = GetTagTable('Image::ExifTool::PDF::Main');
+#
+# check for a linearized PDF (only if reading)
+#
+    my $capture = $$exifTool{PDF_CAPTURE};
+    unless ($capture) {
+        my $lin = 'false';
+        if ($buff =~ /<</g) {
+            $buff = substr($buff, pos($buff) - 2);
+            my $dict = ExtractObject($exifTool, \$buff);
+            if (ref $dict eq 'HASH' and $$dict{Linearized} and $$dict{L}) {
+                if (not $$exifTool{VALUE}{FileSize}) {
+                    undef $lin; # can't determine if it is linearized
+                } elsif ($$dict{L} == $$exifTool{VALUE}{FileSize}) {
+                    $lin = 'true';
+                }
+            }
+        }
+        $exifTool->HandleTag($tagTablePtr, '_linearized', $lin) if $lin;
+    }
 #
 # read the xref tables referenced from startxref at the end of the file
@@ -1103 +1703 @@
     $len = 1024 if $len > 1024;
     $raf->Seek(-$len, 2) or return -2;
-    $raf->Read($data, $len) == $len or return -3;
-    $data =~ /.*startxref(\x0d\x0a|\x0a\x0a|\x0d|\x0a)(\d+)\1%%EOF/s or return -4;
-    $/ = $1;    # set input record separator
-    push @xrefOffsets, $2;
-    my (%xref, @mainDicts, %loaded);
+    $raf->Read($buff, $len) == $len or return -3;
+    # find the last xref table in the file (may be multiple %%EOF marks)
+    $buff =~ /.*startxref *(\x0d\x0a|\x0d|\x0a)\s*?(\d+)\s+%%EOF/s or return -4;
+    local $/ = $1;    # set input record separator
+    push @xrefOffsets, $2, 'Main';
+    my (%xref, @mainDicts, %loaded, $mainFree);
+    # initialize variables to capture when rewriting
+    if ($capture) {
+        $capture->{startxref} = $2;
+        $capture->{xref} = \%xref;
+        $capture->{newline} = $/;
+        $capture->{mainFree} = $mainFree = { };
+    }
     while (@xrefOffsets) {
         my $offset = shift @xrefOffsets;
+        my $type = shift @xrefOffsets;
         next if $loaded{$offset};   # avoid infinite recursion
         unless ($raf->Seek($offset, 0)) {
@@ -1116 +1725 @@
             next;
         }
-        unless ($raf->ReadLine($data)) {
+        # Note: care must be taken because ReadLine may read more than we want if
+        # the newline sequence for this table is different than the rest of the file
+        unless ($raf->ReadLine($buff)) {
             %loaded or return -6;
             $exifTool->Warn('Bad offset for secondary xref table');
@@ -1122 +1733 @@
         }
         my $loadXRefStream;
-        if ($data eq "xref$/") {
+        if ($buff =~ s/^xref\s+//s) {
             # load xref table
             for (;;) {
-                $raf->ReadLine($data) or return -6;
-                last if $data eq "trailer$/";
-                my ($start, $num) = $data =~ /(\d+)\s+(\d+)/;
-                $num or return -4;
+                # read another line if necessary (skipping blank lines)
+                $raf->ReadLine($buff) or return -6 until $buff =~ /\S/;
+                last if $buff =~ s/^\s*trailer\s+//s;
+                $buff =~ s/\s*(\d+)\s+(\d+)\s+//s or return -4;
+                my ($start, $num) = ($1, $2);
+                $raf->Seek(-length($buff), 1) or return -4;
                 my $i;
                 for ($i=0; $i<$num; ++$i) {
-                    $raf->Read($data, 20) == 20 or return -6;
-                    $data =~ /^(\d{10}) (\d{5}) (f|n)/ or return -4;
-                    next if $3 eq 'f';  # ignore free entries
-                    # save the object offset keyed by its reference
-                    my $ref = ($start + $i) . ' ' . int($2) . ' R';
-                    $xref{$ref} = int($1);
+                    $raf->Read($buff, 20) == 20 or return -6;
+                    $buff =~ /^\s*(\d{10}) (\d{5}) (f|n)/s or return -4;
+                    my $num = $start + $i;
+                    # save offset for newest copy of all objects
+                    # (or next object number for free objects)
+                    unless (defined $xref{$num}) {
+                        my ($offset, $gen) = (int($1), int($2));
+                        $xref{$num} = $offset;
+                        if ($3 eq 'f') {
+                            # save free objects in last xref table for rewriting
+                            $$mainFree{$num} =  [ $offset, $gen, 'f' ] if $mainFree;
+                            next;
+                        }
+                        # also save offset keyed by object reference string
+                        $xref{"$num $gen R"} = $offset;
+                    }
                 }
-            }
-            %xref or return -4;
-            $data = '';
-        } elsif ($data =~ s/^(\d+)\s+(\d+)\s+obj//) {
+                # (I have a sample from Adobe which has an empty xref table)
+                # %xref or return -4; # xref table may not be empty
+                $buff = '';
+            }
+            undef $mainFree;    # only do this for the last xref table
+        } elsif ($buff =~ s/^(\d+)\s+(\d+)\s+obj//s) {
             # this is a PDF-1.5 cross-reference stream dictionary
             $loadXRefStream = 1;
@@ -1149 +1774 @@
             next;
         }
-        my $mainDict = ExtractObject($exifTool, \$data, $raf, \%xref);
-        unless ($mainDict) {
+        my $mainDict = ExtractObject($exifTool, \$buff, $raf, \%xref);
+        unless (ref $mainDict eq 'HASH') {
             %loaded or return -8;
             $exifTool->Warn('Error loading secondary dictionary');
@@ -1157 +1782 @@
         if ($loadXRefStream) {
             # decode and save our XRef stream from PDF-1.5 file
-            # (parse it later as required to avoid wasting time)
+            # (but parse it later as required to save time)
+            # Note: this technique can potentially result in an old object
+            # being used if the file was incrementally updated and an older
+            # object from an xref table was replaced by a newer object in an
+            # xref stream.  But doing so isn't a good idea (if allowed at all)
+            # because a PDF 1.4 consumer would also make this same mistake.
             if ($$mainDict{Type} eq '/XRef' and $$mainDict{W} and
                 @{$$mainDict{W}} > 2 and $$mainDict{Size} and
@@ -1164 +1794 @@
                 # create Index entry if it doesn't exist
                 $$mainDict{Index} or $$mainDict{Index} = [ 0, $$mainDict{Size} ];
-                # create 'entry_size' entry for internal use
+                # create '_entry_size' entry for internal use
                 my $w = $$mainDict{W};
                 my $size = 0;
                 foreach (@$w) { $size += $_; }
-                $$mainDict{entry_size} = $size;
+                $$mainDict{_entry_size} = $size;
                 # save this stream dictionary to use later if required
                 $xref{dicts} = [] unless $xref{dicts};
@@ -1179 +1809 @@
         $loaded{$offset} = 1;
         # load XRef stream in hybrid file if it exists
-        push @xrefOffsets, $$mainDict{XRefStm} if $$mainDict{XRefStm};
+        push @xrefOffsets, $$mainDict{XRefStm}, 'XRefStm' if $$mainDict{XRefStm};
         $encrypt = $$mainDict{Encrypt} if $$mainDict{Encrypt};
         if ($$mainDict{ID} and ref $$mainDict{ID} eq 'ARRAY') {
-            $id = $mainDict->{ID}->[0];
-        }
-        push @mainDicts, $mainDict;
+            $id = ReadPDFValue($mainDict->{ID}->[0]);
+        }
+        push @mainDicts, $mainDict, $type;
         # load previous xref table if it exists
-        push @xrefOffsets, $$mainDict{Prev} if $$mainDict{Prev};
+        push @xrefOffsets, $$mainDict{Prev}, 'Prev' if $$mainDict{Prev};
     }
 #
@@ -1197 +1827 @@
         # generate Encryption tag information
         my $err = DecryptInit($exifTool, $encrypt, $id);
-        $err and $exifTool->Warn($err), return -1;
+        if ($err) {
+            $exifTool->Warn($err);
+            $$capture{Error} = $err if $capture;
+            return -1;
+        }
     }
 #
 # extract the information beginning with each of the main dictionaries
 #
-    my $dict;
-    foreach $dict (@mainDicts) {
+    while (@mainDicts) {
+        my $dict = shift @mainDicts;
+        my $type = shift @mainDicts;
         if ($verbose) {
-            my $n = scalar(@{$$dict{tags}});
+            my $n = scalar(@{$$dict{_tags}});
             $exifTool->VPrint(0, "PDF dictionary with $n entries:\n");
         }
-        ProcessDict($exifTool, $tagTablePtr, $dict, \%xref);
+        ProcessDict($exifTool, $tagTablePtr, $dict, \%xref, 0, $type);
+    }
+    # handle any decryption errors
+    if ($encrypt) {
+        my $err = $$encrypt{_error};
+        if ($err) {
+            $exifTool->Warn($err);
+            $$capture{Error} = $err if $capture;
+            return -1;
+        }
     }
     return 1;
@@ -1235 +1879 @@
     my ($exifTool, $dirInfo) = @_;
 
-    my $oldsep = $/;
+    undef $cryptInfo;   # (must not delete after returning so writer can use it)
+    undef $cryptStream;
+    undef $cryptString;
     my $result = ReadPDF($exifTool, $dirInfo);
-    $/ = $oldsep;   # restore input record separator in case it was changed
     if ($result < 0) {
         $exifTool->Warn($pdfWarning{$result}) if $pdfWarning{$result};
@@ -1243 +1888 @@
     }
     # clean up and return
-    undef %warnedOnce;
     undef %streamObjs;
     undef %fetched;
-    undef $cryptInfo;
     return $result;
 }
@@ -1267 +1910 @@
 This code reads meta information from PDF (Adobe Portable Document Format)
 files.  It supports object streams introduced in PDF-1.5 but only with a
-limited set of Filter and Predictor algorithms, and it decodes encrypted
-information but only with a limited number of algorithms.
+limited set of Filter and Predictor algorithms, however all standard
+encryption methods through PDF-1.7 extension level 3 are supported,
+including AESV2 (AES-128) and AESV3 (AES-256).
 
 =head1 AUTHOR
 
-Copyright 2003-2007, Phil Harvey (phil at owl.phy.queensu.ca)
+Copyright 2003-2011, Phil Harvey (phil at owl.phy.queensu.ca)
 
 This library is free software; you can redistribute it and/or modify it
@@ -1283 +1927 @@
 =item L<http://partners.adobe.com/public/developer/pdf/index_reference.html>
 
-=item L<http://www.cr0.net:8040/code/crypto/rc4/>
+=item L<Crypt::RC4|Crypt::RC4>
+
+=item L<http://www.adobe.com/devnet/acrobat/pdfs/PDF32000_2008.pdf>
+
+=item L<http://www.adobe.com/content/dam/Adobe/en/devnet/pdf/pdfs/adobe_supplement_iso32000.pdf>
+
+=item L<http://tools.ietf.org/search/rfc3454>
+
+=item L<http://www.armware.dk/RFC/rfc/rfc4013.html>
 
 =back