exiftool_vendored 9.45.0 → 9.46.0

data/bin/Image-ExifTool-9.46/lib/Image/ExifTool/MPF.pm

@@ -0,0 +1,289 @@
+#------------------------------------------------------------------------------
+# File:         MPF.pm
+#
+# Description:  Read Multi-Picture Format information
+#
+# Revisions:    06/12/2009 - P. Harvey Created
+#
+# References:   1) http://www.cipa.jp/english/hyoujunka/kikaku/pdf/DC-007_E.pdf
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::MPF;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::Exif;
+
+$VERSION = '1.07';
+
+sub ProcessMPImageList($$$);
+
+# Tags found in MPF APP2 segment in JPEG images
+%Image::ExifTool::MPF::Main = (
+    GROUPS => { 0 => 'MPF', 1 => 'MPF0', 2 => 'Image'},
+    NOTES => q{
+        These tags are part of the CIPA Multi-Picture Format specification, and are
+        found in the APP2 "MPF" segment of JPEG images.  MPImage data referenced
+        from this segment is stored as a JPEG trailer.  The MPF tags are not
+        writable, however the MPG segment may be deleted as a group (with "MPF:All")
+        but then the JPEG trailer should also be deleted (with "Trailer:All").  See
+        L<http://www.cipa.jp/english/hyoujunka/kikaku/pdf/DC-007_E.pdf> for the
+        official specification.
+    },
+    0xb000 => 'MPFVersion',
+    0xb001 => 'NumberOfImages',
+    0xb002 => {
+        Name => 'MPImageList',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::MPF::MPImage',
+            ProcessProc => \&ProcessMPImageList,
+        },
+    },
+    0xb003 => {
+        Name => 'ImageUIDList',
+        Binary => 1,
+    },
+    0xb004 => 'TotalFrames',
+    0xb101 => 'MPIndividualNum',
+    0xb201 => {
+        Name => 'PanOrientation',
+        PrintHex => 1,
+        Notes => 'long integer is split into 4 bytes',
+        ValueConv => 'join(" ",unpack("C*",pack("N",$val)))',
+        PrintConv => [
+            '"$val rows"',
+            '"$val columns"',
+            {
+                0 => '[unused]',
+                1 => 'Start at top right',
+                2 => 'Start at top left',
+                3 => 'Start at bottom left',
+                4 => 'Start at bottom right',
+            },
+            {
+                0x01 => 'Left to right',
+                0x02 => 'Right to left',
+                0x03 => 'Top to bottom',
+                0x04 => 'Bottom to top',
+                0x10 => 'Clockwise',
+                0x20 => 'Counter clockwise',
+                0x30 => 'Zigzag (row start)',
+                0x40 => 'Zigzag (column start)',
+            },
+        ],
+    },          
+    0xb202 => 'PanOverlapH',
+    0xb203 => 'PanOverlapV',
+    0xb204 => 'BaseViewpointNum',
+    0xb205 => 'ConvergenceAngle',
+    0xb206 => 'BaselineLength',
+    0xb207 => 'VerticalDivergence',
+    0xb208 => 'AxisDistanceX',
+    0xb209 => 'AxisDistanceY',
+    0xb20a => 'AxisDistanceZ',
+    0xb20b => 'YawAngle',
+    0xb20c => 'PitchAngle',
+    0xb20d => 'RollAngle',
+);
+
+# Tags found in MPImage structure
+%Image::ExifTool::MPF::MPImage = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    #WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
+    #CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
+    #WRITABLE => 1,
+    GROUPS => { 0 => 'MPF', 1 => 'MPImage', 2 => 'Image'},
+    NOTES => q{
+        The first MPF "Large Thumbnail" image is extracted as PreviewImage, and the
+        rest of the embedded MPF images are extracted as MPImage#.  The
+        ExtractEmbedded (-ee) option may be used to extract information from these
+        embedded images.
+    },
+    0.1 => {
+        Name => 'MPImageFlags',
+        Format => 'int32u',
+        Mask => 0xf8000000,
+        PrintConv => { BITMASK => {
+            29 => 'Representative image',
+            30 => 'Dependent child image',
+            31 => 'Dependent parent image',
+        }},
+    },
+    0.2 => {
+        Name => 'MPImageFormat',
+        Format => 'int32u',
+        Mask => 0x07000000,
+        PrintConv => {
+            0 => 'JPEG',
+        },
+    },
+    0.3 => {
+        Name => 'MPImageType',
+        Format => 'int32u',
+        Mask => 0x00ffffff,
+        PrintHex => 1,
+        PrintConv => {
+            0x000000 => 'Undefined',
+            0x010001 => 'Large Thumbnail (VGA equivalent)',
+            0x010002 => 'Large Thumbnail (full HD equivalent)',
+            0x020001 => 'Multi-frame Panorama',
+            0x020002 => 'Multi-frame Disparity',
+            0x020003 => 'Multi-angle',
+            0x030000 => 'Baseline MP Primary Image',
+        },
+    },
+    4 => {
+        Name => 'MPImageLength',
+        Format => 'int32u',
+    },
+    8 => {
+        Name => 'MPImageStart',
+        Format => 'int32u',
+        IsOffset => '$val',
+    },
+    12 => {
+        Name => 'DependentImage1EntryNumber',
+        Format => 'int16u',
+    },
+    14 => {
+        Name => 'DependentImage2EntryNumber',
+        Format => 'int16u',
+    },
+);
+
+# extract MP Images as composite tags
+%Image::ExifTool::MPF::Composite = (
+    GROUPS => { 2 => 'Image' },
+    MPImage => {
+        Require => {
+            0 => 'MPImageStart',
+            1 => 'MPImageLength',
+            2 => 'MPImageType',
+        },
+        Notes => q{
+            the first MPF "Large Thumbnail" is extracted as PreviewImage, and the rest
+            of the embedded MPF images are extracted as MPImage#.  The ExtractEmbedded
+            option may be used to extract information from these embedded images.
+        },
+        # extract all MPF images (not just one)
+        RawConv => q{
+            require Image::ExifTool::MPF;
+            Image::ExifTool::MPF::ExtractMPImages($self);
+        },
+    },
+);
+
+# add our composite tags
+Image::ExifTool::AddCompositeTags('Image::ExifTool::MPF');
+
+#------------------------------------------------------------------------------
+# Extract all MP images
+# Inputs: 0) ExifTool object ref
+# Returns: undef
+sub ExtractMPImages($)
+{
+    my $et = shift;
+    my $ee = $et->Options('ExtractEmbedded');
+    my $saveBinary = $et->Options('Binary');
+    my ($i, $didPreview, $xtra);
+
+    for ($i=1; $xtra or not defined $xtra; ++$i) {
+        # run through MP images in the same order they were extracted
+        $xtra = defined $$et{VALUE}{"MPImageStart ($i)"} ? " ($i)" : '';
+        my $off = $et->GetValue("MPImageStart$xtra");
+        my $len = $et->GetValue("MPImageLength$xtra");
+        if ($off and $len) {
+            my $type = $et->GetValue("MPImageType$xtra", 'ValueConv');
+            my $tag = "MPImage$i";
+            # store first "Large Thumbnail" as a PreviewImage
+            if (not $didPreview and $type and ($type & 0x0f0000) == 0x010000) {
+                $tag = 'PreviewImage';
+                $didPreview = 1;
+            }
+            $et->Options('Binary', 1) if $ee;
+            my $val = Image::ExifTool::Exif::ExtractImage($et, $off, $len, $tag);
+            $et->Options('Binary', $saveBinary) if $ee;
+            next unless defined $val;
+            unless ($Image::ExifTool::Extra{$tag}) {
+                AddTagToTable(\%Image::ExifTool::Extra, $tag, {
+                    Name => $tag,
+                    Groups => { 0 => 'Composite', 1 => 'Composite', 2 => 'Image'},
+                });
+            }
+            my $key = $et->FoundTag($tag, $val);
+            # set groups for PreviewImage
+            if ($tag eq 'PreviewImage') {
+                $et->SetGroup($key, 'Composite', 0);
+                $et->SetGroup($key, 'Composite');
+            }
+            # extract information from MP images if ExtractEmbedded option used
+            if ($ee) {
+                $$et{DOC_NUM} = $i;
+                $et->ExtractInfo($val, { ReEntry => 1 });
+                delete $$et{DOC_NUM};
+            }
+        }
+    }
+    return undef;
+}
+
+#------------------------------------------------------------------------------
+# Process MP Entry list
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessMPImageList($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $num = int($$dirInfo{DirLen} / 16); # (16 bytes per MP Entry)
+    $$dirInfo{DirLen} = 16;
+    my ($i, $success);
+    my $oldG1 = $$et{SET_GROUP1};
+    for ($i=0; $i<$num; ++$i) {
+        $$et{SET_GROUP1} = '+' . ($i + 1);
+        $success = $et->ProcessBinaryData($dirInfo, $tagTablePtr);
+        $$dirInfo{DirStart} += 16;
+    }
+    $$et{SET_GROUP1} = $oldG1;
+    return $success;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::MPF - Read Multi-Picture Format information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains tag definitions and routines to read Multi-Picture
+Format (MPF) information from JPEG images.
+
+=head1 AUTHOR
+
+Copyright 2003-2014, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.cipa.jp/english/hyoujunka/kikaku/pdf/DC-007_E.pdf>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/MPF Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

data/bin/Image-ExifTool-9.46/lib/Image/ExifTool/MWG.pm

@@ -0,0 +1,748 @@
+#------------------------------------------------------------------------------
+# File:         MWG.pm
+#
+# Description:  Metadata Working Group support
+#
+# Revisions:    2009/10/21 - P. Harvey Created
+#
+# References:   1) http://www.metadataworkinggroup.org/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::MWG;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::Exif;
+use Image::ExifTool::XMP;
+
+$VERSION = '1.14';
+
+sub RecoverTruncatedIPTC($$$);
+sub ListToString($);
+sub StringToList($$);
+sub OverwriteStringList($$$$);
+
+my $mwgLoaded;  # flag set if we alreaded Load()ed the MWG tags
+
+# MWG Composite tags
+%Image::ExifTool::MWG::Composite = (
+    GROUPS => { 0 => 'Composite', 1 => 'MWG', 2 => 'Image' },
+    VARS => { NO_ID => 1 },
+    NOTES => q{
+        The table below lists special Composite tags which are used to access other
+        tags based on the MWG 2.0 recommendations.  These tags are only accessible
+        when explicitly loaded, but this is done automatically by the exiftool
+        application if MWG is specified as a group for any tag on the command line,
+        or manually with the C<-use MWG> option.  Via the API, the MWG Composite
+        tags are loaded by calling "C<Image::ExifTool::MWG::Load()>".
+
+        When reading, the value of each MWG tag is B<Derived From> the specified
+        tags based on the MWG guidelines.  When writing, the appropriate associated
+        tags are written.  The value of the IPTCDigest tag is updated automatically
+        when the IPTC is changed if either the IPTCDigest tag didn't exist
+        beforehand or its value agreed with the original IPTC digest (indicating
+        that the XMP is synchronized with the IPTC).  IPTC information is written
+        only if the original file contained IPTC.
+
+        Loading the MWG module activates "strict MWG conformance mode", which has
+        the effect of causing EXIF, IPTC and XMP in non-standard locations to be
+        ignored when reading, as per the MWG recommendations.  Instead, a "Warning"
+        tag is generated when non-standard metadata is encountered.  This feature
+        may be disabled by setting C<$Image::ExifTool::MWG::strict = 0> in the
+        L<ExifTool config file|../config.html> (or from your Perl script when using the API).  Note
+        that the behaviour when writing is not changed:  ExifTool always creates new
+        records only in the standard location, but writes new tags to any
+        EXIF/IPTC/XMP records that exist.
+
+        Contrary to the EXIF specification, the MWG recommends that EXIF "ASCII"
+        string values be stored as UTF-8.  To honour this, the exiftool application
+        sets the default internal EXIF string encoding to "UTF8" when the MWG module
+        is loaded (but this setting does not change automatically via the API).
+
+        A complication of the MWG specification is that although the MWG:Creator
+        property may consist of multiple values, the associated EXIF tag
+        (EXIF:Artist) is only a simple string.  To resolve this discrepancy the MWG
+        recommends a technique which allows a list of values to be stored in a
+        string by using a semicolon-space separator (with quotes around values if
+        necessary).  When the MWG module is loaded, ExifTool automatically
+        implements this policy and changes EXIF:Artist to a list-type tag.
+    },
+    Keywords => {
+        Flags  => ['Writable','List'],
+        Desire => {
+            0 => 'IPTC:Keywords', # (64-character limit)
+            1 => 'XMP-dc:Subject',
+            2 => 'CurrentIPTCDigest',
+            3 => 'IPTCDigest',
+        },
+        RawConv => q{
+            return $val[1] if not defined $val[2] or (defined $val[1] and
+                             (not defined $val[3] or $val[2] eq $val[3]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[0], $val[1], 64);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            # only write Keywords if IPTC exists (ie. set EditGroup option)
+            'IPTC:Keywords'  => '$opts{EditGroup} = 1; $val',
+            'XMP-dc:Subject' => '$val',
+        },
+    },
+    Description => {
+        Writable => 1,
+        Desire => {
+            0 => 'EXIF:ImageDescription',
+            1 => 'IPTC:Caption-Abstract', # (2000-character limit)
+            2 => 'XMP-dc:Description',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            return $val[0] if defined $val[0] and $val[0] !~ /^ *$/;
+            return $val[2] if not defined $val[3] or (defined $val[2] and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[1], $val[2], 2000);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'EXIF:ImageDescription' => '$val',
+            'IPTC:Caption-Abstract' => '$opts{EditGroup} = 1; $val',
+            'XMP-dc:Description'    => '$val',
+        },
+    },
+    DateTimeOriginal => {
+        Description => 'Date/Time Original',
+        Groups => { 2 => 'Time' },
+        Notes => '"creation date of the intellectual content being shown" - MWG',
+        Writable => 1,
+        Desire => {
+            0 => 'EXIF:DateTimeOriginal',
+            1 => 'EXIF:SubSecTimeOriginal',
+            2 => 'IPTC:DateCreated',
+            3 => 'IPTC:TimeCreated',
+            4 => 'XMP-photoshop:DateCreated',
+            5 => 'CurrentIPTCDigest',
+            6 => 'IPTCDigest',
+        },
+        # must check for validity in RawConv to avoid hiding a same-named tag,
+        # but IPTC dates use a ValueConv so we need to derive the value there
+        RawConv => '(defined $val[0] or defined $val[2] or defined $val[4]) ? $val : undef',
+        ValueConv => q{
+            if (defined $val[0] and $val[0] !~ /^[: ]*$/) {
+                return ($val[1] and $val[1] !~ /^ *$/) ? "$val[0].$val[1]" : $val[0];
+            }
+            return $val[4] if not defined $val[5] or (defined $val[4] and
+                             (not defined $val[6] or $val[5] eq $val[6]));
+            return $val[3] ? "$val[2] $val[3]" : $val[2] if $val[2];
+            return undef;
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val,undef,1)',
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            # set EXIF date/time values according to PrintConv option instead
+            # of defaulting to Type=ValueConv to allow reformatting to be applied
+            'EXIF:DateTimeOriginal'     => 'delete $opts{Type}; $val',
+            'EXIF:SubSecTimeOriginal'   => 'delete $opts{Type}; $val',
+            'IPTC:DateCreated'          => '$opts{EditGroup} = 1; $val',
+            'IPTC:TimeCreated'          => '$opts{EditGroup} = 1; $val',
+            'XMP-photoshop:DateCreated' => '$val',
+        },
+    },
+    CreateDate => {
+        Groups => { 2 => 'Time' },
+        Notes => '"creation date of the digital representation" - MWG',
+        Writable => 1,
+        Desire => {
+            0 => 'EXIF:CreateDate',
+            1 => 'EXIF:SubSecTimeDigitized',
+            2 => 'IPTC:DigitalCreationDate',
+            3 => 'IPTC:DigitalCreationTime',
+            4 => 'XMP-xmp:CreateDate',
+            5 => 'CurrentIPTCDigest',
+            6 => 'IPTCDigest',
+        },
+        RawConv => '(defined $val[0] or defined $val[2] or defined $val[4]) ? $val : undef',
+        ValueConv => q{
+            if (defined $val[0] and $val[0] !~ /^[: ]*$/) {
+                return ($val[1] and $val[1] !~ /^ *$/) ? "$val[0].$val[1]" : $val[0];
+            }
+            return $val[4] if not defined $val[5] or (defined $val[4] and
+                             (not defined $val[6] or $val[5] eq $val[6]));
+            return $val[3] ? "$val[2] $val[3]" : $val[2] if $val[2];
+            return undef;
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val,undef,1)',
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'EXIF:CreateDate'          => 'delete $opts{Type}; $val',
+            'EXIF:SubSecTimeDigitized' => 'delete $opts{Type}; $val',
+            'IPTC:DigitalCreationDate' => '$opts{EditGroup} = 1; $val',
+            'IPTC:DigitalCreationTime' => '$opts{EditGroup} = 1; $val',
+            'XMP-xmp:CreateDate'       => '$val',
+        },
+    },
+    ModifyDate => {
+        Groups => { 2 => 'Time' },
+        Notes => '"modification date of the digital image file" - MWG',
+        Writable => 1,
+        Desire => {
+            0 => 'EXIF:ModifyDate',
+            1 => 'EXIF:SubSecTime',
+            2 => 'XMP-xmp:ModifyDate',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            if (defined $val[0] and $val[0] !~ /^[: ]*$/) {
+                return ($val[1] and $val[1] !~ /^ *$/) ? "$val[0].$val[1]" : $val[0];
+            }
+            return $val[2] if not defined $val[3] or not defined $val[4] or $val[3] eq $val[4];
+            return undef;
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+        PrintConvInv => '$self->InverseDateTime($val,undef,1)',
+        # return empty string from check routines so this tag will never be set
+        # (only WriteAlso tags are written), the only difference is a -v2 message
+        DelCheck   => '""',
+        WriteCheck => '""',
+        WriteAlso  => {
+            'EXIF:ModifyDate'    => 'delete $opts{Type}; $val',
+            'EXIF:SubSecTime'    => 'delete $opts{Type}; $val',
+            'XMP-xmp:ModifyDate' => '$val',
+        },
+    },
+    Orientation => {
+        Writable   => 1,
+        Require    => 'EXIF:Orientation',
+        ValueConv  => '$val',
+        PrintConv  => \%Image::ExifTool::Exif::orientation,
+        DelCheck   => '""',
+        WriteCheck => '""',
+        WriteAlso  => {
+            'EXIF:Orientation' => '$val',
+        },
+    },
+    Rating => {
+        Writable   => 1,
+        Require    => 'XMP-xmp:Rating',
+        ValueConv  => '$val',
+        DelCheck   => '""',
+        WriteCheck => '""',
+        WriteAlso  => {
+            'XMP-xmp:Rating' => '$val',
+        },
+    },
+    Copyright => {
+        Groups => { 2 => 'Author' },
+        Writable => 1,
+        Desire => {
+            0 => 'EXIF:Copyright',
+            1 => 'IPTC:CopyrightNotice', # (128-character limit)
+            2 => 'XMP-dc:Rights',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            return $val[0] if defined $val[0] and $val[0] !~ /^ *$/;
+            return $val[2] if not defined $val[3] or (defined $val[2] and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[1], $val[2], 128);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'EXIF:Copyright'       => '$val',
+            'IPTC:CopyrightNotice' => '$opts{EditGroup} = 1; $val',
+            'XMP-dc:Rights'        => '$val',
+        },
+    },
+    Creator => {
+        Groups => { 2 => 'Author' },
+        Flags  => ['Writable','List'],
+        Desire => {
+            0 => 'EXIF:Artist',
+            1 => 'IPTC:By-line', # (32-character limit)
+            2 => 'XMP-dc:Creator',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            return $val[0] if defined $val[0] and $val[0] !~ /^ *$/;
+            return $val[2] if not defined $val[3] or (defined $val[2] and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[1], $val[2], 32);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'EXIF:Artist'    => '$val',
+            'IPTC:By-line'   => '$opts{EditGroup} = 1; $val',
+            'XMP-dc:Creator' => '$val',
+        },
+    },
+    Country => {
+        Groups => { 2 => 'Location' },
+        Writable => 1,
+        Desire => {
+            0 => 'IPTC:Country-PrimaryLocationName', # (64-character limit)
+            1 => 'XMP-photoshop:Country',
+            2 => 'XMP-iptcExt:LocationShownCountryName',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            my $xmpVal = $val[2] || $val[1];
+            return $xmpVal if not defined $val[3] or (defined $xmpVal and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[0], $xmpVal, 64);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'IPTC:Country-PrimaryLocationName' => '$opts{EditGroup} = 1; $val',
+            'XMP-photoshop:Country'            => '$val', # (legacy)
+            'XMP-iptcExt:LocationShownCountryName' => '$val',
+        },
+    },
+    State => {
+        Groups => { 2 => 'Location' },
+        Writable => 1,
+        Desire => {
+            0 => 'IPTC:Province-State', # (32-character limit)
+            1 => 'XMP-photoshop:State',
+            2 => 'XMP-iptcExt:LocationShownProvinceState',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            my $xmpVal = $val[2] || $val[1];
+            return $xmpVal if not defined $val[3] or (defined $xmpVal and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[0], $xmpVal, 32);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'IPTC:Province-State' => '$opts{EditGroup} = 1; $val',
+            'XMP-photoshop:State' => '$val', # (legacy)
+            'XMP-iptcExt:LocationShownProvinceState' => '$val',
+        },
+    },
+    City => {
+        Groups => { 2 => 'Location' },
+        Writable => 1,
+        Desire => {
+            0 => 'IPTC:City', # (32-character limit)
+            1 => 'XMP-photoshop:City',
+            2 => 'XMP-iptcExt:LocationShownCity',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            my $xmpVal = $val[2] || $val[1];
+            return $xmpVal if not defined $val[3] or (defined $xmpVal and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[0], $xmpVal, 32);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'IPTC:City'          => '$opts{EditGroup} = 1; $val',
+            'XMP-photoshop:City' => '$val', # (legacy)
+            'XMP-iptcExt:LocationShownCity' => '$val',
+        },
+    },
+    Location => {
+        Groups => { 2 => 'Location' },
+        Writable => 1,
+        Desire => {
+            0 => 'IPTC:Sub-location', # (32-character limit)
+            1 => 'XMP-iptcCore:Location',
+            2 => 'XMP-iptcExt:LocationShownSublocation',
+            3 => 'CurrentIPTCDigest',
+            4 => 'IPTCDigest',
+        },
+        RawConv => q{
+            my $xmpVal = $val[2] || $val[1];
+            return $xmpVal if not defined $val[3] or (defined $xmpVal and
+                             (not defined $val[4] or $val[3] eq $val[4]));
+            return Image::ExifTool::MWG::RecoverTruncatedIPTC($val[0], $xmpVal, 32);
+        },
+        DelCheck   => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteCheck => 'Image::ExifTool::MWG::ReconcileIPTCDigest($self)',
+        WriteAlso  => {
+            'IPTC:Sub-location'     => '$opts{EditGroup} = 1; $val',
+            'XMP-iptcCore:Location' => '$val', # (legacy)
+            'XMP-iptcExt:LocationShownSublocation' => '$val',
+        },
+    },
+);
+
+# MWG XMP structures
+my %sExtensions = (
+    STRUCT_NAME => 'MWG Extensions',
+    NAMESPACE   => undef, # variable namespace
+    NOTES => q{
+        This structure may contain any top-level XMP tags, but none have been
+        pre-defined in ExifTool.  Since no flattened tags have been pre-defined,
+        RegionExtensions is writable only as a structure (ie.
+        C<{xmp-dc:creator=me,rating=5}>).  Fields for this structure are identified
+        using the standard ExifTool tag name (with optional leading group name,
+        and/or trailing language code, and/or trailing C<#> symbol to disable print
+        conversion).
+    },
+);
+my %sRegionStruct = (
+    STRUCT_NAME => 'MWG RegionStruct',
+    NAMESPACE   => 'mwg-rs',
+    Area => { Struct => \%Image::ExifTool::XMP::sArea },
+    Type => {
+        PrintConv => {
+            Face => 'Face',
+            Pet => 'Pet',
+            Focus => 'Focus',
+            BarCode => 'BarCode',
+        },
+    },
+    Name        => { },
+    Description => { },
+    FocusUsage  => {
+        PrintConv => {
+            EvaluatedUsed => 'Evaluated, Used',
+            EvaluatedNotUsed => 'Evaluated, Not Used',
+            NotEvaluatedNotUsed => 'Not Evaluated, Not Used',
+        },
+    },
+    BarCodeValue=> { },
+    Extensions  => { Struct => \%sExtensions },
+    seeAlso => { Namespace => 'rdfs', Resource => 1 },
+);
+my %sKeywordStruct;
+%sKeywordStruct = (
+    STRUCT_NAME => 'MWG KeywordStruct',
+    NAMESPACE   => 'mwg-kw',
+    Keyword   => { },
+    Applied   => { Writable => 'boolean' },
+    Children  => { Struct => \%sKeywordStruct, List => 'Bag' },
+);
+
+# MWG 2.0 XMP region namespace tags
+%Image::ExifTool::MWG::Regions = (
+    %Image::ExifTool::XMP::xmpTableDefaults,
+    GROUPS => { 0 => 'XMP', 1 => 'XMP-mwg-rs', 2 => 'Image' },
+    NAMESPACE => 'mwg-rs',
+    NOTES => q{
+        Image region metadata defined by the MWG 2.0 specification.  These tags
+        belong to the ExifTool XMP-mwg-rs group, and as such they may be accessed
+        without the need to load the MWG Composite tags above.  See
+        L<http://www.metadataworkinggroup.org/> for the official specification.
+    },
+    Regions => {
+        Name => 'RegionInfo',
+        FlatName => 'Region',
+        Struct => {
+            STRUCT_NAME => 'MWG RegionInfo',
+            NAMESPACE   => 'mwg-rs',
+            RegionList => {
+                FlatName => 'Region',
+                Struct => \%sRegionStruct,
+                List => 'Bag',
+            },
+            AppliedToDimensions => { Struct => \%Image::ExifTool::XMP::sDimensions },
+        },
+    },
+    RegionsRegionList => { Flat => 1, Name => 'RegionList' },
+);
+
+# MWG 2.0 XMP hierarchical keyword namespace tags
+%Image::ExifTool::MWG::Keywords = (
+    %Image::ExifTool::XMP::xmpTableDefaults,
+    GROUPS => { 0 => 'XMP', 1 => 'XMP-mwg-kw', 2 => 'Image' },
+    NAMESPACE => 'mwg-kw',
+    NOTES => q{
+        Hierarchical keywords metadata defined by the MWG 2.0 specification.  These
+        tags belong to the ExifTool XMP-mwg-kw group. ExifTool unrolls keyword
+        structures to an arbitrary depth of 6 to allow individual levels to be
+        accessed with different tag names, and to avoid infinite recursion.  See
+        L<http://www.metadataworkinggroup.org/> for the official specification.
+    },
+    # arbitrarily define only the first 6 levels of the keyword hierarchy
+    Keywords => {
+        Name => 'KeywordInfo',
+        Struct => {
+            STRUCT_NAME => 'MWG KeywordInfo',
+            NAMESPACE   => 'mwg-kw',
+            Hierarchy => { Struct => \%sKeywordStruct, List => 'Bag' },
+        },
+    },
+    KeywordsHierarchy => { Name => 'HierarchicalKeywords', Flat => 1 },
+    KeywordsHierarchyKeyword  => { Name => 'HierarchicalKeywords1', Flat => 1 },
+    KeywordsHierarchyApplied  => { Name => 'HierarchicalKeywords1Applied', Flat => 1 },
+    KeywordsHierarchyChildren => { Name => 'HierarchicalKeywords1Children', Flat => 1 },
+    KeywordsHierarchyChildrenKeyword  => { Name => 'HierarchicalKeywords2', Flat => 1 },
+    KeywordsHierarchyChildrenApplied  => { Name => 'HierarchicalKeywords2Applied', Flat => 1 },
+    KeywordsHierarchyChildrenChildren => { Name => 'HierarchicalKeywords2Children', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenKeyword  => { Name => 'HierarchicalKeywords3', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenApplied  => { Name => 'HierarchicalKeywords3Applied', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildren => { Name => 'HierarchicalKeywords3Children', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenKeyword  => { Name => 'HierarchicalKeywords4', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenApplied  => { Name => 'HierarchicalKeywords4Applied', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenChildren => { Name => 'HierarchicalKeywords4Children', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenChildrenKeyword  => { Name => 'HierarchicalKeywords5', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenChildrenApplied  => { Name => 'HierarchicalKeywords5Applied', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenChildrenChildren => { Name => 'HierarchicalKeywords5Children', Flat => 1, NoSubStruct => 1 }, # break infinite recursion
+    KeywordsHierarchyChildrenChildrenChildrenChildrenChildrenKeyword => { Name => 'HierarchicalKeywords6', Flat => 1 },
+    KeywordsHierarchyChildrenChildrenChildrenChildrenChildrenApplied => { Name => 'HierarchicalKeywords6Applied', Flat => 1 },
+);
+
+# MWG 2.0 XMP collections namespace tags
+%Image::ExifTool::MWG::Collections = (
+    %Image::ExifTool::XMP::xmpTableDefaults,
+    GROUPS => { 0 => 'XMP', 1 => 'XMP-mwg-coll', 2 => 'Image' },
+    NAMESPACE => 'mwg-coll',
+    NOTES => q{
+        Collections metadata defined by the MWG 2.0 specification.  These tags
+        belong to the ExifTool XMP-mwg-coll group.  See
+        L<http://www.metadataworkinggroup.org/> for the official specification.
+    },
+    Collections => {
+        FlatName => '',
+        List => 'Bag',
+        Struct => {
+            STRUCT_NAME => 'MWG CollectionInfo',
+            NAMESPACE   => 'mwg-coll',
+            CollectionName => { },
+            CollectionURI  => { },
+        },
+    },
+);
+
+
+#------------------------------------------------------------------------------
+# Load the MWG Composite tags
+sub Load()
+{
+    return if $mwgLoaded;
+
+    # add our composite tags
+    Image::ExifTool::AddCompositeTags('Image::ExifTool::MWG');
+    # must also add to lookup so we can write them
+    # (since MWG tags aren't in the tag lookup by default)
+    Image::ExifTool::AddTagsToLookup(\%Image::ExifTool::MWG::Composite,
+                                     'Image::ExifTool::Composite');
+
+    # modify EXIF:Artist to behave as a list-type tag
+    my $artist = $Image::ExifTool::Exif::Main{0x13b};
+    $$artist{List} = 1;
+    $$artist{IsOverwriting} = \&OverwriteStringList;
+    $$artist{RawConv} = \&StringToList;
+
+    # enable MWG strict mode if not set already
+    # (causes non-standard EXIF, IPTC and XMP to be ignored)
+    $Image::ExifTool::MWG::strict = 1 unless defined $Image::ExifTool::MWG::strict;
+
+    $mwgLoaded = 1;
+}
+
+#------------------------------------------------------------------------------
+# Change a list of values to a string using MWG rules
+# Inputs: 0)reference to list of values
+# Returns: string of values (and may reformat list entries)
+sub ListToString($)
+{
+    my $vals = shift;
+    foreach (@$vals) {
+        # double all quotes in value and quote the value if it begins
+        # with a quote or contains a semicolon-space separator
+        if (/^"/ or /; /) {
+            s/"/""/g;       # double all quotes
+            $_ = qq{"$_"};  # quote the value
+        }
+    }
+    return join('; ', @$vals);
+}
+
+#------------------------------------------------------------------------------
+# Change a string value to a list of values using MWG rules
+# Inputs: 0) string of values, 1) ExifTool ref
+# Returns: value or list reference if more than one value
+# Notes: Sets Warning tag on error
+sub StringToList($$)
+{
+    my ($str, $et) = @_;
+    my (@vals, $inQuotes);
+    my @t = split '; ', $str, -1;
+    foreach (@t) {
+        my $wasQuotes = $inQuotes;
+        $inQuotes = 1 if not $inQuotes and s/^"//;
+        if ($inQuotes) {
+            # remove the last quote and reset the inQuotes flag if
+            # the value ended in an odd number of quotes
+            $inQuotes = 0 if s/((^|[^"])("")*)"$/$1/;
+            s/""/"/g;   # un-double the contained quotes
+        }
+        if ($wasQuotes) {
+            # previous separator was quoted, so concatinate with previous value
+            $vals[-1] .= '; ' . $_;
+        } else {
+            push @vals, $_;
+        }
+    }
+    $et->Warn('Incorrectly quoted MWG string-list value') if $inQuotes;
+    return @vals > 1 ? \@vals : $vals[0];
+}
+
+#------------------------------------------------------------------------------
+# Handle logic for overwriting EXIF string-type list tag
+# Inputs: 0) new value hash ref, 1) new value hash ref,
+#         2) old string value (or undef if it didn't exist), 3) new value ref
+# Returns: 1 and sets the new value for the tag
+sub OverwriteStringList($$$$)
+{
+    local $_;
+    my ($et, $nvHash, $val, $newValuePt) = @_;
+    my (@new, $delIndex);
+    if ($$nvHash{DelValue} and defined $val) {
+        # preserve specified old values
+        my $old = StringToList($val, $et);
+        my @old = ref $old eq 'ARRAY' ? @$old : $old;
+        if (@{$$nvHash{DelValue}}) {
+            my %del;
+            $del{$_} = 1 foreach @{$$nvHash{DelValue}};
+            foreach (@old) {
+                $del{$_} or push(@new, $_), next;
+                $delIndex or $delIndex = scalar @new;
+            }
+        } else {
+            push @new, @old;
+        }
+    }
+    # add new values (at location of deleted values, if any)
+    if ($$nvHash{Value}) {
+        if (defined $delIndex) {
+            splice @new, $delIndex, 0, @{$$nvHash{Value}};
+        } else {
+            push @new, @{$$nvHash{Value}};
+        }
+    }
+    if (@new) {
+        # convert back to string format
+        $$newValuePt = ListToString(\@new);
+    } else {
+        $$newValuePt = undef;   # delete the tag
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Reconcile IPTC digest after writing an MWG tag
+# Inputs: 0) ExifTool object ref
+# Returns: empty string
+sub ReconcileIPTCDigest($)
+{
+    my $et = shift;
+
+    # set new value for IPTCDigest if not done already
+    unless ($Image::ExifTool::Photoshop::iptcDigestInfo and
+            $$et{NEW_VALUE}{$Image::ExifTool::Photoshop::iptcDigestInfo})
+    {
+        # write new IPTCDigest only if it doesn't exist or
+        # is the same as the digest of the original IPTC
+        my @a; # (capture warning messages)
+        @a = $et->SetNewValue('Photoshop:IPTCDigest', 'old', Protected => 1, DelValue => 1);
+        @a = $et->SetNewValue('Photoshop:IPTCDigest', 'new', Protected => 1);
+    }
+    return '';
+}
+
+#------------------------------------------------------------------------------
+# Recover strings which were truncated by IPTC dataset length limit
+# Inputs: 0) IPTC value, 1) XMP value, 2) length limit
+# Notes: handles the case where IPTC and/or XMP values are lists
+sub RecoverTruncatedIPTC($$$)
+{
+    my ($iptc, $xmp, $limit) = @_;
+
+    return $iptc unless defined $xmp;
+    if (ref $iptc) {
+        $xmp = [ $xmp ] unless ref $xmp;
+        my ($i, @vals);
+        for ($i=0; $i<@$iptc; ++$i) {
+            push @vals, RecoverTruncatedIPTC($$iptc[$i], $$xmp[$i], $limit);
+        }
+        return \@vals;
+    } elsif (defined $iptc and length $iptc == $limit) {    
+        $xmp = $$xmp[0] if ref $xmp;    # take first element of list
+        return $xmp if length $xmp > $limit and $iptc eq substr($xmp, 0, $limit);
+    }
+    return $iptc;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::MWG - Metadata Working Group support
+
+=head1 SYNOPSIS
+
+    # enable MWG Composite tags
+    use Image::ExifTool::MWG;
+    Image::ExifTool::MWG::Load();
+
+    # enable MWG strict mode
+    $Image::ExifTool::MWG::strict = 1;
+
+    # disable MWG strict mode
+    $Image::ExifTool::MWG::strict = 0;
+
+=head1 DESCRIPTION
+
+The MWG module contains Composite tag definitions which are designed to
+simplify implementation of the Metadata Working Group guidelines.  These
+special MWG Composite tags are enabled by calling the Load() method:
+
+    use Image::ExifTool::MWG;
+    Image::ExifTool::MWG::Load();
+
+By default, loading the MWG Composite tags enables "strict MWG conformance"
+unless previously enabled or disabled by the user.  In this mode, ExifTool
+will generate a Warning instead of extracting EXIF, IPTC and XMP from
+non-standard locations.  The strict mode may be disabled or enabled at any
+time by setting the MWG "strict" flag to 0 or 1.  ie)
+
+    $Image::ExifTool::MWG::strict = 0;
+
+This module also contains the MWG XMP tags which are loaded automatically by
+ExifTool as required, and are independent of the MWG Composite tags which
+must be loaded explicitly as described above.
+
+=head1 AUTHOR
+
+Copyright 2003-2014, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://www.metadataworkinggroup.org/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/MWG Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut