Changeset 24107 for main/trunk/greenstone2/perllib/cpan/Image/ExifTool.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.pm (modified) (194 diffs)

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

@@ -6 +6 @@
 # URL:          http://owl.phy.queensu.ca/~phil/exiftool/
 #
-# Revisions:    Nov. 12/03 - P. Harvey Created
+# Revisions:    Nov. 12/2003 - P. Harvey Created
 #               (See html/history.html for revision history)
 #
-# Legal:        Copyright (c) 2003-2007, Phil Harvey (phil at owl.phy.queensu.ca)
+# Legal:        Copyright (c) 2003-2010, 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.
@@ -20 +20 @@
 require Exporter;
 use File::RandomAccess;
-    
+
 use vars qw($VERSION $RELEASE @ISA %EXPORT_TAGS $AUTOLOAD @fileTypes %allTables
-            @tableOrder $exifAPP1hdr $xmpAPP1hdr $psAPP13hdr $psAPP13old
-            @loadAllTables %UserDefined $evalWarning);
-
-$VERSION = '7.00';
+            @tableOrder $exifAPP1hdr $xmpAPP1hdr $xmpExtAPP1hdr $psAPP13hdr
+            $psAPP13old @loadAllTables %UserDefined $evalWarning %noWriteFile
+            %magicNumber @langs $defaultLang %langName %charsetName %mimeType
+            $swapBytes $swapWords $currentByteOrder %unpackStd);
+
+$VERSION = '8.57';
 $RELEASE = '';
 @ISA = qw(Exporter);
 %EXPORT_TAGS = (
-    # all public non-object-oriented functions
+    # all public non-object-oriented functions:
     Public => [qw(
         ImageInfo GetTagName GetShortcuts GetAllTags GetWritableTags
         GetAllGroups GetDeleteGroups GetFileType CanWrite CanCreate
     )],
+    # exports not part of the public API, but used by ExifTool modules:
     DataAccess => [qw(
         ReadValue GetByteOrder SetByteOrder ToggleByteOrder Get8u Get8s Get16u
-        Get16s Get32u Get32s GetFloat GetDouble GetFixed32s Write WriteValue
-        Tell Set8u Set8s Set16u Set32u
+        Get16s Get32u Get32s Get64u GetFloat GetDouble GetFixed32s Write
+        WriteValue Tell Set8u Set8s Set16u Set32u
     )],
-    Utils => [qw(
-        GetTagTable TagTableKeys GetTagInfoList GenerateTagIDs SetFileType
-        HtmlDump
-    )],
-    Vars => [qw(
-        %allTables @tableOrder @fileTypes
-    )],
+    Utils => [qw(GetTagTable TagTableKeys GetTagInfoList)],
+    Vars  => [qw(%allTables @tableOrder @fileTypes)],
 );
 # set all of our EXPORT_TAGS in EXPORT_OK
@@ -54 +52 @@
 
 # The following functions defined in Image::ExifTool::Writer are declared
-# here so their prototypes will be available.  The Writer routines will be
-# autoloaded when any of these are called.
+# here so their prototypes will be available.  These Writer routines will be
+# autoloaded when any of them is called.
 sub SetNewValue($;$$%);
 sub SetNewValuesFromFile($$;@);
@@ -74 +72 @@
 sub IsWritable($);
 sub GetNewFileName($$);
+sub NextTagKey($$);
 sub LoadAllTables();
 sub GetNewTagInfoList($;$);
@@ -88 +87 @@
 sub VerboseInfo($$$%);
 sub VerboseDir($$;$$);
+sub VerboseValue($$$;$);
 sub VPrint($$@);
 sub Rationalize($;$);
 sub Write($@);
-sub ProcessTrailers($$);
 sub WriteTrailerBuffer($$$);
 sub AddNewTrailers($;@);
@@ -100 +99 @@
 sub CheckBinaryData($$$);
 sub WriteTIFF($$$);
-sub Charset2Unicode($$;$);
-sub Latin2Unicode($$);
-sub UTF82Unicode($$;$);
-sub Unicode2Charset($$;$);
-sub Unicode2Latin($$;$);
-sub Unicode2UTF8($$);
 sub PackUTF8(@);
 sub UnpackUTF8($);
+sub SetPreferredByteOrder($);
+sub CopyBlock($$$);
+sub CopyFileAttrs($$);
+
+# other subroutine definitions
+sub DoEscape($$);
+sub ConvertFileSize($);
+sub ParseArguments($;@); #(defined in attempt to avoid mod_perl problem)
 
 # list of main tag tables to load in LoadAllTables() (sub-tables are recursed
 # automatically).  Note: They will appear in this order in the documentation
-# (unless tweaked in BuildTagLookup::GetTableOrder()), so put Exif first.
+# unless tweaked in BuildTagLookup::GetTableOrder().
 @loadAllTables = qw(
-    PhotoMechanic Exif GeoTiff CanonRaw KyoceraRaw MinoltaRaw SigmaRaw JPEG
-    Jpeg2000 BMP BMP PICT PNG MNG MIFF PDF PostScript Photoshop::Header
-    FujiFilm::RAF Panasonic::Raw Sony::SR2SubIFD ID3 Vorbis FLAC APE
-    APE::NewHeader APE::OldHeader MPC MPEG::Audio MPEG::Video QuickTime
-    QuickTime::ImageFile Flash Flash::FLV Real::Media Real::Audio
-    Real::Metafile RIFF AIFF ASF DICOM MIE HTML
+    PhotoMechanic Exif GeoTiff CanonRaw KyoceraRaw MinoltaRaw PanasonicRaw
+    SigmaRaw JPEG GIMP Jpeg2000 GIF BMP BMP::OS2 PICT PNG MNG DjVu PGF MIFF PSP
+    PDF PostScript Photoshop::Header FujiFilm::RAF Sony::SRF2 Sony::SR2SubIFD
+    Sony::PMP ITC ID3 Vorbis FLAC APE APE::NewHeader APE::OldHeader MPC
+    MPEG::Audio MPEG::Video MPEG::Xing M2TS QuickTime QuickTime::ImageFile
+    Matroska MXF DV Flash Flash::FLV Real::Media Real::Audio Real::Metafile RIFF
+    AIFF ASF DICOM MIE HTML XMP::SVG EXE EXE::PEVersion EXE::PEString EXE::MachO
+    EXE::PEF EXE::ELF LNK Font RSRC Rawzor ZIP ZIP::GZIP ZIP::RAR RTF OOXML
+    iWork
+);
+
+# alphabetical list of current Lang modules
+@langs = qw(cs de en en_ca en_gb es fr it ja ko nl pl ru sv tr zh_cn zh_tw);
+
+$defaultLang = 'en';    # default language
+
+# language names
+%langName = (
+    cs => 'Czech (Čeština)',
+    de => 'German (Deutsch)',
+    en => 'English',
+    en_ca => 'Canadian English',
+    en_gb => 'British English',
+    es => 'Spanish (Español)',
+    fr => 'French (Français)',
+    it => 'Italian (Italiano)',
+    ja => 'Japanese (日本語)',
+    ko => 'Korean (한국얎)',
+    nl => 'Dutch (Nederlands)',
+    pl => 'Polish (Polski)',
+    ru => 'Russian (РусскОй)',
+    sv => 'Swedish (Svenska)',
+   'tr'=> 'Turkish (TÌrkçe)',
+    zh_cn => 'Simplified Chinese (简䜓䞭文)',
+    zh_tw => 'Traditional Chinese (繁體䞭文)',
 );
 
 # recognized file types, in the order we test unknown files
 # Notes: 1) There is no need to test for like types separately here
-# 2) Put types with no file signature at end of list to avoid false matches
+# 2) Put types with weak file signatures at end of list to avoid false matches
 @fileTypes = qw(JPEG CRW TIFF GIF MRW RAF X3F JP2 PNG MIE MIFF PS PDF PSD XMP
-                BMP PPM RIFF AIFF ASF MOV MPEG Real SWF FLV OGG FLAC APE MPC
-                ICC HTML VRD QTIF FPX PICT MP3 DICM RAW);
+                BMP PPM RIFF AIFF ASF MOV MPEG Real SWF PSP FLV OGG FLAC APE MPC
+                MKV MXF DV PMP IND PGF ICC ITC HTML VRD RTF XCF QTIF FPX PICT
+                ZIP GZIP RAR BZ2 TAR RWZ EXE LNK RAW Font RSRC M2TS MP3 DICM);
 
 # file types that we can write (edit)
-my @writeTypes = qw(JPEG TIFF GIF CRW MRW ORF PNG MIE PSD XMP PPM EPS PS ICC
-                    VRD JP2);
+my @writeTypes = qw(JPEG TIFF GIF CRW MRW ORF RAF RAW PNG MIE PSD XMP PPM
+                    EPS X3F PS PDF ICC VRD JP2 EXIF AI AIT IND);
+
+# file extensions that we can't write for various base types
+%noWriteFile = (
+    TIFF => [ qw(3FR DCR K25 KDC SRF) ],
+    XMP  => [ 'SVG' ],
+);
 
 # file types that we can create from scratch
-my @createTypes = qw(XMP ICC MIE VRD);
+# - must update CanCreate() documentation if this list is changed!
+my %createTypes = (XMP=>1, ICC=>1, MIE=>1, VRD=>1, EXIF=>1);
 
 # file type lookup for all recognized file extensions
 my %fileTypeLookup = (
+   '3FR' => ['TIFF', 'Hasselblad RAW format'],
+   '3G2' => ['MOV',  '3rd Gen. Partnership Project 2 audio/video'],
+   '3GP' => ['MOV',  '3rd Gen. Partnership Project audio/video'],
+   '3GP2'=>  '3G2',
+   '3GPP'=>  '3GP',
     ACR  => ['DICM', 'American College of Radiology ACR-NEMA'],
-    AI   => [['PDF','PS'], 'Adobe Illustrator (PDF-like or PS-like)'],
-    AIF  => ['AIFF', 'Audio Interchange File Format'],
+    ACFM => ['Font', 'Adobe Composite Font Metrics'],
+    AFM  => ['Font', 'Adobe Font Metrics'],
+    AMFM => ['Font', 'Adobe Multiple Master Font Metrics'],
+    AI   => [['PDF','PS'], 'Adobe Illustrator'],
+    AIF  =>  'AIFF',
     AIFC => ['AIFF', 'Audio Interchange File Format Compressed'],
     AIFF => ['AIFF', 'Audio Interchange File Format'],
+    AIT  =>  'AI',
     APE  => ['APE',  "Monkey's Audio format"],
-    ARW  => ['TIFF', 'Sony Alpha RAW format (TIFF-like)'],
+    ARW  => ['TIFF', 'Sony Alpha RAW format'],
     ASF  => ['ASF',  'Microsoft Advanced Systems Format'],
-    AVI  => ['RIFF', 'Audio Video Interleaved (RIFF-based)'],
-    BMP  => ['BMP',  'Windows BitMaP'],
-    BTF  => ['BTF',  'Big Tagged Image File Format'],
-    CIFF => ['CRW',  'Camera Image File Format (same as CRW)'],
-    CR2  => ['TIFF', 'Canon RAW 2 format (TIFF-like)'],
+    AVI  => ['RIFF', 'Audio Video Interleaved'],
+    BMP  => ['BMP',  'Windows Bitmap'],
+    BTF  => ['BTF',  'Big Tagged Image File Format'], #(unofficial)
+    BZ2  => ['BZ2',  'BZIP2 archive'],
+    CIFF => ['CRW',  'Camera Image File Format'],
+    COS  => ['COS',  'Capture One Settings'],
+    CR2  => ['TIFF', 'Canon RAW 2 format'],
     CRW  => ['CRW',  'Canon RAW format'],
-    CS1  => ['PSD',  'Sinar CaptureShop 1-Shot RAW (PSD-like)'],
-    DC3  => ['DICM', 'DICOM image file'],
-    DCM  => ['DICM', 'DICOM image file'],
-    DIB  => ['BMP',  'Device Independent Bitmap (aka. BMP)'],
-    DIC  => ['DICM', 'DICOM image file'],
-    DICM => ['DICM', 'DICOM image file'],
-    DNG  => ['TIFF', 'Digital Negative (TIFF-like)'],
-    DCR  => ['TIFF', 'Kodak Digital Camera RAW (TIFF-like)'],
-    DOC  => ['FPX',  'Microsoft Word Document (FPX-like)'],
+    CS1  => ['PSD',  'Sinar CaptureShop 1-Shot RAW'],
+    DC3  =>  'DICM',
+    DCM  =>  'DICM',
+    DCP  => ['TIFF', 'DNG Camera Profile'],
+    DCR  => ['TIFF', 'Kodak Digital Camera RAW'],
+    DFONT=> ['Font', 'Macintosh Data fork Font'],
+    DIB  => ['BMP',  'Device Independent Bitmap'],
+    DIC  =>  'DICM',
+    DICM => ['DICM', 'Digital Imaging and Communications in Medicine'],
+    DIVX => ['ASF',  'DivX media format'],
+    DJV  =>  'DJVU',
+    DJVU => ['AIFF', 'DjVu image'],
+    DLL  => ['EXE',  'Windows Dynamic Link Library'],
+    DNG  => ['TIFF', 'Digital Negative'],
+    DOC  => ['FPX',  'Microsoft Word Document'],
+    DOCM => [['ZIP','FPX'], 'Office Open XML Document Macro-enabled'],
+    # Note: I have seen a password-protected DOCX file which was FPX-like, so I assume
+    # that any other MS Office file could be like this too.  The only difference is
+    # that the ZIP and FPX formats are checked first, so if this is wrong, no biggie.
+    DOCX => [['ZIP','FPX'], 'Office Open XML Document'],
+    DOT  => ['FPX',  'Microsoft Word Template'],
+    DOTM => [['ZIP','FPX'], 'Office Open XML Document Template Macro-enabled'],
+    DOTX => [['ZIP','FPX'], 'Office Open XML Document Template'],
+    DV   => ['DV',   'Digital Video'],
+    DVB  => ['MOV',  'Digital Video Broadcasting'],
+    DYLIB=> ['EXE',  'Mach-O Dynamic Link Library'],
+    EIP  => ['ZIP',  'Capture One Enhanced Image Package'],
     EPS  => ['EPS',  'Encapsulated PostScript Format'],
-    EPSF => ['EPS',  'Encapsulated PostScript Format'],
-    ERF  => ['TIFF', 'Epson Raw Format (TIFF-like)'],
+    EPS2 =>  'EPS',
+    EPS3 =>  'EPS',
+    EPSF =>  'EPS',
+    ERF  => ['TIFF', 'Epson Raw Format'],
+    EXE  => ['EXE',  'Windows executable file'],
+    EXIF => ['EXIF', 'Exchangable Image File Metadata'],
+    F4A  => ['MOV',  'Adobe Flash Player 9+ Audio'],
+    F4B  => ['MOV',  'Adobe Flash Player 9+ audio Book'],
+    F4P  => ['MOV',  'Adobe Flash Player 9+ Protected'],
+    F4V  => ['MOV',  'Adobe Flash Player 9+ Video'],
     FLAC => ['FLAC', 'Free Lossless Audio Codec'],
+    FLA  => ['FPX',  'Macromedia/Adobe Flash project'],
     FLV  => ['FLV',  'Flash Video'],
     FPX  => ['FPX',  'FlashPix'],
     GIF  => ['GIF',  'Compuserve Graphics Interchange Format'],
-    HTM  => ['HTML', 'HyperText Markup Language'],
+    GZ   =>  'GZIP',
+    GZIP => ['GZIP', 'GNU ZIP compressed archive'],
+    HDP  => ['TIFF', 'Windows HD Photo'],
+    HTM  =>  'HTML',
     HTML => ['HTML', 'HyperText Markup Language'],
     ICC  => ['ICC',  'International Color Consortium'],
-    ICM  => ['ICC',  'International Color Consortium'],
-    JNG  => ['PNG',  'JPG Network Graphics (PNG-like)'],
+    ICM  =>  'ICC',
+    IIQ  => ['TIFF', 'Phase One Intelligent Image Quality RAW'],
+    IND  => ['IND',  'Adobe InDesign'],
+    INDD => ['IND',  'Adobe InDesign Document'],
+    INDT => ['IND',  'Adobe InDesign Template'],
+    ITC  => ['ITC',  'iTunes Cover Flow'],
+    JNG  => ['PNG',  'JPG Network Graphics'],
     JP2  => ['JP2',  'JPEG 2000 file'],
-    JPEG => ['JPEG', 'Joint Photographic Experts Group'],
+    # JP4? - looks like a JPEG but the image data is different
+    JPEG =>  'JPG',
     JPG  => ['JPEG', 'Joint Photographic Experts Group'],
-    JPX  => ['JP2',  'JPEG 2000 file'],
-    K25  => ['TIFF', 'Kodak DC25 RAW (TIFF-like)'],
-    M4A  => ['MOV',  'MPG4 Audio (QuickTime-based)'],
-    MEF  => ['TIFF', 'Mamiya (RAW) Electronic Format (TIFF-like)'],
+    JPM  => ['JP2',  'JPEG 2000 compound image'],
+    JPX  => ['JP2',  'JPEG 2000 with extensions'],
+    K25  => ['TIFF', 'Kodak DC25 RAW'],
+    KDC  => ['TIFF', 'Kodak Digital Camera RAW'],
+    KEY  => ['ZIP',  'Apple Keynote presentation'],
+    KTH  => ['ZIP',  'Apple Keynote Theme'],
+    LNK  => ['LNK',  'Windows shortcut'],
+    M2T  =>  'M2TS',
+    M2TS => ['M2TS', 'MPEG-2 Transport Stream'],
+    M2V  => ['MPEG', 'MPEG-2 Video'],
+    M4A  => ['MOV',  'MPEG-4 Audio'],
+    M4B  => ['MOV',  'MPEG-4 audio Book'],
+    M4P  => ['MOV',  'MPEG-4 Protected'],
+    M4V  => ['MOV',  'MPEG-4 Video'],
+    MEF  => ['TIFF', 'Mamiya (RAW) Electronic Format'],
     MIE  => ['MIE',  'Meta Information Encapsulation format'],
-    MIF  => ['MIFF', 'Magick Image File Format'],
+    MIF  =>  'MIFF',
     MIFF => ['MIFF', 'Magick Image File Format'],
-    MNG  => ['PNG',  'Multiple-image Network Graphics (PNG-like)'],
-    MOS  => ['TIFF', 'Creo Leaf Mosaic (TIFF-like)'],
+    MKA  => ['MKV',  'Matroska Audio'],
+    MKS  => ['MKV',  'Matroska Subtitle'],
+    MKV  => ['MKV',  'Matroska Video'],
+    MNG  => ['PNG',  'Multiple-image Network Graphics'],
+  # MODD => ['PLIST','Sony Picture Motion Metadata'],
+    MOS  => ['TIFF', 'Creo Leaf Mosaic'],
     MOV  => ['MOV',  'Apple QuickTime movie'],
-    MP3  => ['MP3',  'MPEG Layer 3 audio (uses ID3 information)'],
-    MP4  => ['MOV',  'MPEG Layer 4 video (QuickTime-based)'],
+    MP3  => ['MP3',  'MPEG-1 Layer 3 audio'],
+    MP4  => ['MOV',  'MPEG-4 video'],
     MPC  => ['MPC',  'Musepack Audio'],
-    MPEG => ['MPEG', 'MPEG audio/video format 1'],
-    MPG  => ['MPEG', 'MPEG audio/video format 1'],
+    MPEG => ['MPEG', 'MPEG-1 or MPEG-2 audio/video'],
+    MPG  =>  'MPEG',
+    MPO  => ['JPEG', 'Extended Multi-Picture format'],
+    MQV  => ['MOV',  'Sony Mobile Quicktime Video'],
     MRW  => ['MRW',  'Minolta RAW format'],
-    NEF  => ['TIFF', 'Nikon (RAW) Electronic Format (TIFF-like)'],
+    MTS  => ['M2TS', 'MPEG-2 Transport Stream'],
+    MXF  => ['MXF',  'Material Exchange Format'],
+  # NDPI => ['TIFF', 'Hamamatsu NanoZoomer Digital Pathology Image'],
+    NEF  => ['TIFF', 'Nikon (RAW) Electronic Format'],
+    NEWER => 'COS',
+    NMBTEMPLATE => ['ZIP','Apple Numbers Template'],
+    NRW  => ['TIFF', 'Nikon RAW (2)'],
+    NUMBERS => ['ZIP','Apple Numbers spreadsheet'],
+    ODP  => ['ZIP',  'Open Document Presentation'],
+    ODS  => ['ZIP',  'Open Document Spreadsheet'],
+    ODT  => ['ZIP',  'Open Document Text file'],
     OGG  => ['OGG',  'Ogg Vorbis audio file'],
     ORF  => ['ORF',  'Olympus RAW format'],
-    PBM  => ['PPM',  'Portable BitMap (PPM-like)'],
-    PCT  => ['PICT', 'Apple PICTure'],
+    OTF  => ['Font', 'Open Type Font'],
+    PAGES => ['ZIP', 'Apple Pages document'],
+    PBM  => ['PPM',  'Portable BitMap'],
+    PCT  =>  'PICT',
     PDF  => ['PDF',  'Adobe Portable Document Format'],
-    PEF  => ['TIFF', 'Pentax (RAW) Electronic Format (TIFF-like)'],
-    PGM  => ['PPM',  'Portable Gray Map (PPM-like)'],
+    PEF  => ['TIFF', 'Pentax (RAW) Electronic Format'],
+    PFA  => ['Font', 'PostScript Font ASCII'],
+    PFB  => ['Font', 'PostScript Font Binary'],
+    PFM  => ['Font', 'Printer Font Metrics'],
+    PGF  => ['PGF',  'Progressive Graphics File'],
+    PGM  => ['PPM',  'Portable Gray Map'],
     PICT => ['PICT', 'Apple PICTure'],
+  # PLIST=> ['PLIST','Apple Property List'],
+    PMP  => ['PMP',  'Sony DSC-F1 Cyber-Shot PMP'], # should stand for Proprietery Metadata Package ;)
     PNG  => ['PNG',  'Portable Network Graphics'],
+    POT  => ['FPX',  'Microsoft PowerPoint Template'],
+    POTM => [['ZIP','FPX'], 'Office Open XML Presentation Template Macro-enabled'],
+    POTX => [['ZIP','FPX'], 'Office Open XML Presentation Template'],
     PPM  => ['PPM',  'Portable Pixel Map'],
-    PPT  => ['FPX',  'Microsoft PowerPoint presentation (FPX-like)'],
+    PPS  => ['FPX',  'Microsoft PowerPoint Slideshow'],
+    PPSM => [['ZIP','FPX'], 'Office Open XML Presentation Slideshow Macro-enabled'],
+    PPSX => [['ZIP','FPX'], 'Office Open XML Presentation Slideshow'],
+    PPT  => ['FPX',  'Microsoft PowerPoint Presentation'],
+    PPTM => [['ZIP','FPX'], 'Office Open XML Presentation Macro-enabled'],
+    PPTX => [['ZIP','FPX'], 'Office Open XML Presentation'],
     PS   => ['PS',   'PostScript'],
-    PSD  => ['PSD',  'PhotoShop Drawing'],
-    QIF  => ['QTIF', 'QuickTime Image File'],
+    PS2  =>  'PS',
+    PS3  =>  'PS',
+    PSB  => ['PSD',  'Photoshop Large Document'],
+    PSD  => ['PSD',  'Photoshop Drawing'],
+    PSP  => ['PSP',  'Paint Shop Pro'],
+    PSPFRAME => 'PSP',
+    PSPIMAGE => 'PSP',
+    PSPSHAPE => 'PSP',
+    PSPTUBE  => 'PSP',
+    QIF  =>  'QTIF',
     QT   => ['MOV',  'QuickTime movie'],
-    QTI  => ['QTIF', 'QuickTime Image File'],
+    QTI  =>  'QTIF',
     QTIF => ['QTIF', 'QuickTime Image File'],
     RA   => ['Real', 'Real Audio'],
     RAF  => ['RAF',  'FujiFilm RAW Format'],
     RAM  => ['Real', 'Real Audio Metafile'],
-    RAW  => ['RAW',  'Kyocera Contax N Digital RAW or Panasonic RAW'],
-    RIF  => ['RIFF', 'Resource Interchange File Format'],
+    RAR  => ['RAR',  'RAR Archive'],
+    RAW  => [['RAW','TIFF'], 'Kyocera Contax N Digital RAW or Panasonic RAW'],
+    RIF  =>  'RIFF',
     RIFF => ['RIFF', 'Resource Interchange File Format'],
     RM   => ['Real', 'Real Media'],
     RMVB => ['Real', 'Real Media Variable Bitrate'],
     RPM  => ['Real', 'Real Media Plug-in Metafile'],
+    RSRC => ['RSRC', 'Mac OS Resource'],
+    RTF  => ['RTF',  'Rich Text Format'],
     RV   => ['Real', 'Real Video'],
-    SR2  => ['TIFF', 'Sony RAW Format 2 (TIFF-like)'],
-    SRF  => ['TIFF', 'Sony RAW Format (TIFF-like)'],
+    RW2  => ['TIFF', 'Panasonic RAW 2'],
+    RWL  => ['TIFF', 'Leica RAW'],
+    RWZ  => ['RWZ',  'Rawzor compressed image'],
+    SO   => ['EXE',  'Shared Object file'],
+    SR2  => ['TIFF', 'Sony RAW Format 2'],
+    SRF  => ['TIFF', 'Sony RAW Format'],
+    SRW  => ['TIFF', 'Samsung RAW format'],
+    SVG  => ['XMP',  'Scalable Vector Graphics'],
     SWF  => ['SWF',  'Shockwave Flash'],
-    THM  => ['JPEG', 'Canon Thumbnail (aka. JPG)'],
-    TIF  => ['TIFF', 'Tagged Image File Format'],
+    TAR  => ['TAR',  'TAR archive'],
+    THM  => ['JPEG', 'Canon Thumbnail'],
+    THMX => [['ZIP','FPX'], 'Office Open XML Theme'],
+    TIF  =>  'TIFF',
     TIFF => ['TIFF', 'Tagged Image File Format'],
-    VRD  => ['VRD',  'Canon VRD Recipe Data (written by DPP)'],
-    WAV  => ['RIFF', 'WAVeform (Windows digital audio format)'],
-    WDP  => ['TIFF', 'Windows Media Photo (TIFF-based)'],
-    WMA  => ['ASF',  'Windows Media Audio (ASF-based)'],
-    WMV  => ['ASF',  'Windows Media Video (ASF-based)'],
+    TS   =>  'M2TS',
+    TTC  => ['Font', 'True Type Font Collection'],
+    TTF  => ['Font', 'True Type Font'],
+    TUB  => 'PSP',
+    VOB  => ['MPEG', 'Video Object'],
+    VRD  => ['VRD',  'Canon VRD Recipe Data'],
+    VSD  => ['FPX',  'Microsoft Visio Drawing'],
+    WAV  => ['RIFF', 'WAVeform (Windows digital audio)'],
+    WDP  => ['TIFF', 'Windows Media Photo'],
+    WEBM => ['MKV',  'Google Web Movie'],
+    WEBP => ['RIFF', 'Google Web Picture'],
+    WMA  => ['ASF',  'Windows Media Audio'],
+    WMV  => ['ASF',  'Windows Media Video'],
     X3F  => ['X3F',  'Sigma RAW format'],
+    XCF  => ['XCF',  'GIMP native image format'],
     XHTML=> ['HTML', 'Extensible HyperText Markup Language'],
-    XLS  => ['FPX',  'Microsoft Excel worksheet (FPX-like)'],
-    XMP  => ['XMP',  'Extensible Metadata Platform data file'],
+    XLA  => ['FPX',  'Microsoft Excel Add-in'],
+    XLAM => [['ZIP','FPX'], 'Office Open XML Spreadsheet Add-in Macro-enabled'],
+    XLS  => ['FPX',  'Microsoft Excel Spreadsheet'],
+    XLSB => [['ZIP','FPX'], 'Office Open XML Spreadsheet Binary'],
+    XLSM => [['ZIP','FPX'], 'Office Open XML Spreadsheet Macro-enabled'],
+    XLSX => [['ZIP','FPX'], 'Office Open XML Spreadsheet'],
+    XLT  => ['FPX',  'Microsoft Excel Template'],
+    XLTM => [['ZIP','FPX'], 'Office Open XML Spreadsheet Template Macro-enabled'],
+    XLTX => [['ZIP','FPX'], 'Office Open XML Spreadsheet Template'],
+    XMP  => ['XMP',  'Extensible Metadata Platform'],
+    ZIP  => ['ZIP',  'ZIP archive'],
 );
 
+# descriptions for file types not found in above file extension lookup
+my %fileDescription = (
+    DICOM => 'Digital Imaging and Communications in Medicine',
+    PLIST => 'Property List',
+    XML   => 'Extensible Markup Language',
+    'DJVU (multi-page)' => 'DjVu multi-page image',
+    'Win32 EXE' => 'Windows 32-bit Executable',
+    'Win32 DLL' => 'Windows 32-bit Dynamic Link Library',
+);
+
 # MIME types for applicable file types above
-# (missing entries default to 'application/unknown')
-my %mimeType = (
-    AIFF => 'audio/aiff',
+# (missing entries default to 'application/unknown', but note that
+#  other mime types may be specified by some modules, ie. QuickTime.pm)
+%mimeType = (
+   '3FR' => 'image/x-hasselblad-3fr',
+    AI   => 'application/vnd.adobe.illustrator',
+    AIFF => 'audio/x-aiff',
     APE  => 'audio/x-monkeys-audio',
     ASF  => 'video/x-ms-asf',
-    ARW  => 'image/x-raw',
-    AVI  => 'video/avi',
+    ARW  => 'image/x-sony-arw',
+    AVI  => 'video/x-msvideo',
     BMP  => 'image/bmp',
-    BTF  => 'application/unknown', #TEMPORARY!
-    CR2  => 'image/x-raw',
-    CRW  => 'image/x-raw',
+    BTF  => 'image/x-tiff-big', #(NC) (ref http://www.asmail.be/msg0055371937.html)
+    BZ2  => 'application/bzip2',
+   'Canon 1D RAW' => 'image/x-raw', # (uses .TIF file extension)
+    CR2  => 'image/x-canon-cr2',
+    CRW  => 'image/x-canon-crw',
+    DCR  => 'image/x-kodak-dcr',
+    DFONT=> 'application/x-dfont',
+    DICM => 'application/dicom',
+    DIVX => 'video/divx',
+    DJVU => 'image/vnd.djvu',
+    DNG  => 'image/x-adobe-dng',
+    DOC  => 'application/msword',
+    DOCM => 'application/vnd.ms-word.document.macroEnabled',
+    DOCX => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    DOT  => 'application/msword',
+    DOTM => 'application/vnd.ms-word.template.macroEnabledTemplate',
+    DOTX => 'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+    DV   => 'video/x-dv',
+    EIP  => 'application/x-captureone', #(NC)
     EPS  => 'application/postscript',
-    ERF  => 'image/x-raw',
-    DCR  => 'image/x-raw',
-    DICM => 'application/dicom',
-    DNG  => 'image/x-raw',
-    DOC  => 'application/msword',
+    ERF  => 'image/x-epson-erf',
+    EXE  => 'application/octet-stream',
+    FLA  => 'application/vnd.adobe.fla',
     FLAC => 'audio/flac',
     FLV  => 'video/x-flv',
+    Font => 'application/x-font-type1', # covers PFA, PFB and PFM (not sure about PFM)
     FPX  => 'image/vnd.fpx',
     GIF  => 'image/gif',
+    GZIP => 'application/x-gzip',
+    HDP  => 'image/vnd.ms-photo',
     HTML => 'text/html',
+    ICC  => 'application/vnd.iccprofile',
+    IIQ  => 'image/x-raw',
+    IND  => 'application/x-indesign',
+    ITC  => 'application/itunes',
     JNG  => 'image/jng',
-    JP2  => 'image/jpeg2000',
+    JP2  => 'image/jp2',
     JPEG => 'image/jpeg',
-    K25  => 'image/x-raw',
-    M4A  => 'audio/mp4',
-    MEF  => 'image/x-raw',
+    JPM  => 'image/jpm',
+    JPX  => 'image/jpx',
+    K25  => 'image/x-kodak-k25',
+    KDC  => 'image/x-kodak-kdc',
+    LNK  => 'application/octet-stream',
+    M2T  => 'video/mpeg',
+    M2TS => 'video/m2ts',
+    MEF  => 'image/x-mamiya-mef',
     MIE  => 'application/x-mie',
     MIFF => 'application/x-magick-image',
+    MKA  => 'audio/x-matroska',
+    MKS  => 'application/x-matroska',
+    MKV  => 'video/x-matroska',
     MNG  => 'video/mng',
     MOS  => 'image/x-raw',
@@ -274 +481 @@
     MPC  => 'audio/x-musepack',
     MPEG => 'video/mpeg',
-    MRW  => 'image/x-raw',
-    NEF  => 'image/x-raw',
+    MRW  => 'image/x-minolta-mrw',
+    MXF  => 'application/mxf',
+    NEF  => 'image/x-nikon-nef',
+    NRW  => 'image/x-nikon-nrw',
+    ODP  => 'application/vnd.oasis.opendocument.presentation',
+    ODS  => 'application/vnd.oasis.opendocument.spreadsheet',
+    ODT  => 'application/vnd.oasis.opendocument.text',
     OGG  => 'audio/x-ogg',
-    ORF  => 'image/x-raw',
+    ORF  => 'image/x-olympus-orf',
+    OTF  => 'application/x-font-otf',
     PBM  => 'image/x-portable-bitmap',
     PDF  => 'application/pdf',
-    PEF  => 'image/x-raw',
+    PEF  => 'image/x-pentax-pef',
+    PGF  => 'image/pgf',
     PGM  => 'image/x-portable-graymap',
     PICT => 'image/pict',
+    PLIST=> 'application/xml',
     PNG  => 'image/png',
+    POT  => 'application/vnd.ms-powerpoint',
+    POTM => 'application/vnd.ms-powerpoint.template.macroEnabled',
+    POTX => 'application/vnd.openxmlformats-officedocument.presentationml.template',
     PPM  => 'image/x-portable-pixmap',
+    PPS  => 'application/vnd.ms-powerpoint',
+    PPSM => 'application/vnd.ms-powerpoint.slideshow.macroEnabled',
+    PPSX => 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
     PPT  => 'application/vnd.ms-powerpoint',
+    PPTM => 'application/vnd.ms-powerpoint.presentation.macroEnabled',
+    PPTX => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
     PS   => 'application/postscript',
-    PSD  => 'application/photoshop',
+    PSD  => 'application/vnd.adobe.photoshop',
+    PSP  => 'image/x-paintshoppro', #(NC)
     QTIF => 'image/x-quicktime',
     RA   => 'audio/x-pn-realaudio',
-    RAF  => 'image/x-raw',
+    RAF  => 'image/x-fujifilm-raf',
     RAM  => 'audio/x-pn-realaudio',
+    RAR  => 'application/x-rar-compressed',
     RAW  => 'image/x-raw',
     RM   => 'application/vnd.rn-realmedia',
     RMVB => 'application/vnd.rn-realmedia-vbr',
     RPM  => 'audio/x-pn-realaudio-plugin',
+    RSRC => 'application/ResEdit',
+    RTF  => 'text/rtf',
     RV   => 'video/vnd.rn-realvideo',
-    SR2  => 'image/x-raw',
-    SRF  => 'image/x-raw',
+    RW2  => 'image/x-panasonic-rw2',
+    RWL  => 'image/x-leica-rwl',
+    RWZ  => 'image/x-rawzor', #(duplicated in Rawzor.pm)
+    SR2  => 'image/x-sony-sr2',
+    SRF  => 'image/x-sony-srf',
+    SRW  => 'image/x-samsung-srw',
+    SVG  => 'image/svg+xml',
     SWF  => 'application/x-shockwave-flash',
+    TAR  => 'application/x-tar',
+    THMX => 'application/vnd.ms-officetheme',
     TIFF => 'image/tiff',
+    TTC  => 'application/x-font-ttf',
+    TTF  => 'application/x-font-ttf',
+    VSD  => 'application/x-visio',
     WAV  => 'audio/x-wav',
     WDP  => 'image/vnd.ms-photo',
+    WEBM => 'video/webm',
+    WEBP => 'image/webp',
     WMA  => 'audio/x-ms-wma',
     WMV  => 'video/x-ms-wmv',
-    X3F  => 'image/x-raw',
+    X3F  => 'image/x-sigma-x3f',
+    XCF  => 'image/x-xcf',
+    XLA  => 'application/vnd.ms-excel',
+    XLAM => 'application/vnd.ms-excel.addin.macroEnabled',
     XLS  => 'application/vnd.ms-excel',
+    XLSB => 'application/vnd.ms-excel.sheet.binary.macroEnabled',
+    XLSM => 'application/vnd.ms-excel.sheet.macroEnabled',
+    XLSX => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    XLT  => 'application/vnd.ms-excel',
+    XLTM => 'application/vnd.ms-excel.template.macroEnabled',
+    XLTX => 'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
+    XML  => 'application/xml',
     XMP  => 'application/rdf+xml',
+    ZIP  => 'application/zip',
 );
 
-# module names for each file type
-# (missing entries have same module name as file type)
+# module names for processing routines of each file type
+# - undefined entries default to same module name as file type
+# - module name '' defaults to Image::ExifTool
+# - module name '0' indicates a recognized but unsupported file
 my %moduleName = (
     BTF  => 'BigTIFF',
+    BZ2  => 0,
     CRW  => 'CanonRaw',
     DICM => 'DICOM',
+    COS  => 'CaptureOne',
+    DOCX => 'OOXML',
     EPS  => 'PostScript',
+    EXIF => '',
     ICC  => 'ICC_Profile',
+    IND  => 'InDesign',
     FLV  => 'Flash',
     FPX  => 'FlashPix',
+    GZIP => 'ZIP',
     JP2  => 'Jpeg2000',
-    JPEG => '',     # (in the current module)
+    JPEG => '',
+  # MODD => 'XML',
     MOV  => 'QuickTime',
+    MKV  => 'Matroska',
     MP3  => 'ID3',
     MRW  => 'MinoltaRaw',
     OGG  => 'Vorbis',
     ORF  => 'Olympus',
+  # PLIST=> 'XML',
+    PMP  => 'Sony',
     PS   => 'PostScript',
     PSD  => 'Photoshop',
     QTIF => 'QuickTime',
     RAF  => 'FujiFilm',
+    RAR  => 'ZIP',
     RAW  => 'KyoceraRaw',
+    RWZ  => 'Rawzor',
     SWF  => 'Flash',
+    TAR  => 0,
     TIFF => '',
     VRD  => 'CanonVRD',
     X3F  => 'SigmaRaw',
+    XCF  => 'GIMP',
+);
+
+# quick "magic number" file test used to avoid loading module unnecessarily:
+# - regular expression evaluated on first 1024 bytes of file
+# - must match beginning at first byte in file
+# - this test must not be more stringent than module logic
+%magicNumber = (
+    AIFF => '(FORM....AIF[FC]|AT&TFORM)',
+    APE  => '(MAC |APETAGEX|ID3)',
+    ASF  => '\x30\x26\xb2\x75\x8e\x66\xcf\x11\xa6\xd9\x00\xaa\x00\x62\xce\x6c',
+    BMP  => 'BM',
+    BTF  => '(II\x2b\0|MM\0\x2b)',
+    BZ2  => 'BZh[1-9]\x31\x41\x59\x26\x53\x59',
+    CRW  => '(II|MM).{4}HEAP(CCDR|JPGM)',
+    DICM => '(.{128}DICM|\0[\x02\x04\x06\x08]\0[\0-\x20]|[\x02\x04\x06\x08]\0[\0-\x20]\0)',
+    DOCX => 'PK\x03\x04',
+    DV   => '\x1f\x07\0[\x3f\xbf]', # (not tested if extension recognized)
+    EPS  => '(%!PS|%!Ad|\xc5\xd0\xd3\xc6)',
+    EXE  => '(MZ|\xca\xfe\xba\xbe|\xfe\xed\xfa[\xce\xcf]|[\xce\xcf]\xfa\xed\xfe|Joy!peff|\x7fELF|#!\s*/\S*bin/|!<arch>\x0a)',
+    EXIF => '(II\x2a\0|MM\0\x2a)',
+    FLAC => '(fLaC|ID3)',
+    FLV  => 'FLV\x01',
+    Font => '((\0\x01\0\0|OTTO|true|typ1)[\0\x01]|ttcf\0[\x01\x02]\0\0|\0[\x01\x02]|' .
+            '(.{6})?%!(PS-(AdobeFont-|Bitstream )|FontType1-)|Start(Comp|Master)?FontMetrics)',
+    FPX  => '\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1',
+    GIF  => 'GIF8[79]a',
+    GZIP => '\x1f\x8b\x08',
+    HTML => '(?i)<(!DOCTYPE\s+HTML|HTML|\?xml)', # (case insensitive)
+    ICC  => '.{12}(scnr|mntr|prtr|link|spac|abst|nmcl|nkpf)(XYZ |Lab |Luv |YCbr|Yxy |RGB |GRAY|HSV |HLS |CMYK|CMY |[2-9A-F]CLR){2}',
+    IND  => '\x06\x06\xed\xf5\xd8\x1d\x46\xe5\xbd\x31\xef\xe7\xfe\x74\xb7\x1d',
+    ITC  => '.{4}itch',
+    JP2  => '\0\0\0\x0cjP(  |\x1a\x1a)\x0d\x0a\x87\x0a',
+    JPEG => '\xff\xd8\xff',
+    LNK  => '.{4}\x01\x14\x02\0{5}\xc0\0{6}\x46',
+    M2TS => '(....)?\x47',
+    MIE  => '~[\x10\x18]\x04.0MIE',
+    MIFF => 'id=ImageMagick',
+    MKV  => '\x1a\x45\xdf\xa3',
+    MOV  => '.{4}(free|skip|wide|ftyp|pnot|PICT|pict|moov|mdat|junk|uuid)',
+  # MP3  =>  difficult to rule out
+    MPC  => '(MP\+|ID3)',
+    MPEG => '\0\0\x01[\xb0-\xbf]',
+    MRW  => '\0MR[MI]',
+    MXF  => '\x06\x0e\x2b\x34\x02\x05\x01\x01\x0d\x01\x02', # (not tested if extension recognized)
+    OGG  => '(OggS|ID3)',
+    ORF  => '(II|MM)',
+    PDF  => '%PDF-\d+\.\d+',
+    PGF  => 'PGF',
+    PICT => '(.{10}|.{522})(\x11\x01|\x00\x11)',
+    PMP  => '.{8}\0{3}\x7c.{112}\xff\xd8\xff\xdb',
+    PNG  => '(\x89P|\x8aM|\x8bJ)NG\r\n\x1a\n',
+    PPM  => 'P[1-6]\s+',
+    PS   => '(%!PS|%!Ad|\xc5\xd0\xd3\xc6)',
+    PSD  => '8BPS\0[\x01\x02]',
+    PSP  => 'Paint Shop Pro Image File\x0a\x1a\0{5}',
+    QTIF => '.{4}(idsc|idat|iicc)',
+    RAF  => 'FUJIFILM',
+    RAR  => 'Rar!\x1a\x07\0',
+    RAW  => '(.{25}ARECOYK|II|MM)',
+    Real => '(\.RMF|\.ra\xfd|pnm://|rtsp://|http://)',
+    RIFF => 'RIFF',
+    RSRC => '(....)?\0\0\x01\0',
+    RTF  => '[\n\r]*\\{[\n\r]*\\\\rtf',
+    # (don't be too restrictive for RW2/RWL -- how does magic number change for big-endian?)
+    RW2  => '(II|MM)', #(\x55\0\x18\0\0\0\x88\xe7\x74\xd8\xf8\x25\x1d\x4d\x94\x7a\x6e\x77\x82\x2b\x5d\x6a)
+    RWL  => '(II|MM)', #(ditto)
+    RWZ  => 'rawzor',
+    SWF  => '[FC]WS[^\0]',
+    TAR  => '.{257}ustar(  )?\0', # (this doesn't catch old-style tar files)
+    TIFF => '(II|MM)', # don't test magic number (some raw formats are different)
+    VRD  => 'CANON OPTIONAL DATA\0',
+    X3F  => 'FOVb',
+    XCF  => 'gimp xcf ',
+    XMP  => '\0{0,3}(\xfe\xff|\xff\xfe|\xef\xbb\xbf)?\0{0,3}\s*<',
+    ZIP  => 'PK\x03\x04',
+);
+
+# lookup for valid character set names (keys are all lower case)
+%charsetName = (
+    #   Charset setting                       alias(es)
+    # -------------------------   --------------------------------------------
+    utf8        => 'UTF8',        cp65001 => 'UTF8', 'utf-8' => 'UTF8',
+    latin       => 'Latin',       cp1252  => 'Latin', latin1 => 'Latin',
+    latin2      => 'Latin2',      cp1250  => 'Latin2',
+    cyrillic    => 'Cyrillic',    cp1251  => 'Cyrillic', russian => 'Cyrillic',
+    greek       => 'Greek',       cp1253  => 'Greek',
+    turkish     => 'Turkish',     cp1254  => 'Turkish',
+    hebrew      => 'Hebrew',      cp1255  => 'Hebrew',
+    arabic      => 'Arabic',      cp1256  => 'Arabic',
+    baltic      => 'Baltic',      cp1257  => 'Baltic',
+    vietnam     => 'Vietnam',     cp1258  => 'Vietnam',
+    thai        => 'Thai',        cp874   => 'Thai',
+    macroman    => 'MacRoman',    cp10000 => 'MacRoman', mac => 'MacRoman', roman => 'MacRoman',
+    maclatin2   => 'MacLatin2',   cp10029 => 'MacLatin2',
+    maccyrillic => 'MacCyrillic', cp10007 => 'MacCyrillic',
+    macgreek    => 'MacGreek',    cp10006 => 'MacGreek',
+    macturkish  => 'MacTurkish',  cp10081 => 'MacTurkish',
+    macromanian => 'MacRomanian', cp10010 => 'MacRomanian',
+    maciceland  => 'MacIceland',  cp10079 => 'MacIceland',
+    maccroatian => 'MacCroatian', cp10082 => 'MacCroatian',
 );
 
@@ -343 +709 @@
 # group hash for ExifTool-generated tags
 my %allGroupsExifTool = ( 0 => 'ExifTool', 1 => 'ExifTool', 2 => 'ExifTool' );
+
+# special tag names (not used for tag info)
+my %specialTags = (
+    TABLE_NAME=>1, SHORT_NAME=>1, PROCESS_PROC=>1, WRITE_PROC=>1, CHECK_PROC=>1,
+    GROUPS=>1, FORMAT=>1, FIRST_ENTRY=>1, TAG_PREFIX=>1, PRINT_CONV=>1,
+    WRITABLE=>1, TABLE_DESC=>1, NOTES=>1, IS_OFFSET=>1, EXTRACT_UNKNOWN=>1,
+    NAMESPACE=>1, PREFERRED=>1, SRC_TABLE=>1, PRIORITY=>1, WRITE_GROUP=>1,
+    LANG_INFO=>1, VARS=>1, DATAMEMBER=>1, IS_SUBDIR=>1, SET_GROUP1=>1,
+);
 
 # headers for various segment types
 $exifAPP1hdr = "Exif\0\0";
 $xmpAPP1hdr = "http://ns.adobe.com/xap/1.0/\0";
+$xmpExtAPP1hdr = "http://ns.adobe.com/xmp/extension/\0";
 $psAPP13hdr = "Photoshop 3.0\0";
 $psAPP13old = 'Adobe_Photoshop2.5:';
 
 sub DummyWriteProc { return 1; }
+
+# lookup for user lenses defined in @Image::ExifTool::UserDefined::Lenses
+%Image::ExifTool::userLens = ( );
+
+# queued plug-in tags to add to lookup
+@Image::ExifTool::pluginTags = ( );
+%Image::ExifTool::pluginTags = ( );
 
 # tag information for preview image -- this should be used for all
@@ -360 +743 @@
     WriteCheck => '$val eq "none" ? undef : $self->CheckImage(\$val)',
     DataTag => 'PreviewImage',
+    # accept either scalar or scalar reference
+    RawConv => '$self->ValidateImage(ref $val ? $val : \$val, $tag)',
     # we allow preview image to be set to '', but we don't want a zero-length value
     # in the IFD, so set it temorarily to 'none'.  Note that the length is <= 4,
     # so this value will fit in the IFD so the preview fixup won't be generated.
-    ValueConv => '$self->ValidateImage(\$val,$tag)',
     ValueConvInv => '$val eq "" and $val="none"; $val',
 );
@@ -372 +756 @@
 %Image::ExifTool::Extra = (
     GROUPS => { 0 => 'File', 1 => 'File', 2 => 'Image' },
-    DID_TAG_ID => 1,   # tag ID's aren't meaningful for these tags
+    VARS => { NO_ID => 1 }, # tag ID's aren't meaningful for these tags
     WRITE_PROC => \&DummyWriteProc,
+    Error   => { Priority => 0, Groups => \%allGroupsExifTool },
+    Warning => { Priority => 0, Groups => \%allGroupsExifTool },
     Comment => {
         Notes => 'comment embedded in JPEG, GIF89a or PPM/PGM/PBM image',
@@ -381 +767 @@
     },
     Directory => {
+        Groups => { 1 => 'System' },
         Writable => 1,
         Protected => 1,
@@ -387 +774 @@
     },
     FileName => {
+        Groups => { 1 => 'System' },
         Writable => 1,
         Protected => 1,
+        Notes => q{
+            may be written with a full path name to set FileName and Directory in one
+            operation.  See L<filename.html|../filename.html> for more information on
+            writing the FileName and Directory tags
+        },
         ValueConvInv => '$val=~tr/\\\\/\//; $val',
     },
     FileSize => {
-        PrintConv => sub {
-            my $val = shift;
-            $val < 2048 and return "$val bytes";
-            $val < 2097152 and return sprintf('%.0f kB', $val / 1024);
-            return sprintf('%.0f MB', $val / 1048576);
+        Groups => { 1 => 'System' },
+        PrintConv => \&ConvertFileSize,
+    },
+    ResourceForkSize => {
+        Groups => { 1 => 'System' },
+        Notes => q{
+            [Mac OS only] size of the file's resource fork if it contains data.  If this
+            tag is generated the ExtractEmbedded option may be used to extract
+            resource-fork information as a sub-document
         },
+        PrintConv => \&ConvertFileSize,
     },
     FileType    => { },
@@ -403 +801 @@
         Description => 'File Modification Date/Time',
         Notes => 'the filesystem modification time',
-        Groups => { 2 => 'Time' },
+        Groups => { 1 => 'System', 2 => 'Time' },
         Writable => 1,
+        # all pseudo-tags must be protected so -tagsfromfile fails with
+        # unrecognized files unless a pseudo tag is specified explicitly
+        Protected => 1,
         Shift => 'Time',
-        ValueConv => 'ConvertUnixTime($val,"local")',
-        ValueConvInv => 'GetUnixTime($val,"local")',
+        ValueConv => 'ConvertUnixTime($val,1)',
+        ValueConvInv => 'GetUnixTime($val,1)',
         PrintConv => '$self->ConvertDateTime($val)',
-        PrintConvInv => '$val',
+        PrintConvInv => '$self->InverseDateTime($val)',
+    },
+    FilePermissions => {
+        Groups => { 1 => 'System' },
+        Notes => q{
+            r=read, w=write and x=execute permissions for the file owner, group and
+            others.  The ValueConv value is an octal number so bit test operations on
+            this value should be done in octal, ie. "oct($filePermissions) & 0200"
+        },
+        ValueConv => 'sprintf("%.3o", $val & 0777)',
+        PrintConv => sub {
+            my ($mask, $str, $val) = (0400, '', oct(shift));
+            while ($mask) {
+                foreach (qw(r w x)) {
+                    $str .= $val & $mask ? $_ : '-';
+                    $mask >>= 1;
+                }
+            }
+            return $str;
+        },
     },
     MIMEType    => { },
@@ -418 +838 @@
     MaxVal      => { }, # max pixel value in PPM or PGM image
     EXIF => {
-        Notes => 'the full EXIF data block',
-        Groups => { 0 => 'EXIF' },
-        Binary => 1,
+        Notes => 'the full EXIF data block from JPEG, PNG, JP2, MIE and MIFF images',
+        Groups => { 0 => 'EXIF', 1 => 'EXIF' },
+        Flags => ['Writable' ,'Protected', 'Binary'],
+        WriteCheck => q{
+            return undef if $val =~ /^(II\x2a\0|MM\0\x2a)/;
+            return 'Invalid EXIF data';
+        },
     },
     ICC_Profile => {
         Notes => 'the full ICC_Profile data block',
-        Groups => { 0 => 'ICC_Profile' },
+        Groups => { 0 => 'ICC_Profile', 1 => 'ICC_Profile' },
         Flags => ['Writable' ,'Protected', 'Binary'],
         WriteCheck => q{
@@ -433 +857 @@
     XMP => {
         Notes => 'the full XMP data block',
-        Groups => { 0 => 'XMP' },
-        Flags => [ 'Writable', 'Binary' ],
+        Groups => { 0 => 'XMP', 1 => 'XMP' },
+        Flags => ['Writable', 'Protected', 'Binary'],
+        Priority => 0,  # so main xmp (which usually comes first) takes priority
         WriteCheck => q{
             require Image::ExifTool::XMP;
@@ -442 +867 @@
     CanonVRD => {
         Notes => 'the full Canon DPP VRD trailer block',
-        Groups => { 0 => 'CanonVRD' },
+        Groups => { 0 => 'CanonVRD', 1 => 'CanonVRD' },
         Flags => ['Writable' ,'Protected', 'Binary'],
+        Permanent => 0, # (this is 1 by default for MakerNotes tags)
         WriteCheck => q{
             return undef if $val =~ /^CANON OPTIONAL DATA\0/;
@@ -449 +875 @@
         },
     },
-    Encryption  => { }, # PDF encryption filter
+    CurrentIPTCDigest => {
+        Notes => q{
+            MD5 digest of existing IPTC data.  All zeros if IPTC exists but Digest::MD5
+            is not installed.  Only calculated for IPTC in the standard location as
+            specified by the L<MWG|http://www.metadataworkinggroup.org/>.  ExifTool
+            automates the handling of this tag in the MWG module -- see the
+            L<MWG Tag Name documentation|MWG.html> for details
+        },
+        ValueConv => 'unpack("H*", $val)',
+    },
+    PreviewImage => {
+        Writable => 1,
+        WriteCheck => '$self->CheckImage(\$val)',
+        # can't delete, so set to empty string and return no error
+        DelCheck => '$val = ""; return undef',
+        # accept either scalar or scalar reference
+        RawConv => '$self->ValidateImage(ref $val ? $val : \$val, $tag)',
+    },
+    PreviewPNG  => { Binary => 1 },
     ExifByteOrder => {
         Writable => 1,
         Notes => 'only writable for newly created EXIF segments',
         PrintConv => {
-            II => 'Little-endian (Intel)',
-            MM => 'Big-endian (Motorola)',
+            II => 'Little-endian (Intel, II)',
+            MM => 'Big-endian (Motorola, MM)',
+        },
+    },
+    ExifUnicodeByteOrder => {
+        Writable => 1,
+        Notes => q{
+            the EXIF specification is particularly vague about the byte ordering for
+            Unicode text, and different applications use different conventions.  By
+            default ExifTool writes Unicode text in EXIF byte order, but this write-only
+            tag may be used to force a specific byte order
+        },
+        PrintConv => {
+            II => 'Little-endian (Intel, II)',
+            MM => 'Big-endian (Motorola, MM)',
         },
     },
     ExifToolVersion => {
         Description => 'ExifTool Version Number',
-        Groups      => \%allGroupsExifTool
+        Groups => \%allGroupsExifTool,
     },
-    Error       => { Priority => 0, Groups => \%allGroupsExifTool },
-    Warning     => { Priority => 0, Groups => \%allGroupsExifTool },
+    RAFVersion => { },
+    JPEGDigest => {
+        Notes => q{
+            an MD5 digest of the JPEG quantization tables is combined with the component
+            sub-sampling values to generate the value of this tag.  The result is
+            compared to known values in an attempt to deduce the originating software
+            based only on the JPEG image data.  For performance reasons, this tag is
+            generated only if specifically requested
+        },
+    },
+    Now => {
+        Groups => { 0 => 'ExifTool', 1 => 'ExifTool', 2 => 'Time' },
+        Notes => q{
+            the current date/time.  Useful when setting the tag values, ie.
+            C<"-modifydate<now">.  Not generated unless specifically requested
+        },
+        ValueConv => sub {
+            my $time = shift;
+            my @tm = localtime $time;
+            my $tz = Image::ExifTool::TimeZoneString(\@tm, $time);
+            sprintf("%4d:%.2d:%.2d %.2d:%.2d:%.2d%s", $tm[5]+1900, $tm[4]+1, $tm[3],
+                    $tm[2], $tm[1], $tm[0], $tz);
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    ID3Size     => { },
+    Geotag => {
+        Writable => 1,
+        AllowGroup => '(exif|gps|xmp|xmp-exif)',
+        Notes => q{
+            this write-only tag is used to define the GPS track log data or track log
+            file name.  Currently supported track log formats are GPX, NMEA RMC/GGA/GLL,
+            KML, IGC, Garmin XML and TCX, and Magellan PMGNTRK.  See
+            L<geotag.html|../geotag.html> for details
+        },
+        DelCheck => q{
+            require Image::ExifTool::Geotag;
+            # delete associated tags
+            Image::ExifTool::Geotag::SetGeoValues($self, undef, $wantGroup);
+        },
+        ValueConvInv => q{
+            require Image::ExifTool::Geotag;
+            # always warn because this tag is never set (warning is "\n" on success)
+            my $result = Image::ExifTool::Geotag::LoadTrackLog($self, $val);
+            return '' if not defined $result;   # deleting geo tags
+            return $result if ref $result;      # geotag data hash reference
+            warn "$result\n";                   # error string
+        },
+    },
+    Geotime => {
+        Writable => 1,
+        AllowGroup => '(exif|gps|xmp|xmp-exif)',
+        Notes => q{
+            this write-only tag is used to define a date/time for interpolating a
+            position in the GPS track specified by the Geotag tag.  Writing this tag
+            causes the following 8 tags to be written:  GPSLatitude, GPSLatitudeRef,
+            GPSLongitude, GPSLongitudeRef, GPSAltitude, GPSAltitudeRef, GPSDateStamp and
+            GPSTimeStamp.  The local system timezone is assumed if the date/time value
+            does not contain a timezone.  May be deleted to delete associated GPS tags.
+            A group name of 'EXIF' or 'XMP' may be specified to write or delete only
+            EXIF or XMP GPS tags.  The value of Geotag must be assigned before this tag
+        },
+        DelCheck => q{
+            require Image::ExifTool::Geotag;
+            # delete associated tags
+            Image::ExifTool::Geotag::SetGeoValues($self, undef, $wantGroup);
+        },
+        ValueConvInv => q{
+            require Image::ExifTool::Geotag;
+            warn Image::ExifTool::Geotag::SetGeoValues($self, $val, $wantGroup) . "\n";
+            return undef;
+        },
+    },
+    Geosync => {
+        Writable => 1,
+        AllowGroup => '(exif|gps|xmp|xmp-exif)',
+        Shift => 'Time', # enables "+=" syntax as well as "=+"
+        Notes => q{
+            this write-only tag specifies a time difference to add to Geotime for
+            synchronization with the GPS clock.  For example, set this to "-12" if the
+            camera clock is 12 seconds faster than GPS time.  Input format is
+            "[+-][[[DD ]HH:]MM:]SS[.ss]".  Must be set before Geotime to be effective.
+            Additional features allow calculation of time differences and time drifts,
+            and extraction of synchronization times from image files. See the
+            L<geotagging documentation|../geotag.html> for details
+        },
+        ValueConvInv => q{
+            require Image::ExifTool::Geotag;
+            return Image::ExifTool::Geotag::ConvertGeosync($self, $val);
+        },
+    },
 );
 
-# information decoded from JPEG SOF frame
-# (define this here to avoid loading JPEG.pm)
+# YCbCrSubSampling values (used by JPEG SOF, EXIF and XMP)
+%Image::ExifTool::JPEG::yCbCrSubSampling = (
+    '1 1' => 'YCbCr4:4:4 (1 1)', #PH
+    '2 1' => 'YCbCr4:2:2 (2 1)', #14 in Exif.pm
+    '2 2' => 'YCbCr4:2:0 (2 2)', #14 in Exif.pm
+    '4 1' => 'YCbCr4:1:1 (4 1)', #14 in Exif.pm
+    '4 2' => 'YCbCr4:1:0 (4 2)', #PH
+    '1 2' => 'YCbCr4:4:0 (1 2)', #PH
+    '1 4' => 'YCbCr4:4:1 (1 4)', #JD
+    '2 4' => 'YCbCr4:2:1 (2 4)', #JD
+);
+
+# define common JPEG segments here to avoid overhead of loading JPEG module
+
+# JPEG SOF (start of frame) tags
 # (ref http://www.w3.org/Graphics/JPEG/itu-t81.pdf)
 %Image::ExifTool::JPEG::SOF = (
     GROUPS => { 0 => 'File', 1 => 'File', 2 => 'Image' },
     NOTES => 'This information is extracted from the JPEG Start Of Frame segment.',
-    VARS => { NO_ID => 1 },
-    EncodingProcess => {
-        PrintHex => 1,
-        PrintConv => {
-            0x0 => 'Baseline DCT, Huffman coding',
+    VARS => { NO_ID => 1 }, # tag ID's aren't meaningful for these tags
+    EncodingProcess => {
+        PrintHex => 1,
+        PrintConv => {
+            0x0 => 'Baseline DCT, Huffman coding',
             0x1 => 'Extended sequential DCT, Huffman coding',
             0x2 => 'Progressive DCT, Huffman coding',
@@ -497 +1056 @@
     YCbCrSubSampling => {
         Notes => 'calculated from components table',
-        PrintConv => {
-            '1 1' => 'YCbCr4:4:4 (1 1)',
-            '2 1' => 'YCbCr4:2:2 (2 1)',
-            '2 2' => 'YCbCr4:2:0 (2 2)',
-            '4 1' => 'YCbCr4:1:1 (4 1)',
-            '4 2' => 'YCbCr4:1:0 (4 2)',
-            '1 2' => 'YCbCr4:4:0 (1 2)',
-        },
+        PrintConv => \%Image::ExifTool::JPEG::yCbCrSubSampling,
     },
 );
 
-# static private ExifTool variables
-
-%allTables = ( );   # list of all tables loaded (except composite tags)
-@tableOrder = ( );  # order the tables were loaded
-
-my $didTagID;       # flag indicating we are accessing tag ID's
-
-# composite tags (accumulation of all Composite tag tables)
-%Image::ExifTool::Composite = (
-    GROUPS => { 0 => 'Composite', 1 => 'Composite' },
-    DID_TAG_ID => 1,    # want empty tagID's for composite tags
-    WRITE_PROC => \&DummyWriteProc,
-);
-
-# JFIF APP0 definitions
+# JPEG JFIF APP0 definitions
 %Image::ExifTool::JFIF::Main = (
     PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
@@ -532 +1070 @@
         Name => 'JFIFVersion',
         Format => 'int8u[2]',
-        PrintConv => '$val=~tr/ /./;$val',
+        PrintConv => 'sprintf("%d.%.2d", split(" ",$val))',
     },
     2 => {
@@ -564 +1102 @@
     0x10 => {
         Name => 'ThumbnailImage',
-        ValueConv => '$self->ValidateImage(\$val,$tag)',
+        RawConv => '$self->ValidateImage(\$val,$tag)',
     },
 );
 
-# special tag names (not used for tag info)
-my %specialTags = (
-    PROCESS_PROC=>1, WRITE_PROC=>1, CHECK_PROC=>1, GROUPS=>1, FORMAT=>1,
-    FIRST_ENTRY=>1, TAG_PREFIX=>1, PRINT_CONV=>1, DID_TAG_ID=>1, WRITABLE=>1,
-    NOTES=>1, IS_OFFSET=>1, EXTRACT_UNKNOWN=>1, NAMESPACE=>1, PREFERRED=>1,
-    PARENT=>1, PRIORITY=>1, WRITE_GROUP=>1, LANG_INFO=>1, VARS=>1,
-    DATAMEMBER=>1,
+# Composite tags (accumulation of all Composite tag tables)
+%Image::ExifTool::Composite = (
+    GROUPS => { 0 => 'Composite', 1 => 'Composite' },
+    TABLE_NAME => 'Image::ExifTool::Composite',
+    SHORT_NAME => 'Composite',
+    VARS => { NO_ID => 1 }, # want empty tagID's for Composite tags
+    WRITE_PROC => \&DummyWriteProc,
 );
+
+# static private ExifTool variables
+
+%allTables = ( );   # list of all tables loaded (except Composite tags)
+@tableOrder = ( );  # order the tables were loaded
 
 #------------------------------------------------------------------------------
@@ -605 +1148 @@
 # New - create new ExifTool object
 # Inputs: 0) reference to exiftool object or ExifTool class name
+# Returns: blessed ExifTool object ref
 sub new
 {
@@ -617 +1161 @@
     $self->ClearOptions();      # create default options hash
     $self->{VALUE} = { };       # must initialize this for warning messages
-    $self->{DEL_GROUP} = { };   # list of groups to delete when writing
+    $self->{DEL_GROUP} = { };   # lookup for groups to delete when writing
 
     # initialize our new groups for writing
@@ -633 +1177 @@
 # Notes:
 #   - if no tags names are specified, the values of all tags are returned
-#   - tags may be specified with leading '-' to exclude
+#   - tags may be specified with leading '-' to exclude, or trailing '#' for ValueConv
 #   - can pass a reference to list of tags to find, in which case the list will
 #     be updated with the tags found in the proper case and in the specified order.
@@ -684 +1228 @@
     while (@_) {
         my $param = shift;
-        $oldVal = $options->{$param};
+        $oldVal = $$options{$param};
         last unless @_;
-        $options->{$param} = shift;
-        # clone Exclude list and expand shortcuts
-        if ($param eq 'Exclude' and defined $options->{$param}) {
+        my $newVal = shift;
+        if ($param eq 'Lang') {
+            # allow this to be set to undef to select the default language
+            $newVal = $defaultLang unless defined $newVal;
+            if ($newVal eq $defaultLang) {
+                $$options{$param} = $newVal;
+                delete $$self{CUR_LANG};
+            # make sure the language is available
+            } elsif (eval "require Image::ExifTool::Lang::$newVal") {
+                my $xlat = "Image::ExifTool::Lang::${newVal}::Translate";
+                no strict 'refs';
+                if (%$xlat) {
+                    $$self{CUR_LANG} = \%$xlat;
+                    $$options{$param} = $newVal;
+                }
+            } # else don't change Lang
+        } elsif ($param eq 'Exclude' and defined $newVal) {
+            # clone Exclude list and expand shortcuts
             my @exclude;
-            my $val = $options->{$param};
-            if (ref $val eq 'ARRAY') {
-                @exclude = @$val;
+            if (ref $newVal eq 'ARRAY') {
+                @exclude = @$newVal;
             } else {
-                @exclude = ($val);
-            }
-            ExpandShortcuts(\@exclude);
-            $options->{$param} = \@exclude;
+                @exclude = ($newVal);
+            }
+            ExpandShortcuts(\@exclude, 1);  # (also remove '#' suffix)
+            $$options{$param} = \@exclude;
+        } elsif ($param =~ /^Charset/ or $param eq 'IPTCCharset') {
+            # only allow valid character sets to be set
+            if ($newVal) {
+                my $charset = $charsetName{lc $newVal};
+                if ($charset) {
+                    $$options{$param} = $charset;
+                    # maintain backward-compatibility with old IPTCCharset option
+                    $$options{CharsetIPTC} = $charset if $param eq 'IPTCCharset';
+                } else {
+                    warn "Invalid Charset $newVal\n";
+                }
+            }
+        } else {
+            if ($param eq 'Escape') {
+                # set ESCAPE_PROC
+                if (defined $newVal and $newVal eq 'XML') {
+                    require Image::ExifTool::XMP;
+                    $$self{ESCAPE_PROC} = \&Image::ExifTool::XMP::EscapeXML;
+                } elsif (defined $newVal and $newVal eq 'HTML') {
+                    require Image::ExifTool::HTML;
+                    $$self{ESCAPE_PROC} = \&Image::ExifTool::HTML::EscapeHTML;
+                } else {
+                    delete $$self{ESCAPE_PROC};
+                }
+                # must forget saved values since they depend on Escape method
+                $self->{BOTH} = { };
+            }
+            $$options{$param} = $newVal;
         }
     }
@@ -713 +1299 @@
     # create options hash with default values
     # (commented out options don't need initializing)
+    # +-----------------------------------------------------+
+    # ! DON'T FORGET!!  When adding any new option, must    !
+    # ! decide how it is handled in SetNewValuesFromFile()  !
+    # +-----------------------------------------------------+
     $self->{OPTIONS} = {
     #   Binary      => undef,   # flag to extract binary values even if tag not specified
     #   ByteOrder   => undef,   # default byte order when creating EXIF information
         Charset     => 'UTF8',  # character set for converting Unicode characters
+        CharsetID3  => 'Latin', # internal ID3v1 character set
+        CharsetIPTC => 'Latin', # fallback IPTC character set if no CodedCharacterSet
     #   Compact     => undef,   # compact XMP and IPTC data
         Composite   => 1,       # flag to calculate Composite tags
@@ -723 +1315 @@
     #   DateFormat  => undef,   # format for date/time
         Duplicates  => 1,       # flag to save duplicate tag values
+    #   Escape      => undef,   # escape special characters
     #   Exclude     => undef,   # tags to exclude
+    #   ExtractEmbedded =>undef,# flag to extract information from embedded documents
     #   FastScan    => undef,   # flag to avoid scanning for trailer
     #   FixBase     => undef,   # fix maker notes base offsets
+    #   GeoMaxIntSecs => undef, # geotag maximum interpolation time (secs)
+    #   GeoMaxExtSecs => undef, # geotag maximum extrapolation time (secs)
+    #   GeoMaxHDOP  => undef,   # geotag maximum HDOP
+    #   GeoMaxPDOP  => undef,   # geotag maximum PDOP
+    #   GeoMinSats  => undef,   # geotag minimum satellites
     #   Group#      => undef,   # return tags for specified groups in family #
         HtmlDump    => 0,       # HTML dump (0-3, higher # = bigger limit)
     #   HtmlDumpBase => undef,  # base address for HTML dump
     #   IgnoreMinorErrors => undef, # ignore minor errors when reading/writing
+        Lang        => $defaultLang,# localized language for descriptions etc
+    #   LargeFileSupport => undef,  # flag indicating support of 64-bit file offsets
     #   List        => undef,   # extract lists of PrintConv values into arrays
+        ListSep     => ', ',    # list item separator
+    #   ListSplit   => undef,   # regex for splitting list-type tag values when writing
     #   MakerNotes  => undef,   # extract maker notes as a block
     #   MissingTagValue =>undef,# value for missing tags when expanded in expressions
+    #   Password    => undef,   # password for password-protected PDF documents
         PrintConv   => 1,       # flag to enable print conversion
+    #   SavePath    => undef,   # (undocumented) save family 5 location path
     #   ScanForXMP  => undef,   # flag to scan for XMP information in all files
         Sort        => 'Input', # order to sort found tags (Input, File, Alpha, Group#)
     #   StrictDate  => undef,   # flag to return undef for invalid date conversions
+    #   Struct      => undef,   # return structures as hash references
         TextOut     => \*STDOUT,# file for Verbose/HtmlDump output
         Unknown     => 0,       # flag to get values of unknown tags (0-2)
-        Verbose     => 0,       # print verbose messages (0-4, higher # = more verbose)
+        Verbose     => 0,       # print verbose messages (0-5, higher # = more verbose)
     };
+    # keep necessary member variables in sync with options
+    delete $$self{CUR_LANG};
+    delete $$self{ESCAPE_PROC};
+
+    # load user-defined default options
+    if (%Image::ExifTool::UserDefined::Options) {
+        foreach (keys %Image::ExifTool::UserDefined::Options) {
+            $self->Options($_, $Image::ExifTool::UserDefined::Options{$_});
+        }
+    }
 }
 
@@ -749 +1365 @@
 # Returns: 1 if this was a valid image, 0 otherwise
 # Notes: pass an undefined value to avoid parsing arguments
+# Internal 'ReEntry' option allows this routine to be called recursively
 sub ExtractInfo($;@)
 {
@@ -754 +1371 @@
     my $self = shift;
     my $options = $self->{OPTIONS};     # pointer to current options
-    my %saveOptions;
-
-    if (defined $_[0] or $options->{HtmlDump}) {
-        %saveOptions = %$options;       # save original options
-        
-        # require duplicates for html dump
-        $self->Options(Duplicates => 1) if $options->{HtmlDump};
-
-        if (defined $_[0]) {
-            # only initialize filename if called with arguments
-            $self->{FILENAME} = undef;  # name of file (or '' if we didn't open it)
-            $self->{RAF} = undef;       # RandomAccess object reference
+    my (%saveOptions, $reEntry, $rsize);
+
+    # check for internal ReEntry option to allow recursive calls to ExtractInfo
+    if (ref $_[1] eq 'HASH' and $_[1]{ReEntry} and
+       (ref $_[0] eq 'SCALAR' or ref $_[0] eq 'GLOB'))
+    {
+        # save necessary members for restoring later
+        $reEntry = {
+            RAF       => $$self{RAF},
+            PROCESSED => $$self{PROCESSED},
+            EXIF_DATA => $$self{EXIF_DATA},
+            EXIF_POS  => $$self{EXIF_POS},
+            FILE_TYPE => $$self{FILE_TYPE},
+        };
+        $self->{RAF} = new File::RandomAccess($_[0]);
+        $$self{PROCESSED} = { };
+        delete $$self{EXIF_DATA};
+        delete $$self{EXIF_POS};
+    } else {
+        if (defined $_[0] or $options->{HtmlDump}) {
+            %saveOptions = %$options;       # save original options
     
-            $self->ParseArguments(@_);  # initialize from our arguments
-        }
-    }
-    # initialize ExifTool object members
-    $self->Init();
-
-    delete $self->{MAKER_NOTE_FIXUP};   # fixup information for extracted maker notes
-    delete $self->{MAKER_NOTE_BYTE_ORDER};
-    delete $self->{DONE_ID3};
-
+            # require duplicates for html dump
+            $self->Options(Duplicates => 1) if $options->{HtmlDump};
+    
+            if (defined $_[0]) {
+                # only initialize filename if called with arguments
+                $self->{FILENAME} = undef;  # name of file (or '' if we didn't open it)
+                $self->{RAF} = undef;       # RandomAccess object reference
+    
+                $self->ParseArguments(@_);  # initialize from our arguments
+            }
+        }
+        # initialize ExifTool object members
+        $self->Init();
+
+        delete $self->{MAKER_NOTE_FIXUP};   # fixup information for extracted maker notes
+        delete $self->{MAKER_NOTE_BYTE_ORDER};
+
+        # return our version number
+        $self->FoundTag('ExifToolVersion', "$VERSION$RELEASE");
+        $self->FoundTag('Now', time()) if $self->{REQ_TAG_LOOKUP}{now} or $self->{TAGS_FROM_FILE};
+    }
     my $filename = $self->{FILENAME};   # image file name ('' if already open)
     my $raf = $self->{RAF};             # RandomAccess object
 
-    # return our version number
-    $self->FoundTag('ExifToolVersion', "$VERSION$RELEASE");
-
     local *EXIFTOOL_FILE;   # avoid clashes with global namespace
 
+    my $realname = $filename;
     unless ($raf) {
         # save file name
         if (defined $filename and $filename ne '') {
             unless ($filename eq '-') {
-                my $name = $filename;
                 # extract file name from pipe if necessary
-                $name =~ /\|$/ and $name =~ s/.*?"(.*)".*/$1/;
-                my $dir;
+                $realname =~ /\|$/ and $realname =~ s/.*?"(.*?)".*/$1/;
+                my ($dir, $name);
                 if (eval 'require File::Basename') {
-                    $dir = File::Basename::dirname($name);
-                    $name = File::Basename::basename($name);
+                    $dir = File::Basename::dirname($realname);
+                    $name = File::Basename::basename($realname);
                 } else {
-                    $name =~ tr/\\/\//;
-                    if ($name =~ s/(.*)\///) {  # remove path
-                        $dir = length($1) ? $1 : '/';
-                    }
+                    ($name = $realname) =~ tr/\\/\//;
+                    # remove path
+                    $dir = length($1) ? $1 : '/' if $name =~ s/(.*)\///;
                 }
                 $self->FoundTag('FileName', $name);
                 $self->FoundTag('Directory', $dir) if defined $dir and length $dir;
+                # get size of resource fork on Mac OS
+                $rsize = -s "$filename/rsrc" if $^O eq 'darwin' and not $$self{IN_RESOURCE};
             }
             # open the file
-            if (open(EXIFTOOL_FILE,$filename)) {
-                my $filePt = \*EXIFTOOL_FILE;
+            if (open(EXIFTOOL_FILE, $filename)) {
                 # create random access file object
-                $raf = new File::RandomAccess($filePt);
+                $raf = new File::RandomAccess(\*EXIFTOOL_FILE);
                 # patch to force pipe to be buffered because seek returns success
                 # in Windows cmd shell pipe even though it really failed
@@ -823 +1457 @@
 
     if ($raf) {
-        # get file size and last modified time if this is a plain file
-        if ($raf->{FILE_PT} and -f $raf->{FILE_PT}) {
+        if ($reEntry) {
+            # we already set these tags
+        } elsif (not $raf->{FILE_PT}) {
+            # get file size from image in memory
+            $self->FoundTag('FileSize', length ${$raf->{BUFF_PT}});
+        } elsif (-f $raf->{FILE_PT}) {
+            # get file size and last modified time if this is a plain file
             my $fileSize = -s _;
             my $fileTime = -M _;
+            my @stat = stat _;
             $self->FoundTag('FileSize', $fileSize) if defined $fileSize;
+            $self->FoundTag('ResourceForkSize', $rsize) if $rsize;
             $self->FoundTag('FileModifyDate', $^T - $fileTime*(24*3600)) if defined $fileTime;
+            $self->FoundTag('FilePermissions', $stat[2]) if defined $stat[2];
         }
 
         # get list of file types to check
-        my $tiffType;
-        $self->{FILE_EXT} = GetFileExtension($filename);
-        my @fileTypeList = GetFileType($filename);
+        my ($tiffType, %noMagic);
+        $self->{FILE_EXT} = GetFileExtension($realname);
+        my @fileTypeList = GetFileType($realname);
         if (@fileTypeList) {
             # add remaining types to end of list so we test them all
@@ -840 +1482 @@
             push @fileTypeList, grep(!/^($pat)$/, @fileTypes);
             $tiffType = $self->{FILE_EXT};
+            $noMagic{MXF} = 1;  # don't do magic number test on MXF or DV files
+            $noMagic{DV} = 1;
         } else {
             # scan through all recognized file types
@@ -851 +1495 @@
         my %dirInfo = ( RAF => $raf, Base => $pos );
         # loop through list of file types to test
-        my $type;
-        for (;;) {
+        my ($type, $buff, $seekErr);
+        # read first 1024 bytes of file for testing
+        $raf->Read($buff, 1024) or $buff = '';
+        $raf->Seek($pos, 0) or $seekErr = 1;
+        until ($seekErr) {
             $type = shift @fileTypeList;
-            unless ($type) {
+            if ($type) {
+                # do quick test for this file type to avoid loading module unnecessarily
+                next if $magicNumber{$type} and $buff !~ /^$magicNumber{$type}/s and
+                        not $noMagic{$type};
+            } else {
                 last unless defined $type;
                 # last ditch effort to scan past unknown header for JPEG/TIFF
-                my $buff;
-                $raf->Read($buff, 1024);
                 next unless $buff =~ /(\xff\xd8\xff|MM\0\x2a|II\x2a\0)/g;
                 $type = ($1 eq "\xff\xd8\xff") ? 'JPEG' : 'TIFF';
                 my $skip = pos($buff) - length($1);
                 $dirInfo{Base} = $pos + $skip;
-                $raf->Seek($pos + $skip, 0);
+                $raf->Seek($pos + $skip, 0) or $seekErr = 1, last;
                 $self->Warn("Skipped unknown $skip byte header");
             }
             # save file type in member variable
-            $self->{FILE_TYPE} = $type;
+            $self->{FILE_TYPE} = $self->{PATH}[0] = $type;
             $dirInfo{Parent} = ($type eq 'TIFF') ? $tiffType : $type;
             my $module = $moduleName{$type};
@@ -877 +1526 @@
                 require "Image/ExifTool/$module.pm";
                 $func = "Image::ExifTool::${module}::$func";
+            } elsif ($module eq '0') {
+                $self->SetFileType();
+                $self->Warn('Unsupported file type');
+                last;
             }
             # process the file
@@ -884 +1537 @@
 
             # seek back to try again from the same position in the file
-            unless ($raf->Seek($pos, 0)) {
-                $self->Error('Error seeking in file');
-                last;
-            }
-        }
-        # scan for XMP if specified
-        if ($self->Options('ScanForXMP') and (not defined $type or
+            $raf->Seek($pos, 0) or $seekErr = 1, last;
+        }
+        if ($seekErr) {
+            $self->Error('Error seeking in file');
+        } elsif ($self->Options('ScanForXMP') and (not defined $type or
             (not $self->Options('FastScan') and not $$self{FoundXMP})))
         {
+            # scan for XMP
             $raf->Seek($pos, 0);
             require Image::ExifTool::XMP;
@@ -901 +1553 @@
             # must be a format error since we couldn't read it, otherwise
             # it is likely we don't support images of this type
-            $self->Error(GetFileType($filename) ?
-                'File format error' : 'Unknown file type');
+            my $fileType = GetFileType($realname);
+            my $err;
+            if (not $fileType) {
+                $err = 'Unknown file type';
+            } elsif ($fileType eq 'RAW') {
+                $err = 'Unsupported RAW file type';
+            } else {
+                $err = 'File format error';
+            }
+            $self->Error($err);
         }
         # extract binary EXIF data block only if requested
-        if (defined $self->{EXIF_DATA} and $self->{REQ_TAG_LOOKUP}->{exif}) {
+        if (defined $self->{EXIF_DATA} and length $$self{EXIF_DATA} > 16 and
+            ($self->{REQ_TAG_LOOKUP}{exif} or $self->{OPTIONS}{Binary}))
+        {
             $self->FoundTag('EXIF', $self->{EXIF_DATA});
         }
-        # calculate composite tags
-        $self->BuildCompositeTags() if $options->{Composite};
-
-        # do our HTML dump if requested
-        if ($self->{HTML_DUMP}) {
-            $raf->Seek(0, 2);   # seek to end of file
-            $self->{HTML_DUMP}->FinishTiffDump($self, $raf->Tell());
-            my $pos = $options->{HtmlDumpBase};
-            $pos = ($self->{FIRST_EXIF_POS} || 0) unless defined $pos;
-            my $dataPt = defined $self->{EXIF_DATA} ? \$self->{EXIF_DATA} : undef;
-            undef $dataPt if defined $self->{EXIF_POS} and $pos != $self->{EXIF_POS};
-            $self->{HTML_DUMP}->Print($raf, $dataPt, $pos,
-                $options->{TextOut}, $options->{HtmlDump},
-                $self->{FILENAME} ? "HTML Dump ($self->{FILENAME})" : 'HTML Dump');
-        }
-
-        $raf->Close() if $filename;     # close the file if we opened it
+        unless ($reEntry) {
+            $self->{PATH} = [ ];    # reset PATH
+            # calculate Composite tags
+            $self->BuildCompositeTags() if $options->{Composite};
+            # do our HTML dump if requested
+            if ($self->{HTML_DUMP}) {
+                $raf->Seek(0, 2);   # seek to end of file
+                $self->{HTML_DUMP}->FinishTiffDump($self, $raf->Tell());
+                my $pos = $options->{HtmlDumpBase};
+                $pos = ($self->{FIRST_EXIF_POS} || 0) unless defined $pos;
+                my $dataPt = defined $self->{EXIF_DATA} ? \$self->{EXIF_DATA} : undef;
+                undef $dataPt if defined $self->{EXIF_POS} and $pos != $self->{EXIF_POS};
+                my $success = $self->{HTML_DUMP}->Print($raf, $dataPt, $pos,
+                    $options->{TextOut}, $options->{HtmlDump},
+                    $self->{FILENAME} ? "HTML Dump ($self->{FILENAME})" : 'HTML Dump');
+                $self->Warn("Error reading $self->{HTML_DUMP}{ERROR}") if $success < 0;
+            }
+        }
+        if ($filename) {
+            $raf->Close();  # close the file if we opened it
+            # process the resource fork as an embedded file on Mac filesystems
+            if ($rsize and $options->{ExtractEmbedded}) {
+                local *RESOURCE_FILE;
+                if (open(RESOURCE_FILE, "$filename/rsrc")) {
+                    $$self{DOC_NUM} = $$self{DOC_COUNT} + 1;
+                    $$self{IN_RESOURCE} = 1;
+                    $self->ExtractInfo(\*RESOURCE_FILE, { ReEntry => 1 });
+                    close RESOURCE_FILE;
+                    delete $$self{IN_RESOURCE};
+                } else {
+                    $self->Warn('Error opening resource fork');
+                }
+            }
+        }
     }
 
@@ -930 +1609 @@
     %saveOptions and $self->{OPTIONS} = \%saveOptions;
 
-    return exists $self->{VALUE}->{Error} ? 0 : 1;
+    if ($reEntry) {
+        # restore necessary members when exiting re-entrant code
+        $$self{$_} = $$reEntry{$_} foreach keys %$reEntry;
+    }
+
+    return exists $self->{VALUE}{Error} ? 0 : 1;
 }
 
@@ -941 +1625 @@
 #        - If groups are specified, first groups take precedence if duplicate
 #          tags found but Duplicates option not set.
+#        - tag names may end in '#' to extract ValueConv value
 sub GetInfo($;@)
 {
@@ -955 +1640 @@
 
     # get reference to list of tags for which we will return info
-    my $rtnTags = $self->SetFoundTags();
+    my ($rtnTags, $byValue) = $self->SetFoundTags();
 
     # build hash of tag information
     my (%info, %ignored);
-    my $conv = $self->{OPTIONS}->{PrintConv} ? 'PrintConv' : 'ValueConv';
+    my $conv = $self->{OPTIONS}{PrintConv} ? 'PrintConv' : 'ValueConv';
     foreach (@$rtnTags) {
         my $val = $self->GetValue($_, $conv);
         defined $val or $ignored{$_} = 1, next;
         $info{$_} = $val;
+    }
+
+    # override specified tags with ValueConv value if necessary
+    if (@$byValue and $conv ne 'ValueConv') {
+        # first determine the number of times each non-ValueConv value is used
+        my %nonVal;
+        $nonVal{$_} = ($nonVal{$_} || 0) + 1 foreach @$rtnTags;
+        --$nonVal{$$rtnTags[$_]} foreach @$byValue;
+        # loop through ValueConv tags, updating tag keys and returned values
+        foreach (@$byValue) {
+            my $tag = $$rtnTags[$_];
+            my $val = $self->GetValue($tag, 'ValueConv');
+            next unless defined $val;
+            my $vtag = $tag;
+            # generate a new tag key like "Tag #" or "Tag #(1)"
+            $vtag =~ s/( |$)/ #/;
+            unless (defined $self->{VALUE}->{$vtag}) {
+                $self->{VALUE}{$vtag} = $self->{VALUE}{$tag};
+                $self->{TAG_INFO}{$vtag} = $self->{TAG_INFO}{$tag};
+                $self->{TAG_EXTRA}{$vtag} = $self->{TAG_EXTRA}{$tag};
+                $self->{FILE_ORDER}{$vtag} = $self->{FILE_ORDER}{$tag};
+                # remove existing PrintConv entry unless we are using it too
+                delete $info{$tag} unless $nonVal{$tag};
+            }
+            $$rtnTags[$_] = $vtag;  # store ValueConv value with new tag key
+            $info{$vtag} = $val;    # return ValueConv value
+        }
     }
 
@@ -980 +1692 @@
         # use file order by default if no tags specified
         # (no such thing as 'Input' order in this case)
-        my $sortOrder = $self->{OPTIONS}->{Sort};
+        my $sortOrder = $self->{OPTIONS}{Sort};
         unless (@$reqTags or ($sortOrder and $sortOrder ne 'Input')) {
             $sortOrder = 'File';
@@ -1003 +1715 @@
     local $_;
     my $self = shift;
-    my (%combinedInfo, $info);
-
-    if ($self->{OPTIONS}->{Duplicates}) {
+    my (%combinedInfo, $info, $tag, %haveInfo);
+
+    if ($self->{OPTIONS}{Duplicates}) {
         while ($info = shift) {
-            my $key;
-            foreach $key (keys %$info) {
-                $combinedInfo{$key} = $$info{$key};
+            foreach $tag (keys %$info) {
+                $combinedInfo{$tag} = $$info{$tag};
             }
         }
     } else {
-        my (%haveInfo, $tag);
         while ($info = shift) {
             foreach $tag (keys %$info) {
@@ -1056 +1766 @@
         $foundTags = $self->{FOUND_TAGS} || $self->SetFoundTags() or return undef;
     }
-    $sortOrder or $sortOrder = $self->{OPTIONS}->{Sort};
+    $sortOrder or $sortOrder = $self->{OPTIONS}{Sort};
 
     # return original list if no sort order specified
@@ -1063 +1773 @@
     if ($sortOrder eq 'Alpha') {
         return sort @$foundTags;
-    } elsif ($sortOrder =~ /^Group(\d*)/) {
+    } elsif ($sortOrder =~ /^Group(\d*(:\d+)*)/) {
         my $family = $1 || 0;
         # want to maintain a basic file order with the groups
@@ -1086 +1796 @@
 # Get list of found tags in specified sort order
 # Inputs: 0) ExifTool object reference, 1) sort order ('File', 'Input', ...)
-# Returns: List of tags in specified order
+# Returns: List of tag keys in specified order
 # Notes: If not specified, sort order is taken from OPTIONS
 sub GetFoundTags($;$)
@@ -1099 +1809 @@
 # Get list of requested tags
 # Inputs: 0) ExifTool object reference
-# Returns: List of requested tags
+# Returns: List of requested tag keys
 sub GetRequestedTags($)
 {
     local $_;
-    return @{$_[0]->{REQUESTED_TAGS}};
+    return @{$_[0]{REQUESTED_TAGS}};
 }
 
 #------------------------------------------------------------------------------
 # Get tag value
-# Inputs: 0) ExifTool object reference, 1) tag key
+# Inputs: 0) ExifTool object reference
+#         1) tag key (or flattened tagInfo for getting field values, not part of public API)
 #         2) [optional] Value type: PrintConv, ValueConv, Both or Raw, the default
 #            is PrintConv or ValueConv, depending on the PrintConv option setting
+#         3) raw field value (not part of public API)
 # Returns: Scalar context: tag value or undefined
 #          List context: list of values or empty list
@@ -1116 +1828 @@
 {
     local $_;
-    my ($self, $tag, $type) = @_;
+    my ($self, $tag, $type) = @_; # plus: ($fieldValue)
+    my (@convTypes, $tagInfo, $valueConv, $both);
+
+    # figure out what conversions to do
+    $type or $type = $self->{OPTIONS}{PrintConv} ? 'PrintConv' : 'ValueConv';
 
     # start with the raw value
-    my $value = $self->{VALUE}->{$tag};
-    return wantarray ? () : undef unless defined $value;
-
-    # figure out what conversions to do
-    my (@convTypes, $tagInfo);
-    $type or $type = $self->{OPTIONS}->{PrintConv} ? 'PrintConv' : 'ValueConv';
-    unless ($type eq 'Raw') {
-        $tagInfo = $self->{TAG_INFO}->{$tag};
-        push @convTypes, 'ValueConv';
-        push @convTypes, 'PrintConv' unless $type eq 'ValueConv';
+    my $value = $self->{VALUE}{$tag};
+    if (not defined $value) {
+        return wantarray ? () : undef unless ref $tag;
+        # get the value of a structure field
+        $tagInfo = $tag;
+        $tag = $$tagInfo{Name};
+        $value = $_[3];
+        # (note: type "Both" is not allowed for structure fields)
+        if ($type ne 'Raw') {
+            push @convTypes, 'ValueConv';
+            push @convTypes, 'PrintConv' unless $type eq 'ValueConv';
+        }
+    } else {
+        $tagInfo = $self->{TAG_INFO}{$tag};
+        if ($$tagInfo{Struct} and ref $value) {
+            # must load XMPStruct.pl just in case (should already be loaded if
+            # a structure was extracted, but we could also arrive here if a simple
+            # list of values was stored incorrectly in a Struct tag)
+            require 'Image/ExifTool/XMPStruct.pl';
+            # convert strucure field values
+            unless ($type eq 'Both') {
+                # (note: ConvertStruct handles the escape too if necessary)
+                return Image::ExifTool::XMP::ConvertStruct($self,$tagInfo,$value,$type);
+            }
+            $valueConv = Image::ExifTool::XMP::ConvertStruct($self,$tagInfo,$value,'ValueConv');
+            $value = Image::ExifTool::XMP::ConvertStruct($self,$tagInfo,$value,'PrintConv');
+            # (must not save these in $$self{BOTH} because the values may have been escaped)
+            return ($valueConv, $value);
+        }
+        if ($type ne 'Raw') {
+            # use values we calculated already if we stored them
+            $both = $self->{BOTH}{$tag};
+            if ($both) {
+                if ($type eq 'PrintConv') {
+                    $value = $$both[1];
+                } elsif ($type eq 'ValueConv') {
+                    $value = $$both[0];
+                    $value = $$both[1] unless defined $value;
+                } else {
+                    ($valueConv, $value) = @$both;
+                }
+            } else {
+                push @convTypes, 'ValueConv';
+                push @convTypes, 'PrintConv' unless $type eq 'ValueConv';
+            }
+        }
     }
 
     # do the conversions
-    my (@val, @prt, @raw, $convType, $valueConv);
+    my (@val, @prt, @raw, $convType);
     foreach $convType (@convTypes) {
-        last if ref $value eq 'SCALAR'; # don't convert a scalar reference
+        # don't convert a scalar reference or structure
+        last if ref $value eq 'SCALAR';
         my $conv = $$tagInfo{$convType};
         unless (defined $conv) {
@@ -1141 +1894 @@
                 $conv = '\$val';  # return scalar reference for binary values
             } else {
-                # use PRINT_CONV from tag table if PrintConv not defined
-                next unless defined($conv = $tagInfo->{Table}->{PRINT_CONV});
+                # use PRINT_CONV from tag table if PrintConv doesn't exist
+                next unless defined($conv = $tagInfo->{Table}{PRINT_CONV});
+                next if exists $$tagInfo{$convType};
             }
         }
@@ -1153 +1907 @@
             $conv = $$convList[0];
             my @valList = split ' ', $value;
-            $value = \@valList;
+            # reorganize list if specified (Note: The writer currently doesn't
+            # relist values, so they may be grouped but the order must not change)
+            my $relist = $$tagInfo{Relist};
+            if ($relist) {
+                my (@newList, $oldIndex);
+                foreach $oldIndex (@$relist) {
+                    my ($newVal, @join);
+                    if (ref $oldIndex) {
+                        foreach (@$oldIndex) {
+                            push @join, $valList[$_] if defined $valList[$_];
+                        }
+                        $newVal = join(' ', @join) if @join;
+                    } else {
+                        $newVal = $valList[$oldIndex];
+                    }
+                    push @newList, $newVal if defined $newVal;
+                }
+                $value = \@newList;
+            } else {
+                $value = \@valList;
+            }
         }
         # initialize array so we can iterate over values in list
@@ -1166 +1940 @@
         for (;;) {
             if (defined $conv) {
-                # get values of required tags if this is a composite tag
+                # get values of required tags if this is a Composite tag
                 if (ref $val eq 'HASH' and not @val) {
+                    # disable escape of source values so we don't double escape them
+                    my $oldEscape = $$self{ESCAPE_PROC};
+                    delete $$self{ESCAPE_PROC};
                     foreach (keys %$val) {
-                        $raw[$_] = $self->{VALUE}->{$$val{$_}};
+                        $raw[$_] = $self->{VALUE}{$$val{$_}};
                         ($val[$_], $prt[$_]) = $self->GetValue($$val{$_}, 'Both');
-                        next if defined $val[$_] or not $tagInfo->{Require}->{$_};
+                        next if defined $val[$_] or not $tagInfo->{Require}{$_};
+                        $$self{ESCAPE_PROC} = $oldEscape;
                         return wantarray ? () : undef;
                     }
+                    $$self{ESCAPE_PROC} = $oldEscape;
                     # set $val to $val[0], or \@val for a CODE ref conversion
                     $val = ref $conv eq 'CODE' ? \@val : $val[0];
@@ -1179 +1958 @@
                 if (ref $conv eq 'HASH') {
                     # look up converted value in hash
-                    unless (defined($value = $$conv{$val})) {
+                    my $lc;
+                    if (defined($value = $$conv{$val})) {
+                        # override with our localized language PrintConv if available
+                        if ($$self{CUR_LANG} and $convType eq 'PrintConv' and
+                            # (no need to check for lang-alt tag names -- they won't have a PrintConv)
+                            ref($lc = $self->{CUR_LANG}{$$tagInfo{Name}}) eq 'HASH' and
+                            ($lc = $$lc{PrintConv}) and ($lc = $$lc{$value}))
+                        {
+                            $value = $self->Decode($lc, 'UTF8');
+                        }
+                    } else {
                         if ($$conv{BITMASK}) {
                             $value = DecodeBits($val, $$conv{BITMASK});
-                        } else {
-                            if ($$tagInfo{PrintHex} and $val and IsInt($val) and
-                                $convType eq 'PrintConv')
+                            # override with localized language strings
+                            if (defined $value and $$self{CUR_LANG} and $convType eq 'PrintConv' and
+                                ref($lc = $self->{CUR_LANG}{$$tagInfo{Name}}) eq 'HASH' and
+                                ($lc = $$lc{PrintConv}))
+                            {
+                                my @vals = split ', ', $value;
+                                foreach (@vals) {
+                                    $_ = $$lc{$_} if defined $$lc{$_};
+                                }
+                                $value = join ', ', @vals;
+                            }
+                        } elsif (not $$conv{OTHER} or
+                                 # use alternate conversion routine if available
+                                 not defined($value = &{$$conv{OTHER}}($val, undef, $conv)))
+                        {
+                            if (($$tagInfo{PrintHex} or
+                                ($$tagInfo{Mask} and not defined $$tagInfo{PrintHex}))
+                                and $val and IsInt($val) and $convType eq 'PrintConv')
                             {
                                 $val = sprintf('0x%x',$val);
@@ -1202 +2006 @@
                         $@ and $evalWarning = $@;
                     }
-                    if ($evalWarning) {
-                        delete $SIG{'__WARN__'};
-                        warn "$convType $tag: " . CleanWarning() . "\n";
-                    }
+                    $self->Warn("$convType $tag: " . CleanWarning()) if $evalWarning;
                 }
             } else {
@@ -1228 +2029 @@
     }
     if ($type eq 'Both') {
-        # $valueConv is undefined if there was no print conversion done
-        $valueConv = $value unless defined $valueConv;
+        # save both (unescaped) values because we often need them again
+        # (Composite tags need "Both" and often Require one tag for various Composite tags)
+        $self->{BOTH}{$tag} = [ $valueConv, $value ] unless $both;
+        # escape values if necessary
+        if ($$self{ESCAPE_PROC}) {
+            DoEscape($value, $$self{ESCAPE_PROC});
+            if (defined $valueConv) {
+                DoEscape($valueConv, $$self{ESCAPE_PROC});
+            } else {
+                $valueConv = $value;
+            }
+        } elsif (not defined $valueConv) {
+            # $valueConv is undefined if there was no print conversion done
+            $valueConv = $value;
+        }
         # return Both values as a list (ValueConv, PrintConv)
         return ($valueConv, $value);
     }
+    # escape value if necessary
+    DoEscape($value, $$self{ESCAPE_PROC}) if $$self{ESCAPE_PROC};
+
     if (ref $value eq 'ARRAY') {
         # return array if requested
         return @$value if wantarray;
-        # return list reference for Raw, ValueConv or if List option set
-        return $value if @convTypes < 2 or $self->{OPTIONS}->{List};
+        # return list reference for Raw, ValueConv or if List or not a list of scalars
+        return $value if $type ne 'PrintConv' or $self->{OPTIONS}{List} or ref $$value[0];
         # otherwise join in comma-separated string
-        $value = join ', ', @$value;
+        $value = join $self->{OPTIONS}{ListSep}, @$value;
     }
     return $value;
@@ -1247 +2064 @@
 # Get tag identification number
 # Inputs: 0) ExifTool object reference, 1) tag key
-# Returns: Tag ID if available, otherwise ''
+# Returns: Scalar context: Tag ID if available, otherwise ''
+#          List context: 0) Tag ID (or ''), 1) language code (or undef)
 sub GetTagID($$)
 {
-    local $_;
     my ($self, $tag) = @_;
-    my $tagInfo = $self->{TAG_INFO}->{$tag};
-
-    if ($tagInfo) {
-        GenerateAllTagIDs();    # make sure tag ID's are generated
-        defined $$tagInfo{TagID} and return $$tagInfo{TagID};
-    }
-    # no ID for this tag (shouldn't happen)
-    return '';
+    my $tagInfo = $self->{TAG_INFO}{$tag};
+    return '' unless $tagInfo and defined $$tagInfo{TagID};
+    return ($$tagInfo{TagID}, $$tagInfo{LangCode}) if wantarray;
+    return $$tagInfo{TagID};
+}
+
+#------------------------------------------------------------------------------
+# Get tag table name
+# Inputs: 0) ExifTool object reference, 1) tag key
+# Returns: Table name if available, otherwise ''
+sub GetTableName($$)
+{
+    my ($self, $tag) = @_;
+    my $tagInfo = $self->{TAG_INFO}{$tag} or return '';
+    return $tagInfo->{Table}{SHORT_NAME};
+}
+
+#------------------------------------------------------------------------------
+# Get tag index number
+# Inputs: 0) ExifTool object reference, 1) tag key
+# Returns: Table index number, or undefined if this tag isn't indexed
+sub GetTagIndex($$)
+{
+    my ($self, $tag) = @_;
+    my $tagInfo = $self->{TAG_INFO}{$tag} or return undef;
+    return $$tagInfo{Index};
 }
 
@@ -1271 +2106 @@
     local $_;
     my ($self, $tag) = @_;
-    my $tagInfo = $self->{TAG_INFO}->{$tag};
-    # ($tagInfo should be defined for any extracted tag,
-    # but we might as well handle the case where it isn't)
-    my $desc;
-    $desc = $$tagInfo{Description} if $tagInfo;
+    my ($desc, $name);
+    my $tagInfo = $self->{TAG_INFO}{$tag};
+    # ($tagInfo won't be defined for missing tags extracted with -f)
+    if ($tagInfo) {
+        # use alternate language description if available
+        while ($$self{CUR_LANG}) {
+            $desc = $self->{CUR_LANG}{$$tagInfo{Name}};
+            if ($desc) {
+                # must look up Description if this tag also has a PrintConv
+                $desc = $$desc{Description} or last if ref $desc;
+            } else {
+                # look up default language of lang-alt tag
+                last unless $$tagInfo{LangCode} and
+                    ($name = $$tagInfo{Name}) =~ s/-$$tagInfo{LangCode}$// and
+                    $desc = $self->{CUR_LANG}{$name};
+                $desc = $$desc{Description} or last if ref $desc;
+                $desc .= " ($$tagInfo{LangCode})";
+            }
+            # escape description if necessary
+            DoEscape($desc, $$self{ESCAPE_PROC}) if $$self{ESCAPE_PROC};
+            # return description in proper Charset
+            return $self->Decode($desc, 'UTF8');
+        }
+        $desc = $$tagInfo{Description};
+    }
     # just make the tag more readable if description doesn't exist
     unless ($desc) {
@@ -1289 +2144 @@
 # Inputs: 0) ExifTool object reference
 #         1) tag key (or reference to tagInfo hash, not part of the public API)
-#         2) [optional] group family number (-1 to get extended group list)
+#         2) [optional] group family (-1 to get extended group list)
 # Returns: Scalar context: Group name (for family 0 if not otherwise specified)
 #          Array context: Group name if family specified, otherwise list of
-#          group names for each family.
+#          group names for each family.  Returns '' for undefined tag.
+# Notes: Mutiple families may be specified with ':' in family argument (ie. '1:2')
 sub GetGroup($$;$)
 {
     local $_;
     my ($self, $tag, $family) = @_;
-    my ($tagInfo, @groups, $extra);
+    my ($tagInfo, @groups, @families, $simplify, $byTagInfo);
     if (ref $tag eq 'HASH') {
         $tagInfo = $tag;
-        $tag = $tagInfo->{Name};
+        $tag = $$tagInfo{Name};
+        # set flag so we don't get extra information for an extracted tag
+        $byTagInfo = 1;
     } else {
-        $tagInfo = $self->{TAG_INFO}->{$tag} or return '';
+        $tagInfo = $self->{TAG_INFO}{$tag} or return '';
     }
     my $groups = $$tagInfo{Groups};
     # fill in default groups unless already done
+    # (after this, Groups 0-2 in tagInfo are guaranteed to be defined)
     unless ($$tagInfo{GotGroups}) {
         my $tagTablePtr = $$tagInfo{Table};
@@ -1313 +2172 @@
             # fill in default groups
             foreach (keys %{$$tagTablePtr{GROUPS}}) {
-                $$groups{$_} or $$groups{$_} = $tagTablePtr->{GROUPS}->{$_};
+                $$groups{$_} or $$groups{$_} = $tagTablePtr->{GROUPS}{$_};
             }
         }
@@ -1319 +2178 @@
         $$tagInfo{GotGroups} = 1;
     }
-    if (defined $family and $family >= 0) {
-        return $$groups{$family} || 'Other' unless $family == 1;
-        $groups[$family] = $$groups{$family};
+    if (defined $family and $family ne '-1') {
+        if ($family =~ /[^\d]/) {
+            @families = ($family =~ /\d+/g);
+            return $$groups{0} unless @families;
+            $simplify = 1 unless $family =~ /^:/;
+            undef $family;
+            foreach (0..2) { $groups[$_] = $$groups{$_}; }
+        } else {
+            return $$groups{$family} if $family == 0 or $family == 2;
+            $groups[1] = $$groups{1};
+        }
     } else {
         return $$groups{0} unless wantarray;
         foreach (0..2) { $groups[$_] = $$groups{$_}; }
     }
-    # modify family 1 group name if necessary
-    if ($extra = $self->{GROUP1}->{$tag}) {
-        if ($extra =~ /^\+(.*)/) {
-            $groups[1] .= $1;
-        } else {
-            $groups[1] = $extra;
-        }
+    $groups[3] = 'Main';
+    $groups[4] = ($tag =~ /\((\d+)\)$/) ? "Copy$1" : '';
+    # handle dynamic group names if necessary
+    my $ex = $self->{TAG_EXTRA}{$tag};
+    if ($ex and not $byTagInfo) {
+        $groups[0] = $$ex{G0} if $$ex{G0};
+        $groups[1] = $$ex{G1} =~ /^\+(.*)/ ? "$groups[1]$1" : $$ex{G1} if $$ex{G1};
+        $groups[3] = 'Doc' . $$ex{G3} if $$ex{G3};
+        $groups[5] = $$ex{G5} || $groups[1] if defined $$ex{G5};
     }
     if ($family) {
-        return $groups[1] if $family == 1;
+        return $groups[$family] || '' if $family > 0;
         # add additional matching group names to list
         # ie) for MIE-Doc, also add MIE1, MIE1-Doc, MIE-Doc1 and MIE1-Doc1
@@ -1346 +2215 @@
         }
     }
+    if (@families) {
+        my @grps;
+        # create list of group names (without identical adjacent groups if simplifying)
+        foreach (@families) {
+            my $grp = $groups[$_] or next;
+            push @grps, $grp unless $simplify and @grps and $grp eq $grps[-1];
+        }
+        # remove leading "Main:" if simplifying
+        shift @grps if $simplify and @grps > 1 and $grps[0] eq 'Main';
+        # return colon-separated string of group names
+        return join ':', @grps;
+    }
     return @groups;
 }
@@ -1353 +2234 @@
 # Inputs: 0) ExifTool object reference
 #         1) [optional] information hash reference (default all extracted info)
-#         2) [optional] group family number (default 0)
+#         2) [optional] group family (default 0)
 # Returns: List of group names in alphabetical order
 sub GetGroups($;$$)
@@ -1401 +2282 @@
 
 #------------------------------------------------------------------------------
-# Build composite tags from required tags
+# Build Composite tags from Require'd/Desire'd tags
 # Inputs: 0) ExifTool object reference
 # Note: Tag values are calculated in alphabetical order unless a tag Require's
-#       or Desire's another composite tag, in which case the calculation is
+#       or Desire's another Composite tag, in which case the calculation is
 #       deferred until after the other tag is calculated.
 sub BuildCompositeTags($)
@@ -1411 +2292 @@
     my $self = shift;
 
-    # first, add user-defined composite tags if necessary
+    $$self{BuildingComposite} = 1;
+    # first, add user-defined Composite tags if necessary
     if (%UserDefined and $UserDefined{'Image::ExifTool::Composite'}) {
-        AddCompositeTags($UserDefined{'Image::ExifTool::Composite'},1);
+        AddCompositeTags($UserDefined{'Image::ExifTool::Composite'}, 1);
         delete $UserDefined{'Image::ExifTool::Composite'};
     }
@@ -1422 +2304 @@
     for (;;) {
         my %notBuilt;
-        foreach (@tagList) {
-            $notBuilt{$_} = 1;
-        }
+        $notBuilt{$_} = 1 foreach @tagList;
         my @deferredTags;
         my $tag;
@@ -1433 +2313 @@
             next unless $tagInfo;
             # put required tags into array and make sure they all exist
-            my (%tagKey, $type, $found);
-            foreach $type ('Require','Desire') {
-                my $req = $$tagInfo{$type} or next;
+            my $subDoc = ($$tagInfo{SubDoc} and $$self{DOC_COUNT});
+            my $require = $$tagInfo{Require} || { };
+            my $desire = $$tagInfo{Desire} || { };
+            # loop through sub-documents if necessary
+            my $doc;
+            for (;;) {
+                my (%tagKey, $found, $index);
                 # save Require'd and Desire'd tag values in list
-                my $index;
-                foreach $index (keys %$req) {
-                    my $reqTag = $$req{$index};
+                for ($index=0; ; ++$index) {
+                    my $reqTag = $$require{$index} || $$desire{$index} or last;
+                    # add family 3 group if generating Composite tags for sub-documents
+                    # (unless tag already begins with family 3 group name)
+                    if ($subDoc and $reqTag !~ /^(Main|Doc\d+):/) {
+                        $reqTag = ($doc ? "Doc$doc:" : 'Main:') . $reqTag;
+                    }
                     # allow tag group to be specified
-                    if ($reqTag =~ /(.+?):(.+)/) {
+                    if ($reqTag =~ /^(.*):(.+)/) {
                         my ($reqGroup, $name) = ($1, $2);
-                        my $family;
-                        $family = $1 if $reqGroup =~ s/^(\d+)//;
-                        my $i = 0;
-                        for (;;++$i) {
-                            $reqTag = $name;
-                            $reqTag .= " ($i)" if $i;
-                            last unless defined $$rawValue{$reqTag};
-                            my @groups = $self->GetGroup($reqTag, $family);
-                            last if grep { $reqGroup eq $_ } @groups;
+                        if ($reqGroup eq 'Composite' and $notBuilt{$name}) {
+                            push @deferredTags, $tag;
+                            next COMPOSITE_TAG;
                         }
+                        my ($i, $key, @keys);
+                        for ($i=0; ; ++$i) {
+                            $key = $name;
+                            $key .= " ($i)" if $i;
+                            last unless defined $$rawValue{$key};
+                            push @keys, $key;
+                        }
+                        # find first matching tag
+                        $key = $self->GroupMatches($reqGroup, \@keys);
+                        $reqTag = $key if $key;
                     } elsif ($notBuilt{$reqTag}) {
                         # calculate this tag later if it relies on another
@@ -1461 +2353 @@
                     if (defined $$rawValue{$reqTag}) {
                         $found = 1;
-                    } else {
-                        # don't continue if we require this tag
-                        $type eq 'Require' and next COMPOSITE_TAG;
+                    } elsif ($$require{$index}) {
+                        $found = 0;
+                        last;   # don't continue since we require this tag
                     }
                     $tagKey{$index} = $reqTag;
                 }
-            }
-            delete $notBuilt{$tag}; # this tag is OK to build now
-            next unless $found;     # can't build tag if no values found
-            # keep track of all require'd tag keys
-            foreach (keys %tagKey) {
-                # only tag keys with same name as a composite tag can be replaced
-                # (also eliminates keys with instance numbers which can't be replaced either)
-                next unless $Image::ExifTool::Composite{$tagKey{$_}};
-                my $keyRef = \$tagKey{$_};
-                $tagsUsed{$$keyRef} or $tagsUsed{$$keyRef} = [ ];
-                push @{$tagsUsed{$$keyRef}}, $keyRef;
-            }
-            # save reference to tag key lookup as value for composite tag
-            my $key = $self->FoundTag($tagInfo, \%tagKey);
-            # check to see if we just replaced one of the tag keys we require'd
-            next unless defined $key and $tagsUsed{$key};
-            foreach (@{$tagsUsed{$key}}) {
-                $$_ = $self->{MOVED_KEY};   # replace with new tag key
-            }
-            delete $tagsUsed{$key};         # can't be replaced again
+                if ($doc) {
+                    if ($found) {
+                        $self->{DOC_NUM} = $doc;
+                        $self->FoundTag($tagInfo, \%tagKey);
+                        delete $self->{DOC_NUM};
+                    }
+                    next if ++$doc <= $self->{DOC_COUNT};
+                    last;
+                } elsif ($found) {
+                    delete $notBuilt{$tag}; # this tag is OK to build now
+                    # keep track of all Require'd tag keys
+                    foreach (keys %tagKey) {
+                        # only tag keys with same name as a Composite tag
+                        # can be replaced (also eliminates keys with
+                        # instance numbers which can't be replaced either)
+                        next unless $Image::ExifTool::Composite{$tagKey{$_}};
+                        my $keyRef = \$tagKey{$_};
+                        $tagsUsed{$$keyRef} or $tagsUsed{$$keyRef} = [ ];
+                        push @{$tagsUsed{$$keyRef}}, $keyRef;
+                    }
+                    # save reference to tag key lookup as value for Composite tag
+                    my $key = $self->FoundTag($tagInfo, \%tagKey);
+                    # check to see if we just replaced one of the tag keys we Require'd
+                    if (defined $key and $tagsUsed{$key}) {
+                        foreach (@{$tagsUsed{$key}}) {
+                            $$_ = $self->{MOVED_KEY};   # replace with new tag key
+                        }
+                        delete $tagsUsed{$key};         # can't be replaced again
+                    }
+                } elsif (not defined $found) {
+                    delete $notBuilt{$tag}; # tag can't be built anyway
+                }
+                last unless $subDoc;
+                $doc = 1;   # continue to process the 1st sub-document
+            }
         }
         last unless @deferredTags;
@@ -1497 +2404 @@
         @tagList = @deferredTags; # calculate deferred tags now
     }
+    delete $$self{BuildingComposite};
 }
 
@@ -1522 +2430 @@
 #------------------------------------------------------------------------------
 # Get file type for specified extension
-# Inputs: 0) file name or extension (case is not significant)
-#         1) flag to return long description instead of type
-# Returns: File type (or desc) or undef if extension not supported.  In array
+# Inputs: 0) file name or extension (case is not significant),
+#            or FileType value if a description is requested
+#         1) flag to return long description instead of type ('0' to return any recognized type)
+# Returns: File type (or desc) or undef if extension not supported or if
+#          description is the same as the input FileType.  In array
 #          context, may return more than one file type if the file may be
-#          different formats.  Returns list of all recognized extensions if no
+#          different formats.  Returns list of all supported extensions if no
 #          file specified
 sub GetFileType(;$$)
@@ -1532 +2442 @@
     local $_;
     my ($file, $desc) = @_;
-    return sort keys %fileTypeLookup unless defined $file;
+    unless (defined $file) {
+        my @types;
+        if (defined $desc and $desc eq '0') {
+            # return all recognized types
+            @types = sort keys %fileTypeLookup;
+        } else {
+            # return all supported types
+            foreach (sort keys %fileTypeLookup) {
+                push @types, $_ unless defined $moduleName{$_} and $moduleName{$_} eq '0';
+            }
+        }
+        return @types;
+    }
     my $fileType;
     my $fileExt = GetFileExtension($file);
     $fileExt = uc($file) unless $fileExt;
     $fileExt and $fileType = $fileTypeLookup{$fileExt}; # look up the file type
-    return $$fileType[1] if $desc;  # return description if specified
+    $fileType = $fileTypeLookup{$fileType} unless ref $fileType or not $fileType;
+    # return description if specified
+    # (allow input $file to be a FileType for this purpose)
+    if ($desc) {
+        return $fileType ? $$fileType[1] : $fileDescription{$file};
+    } elsif ($fileType and (not defined $desc or $desc ne '0')) {
+        # return only supported file types
+        my $mod = $moduleName{$$fileType[0]};
+        undef $fileType if defined $mod and $mod eq '0';
+    }
+    $fileType or return wantarray ? () : undef;
     $fileType = $$fileType[0];      # get file type (or list of types)
     if (wantarray) {
-        return () unless $fileType;
         return @$fileType if ref $fileType eq 'ARRAY';
     } elsif ($fileType) {
@@ -1550 +2481 @@
 #------------------------------------------------------------------------------
 # Return true if we can write the specified file type
-# Inputs: 0) file name or ext,
+# Inputs: 0) file name or ext
 # Returns: true if writable, 0 if not writable, undef if unrecognized
-# Note: This will return true for some TIFF-based RAW images which we shouldn't really write
 sub CanWrite($)
 {
@@ -1558 +2488 @@
     my $file = shift or return undef;
     my $type = GetFileType($file) or return undef;
+    if ($noWriteFile{$type}) {
+        # can't write TIFF files with certain extensions (various RAW formats)
+        my $ext = GetFileExtension($file) || uc($file);
+        return grep(/^$ext$/, @{$noWriteFile{$type}}) ? 0 : 1 if $ext;
+    }
     return scalar(grep /^$type$/, @writeTypes);
 }
@@ -1563 +2498 @@
 #------------------------------------------------------------------------------
 # Return true if we can create the specified file type
-# Inputs: 0) file name or ext,
+# Inputs: 0) file name or ext
 # Returns: true if creatable, 0 if not writable, undef if unrecognized
 sub CanCreate($)
@@ -1569 +2504 @@
     local $_;
     my $file = shift or return undef;
+    my $ext = GetFileExtension($file) || uc($file);
     my $type = GetFileType($file) or return undef;
-    return scalar(grep /^$type$/, @createTypes);
+    return 1 if $createTypes{$ext} or $createTypes{$type};
+    return 0;
 }
 
@@ -1590 +2527 @@
     delete $self->{EXIF_POS};       # EXIF position in file
     delete $self->{FIRST_EXIF_POS}; # position of first EXIF in file
-    delete $self->{EXIF_BYTE_ORDER};# the EXIF byte ordering
     delete $self->{HTML_DUMP};      # html dump information
+    delete $self->{SET_GROUP1};     # group1 name override
+    delete $self->{DOC_NUM};        # current embedded document number
+    $self->{DOC_COUNT}  = 0;        # count of embedded documents processed
     $self->{BASE}       = 0;        # base for offsets from start of file
-    $self->{FILE_ORDER} = { };      # hash of tag order in file
-    $self->{VALUE}      = { };      # hash of raw tag values
-    $self->{TAG_INFO}   = { };      # hash of tag information
-    $self->{GROUP1}     = { };      # hash of family 1 group names
-    $self->{PRIORITY}   = { };      # priority of current tags
+    $self->{FILE_ORDER} = { };      # * hash of tag order in file
+    $self->{VALUE}      = { };      # * hash of raw tag values
+    $self->{BOTH}       = { };      # * hash for Value/PrintConv values of Require'd tags
+    $self->{TAG_INFO}   = { };      # * hash of tag information
+    $self->{TAG_EXTRA}  = { };      # * hash of extra tag information (dynamic group names)
+    $self->{PRIORITY}   = { };      # * priority of current tags
+    $self->{LIST_TAGS}  = { };      # hash of tagInfo refs for active List-type tags
     $self->{PROCESSED}  = { };      # hash of processed directory start positions
     $self->{DIR_COUNT}  = { };      # count various types of directories
+    $self->{DUPL_TAG}   = { };      # last-used index for duplicate-tag keys
+    $self->{WARNED_ONCE}= { };      # WarnOnce() warnings already issued
+    $self->{PATH}       = [ ];      # current subdirectory path in file when reading
     $self->{NUM_FOUND}  = 0;        # total number of tags found (incl. duplicates)
     $self->{CHANGED}    = 0;        # number of tags changed (writer only)
     $self->{INDENT}     = '  ';     # initial indent for verbose messages
     $self->{PRIORITY_DIR} = '';     # the priority directory name
+    $self->{LOW_PRIORITY_DIR} = { PreviewIFD => 1 }; # names of priority 0 directories
     $self->{TIFF_TYPE}  = '';       # type of TIFF data (APP1, TIFF, NEF, etc...)
-    $self->{CameraMake} = '';       # camera make
-    $self->{CameraModel}= '';       # camera model
+    $self->{Make}       = '';       # camera make
+    $self->{Model}      = '';       # camera model
     $self->{CameraType} = '';       # Olympus camera type
     if ($self->Options('HtmlDump')) {
@@ -1613 +2558 @@
     }
     # make sure our TextOut is a file reference
-    $self->{OPTIONS}->{TextOut} = \*STDOUT unless ref $self->{OPTIONS}->{TextOut};
+    $self->{OPTIONS}{TextOut} = \*STDOUT unless ref $self->{OPTIONS}{TextOut};
 }
 
@@ -1655 +2600 @@
                         undef @oldGroupOpts;
                     }
-                    $options->{$opt} = $$arg{$opt};
+                    $self->Options($opt, $$arg{$opt});
                     $opt eq 'Exclude' and $wasExcludeOpt = 1;
                 }
@@ -1662 +2607 @@
                 # convert image data from UTF-8 to character stream if necessary
                 # (patches RHEL 3 UTF8 LANG problem)
-                if (ref $arg eq 'SCALAR' and eval 'require Encode; Encode::is_utf8($$arg)') {
-                    my $buff = pack('C*', unpack('U0U*', $$arg));
+                if (ref $arg eq 'SCALAR' and $] >= 5.006 and
+                    (eval 'require Encode; Encode::is_utf8($$arg)' or $@))
+                {
+                    # repack by hand if Encode isn't available
+                    my $buff = $@ ? pack('C*',unpack('U0C*',$$arg)) : Encode::encode('utf8',$$arg);
                     $arg = \$buff;
                 }
@@ -1670 +2618 @@
                 # we have a file but we didn't open it
                 $self->{FILENAME} = '';
+            } elsif (UNIVERSAL::isa($arg, 'File::RandomAccess')) {
+                $self->{RAF} = $arg;
+                $self->{FILENAME} = '';
             } else {
                 warn "Don't understand ImageInfo argument $arg\n";
@@ -1688 +2639 @@
         # initialize lookup for requested tags
         foreach (@{$self->{REQUESTED_TAGS}}) {
-            $self->{REQ_TAG_LOOKUP}->{lc(/.+?:(.+)/ ? $1 : $_)} = 1;
+            $self->{REQ_TAG_LOOKUP}{lc(/.+:(.+)/ ? $1 : $_)} = 1;
         }
     }
@@ -1703 +2654 @@
         $options->{Exclude} = \@exclude;
         # expand shortcuts in new exclude list
-        ExpandShortcuts($options->{Exclude});
-    }
-}
-
-#------------------------------------------------------------------------------
-# Set list of found tags
+        ExpandShortcuts($options->{Exclude}, 1); # (also remove '#' suffix)
+    }
+}
+
+#------------------------------------------------------------------------------
+# Get list of tags in specified group
+# Inputs: 0) ExifTool ref, 1) group spec, 2) tag key or reference to list of tag keys
+# Returns: list of matching tags in list context, or first match in scalar context
+# Notes: Group spec may contain multiple groups separated by colons, each
+#        possibly with a leading family number
+sub GroupMatches($$$)
+{
+    my ($self, $group, $tagList) = @_;
+    $tagList = [ $tagList ] unless ref $tagList;
+    my ($tag, @matches);
+    if ($group =~ /:/) {
+        # check each group name individually (ie. "Author:1IPTC")
+        my @grps = split ':', lc $group;
+        my (@fmys, $g);
+        for ($g=0; $g<@grps; ++$g) {
+            $fmys[$g] = $1 if $grps[$g] =~ s/^(\d+)//;
+        }
+        foreach $tag (@$tagList) {
+            my @groups = $self->GetGroup($tag, -1);
+            for ($g=0; $g<@grps; ++$g) {
+                my $grp = $grps[$g];
+                next if $grp eq '*' or $grp eq 'all';
+                if (defined $fmys[$g]) {
+                    my $f = $fmys[$g];
+                    last unless $groups[$f] and $grps[$g] eq lc $groups[$f];
+                } else {
+                    last unless grep /^$grps[$g]$/i, @groups;
+                }
+            }
+            push @matches, $tag if $g == @grps;
+        }
+    } else {
+        my $family = ($group =~ s/^(\d+)//) ? $1 : -1;
+        foreach $tag (@$tagList) {
+            my @groups = $self->GetGroup($tag, $family);
+            push @matches, $tag if grep(/^$group$/i, @groups);
+        }
+    }
+    return wantarray ? @matches : $matches[0];
+}
+
+#------------------------------------------------------------------------------
+# Set list of found tags from previously requested tags
 # Inputs: 0) ExifTool object reference
-# Returns: Reference to found tags list (in order of requested tags)
+# Returns: 0) Reference to list of found tag keys (in order of requested tags)
+#          1) Reference to list of indices for tags requested by value
 sub SetFoundTags($)
 {
@@ -1721 +2715 @@
     my @groupOptions = sort grep /^Group/, keys %$options;
     my $doDups = $duplicates || $exclude || @groupOptions;
-    my ($tag, $rtnTags);
+    my ($tag, $rtnTags, @byValue);
 
     # only return requested tags if specified
@@ -1730 +2724 @@
         my $reqTag;
         foreach $reqTag (@$reqTags) {
-            my (@matches, $group, $family, $allGrp, $allTag);
-            if ($reqTag =~ /^(\d+)?(.+?):(.+)/) {
-                ($family, $group, $tag) = ($1, $2, $3);
-                $allGrp = 1 if $group =~ /^(\*|all)$/i;
-                $family = -1 unless defined $family;
+            my (@matches, $group, $allGrp, $allTag, $byValue);
+            if ($reqTag =~ /^(.*):(.+)/) {
+                ($group, $tag) = ($1, $2);
+                if ($group =~ /^(\*|all)$/i) {
+                    $allGrp = 1;
+                } elsif ($group !~ /^[-\w:]*$/) {
+                    $self->Warn("Invalid group name '$group'");
+                    $group = 'invalid';
+                }
             } else {
                 $tag = $reqTag;
-                $family = -1;
-            }
+            }
+            $byValue = 1 if $tag =~ s/#$//;
             if (defined $tagHash->{$reqTag} and not $doDups) {
                 $matches[0] = $tag;
@@ -1750 +2748 @@
                 next unless @matches;   # don't want entry in list for '*' tag
                 $allTag = 1;
+            } elsif ($tag =~ /[*?]/) {
+                # allow wildcards in tag names
+                $tag =~ s/\*/[-\\w]*/g;
+                $tag =~ s/\?/[-\\w]/g;
+                $tag .= '( .*)?' if $doDups or $allGrp;
+                @matches = grep(/^$tag$/i, keys %$tagHash);
+                next unless @matches;   # don't want entry in list for wildcard tags
+                $allTag = 1;
             } elsif ($doDups or defined $group) {
                 # must also look for tags like "Tag (1)"
-                @matches = grep(/^$tag(\s|$)/i, keys %$tagHash);
-            } else {
+                @matches = grep(/^$tag( |$)/i, keys %$tagHash);
+            } elsif ($tag =~ /^[-\w]+$/) {
                 # find first matching value
                 # (use in list context to return value instead of count)
                 ($matches[0]) = grep /^$tag$/i, keys %$tagHash;
                 defined $matches[0] or undef @matches;
+            } else {
+                $self->Warn("Invalid tag name '$tag'");
             }
             if (defined $group and not $allGrp) {
                 # keep only specified group
-                my @grpMatches;
-                foreach (@matches) {
-                    my @groups = $self->GetGroup($_, $family);
-                    next unless grep /^$group$/i, @groups;
-                    push @grpMatches, $_;
-                }
-                @matches = @grpMatches;
+                @matches = $self->GroupMatches($group, \@matches);
                 next unless @matches or not $allTag;
             }
@@ -1776 +2778 @@
                 unless ($doDups or $allTag or $allGrp) {
                     $tag = shift @matches;
-                    my $oldPriority = $self->{PRIORITY}->{$tag} || 1;
+                    my $oldPriority = $self->{PRIORITY}{$tag} || 1;
                     foreach (@matches) {
-                        my $priority = $self->{PRIORITY}->{$_};
+                        my $priority = $self->{PRIORITY}{$_};
                         $priority = 1 unless defined $priority;
                         next unless $priority >= $oldPriority;
@@ -1790 +2792 @@
                 $matches[0] = "$tag (0)";
                 # bogus file order entry to avoid warning if sorting in file order
-                $self->{FILE_ORDER}->{$matches[0]} = 999;
-            }
+                $self->{FILE_ORDER}{$matches[0]} = 999;
+            }
+            # save indices of tags extracted by value
+            push @byValue, scalar(@$rtnTags) .. (scalar(@$rtnTags)+scalar(@matches)-1) if $byValue;
             push @$rtnTags, @matches;
         }
@@ -1811 +2815 @@
     while (($exclude or @groupOptions) and @$rtnTags) {
         if ($exclude) {
-            my @filteredTags;
-EX_TAG:     foreach $tag (@$rtnTags) {
-                my $tagName = GetTagName($tag);
-                my @matches = grep /(^|:)($tagName|\*|all)$/i, @$exclude;
-                foreach (@matches) {
-                    next EX_TAG unless /^(\d+)?(.+?):/;
-                    my ($family, $group) = ($1, $2);
-                    next EX_TAG if $group =~ /^(\*|all)$/i;
-                    $family = -1 unless defined $family;
-                    my @groups = $self->GetGroup($tag, $family);
-                    next EX_TAG if grep /^$group$/i, @groups;
+            my ($pat, %exclude);
+            foreach $pat (@$exclude) {
+                my $group;
+                if ($pat =~ /^(.*):(.+)/) {
+                    ($group, $tag) = ($1, $2);
+                    if ($group =~ /^(\*|all)$/i) {
+                        undef $group;
+                    } elsif ($group !~ /^[-\w:]*$/) {
+                        $self->Warn("Invalid group name '$group'");
+                        $group = 'invalid';
+                    }
+                } else {
+                    $tag = $pat;
                 }
-                push @filteredTags, $tag;
-            }
-            $rtnTags = \@filteredTags;      # use new filtered tag list
+                my @matches;
+                if ($tag =~ /^(\*|all)$/i) {
+                    @matches = @$rtnTags;
+                } else {
+                    # allow wildcards in tag names
+                    $tag =~ s/\*/[-\\w]*/g;
+                    $tag =~ s/\?/[-\\w]/g;
+                    @matches = grep(/^$tag( |$)/i, @$rtnTags);
+                }
+                @matches = $self->GroupMatches($group, \@matches) if $group and @matches;
+                $exclude{$_} = 1 foreach @matches;
+            }
+            if (%exclude) {
+                my @filteredTags;
+                $exclude{$_} or push @filteredTags, $_ foreach @$rtnTags;
+                $rtnTags = \@filteredTags;      # use new filtered tag list
+                last unless @filteredTags;      # all done if nothing left
+            }
             last if $duplicates and not @groupOptions;
         }
@@ -1834 +2855 @@
         my $wantOrder = 0;
         foreach $groupOpt (@groupOptions) {
-            $groupOpt =~ /^Group(\d*)/ or next;
+            $groupOpt =~ /^Group(\d*(:\d+)*)/ or next;
             $family = $1 || 0;
             $wantGroup{$family} or $wantGroup{$family} = { };
@@ -1856 +2877 @@
                     $allGroups = 0;     # don't want all groups if we requested one
                 }
-                $wantGroup{$family}->{$groupName} = $want;
+                $wantGroup{$family}{$groupName} = $want;
             }
         }
@@ -1865 +2886 @@
             foreach $family (keys %wantGroup) {
                 my $group = $self->GetGroup($tag, $family);
-                my $wanted = $wantGroup{$family}->{$group};
+                my $wanted = $wantGroup{$family}{$group};
                 next unless defined $wanted;
                 next GR_TAG unless $wanted;     # skip tag if group excluded
@@ -1903 +2924 @@
         last;
     }
-
-    # save found tags and return reference
-    return $self->{FOUND_TAGS} = $rtnTags;
+    $self->{FOUND_TAGS} = $rtnTags;     # save found tags 
+
+    # return reference to found tag keys (and list of indices of tags to extract by value)
+    return wantarray ? ($rtnTags, \@byValue) : $rtnTags;
 }
 
@@ -1955 +2977 @@
     my ($self, $str, $ignorable) = @_;
     if ($ignorable) {
-        return 0 if $self->{OPTIONS}->{IgnoreMinorErrors};
+        return 0 if $self->{OPTIONS}{IgnoreMinorErrors};
         $str = "[minor] $str";
     }
     $self->FoundTag('Warning', $str);
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Add warning tag only once per processed file
+# Inputs: 0) ExifTool object reference, 1) warning message, 2) true if minor
+# Returns: true if warning tag was added
+sub WarnOnce($$;$)
+{
+    my ($self, $str, $ignorable) = @_;
+    return 0 if $ignorable and $self->{OPTIONS}{IgnoreMinorErrors};
+    unless ($$self{WARNED_ONCE}{$str}) {
+        $self->Warn($str, $ignorable);
+        $$self{WARNED_ONCE}{$str} = 1;
+    }
     return 1;
 }
@@ -1970 +3007 @@
     my ($self, $str, $ignorable) = @_;
     if ($ignorable) {
-        if ($self->{OPTIONS}->{IgnoreMinorErrors}) {
+        if ($self->{OPTIONS}{IgnoreMinorErrors}) {
             $self->Warn($str);
             return 0;
@@ -1982 +3019 @@
 #------------------------------------------------------------------------------
 # Expand shortcuts
-# Inputs: 0) reference to list of tags
-# Notes: Handles leading '-' for excluded tags, group names, and redirected tags
-sub ExpandShortcuts($)
-{
-    my $tagList = shift || return;
+# Inputs: 0) reference to list of tags, 1) set to remove trailing '#'
+# Notes: Handles leading '-' for excluded tags, trailing '#' for ValueConv,
+#        multiple group names, and redirected tags
+sub ExpandShortcuts($;$)
+{
+    my ($tagList, $removeSuffix) = @_;
+    return unless $tagList and @$tagList;
 
     require Image::ExifTool::Shortcuts;
 
     # expand shortcuts
+    my $suffix = $removeSuffix ? '' : '#';
     my @expandedTags;
     my ($entry, $tag, $excl);
     foreach $entry (@$tagList) {
+        # skip things like options hash references in list
+        if (ref $entry) {
+            push @expandedTags, $entry;
+            next;
+        }
         # remove leading '-'
         ($excl, $tag) = $entry =~ /^(-?)(.*)/s;
-        my ($post, @post);
+        my ($post, @post, $pre, $v);
         # handle redirection
-        if ($tag =~ /(.+?)([-+]?[<>].+)/s and not $excl) {
+        if (not $excl and $tag =~ /(.+?)([-+]?[<>].+)/s) {
             ($tag, $post) = ($1, $2);
             if ($post =~ /^[-+]?>/ or $post !~ /\$/) {
                 # expand shortcuts in postfix (rhs of redirection)
-                my ($op, $p2, $t2) = ($post =~ /([-+]?[<>])(.+?:)?(.+)/);
+                my ($op, $p2, $t2) = ($post =~ /([-+]?[<>])(.+:)?(.+)/);
                 $p2 = '' unless defined $p2;
+                $v = ($t2 =~ s/#$//) ? $suffix : ''; # ValueConv suffix
                 my ($match) = grep /^\Q$t2\E$/i, keys %Image::ExifTool::Shortcuts::Main;
                 if ($match) {
                     foreach (@{$Image::ExifTool::Shortcuts::Main{$match}}) {
                         /^-/ and next;  # ignore excluded tags
-                        if ($p2 and /(.+?:)(.+)/) {
-                            push @post, "$op$_";
+                        if ($p2 and /(.+:)(.+)/) {
+                            push @post, "$op$_$v";
                         } else {
-                            push @post, "$op$p2$_";
+                            push @post, "$op$p2$_$v";
                         }
                     }
@@ -2022 +3068 @@
         }
         # handle group names
-        my $pre;
-        if ($tag =~ /(.+?:)(.+)/) {
+        if ($tag =~ /(.+:)(.+)/) {
             ($pre, $tag) = ($1, $2);
         } else {
             $pre = '';
         }
+        $v = ($tag =~ s/#$//) ? $suffix : '';   # ValueConv suffix
         # loop over all postfixes
         for (;;) {
@@ -2038 +3084 @@
                         /^-/ and next;  # ignore excluded exclude tags
                         # group of expanded tag takes precedence
-                        if ($pre and /(.+?:)(.+)/) {
+                        if ($pre and /(.+:)(.+)/) {
                             push @expandedTags, "$excl$_";
                         } else {
@@ -2044 +3090 @@
                         }
                     }
-                } elsif (length $pre or length $post) {
+                } elsif (length $pre or length $post or $v) {
                     foreach (@{$Image::ExifTool::Shortcuts::Main{$match}}) {
-                        /(-?)(.+?:)?(.+)/;
+                        /(-?)(.+:)?(.+)/;
                         if ($2) {
                             # group from expanded tag takes precedence
-                            push @expandedTags, "$_$post";
+                            push @expandedTags, "$_$v$post";
                         } else {
-                            push @expandedTags, "$1$pre$3$post";
+                            push @expandedTags, "$1$pre$3$v$post";
                         }
                     }
@@ -2058 +3104 @@
                 }
             } else {
-                push @expandedTags, "$excl$pre$tag$post";
+                push @expandedTags, "$excl$pre$tag$v$post";
             }
             last unless @post;
@@ -2068 +3114 @@
 
 #------------------------------------------------------------------------------
-# Add hash of composite tags to our composites
-# Inputs: 0) hash reference to table of composite tags to add or module name,
+# Add hash of Composite tags to our composites
+# Inputs: 0) hash reference to table of Composite tags to add or module name,
 #         1) overwrite existing tag
 sub AddCompositeTags($;$)
@@ -2092 +3138 @@
         $defaultGroups = $$add{GROUPS} = { 0 => 'Composite', 1 => 'Composite', 2 => 'Other' };
     }
-    SetupTagTable($add);
+    SetupTagTable($add);    # generate tag Name, etc
     my $tagID;
-    foreach $tagID (keys %$add) {
+    foreach $tagID (sort keys %$add) {
         next if $specialTags{$tagID};   # must skip special tags
         my $tagInfo = $$add{$tagID};
@@ -2100 +3146 @@
         my $tag = $$tagInfo{Name};
         $$tagInfo{Module} = $module if $$tagInfo{Writable};
-        # allow composite tags with the same name
+        # allow Composite tags with the same name
         my ($t, $n, $type);
         while ($Image::ExifTool::Composite{$tag} and not $overwrite) {
-            $n ? $n += 1 : $n = 2, $t = $tag;
+            $n ? $n += 1 : ($n = 2, $t = $tag);
             $tag = "${t}_$n";
+            $$tagInfo{NewTagID} = $tag; # save new ID so we can use it in TagLookup
         }
         # convert scalar Require/Desire entries
@@ -2111 +3158 @@
             $$tagInfo{$type} = { 0 => $req } if ref($req) ne 'HASH';
         }
-        # add this composite tag to our main composite table
+        # add this Composite tag to our main Composite table
         $$tagInfo{Table} = \%Image::ExifTool::Composite;
+        # (use the original TagID, even if we changed it)
+        # $$tagInfo{TagID} = $tag;
+        # save new tag ID so we can find entry in Composite table
         $Image::ExifTool::Composite{$tag} = $tagInfo;
         # set all default groups in tag
@@ -2127 +3177 @@
 
 #------------------------------------------------------------------------------
+# Add tags to TagLookup (used for writing)
+# Inputs: 0) source hash of tag definitions, 1) name of destination tag table
+sub AddTagsToLookup($$)
+{
+    my ($tagHash, $table) = @_;
+    if (defined &Image::ExifTool::TagLookup::AddTags) {
+        Image::ExifTool::TagLookup::AddTags($tagHash, $table);
+    } elsif (not $Image::ExifTool::pluginTags{$tagHash}) {
+        # queue these tags until TagLookup is loaded
+        push @Image::ExifTool::pluginTags, [ $tagHash, $table ];
+        # set flag so we don't load same tags twice
+        $Image::ExifTool::pluginTags{$tagHash} = 1;
+    }
+}
+
+#------------------------------------------------------------------------------
 # Expand tagInfo Flags
 # Inputs: 0) tagInfo hash ref
@@ -2152 +3218 @@
 # Inputs: 0) Reference to tag table
 # Notes: - generates 'Name' field from key if it doesn't exist
-#        - stores 'Table' pointer
+#        - stores 'Table' pointer and 'TagID' value
 #        - expands 'Flags' for quick lookup
 sub SetupTagTable($)
 {
     my $tagTablePtr = shift;
-    my $tagID;
+    my ($tagID, $tagInfo);
     foreach $tagID (TagTableKeys($tagTablePtr)) {
         my @infoArray = GetTagInfoList($tagTablePtr,$tagID);
         # process conditional tagInfo arrays
-        my $tagInfo;
         foreach $tagInfo (@infoArray) {
             $$tagInfo{Table} = $tagTablePtr;
+            $$tagInfo{TagID} = $tagID;
             my $tag = $$tagInfo{Name};
             unless (defined $tag) {
@@ -2172 +3238 @@
             $$tagInfo{Flags} and ExpandFlags($tagInfo);
         }
+        next unless @infoArray > 1;
+        # add an "Index" member to each tagInfo in a list
+        my $index = 0;
+        foreach $tagInfo (@infoArray) {
+            $$tagInfo{Index} = $index++;
+        }
     }
 }
@@ -2180 +3252 @@
 # Notes: May change commas to decimals in floats for use in other locales
 sub IsFloat($) {
-    return 1 if $_[0] =~ /^([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
+    return 1 if $_[0] =~ /^[+-]?(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/;
     # allow comma separators (for other locales)
-    return 0 unless $_[0] =~ /^([+-]?)(?=\d|,\d)\d*(,\d*)?([Ee]([+-]?\d+))?$/;
+    return 0 unless $_[0] =~ /^[+-]?(?=\d|,\d)\d*(,\d*)?([Ee]([+-]?\d+))?$/;
     $_[0] =~ tr/,/./;   # but translate ',' to '.'
     return 1;
 }
-sub IsInt($)   { return scalar($_[0] =~ /^[+-]?\d+$/); }
-sub IsHex($)   { return scalar($_[0] =~ /^(0x)?[0-9a-f]{1,8}$/i); }
+sub IsInt($)      { return scalar($_[0] =~ /^[+-]?\d+$/); }
+sub IsHex($)      { return scalar($_[0] =~ /^(0x)?[0-9a-f]{1,8}$/i); }
+sub IsRational($) { return scalar($_[0] =~ m{^[-+]?\d+/\d+$}); }
 
 # round floating point value to specified number of significant digits
@@ -2201 +3274 @@
 }
 
+# Convert strings to floating point numbers (or undef)
+# Inputs: 0-N) list of strings (may be undef)
+# Returns: last value converted
+sub ToFloat(@)
+{
+    local $_;
+    foreach (@_) {
+        next unless defined $_;
+        # (add 0 to convert "0.0" to "0" for tests)
+        $_ = /((?:[+-]?)(?=\d|\.\d)\d*(?:\.\d*)?(?:[Ee](?:[+-]?\d+))?)/ ? $1 + 0 : undef;
+    }
+    return $_[-1];
+}
+
 #------------------------------------------------------------------------------
 # Utility routines to for reading binary data values from file
 
-my $swapBytes;               # set if EXIF header is not native byte ordering
-my $swapWords;               # swap 32-bit words in doubles (ARM quirk)
-my $currentByteOrder = 'MM'; # current byte ordering ('II' or 'MM')
 my %unpackMotorola = ( S => 'n', L => 'N', C => 'C', c => 'c' );
 my %unpackIntel    = ( S => 'v', L => 'V', C => 'C', c => 'c' );
-my %unpackStd = %unpackMotorola;
+my %unpackRev = ( N => 'V', V => 'N', C => 'C', n => 'v', v => 'n', c => 'c' );
+
+# the following 4 variables are defined in 'use vars' instead of using 'my'
+# because mod_perl 5.6.1 apparently has a problem with setting file-scope 'my'
+# variables from within subroutines (ref communication with Pavel Merdin):
+# $swapBytes - set if EXIF header is not native byte ordering
+# $swapWords - swap 32-bit words in doubles (ARM quirk)
+$currentByteOrder = 'MM'; # current byte ordering ('II' or 'MM')
+%unpackStd = %unpackMotorola;
 
 # Swap bytes in data if necessary
@@ -2240 +3332 @@
     return unpack($unpackStd{$_[0]}, ${$_[1]});
 }
+# same, but with reversed byte order
+sub DoUnpackRev(@)
+{
+    my $fmt = $unpackRev{$unpackStd{$_[0]}};
+    $_[2] and return unpack("x$_[2] $fmt", ${$_[1]});
+    return unpack($fmt, ${$_[1]});
+}
 # Pack value
 # Inputs: 0) template, 1) value, 2) data ref (or undef), 3) offset (if data ref)
@@ -2246 +3345 @@
 {
     my $val = pack($unpackStd{$_[0]}, $_[1]);
+    $_[2] and substr(${$_[2]}, $_[3], length($val)) = $val;
+    return $val;
+}
+# same, but with reversed byte order
+sub DoPackRev(@)
+{
+    my $val = pack($unpackRev{$unpackStd{$_[0]}}, $_[1]);
     $_[2] and substr(${$_[2]}, $_[3], length($val)) = $val;
     return $val;
@@ -2289 +3395 @@
 sub GetFloat($$)  { return DoUnpack(4, 'f', @_); }
 sub GetDouble($$) { return DoUnpackDbl('d', @_); }
-
+sub Get16uRev($$) { return DoUnpackRev('S', @_); }
+
+# rationals may be a floating point number, 'inf' or 'undef'
 sub GetRational32s($$)
 {
     my ($dataPt, $pos) = @_;
-    my $denom = Get16s($dataPt, $pos + 2) or return 'inf';
+    my $numer = Get16s($dataPt,$pos);
+    my $denom = Get16s($dataPt, $pos + 2) or return $numer ? 'inf' : 'undef';
     # round off to a reasonable number of significant figures
-    return RoundFloat(Get16s($dataPt,$pos) / $denom, 7);
+    return RoundFloat($numer / $denom, 7);
 }
 sub GetRational32u($$)
 {
     my ($dataPt, $pos) = @_;
-    my $denom = Get16u($dataPt, $pos + 2) or return 'inf';
-    return RoundFloat(Get16u($dataPt,$pos) / $denom, 7);
+    my $numer = Get16u($dataPt,$pos);
+    my $denom = Get16u($dataPt, $pos + 2) or return $numer ? 'inf' : 'undef';
+    return RoundFloat($numer / $denom, 7);
 }
 sub GetRational64s($$)
 {
     my ($dataPt, $pos) = @_;
-    my $denom = Get32s($dataPt, $pos + 4) or return 'inf';
-    return RoundFloat(Get32s($dataPt,$pos) / $denom, 10);
+    my $numer = Get32s($dataPt,$pos);
+    my $denom = Get32s($dataPt, $pos + 4) or return $numer ? 'inf' : 'undef';
+    return RoundFloat($numer / $denom, 10);
 }
 sub GetRational64u($$)
 {
     my ($dataPt, $pos) = @_;
-    my $denom = Get32u($dataPt, $pos + 4) or return 'inf';
-    return RoundFloat(Get32u($dataPt,$pos) / $denom, 10);
+    my $numer = Get32u($dataPt,$pos);
+    my $denom = Get32u($dataPt, $pos + 4) or return $numer ? 'inf' : 'undef';
+    return RoundFloat($numer / $denom, 10);
 }
 sub GetFixed16s($$)
@@ -2344 +3456 @@
 sub Set16u(@) { return DoPackStd('S', @_); }
 sub Set32u(@) { return DoPackStd('L', @_); }
+sub Set16uRev(@) { return DoPackRev('S', @_); }
 
 #------------------------------------------------------------------------------
@@ -2351 +3464 @@
 #------------------------------------------------------------------------------
 # Set byte ordering
-# Inputs: 0) 'II'=intel, 'MM'=motorola
+# Inputs: 0) 'MM'=motorola, 'II'=intel (will translate 'BigEndian', 'LittleEndian')
 # Returns: 1 on success
 sub SetByteOrder($)
@@ -2360 +3473 @@
         %unpackStd = %unpackMotorola;
     } elsif ($order eq 'II') {  # little endian (Intel)
+        %unpackStd = %unpackIntel;
+    } elsif ($order =~ /^Big/i) {
+        $order = 'MM';
+        %unpackStd = %unpackMotorola;
+    } elsif ($order =~ /^Little/i) {
+        $order = 'II';
         %unpackStd = %unpackIntel;
     } else {
@@ -2402 +3521 @@
     int16s => 2,
     int16u => 2,
+    int16uRev => 2,
     int32s => 4,
     int32u => 4,
@@ -2417 +3537 @@
     double => 8,
     extended => 10,
+    unicode => 2,
+    complex => 8,
     string => 1,
     binary => 1,
    'undef' => 1,
     ifd => 4,
-    ifd8 => 8,
+    ifd64 => 8,
 );
 my %readValueProc = (
@@ -2428 +3550 @@
     int16s => \&Get16s,
     int16u => \&Get16u,
+    int16uRev => \&Get16uRev,
     int32s => \&Get32s,
     int32u => \&Get32u,
@@ -2444 +3567 @@
     extended => \&GetExtended,
     ifd => \&Get32u,
-    ifd8 => \&Get64u,
+    ifd64 => \&Get64u,
 );
 sub FormatSize($) { return $formatSize{$_[0]}; }
@@ -2482 +3605 @@
         }
     } else {
-        # handle undef/binary/string
-        $vals[0] = substr($$dataPt, $offset, $count);
+        # handle undef/binary/string (also unsupported unicode/complex)
+        $vals[0] = substr($$dataPt, $offset, $count * $len);
         # truncate string at null terminator if necessary
         $vals[0] =~ s/\0.*//s if $format eq 'string';
     }
-    if (wantarray) {
-        return @vals;
-    } elsif (@vals > 1) {
-        return join(' ', @vals);
-    } else {
-        return $vals[0];
-    }
-}
-
-#------------------------------------------------------------------------------
-# Convert UTF-8 to current character set
-# Inputs: 0) ExifTool ref, 1) UTF-8 string
-# Return: Converted string
-sub UTF82Charset($$)
-{
-    my ($self, $val) = @_;
-    if ($self->{OPTIONS}->{Charset} eq 'Latin' and $val =~ /[\x80-\xff]/) {
-        $val = Image::ExifTool::UTF82Unicode($val,'n',$self);
-        $val = Image::ExifTool::Unicode2Latin($val,'n',$self);
+    return @vals if wantarray;
+    return join(' ', @vals) if @vals > 1;
+    return $vals[0];
+}
+
+#------------------------------------------------------------------------------
+# Decode string with specified encoding
+# Inputs: 0) ExifTool object ref, 1) string to decode
+#         2) source character set name (undef for current Charset)
+#         3) optional source byte order (2-byte and 4-byte fixed-width sets only)
+#         4) optional destination character set (defaults to Charset setting)
+#         5) optional destination byte order (2-byte and 4-byte fixed-width only)
+# Returns: string in destination encoding
+# Note: ExifTool ref may be undef if character both character sets are provided
+#       (but in this case no warnings will be issued)
+sub Decode($$$;$$$)
+{
+    my ($self, $val, $from, $fromOrder, $to, $toOrder) = @_;
+    $from or $from = $$self{OPTIONS}{Charset};
+    $to or $to = $$self{OPTIONS}{Charset};
+    if ($from ne $to and length $val) {
+        require Image::ExifTool::Charset;
+        my $cs1 = $Image::ExifTool::Charset::csType{$from};
+        my $cs2 = $Image::ExifTool::Charset::csType{$to};
+        if ($cs1 and $cs2 and not $cs2 & 0x002) {
+            # treat as straight ASCII if no character will need remapping
+            if (($cs1 | $cs2) & 0x680 or $val =~ /[\x80-\xff]/) {
+                my $uni = Image::ExifTool::Charset::Decompose($self, $val, $from, $fromOrder);
+                $val = Image::ExifTool::Charset::Recompose($self, $uni, $to, $toOrder);
+            }
+        } elsif ($self) {
+            my $set = $cs1 ? $to : $from;
+            unless ($$self{"DecodeWarn$set"}) {
+                $self->Warn("Unsupported character set ($set)");
+                $$self{"DecodeWarn$set"} = 1;
+            }
+        }
     }
     return $val;
@@ -2511 +3652 @@
 
 #------------------------------------------------------------------------------
-# Convert Latin to current character set
-# Inputs: 0) ExifTool ref, 1) Latin string
-# Return: Converted string
-sub Latin2Charset($$)
-{
-    my ($self, $val) = @_;
-    if ($self->{OPTIONS}->{Charset} eq 'UTF8' and $val =~ /[\x80-\xff]/) {
-        $val = Image::ExifTool::Latin2Unicode($val,'n');
-        $val = Image::ExifTool::Unicode2UTF8($val,'n');
-    }
-    return $val;
+# Encode string with specified encoding
+# Inputs: 0) ExifTool object ref, 1) string, 2) destination character set name,
+#         3) optional destination byte order (2-byte and 4-byte fixed-width sets only)
+# Returns: string in specified encoding
+sub Encode($$$;$)
+{
+    my ($self, $val, $to, $toOrder) = @_;
+    return $self->Decode($val, undef, undef, $to, $toOrder);
 }
 
@@ -2554 +3692 @@
 #------------------------------------------------------------------------------
 # Validate an extracted image and repair if necessary
-# Inputs: 0) ExifTool object reference, 1) image reference, 2) tag name
+# Inputs: 0) ExifTool object reference, 1) image reference, 2) tag name or key
 # Returns: image reference or undef if it wasn't valid
+# Note: should be called from RawConv, not ValueConv
 sub ValidateImage($$$)
 {
@@ -2563 +3702 @@
             # the first byte of the preview of some Minolta cameras is wrong,
             # so check for this and set it back to 0xff if necessary
-            $$imagePt =~ s/^.(\xd8\xff\xdb)/\xff$1/ or
+            $$imagePt =~ s/^.(\xd8\xff\xdb)/\xff$1/s or
             $self->Options('IgnoreMinorErrors'))
     {
         # issue warning only if the tag was specifically requested
-        if ($self->{REQ_TAG_LOOKUP}->{lc($tag)}) {
+        if ($self->{REQ_TAG_LOOKUP}{lc GetTagName($tag)}) {
             $self->Warn("$tag is not a valid JPEG image",1);
             return undef;
@@ -2584 +3723 @@
     # start with the tag name and force first letter to be upper case
     my $desc = ucfirst($tag);
-    $desc =~ tr/_/ /;       # translate underlines to spaces
+    # translate underlines to spaces
+    $desc =~ tr/_/ /;
+    # remove hex TagID from name (to avoid inserting spaces in the number)
+    $desc =~ s/ (0x[\da-f]+)$//i and $tagID = $1 unless defined $tagID;
     # put a space between lower/UPPER case and lower/number combinations
     $desc =~ s/([a-z])([A-Z\d])/$1 $2/g;
@@ -2591 +3733 @@
     # put spaces after numbers (if more than one character following number)
     $desc =~ s/(\d)([A-Z]\S)/$1 $2/g;
-    # remove space in hex number
-    $desc =~ s/ 0x ([\dA-Fa-f])/ 0x$1/g;
+    # add TagID to description
     $desc .= ' ' . $tagID if defined $tagID;
     return $desc;
@@ -2600 +3741 @@
 # Return printable value
 # Inputs: 0) ExifTool object reference
-#         1) value to print, 2) true for unlimited line length
+#         1) value to print, 2) line length limit (undef defaults to 60, 0=unlimited)
 sub Printable($;$)
 {
-    my ($self, $outStr, $unlimited) = @_;
+    my ($self, $outStr, $maxLen) = @_;
     return '(undef)' unless defined $outStr;
     $outStr =~ tr/\x01-\x1f\x7f-\xff/./;
     $outStr =~ s/\x00//g;
-    # limit length if verbose < 4
-    if (length($outStr) > 60 and not $unlimited and $self->{OPTIONS}->{Verbose} < 4) {
-        $outStr = substr($outStr,0,54) . '[snip]';
+    if (defined $maxLen) {
+        # minimum length is 20 (0 is unlimited)
+        $maxLen = 20 if $maxLen and $maxLen < 20;
+    } else {
+        $maxLen = 60;                   # default length is 60
+    }
+    # limit length only if verbose < 4
+    if ($maxLen and length($outStr) > $maxLen and $self->{OPTIONS}{Verbose} < 4) {
+        $outStr = substr($outStr,0,$maxLen-6) . '[snip]';
     }
     return $outStr;
@@ -2621 +3768 @@
 {
     my ($self, $date) = @_;
-    my $dateFormat = $self->{OPTIONS}->{DateFormat};
+    my $dateFormat = $self->{OPTIONS}{DateFormat};
     # only convert date if a format was specified and the date is recognizable
     if ($dateFormat) {
-        if ($date =~ /^(\d+):(\d+):(\d+)\s+(\d+):(\d+):(\d+)/ and eval 'require POSIX') {
-            $date = POSIX::strftime($dateFormat, $6, $5, $4, $3, $2-1, $1-1900);
-        } elsif ($self->{OPTIONS}->{StrictDate}) {
+        # a few cameras use incorrect date/time formatting:
+        # - slashes instead of colons in date (RolleiD330, ImpressCam)
+        # - date/time values separated by colon instead of space (Polariod, Sanyo, Sharp, Vivitar)
+        # - single-digit seconds with leading space (HP scanners)
+        $date =~ s/[-+]\d{2}:\d{2}$//;  # remove timezone if it exists
+        my @a = ($date =~ /\d+/g);      # be very flexible about date/time format
+        if (@a and $a[0] > 1900 and $a[0] < 3000 and eval 'require POSIX') {
+            $date = POSIX::strftime($dateFormat, $a[5]||0, $a[4]||0, $a[3]||0,
+                                                 $a[2]||1, ($a[1]||1)-1, $a[0]-1900);
+        } elsif ($self->{OPTIONS}{StrictDate}) {
             undef $date;
         }
@@ -2634 +3788 @@
 
 #------------------------------------------------------------------------------
+# Print conversion for time span value
+# Inputs: 0) time ticks, 1) number of seconds per tick (default 1)
+# Returns: readable time
+sub ConvertTimeSpan($;$)
+{
+    my ($val, $mult) = @_;
+    if (Image::ExifTool::IsFloat($val) and $val != 0) {
+        $val *= $mult if $mult;
+        if ($val < 60) {
+            $val = "$val seconds";
+        } elsif ($val < 3600) {
+            my $fmt = ($mult and $mult >= 60) ? '%d' : '%.1f';
+            my $s = ($val == 60 and $mult) ? '' : 's';
+            $val = sprintf("$fmt minute$s", $val / 60);
+        } elsif ($val < 24 * 3600) {
+            $val = sprintf("%.1f hours", $val / 3600);
+        } else {
+            $val = sprintf("%.1f days", $val / (24 * 3600));
+        }
+    }
+    return $val;
+}
+
+#------------------------------------------------------------------------------
+# Patched timelocal() that fixes ActivePerl timezone bug
+# Inputs/Returns: same as timelocal()
+# Notes: must 'require Time::Local' before calling this routine
+sub TimeLocal(@)
+{
+    my $tm = Time::Local::timelocal(@_);
+    if ($^O eq 'MSWin32') {
+        # patch for ActivePerl timezone bug
+        my @t2 = localtime($tm);
+        my $t2 = Time::Local::timelocal(@t2);
+        # adjust timelocal() return value to be consistent with localtime()
+        $tm += $tm - $t2;
+    }
+    return $tm;
+}
+
+#------------------------------------------------------------------------------
+# Get time zone in minutes
+# Inputs: 0) localtime array ref, 1) gmtime array ref
+# Returns: time zone offset in minutes
+sub GetTimeZone(;$$)
+{
+    my ($tm, $gm) = @_;
+    # compute the number of minutes between localtime and gmtime
+    my $min = $$tm[2] * 60 + $$tm[1] - ($$gm[2] * 60 + $$gm[1]);
+    if ($$tm[3] != $$gm[3]) {
+        # account for case where one date wraps to the first of the next month
+        $$gm[3] = $$tm[3] - ($$tm[3]==1 ? 1 : -1) if abs($$tm[3]-$$gm[3]) != 1;
+        # adjust for the +/- one day difference
+        $min += ($$tm[3] - $$gm[3]) * 24 * 60;
+    }
+    return $min;
+}
+
+#------------------------------------------------------------------------------
+# Get time zone string
+# Inputs: 0) time zone offset in minutes
+#     or  0) localtime array ref, 1) corresponding time value
+# Returns: time zone string ("+/-HH:MM")
+sub TimeZoneString($;$)
+{
+    my $min = shift;
+    if (ref $min) {
+        my @gm = gmtime(shift);
+        $min = GetTimeZone($min, \@gm);
+    }
+    my $sign = '+';
+    $min < 0 and $sign = '-', $min = -$min;
+    my $h = int($min / 60);
+    return sprintf('%s%.2d:%.2d', $sign, $h, $min - $h * 60);
+}
+
+#------------------------------------------------------------------------------
 # Convert Unix time to EXIF date/time string
-# Inputs: 0) Unix time value, 1) non-zero to use local instead of GMT time
-# Returns: EXIF date/time string
+# Inputs: 0) Unix time value, 1) non-zero to convert to local time
+# Returns: EXIF date/time string (with timezone for local times)
+# Notes: fractional seconds are ignored
 sub ConvertUnixTime($;$)
 {
-    my $time = shift;
+    my ($time, $toLocal) = @_;
     return '0000:00:00 00:00:00' if $time == 0;
-    my @tm = shift() ? localtime($time) : gmtime($time);
-    return sprintf("%4d:%.2d:%.2d %.2d:%.2d:%.2d", $tm[5]+1900, $tm[4]+1,
-                   $tm[3], $tm[2], $tm[1], $tm[0]);
-}
-
-#------------------------------------------------------------------------------
-# Get Unix time from EXIF-formatted date/time string
-# Inputs: 0) EXIF date/time string, 1) non-zero to use local instead of GMT time
-# Returns: Unix time or undefined on error
+    my (@tm, $tz);
+    if ($toLocal) {
+        @tm = localtime($time);
+        $tz = TimeZoneString(\@tm, $time);
+    } else {
+        @tm = gmtime($time);
+        $tz = '';
+    }
+    my $str = sprintf("%4d:%.2d:%.2d %.2d:%.2d:%.2d%s",
+                      $tm[5]+1900, $tm[4]+1, $tm[3], $tm[2], $tm[1], $tm[0], $tz);
+    return $str;
+}
+
+#------------------------------------------------------------------------------
+# Get Unix time from EXIF-formatted date/time string with optional timezone
+# Inputs: 0) EXIF date/time string, 1) non-zero if time is local
+# Returns: Unix time (seconds since 0:00 GMT Jan 1, 1970) or undefined on error
 sub GetUnixTime($;$)
 {
-    my $timeStr = shift;
+    my ($timeStr, $isLocal) = @_;
     return 0 if $timeStr eq '0000:00:00 00:00:00';
     my @tm = ($timeStr =~ /^(\d+):(\d+):(\d+)\s+(\d+):(\d+):(\d+)/);
-    return undef unless @tm == 6;
-    return undef unless eval 'require Time::Local';
+    return undef unless @tm == 6 and eval 'require Time::Local';
+    my $tzsec = 0;
+    # use specified timezone offset (if given) instead of local system time
+    # if we are converting a local time value
+    if ($isLocal and $timeStr =~ /(?:Z|([-+])(\d+):(\d+))$/i) {
+        # use specified timezone if one exists
+        $tzsec = ($2 * 60 + $3) * ($1 eq '-' ? -60 : 60) if $1;
+        undef $isLocal; # convert using GMT corrected for specified timezone
+    }
     $tm[0] -= 1900;     # convert year
     $tm[1] -= 1;        # convert month
     @tm = reverse @tm;  # change to order required by timelocal()
-    return shift() ? Time::Local::timelocal(@tm) : Time::Local::timegm(@tm);
+    return $isLocal ? TimeLocal(@tm) : Time::Local::timegm(@tm) - $tzsec;
+}
+
+#------------------------------------------------------------------------------
+# Print conversion for file size
+# Inputs: 0) file size in bytes
+# Returns: converted file size
+sub ConvertFileSize($)
+{
+    my $val = shift;
+    $val < 2048 and return "$val bytes";
+    $val < 10240 and return sprintf('%.1f kB', $val / 1024);
+    $val < 2097152 and return sprintf('%.0f kB', $val / 1024);
+    $val < 10485760 and return sprintf('%.1f MB', $val / 1048576);
+    return sprintf('%.0f MB', $val / 1048576);
+}
+
+#------------------------------------------------------------------------------
+# Convert seconds to duration string (handles negative durations)
+# Inputs: 0) floating point seconds
+# Returns: duration string in form "S.SS s", "MM:SS" or "H:MM:SS"
+sub ConvertDuration($)
+{
+    my $time = shift;
+    return $time unless IsFloat($time);
+    return '0 s' if $time == 0;
+    my $sign = ($time > 0 ? '' : (($time = -$time), '-'));
+    return sprintf("$sign%.2f s", $time) if $time < 30;
+    my $h = int($time / 3600);
+    $time -= $h * 3600;
+    my $m = int($time / 60);
+    $time -= $m * 60;
+    return sprintf("$sign%d:%.2d:%.2d", $h, $m, int($time));
+}
+
+#------------------------------------------------------------------------------
+# Print conversion for bitrate values
+# Inputs: 0) bitrate in bits per second
+# Returns: human-readable bitrate string
+# Notes: returns input value without formatting if it isn't numerical
+sub ConvertBitrate($)
+{
+    my $bitrate = shift;
+    IsFloat($bitrate) or return $bitrate;
+    my @units = ('bps', 'kbps', 'Mbps', 'Gbps');
+    for (;;) {
+        my $units = shift @units;
+        $bitrate >= 1000 and @units and $bitrate /= 1000, next;
+        my $fmt = $bitrate < 100 ? '%.3g' : '%.0f';
+        return sprintf("$fmt $units", $bitrate);
+    }
 }
 
@@ -2667 +3964 @@
 # Inputs: 0) ExifTool hash ref, 1) start offset, 2) data size
 #         3) comment string, 4) tool tip (or SAME), 5) flags
-sub HtmlDump($$$$;$$)
+sub HDump($$$$;$$)
 {
     my $self = shift;
@@ -2752 +4049 @@
 
 #------------------------------------------------------------------------------
+# Read/rewrite trailer information (including multiple trailers)
+# Inputs: 0) ExifTool object ref, 1) DirInfo ref:
+# - requires RAF and DirName
+# - OutFile is a scalar reference for writing
+# - scans from current file position if ScanForAFCP is set
+# Returns: 1 if trailer was processed or couldn't be processed (or written OK)
+#          0 if trailer was recognized but offsets need fixing (or write error)
+# - DirName, DirLen, DataPos, Offset, Fixup and OutFile are updated
+# - preserves current file position and byte order
+sub ProcessTrailers($$)
+{
+    my ($self, $dirInfo) = @_;
+    my $dirName = $$dirInfo{DirName};
+    my $outfile = $$dirInfo{OutFile};
+    my $offset = $$dirInfo{Offset} || 0;
+    my $fixup = $$dirInfo{Fixup};
+    my $raf = $$dirInfo{RAF};
+    my $pos = $raf->Tell();
+    my $byteOrder = GetByteOrder();
+    my $success = 1;
+    my $path = $$self{PATH};
+
+    for (;;) { # loop through all trailers
+        require "Image/ExifTool/$dirName.pm";
+        my $proc = "Image::ExifTool::${dirName}::Process$dirName";
+        my $outBuff;
+        if ($outfile) {
+            # write to local buffer so we can add trailer in proper order later
+            $$outfile and $$dirInfo{OutFile} = \$outBuff, $outBuff = '';
+            # must generate new fixup if necessary so we can shift
+            # the old fixup separately after we prepend this trailer
+            delete $$dirInfo{Fixup};
+        }
+        delete $$dirInfo{DirLen};       # reset trailer length
+        $$dirInfo{Offset} = $offset;    # set offset from end of file
+        $$dirInfo{Trailer} = 1;         # set Trailer flag in case proc cares
+        # add trailer and DirName to SubDirectory PATH
+        push @$path, 'Trailer', $dirName;
+
+        # read or write this trailer
+        # (proc takes Offset as offset from end of trailer to end of file,
+        #  and returns DataPos and DirLen, and Fixup if applicable)
+        no strict 'refs';
+        my $result = &$proc($self, $dirInfo);
+        use strict 'refs';
+
+        # restore PATH
+        pop @$path;
+        pop @$path;
+        # check result
+        if ($outfile) {
+            if ($result > 0) {
+                if ($outBuff) {
+                    # write trailers to OutFile in original order
+                    $$outfile = $outBuff . $$outfile;
+                    # must adjust old fixup start if it exists
+                    $$fixup{Start} += length($outBuff) if $fixup;
+                    $outBuff = '';      # free memory
+                }
+                if ($fixup) {
+                    # add new fixup information if any
+                    $fixup->AddFixup($$dirInfo{Fixup}) if $$dirInfo{Fixup};
+                } else {
+                    $fixup = $$dirInfo{Fixup};  # save fixup
+                }
+            } else {
+                $success = 0 if $self->Error("Error rewriting $dirName trailer", 1);
+                last;
+            }
+        } elsif ($result < 0) {
+            # can't continue if we must scan for this trailer
+            $success = 0;
+            last;
+        }
+        last unless $result > 0 and $$dirInfo{DirLen};
+        # look for next trailer
+        $offset += $$dirInfo{DirLen};
+        my $nextTrail = IdentifyTrailer($raf, $offset) or last;
+        $dirName = $$dirInfo{DirName} = $$nextTrail{DirName};
+        $raf->Seek($pos, 0);
+    }
+    SetByteOrder($byteOrder);       # restore original byte order
+    $raf->Seek($pos, 0);            # restore original file position
+    $$dirInfo{OutFile} = $outfile;  # restore original outfile
+    $$dirInfo{Offset} = $offset;    # return offset from EOF to start of first trailer
+    $$dirInfo{Fixup} = $fixup;      # return fixup information
+    return $success;
+}
+
+#------------------------------------------------------------------------------
 # Extract EXIF information from a jpg image
 # Inputs: 0) ExifTool object reference, 1) dirInfo ref with RAF set
@@ -2757 +4144 @@
 sub ProcessJPEG($$)
 {
+    local $_;
     my ($self, $dirInfo) = @_;
-    my ($ch,$s,$length);
-    my $verbose = $self->{OPTIONS}->{Verbose};
-    my $out = $self->{OPTIONS}->{TextOut};
+    my ($ch, $s, $length);
+    my $verbose = $self->{OPTIONS}{Verbose};
+    my $out = $self->{OPTIONS}{TextOut};
+    my $fast = $self->{OPTIONS}{FastScan};
     my $raf = $$dirInfo{RAF};
     my $htmlDump = $self->{HTML_DUMP};
     my %dumpParms = ( Out => $out );
-    my ($success, $icc_profile, $wantPreview, $trailInfo);
+    my ($success, $icc_profile, $wantTrailer, $trailInfo, %extendedXMP);
+    my ($preview, $scalado, @dqt, $subSampling, $dumpEnd);
 
     # check to be sure this is a valid JPG file
     return 0 unless $raf->Read($s, 2) == 2 and $s eq "\xff\xd8";
     $dumpParms{MaxLen} = 128 if $verbose < 4;
-    $self->SetFileType();   # set FileType tag
+    unless ($self->{VALUE}{FileType}) {
+        $self->SetFileType();               # set FileType tag
+        $$self{LOW_PRIORITY_DIR}{IFD1} = 1; # lower priority of IFD1 tags
+    }
     if ($htmlDump) {
-        my $pos = $raf->Tell() - 2;
-        $self->HtmlDump(0, $pos, '[unknown header]') if $pos;
-        $self->HtmlDump($pos, 2, 'JPEG header', 'SOI Marker');
-    }
+        $dumpEnd = $raf->Tell();
+        my $pos = $dumpEnd - 2;
+        $self->HDump(0, $pos, '[unknown header]') if $pos;
+        $self->HDump($pos, 2, 'JPEG header', 'SOI Marker');
+    }
+    my $path = $$self{PATH};
+    my $pn = scalar @$path;
 
     # set input record separator to 0xff (the JPEG marker) to make reading quicker
-    my $oldsep = $/;
-    $/ = "\xff";
-
-    my ($nextMarker, $nextSegDataPt, $nextSegPos, $combinedSegData, $dumpEnd);
+    local $/ = "\xff";
+
+    my ($nextMarker, $nextSegDataPt, $nextSegPos, $combinedSegData);
 
     # read file until we reach an end of image (EOI) or start of scan (SOS)
@@ -2793 +4188 @@
 # read ahead to the next segment unless we have reached EOI or SOS
 #
-        unless ($marker and ($marker==0xd9 or ($marker==0xda and not $wantPreview))) {
+        unless ($marker and ($marker==0xd9 or ($marker==0xda and not $wantTrailer))) {
             # read up to next marker (JPEG markers begin with 0xff)
             my $buff;
@@ -2821 +4216 @@
         }
         # set some useful variables for the current segment
-        my $hdr = "\xff" . chr($marker);    # header for this segment
         my $markerName = JpegMarkerName($marker);
+        $$path[$pn] = $markerName;
 #
 # parse the current segment
@@ -2845 +4240 @@
             my ($i, $hmin, $hmax, $vmin, $vmax);
             # loop through all components to determine sampling frequency
+            $subSampling = '';
             for ($i=0; $i<$n; ++$i) {
                 my $sf = Get8u($segDataPt, 7 + 3 * $i);
+                $subSampling .= sprintf('%.2x', $sf);
                 # isolate horizontal and vertical components
                 my ($hf, $vf) = ($sf >> 4, $sf & 0x0f);
@@ -2866 +4263 @@
             next;
         } elsif ($marker == 0xd9) {         # EOI
+            pop @$path;
             $verbose and print $out "JPEG EOI\n";
             my $pos = $raf->Tell();
             if ($htmlDump and $dumpEnd) {
-                $self->HtmlDump($dumpEnd, $pos-2-$dumpEnd, '[JPEG Image Data]', undef, 0x08);
-                $self->HtmlDump($pos-2, 2, 'JPEG EOI', undef);
+                $self->HDump($dumpEnd, $pos-2-$dumpEnd, '[JPEG Image Data]', undef, 0x08);
+                $self->HDump($pos-2, 2, 'JPEG EOI', undef);
                 $dumpEnd = 0;
             }
             $success = 1;
             # we are here because we are looking for trailer information
-            if ($wantPreview and $self->{VALUE}->{PreviewImageStart}) {
-                my $buff;
-                # most previews start right after the JPEG EOI, but the Olympus E-20
-                # preview is 508 bytes into the trailer, and the K-M Maxxum 7D preview
-                # is 979 bytes in, but Minolta previews can have a random first byte...
-                if ($raf->Read($buff, 1024) and ($buff =~ /\xff\xd8\xff./g or
-                    ($self->{CameraMake} =~ /Minolta/i and $buff =~ /.\xd8\xff\xdb/g)))
-                {
-                    # adjust PreviewImageStart to this location
-                    my $start = $self->{VALUE}->{PreviewImageStart};
-                    my $actual = $pos + pos($buff) - 4;
-                    if ($start ne $actual and $verbose > 1) {
-                        print $out "(Fixed PreviewImage location: $start -> $actual)\n";
+            if ($wantTrailer) {
+                my $start = $$self{PreviewImageStart};
+                if ($start) {
+                    my $buff;
+                    # most previews start right after the JPEG EOI, but the Olympus E-20
+                    # preview is 508 bytes into the trailer, the K-M Maxxum 7D preview is
+                    # 979 bytes in, and Sony previews can start up to 32 kB into the trailer.
+                    # (and Minolta and Sony previews can have a random first byte...)
+                    my $scanLen = $$self{Make} =~ /Sony/i ? 65536 : 1024;
+                    if ($raf->Read($buff, $scanLen) and ($buff =~ /\xff\xd8\xff./g or
+                        ($self->{Make} =~ /(Minolta|Sony)/i and $buff =~ /.\xd8\xff\xdb/g)))
+                    {
+                        # adjust PreviewImageStart to this location
+                        my $actual = $pos + pos($buff) - 4;
+                        if ($start ne $actual and $verbose > 1) {
+                            print $out "(Fixed PreviewImage location: $start -> $actual)\n";
+                        }
+                        # update preview image offsets
+                        $self->{VALUE}{PreviewImageStart} = $actual if $self->{VALUE}{PreviewImageStart};
+                        $$self{PreviewImageStart} = $actual;
+                        # load preview now if we tried and failed earlier
+                        if ($$self{PreviewError} and $$self{PreviewImageLength}) {
+                            if ($raf->Seek($actual, 0) and $raf->Read($buff, $$self{PreviewImageLength})) {
+                                $self->FoundTag('PreviewImage', $buff);
+                                delete $$self{PreviewError};
+                            }
+                        }
                     }
-                    $self->{VALUE}->{PreviewImageStart} = $actual;
+                    $raf->Seek($pos, 0);
                 }
-                $raf->Seek($pos, 0);
             }
             # process trailer now or finish processing trailers
@@ -2903 +4314 @@
                 undef $trailInfo;
             }
+            if ($$self{LeicaTrailer}) {
+                $raf->Seek(0, 2);
+                $$self{LeicaTrailer}{TrailPos} = $pos;
+                $$self{LeicaTrailer}{TrailLen} = $raf->Tell() - $pos - $fromEnd;
+                Image::ExifTool::Panasonic::ProcessLeicaTrailer($self);
+            }
             # finally, dump remaining information in JPEG trailer
             if ($verbose or $htmlDump) {
-                $raf->Seek(0, 2);
-                my $endPos = $raf->Tell() - $fromEnd;
+                my $endPos = $$self{LeicaTrailerPos};
+                unless ($endPos) {
+                    $raf->Seek(0, 2);
+                    $endPos = $raf->Tell() - $fromEnd;
+                }
                 $self->DumpUnknownTrailer({
                     RAF => $raf,
@@ -2915 +4335 @@
             last;       # all done parsing file
         } elsif ($marker == 0xda) {         # SOS
+            pop @$path;
             # all done with meta information unless we have a trailer
             $verbose and print $out "JPEG SOS\n";
-            unless ($self->Options('FastScan')) {
+            unless ($fast) {
                 $trailInfo = IdentifyTrailer($raf);
                 # process trailer now unless we are doing verbose dump
@@ -2925 +4346 @@
                     $self->ProcessTrailers($trailInfo) and undef $trailInfo;
                 }
-                if ($wantPreview) {
+                if ($wantTrailer) {
                     # seek ahead and validate preview image
                     my $buff;
                     my $curPos = $raf->Tell();
-                    if ($raf->Seek($self->GetValue('PreviewImageStart'), 0) and
+                    if ($raf->Seek($$self{PreviewImageStart}, 0) and
                         $raf->Read($buff, 4) == 4 and
                         $buff =~ /^.\xd8\xff[\xc4\xdb\xe0-\xef]/)
                     {
-                        undef $wantPreview;
+                        undef $wantTrailer;
                     }
                     $raf->Seek($curPos, 0) or last;
                 }
-                next if $trailInfo or $wantPreview or $verbose > 2 or $htmlDump;
+                # seek ahead and process Leica trailer
+                if ($$self{LeicaTrailer}) {
+                    require Image::ExifTool::Panasonic;
+                    Image::ExifTool::Panasonic::ProcessLeicaTrailer($self);
+                    $wantTrailer = 1 if $$self{LeicaTrailer};
+                }
+                next if $trailInfo or $wantTrailer or $verbose > 2 or $htmlDump;
             }
             # nothing interesting to parse after start of scan (SOS)
@@ -2946 +4373 @@
             $verbose and $marker and print $out "JPEG $markerName:\n";
             next;
+        } elsif ($marker == 0xdb and length($$segDataPt) and    # DQT
+            # save the DQT data only if JPEGDigest has been requested
+            $self->{REQ_TAG_LOOKUP}->{jpegdigest})
+        {
+            my $num = unpack('C',$$segDataPt) & 0x0f;   # get table index
+            $dqt[$num] = $$segDataPt if $num < 4;       # save for MD5 calculation
         }
         # handle all other markers
@@ -2958 +4391 @@
             }
         }
-        if ($marker == 0xe0) {              # APP0 (JFIF, CIFF)
+        if ($marker == 0xe0) {              # APP0 (JFIF, JFXX, CIFF, AVI1, Ocad)
             if ($$segDataPt =~ /^JFIF\0/) {
                 $dumpType = 'JFIF';
@@ -2976 +4409 @@
                 $self->FoundTag($tagInfo, substr($$segDataPt, 6));
             } elsif ($$segDataPt =~ /^(II|MM).{4}HEAPJPGM/s) {
+                next if $fast and $fast > 1;    # skip processing for very fast
                 $dumpType = 'CIFF';
                 my %dirInfo = (
@@ -2984 +4418 @@
                 Image::ExifTool::CanonRaw::ProcessCRW($self, \%dirInfo);
                 delete $self->{SET_GROUP1};
-            }
-        } elsif ($marker == 0xe1) {         # APP1 (EXIF, XMP)
+            } elsif ($$segDataPt =~ /^(AVI1|Ocad)/) {
+                $dumpType = $1;
+                SetByteOrder('MM');
+                my $tagTablePtr = GetTagTable("Image::ExifTool::JPEG::$dumpType");
+                my %dirInfo = (
+                    DataPt   => $segDataPt,
+                    DataPos  => $segPos,
+                    DirStart => 4,
+                    DirLen   => $length - 4,
+                );
+                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            }
+        } elsif ($marker == 0xe1) {         # APP1 (EXIF, XMP, QVCI)
             if ($$segDataPt =~ /^Exif\0/) { # (some Kodak cameras don't put a second \0)
                 undef $dumpType;    # (will be dumped here)
@@ -2999 +4444 @@
                 );
                 if ($htmlDump) {
-                    $self->HtmlDump($segPos-4, 4, 'APP1 header',
-                             "Data size: $length bytes");
-                    $self->HtmlDump($segPos, $hdrLen, 'Exif header',
-                             'APP1 data type: Exif');
+                    $self->HDump($segPos-4, 4, 'APP1 header', "Data size: $length bytes");
+                    $self->HDump($segPos, $hdrLen, 'Exif header', 'APP1 data type: Exif');
                     $dumpEnd = $segPos + $length;
                 }
@@ -3012 +4455 @@
                 my $start = $self->GetValue('PreviewImageStart');
                 my $length = $self->GetValue('PreviewImageLength');
+                if (not $start or not $length and $$self{PreviewError}) {
+                    $start = $$self{PreviewImageStart};
+                    $length = $$self{PreviewImageLength};
+                }
                 if ($start and $length and
                     $start + $length > $self->{EXIF_POS} + length($self->{EXIF_DATA}) and
-                    $self->{REQ_TAG_LOOKUP}->{previewimage})
+                    $self->{REQ_TAG_LOOKUP}{previewimage})
                 {
-                    $wantPreview = 1;
+                    $$self{PreviewImageStart} = $start;
+                    $$self{PreviewImageLength} = $length;
+                    $wantTrailer = 1;
                 }
+            } elsif ($$segDataPt =~ /^$xmpExtAPP1hdr/) {
+                # off len -- extended XMP header (75 bytes total):
+                #   0  35 bytes - signature
+                #  35  32 bytes - GUID (MD5 hash of full extended XMP data in ASCII)
+                #  67   4 bytes - total size of extended XMP data
+                #  71   4 bytes - offset for this XMP data portion
+                $dumpType = 'Extended XMP';
+                if (length $$segDataPt > 75) {
+                    my ($size, $off) = unpack('x67N2', $$segDataPt);
+                    my $guid = substr($$segDataPt, 35, 32);
+                    my $extXMP = $extendedXMP{$guid};
+                    $extXMP or $extXMP = $extendedXMP{$guid} = { };
+                    $$extXMP{Size} = $size;
+                    $$extXMP{$off} = substr($$segDataPt, 75);
+                    # process extended XMP if complete
+                    my @offsets;
+                    for ($off=0; $off<$size; ) {
+                        last unless defined $$extXMP{$off};
+                        push @offsets, $off;
+                        $off += length $$extXMP{$off};
+                    }
+                    if ($off == $size) {
+                        my $buff = '';
+                        # assemble XMP all together
+                        $buff .= $$extXMP{$_} foreach @offsets;
+                        $dumpType = 'Extended XMP';
+                        my $tagTablePtr = GetTagTable('Image::ExifTool::XMP::Main');
+                        my %dirInfo = (
+                            DataPt   => \$buff,
+                            Parent   => $markerName,
+                        );
+                        $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                        delete $extendedXMP{$guid};
+                    }
+                } else {
+                    $self->Warn('Invalid extended XMP segment');
+                }
+            } elsif ($$segDataPt =~ /^QVCI\0/) {
+                $dumpType = 'QVCI';
+                my $tagTablePtr = GetTagTable('Image::ExifTool::Casio::QVCI');
+                my %dirInfo = (
+                    Base     => 0,
+                    DataPt   => $segDataPt,
+                    DataPos  => $segPos,
+                    DataLen  => $length,
+                    DirStart => 0,
+                    DirLen   => $length,
+                    Parent   => $markerName,
+                );
+                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
             } else {
                 # Hmmm.  Could be XMP, let's see
@@ -3023 +4522 @@
                 if ($$segDataPt =~ /^http/ or $$segDataPt =~ /<exif:/) {
                     $dumpType = 'XMP';
+                    # also try to parse XMP with a non-standard header
+                    # (note: this non-standard XMP is ignored when writing)
                     my $start = ($$segDataPt =~ /^$xmpAPP1hdr/) ? length($xmpAPP1hdr) : 0;
                     my $tagTablePtr = GetTagTable('Image::ExifTool::XMP::Main');
@@ -3035 +4536 @@
                     );
                     $processed = $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                    if ($processed and not $start) {
+                        $self->Warn('Non-standard header for APP1 XMP segment');
+                    }
                 }
                 if ($verbose and not $processed) {
@@ -3040 +4544 @@
                 }
             }
-        } elsif ($marker == 0xe2) {         # APP2 (ICC Profile, FPXR)
+        } elsif ($marker == 0xe2) {         # APP2 (ICC Profile, FPXR, MPF, PreviewImage)
             if ($$segDataPt =~ /^ICC_PROFILE\0/) {
                 $dumpType = 'ICC_Profile';
@@ -3064 +4568 @@
                 }
             } elsif ($$segDataPt =~ /^FPXR\0/) {
+                next if $fast and $fast > 1;    # skip processing for very fast
                 $dumpType = 'FPXR';
                 my $tagTablePtr = GetTagTable('Image::ExifTool::FlashPix::Main');
@@ -3077 +4582 @@
                 );
                 $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
-            }
-        } elsif ($marker == 0xe3) {         # APP3 (Kodak "Meta")
+            } elsif ($$segDataPt =~ /^MPF\0/) {
+                undef $dumpType;    # (will be dumped here)
+                my %dirInfo = (
+                    Parent => $markerName,
+                    DataPt => $segDataPt,
+                    DataPos => $segPos,
+                    DirStart => 4,
+                    Base => $segPos + 4,
+                    Multi => 1, # the MP Attribute IFD will be MPF1
+                );
+                if ($htmlDump) {
+                    $self->HDump($segPos-4, 4, 'APP2 header', "Data size: $length bytes");
+                    $self->HDump($segPos, 4, 'MPF header', 'APP2 data type: MPF');
+                    $dumpEnd = $segPos + $length;
+                }
+                # extract the MPF information (it is in standard TIFF format)
+                my $tagTablePtr = GetTagTable('Image::ExifTool::MPF::Main');
+                $self->ProcessTIFF(\%dirInfo, $tagTablePtr);
+            } elsif ($$segDataPt =~ /^\xff\xd8\xff\xdb/) {
+                $preview = $$segDataPt;
+                $dumpType = 'Samsung Preview';
+            } elsif ($preview) {
+                $preview .= $$segDataPt;
+                $dumpType = 'Samsung Preview';
+            }
+            if ($preview and $nextMarker ne $marker) {
+                $self->FoundTag('PreviewImage', $preview);
+                undef $preview;
+            }
+        } elsif ($marker == 0xe3) {         # APP3 (Kodak "Meta", Stim)
             if ($$segDataPt =~ /^(Meta|META|Exif)\0\0/) {
                 undef $dumpType;    # (will be dumped here)
@@ -3089 +4622 @@
                 );
                 if ($htmlDump) {
-                    $self->HtmlDump($segPos-4, 10, 'APP3 Meta header');
+                    $self->HDump($segPos-4, 10, 'APP3 Meta header');
                     $dumpEnd = $segPos + $length;
                 }
                 my $tagTablePtr = GetTagTable('Image::ExifTool::Kodak::Meta');
                 $self->ProcessTIFF(\%dirInfo, $tagTablePtr);
+            } elsif ($$segDataPt =~ /^Stim\0/) {
+                undef $dumpType;    # (will be dumped here)
+                my %dirInfo = (
+                    Parent => $markerName,
+                    DataPt => $segDataPt,
+                    DataPos => $segPos,
+                    DirStart => 6,
+                    Base => $segPos + 6,
+                );
+                if ($htmlDump) {
+                    $self->HDump($segPos-4, 4, 'APP3 header', "Data size: $length bytes");
+                    $self->HDump($segPos, 5, 'Stim header', 'APP3 data type: Stim');
+                    $dumpEnd = $segPos + $length;
+                }
+                # extract the Stim information (it is in standard TIFF format)
+                my $tagTablePtr = GetTagTable('Image::ExifTool::Stim::Main');
+                $self->ProcessTIFF(\%dirInfo, $tagTablePtr);
+            } elsif ($$segDataPt =~ /^\xff\xd8\xff\xdb/) {
+                $preview = $$segDataPt;
+                $dumpType = 'Samsung/HP Preview';
+            }
+            # Samsung continues the preview in APP4
+            if ($preview and $nextMarker ne 0xe4) {
+                $self->FoundTag('PreviewImage', $preview);
+                undef $preview;
+            }
+        } elsif ($marker == 0xe4) {         # APP4 ("SCALADO", FPXR, PreviewImage)
+            if ($$segDataPt =~ /^SCALADO\0/ and $length >= 16) {
+                $dumpType = 'SCALADO';
+                my ($num, $idx, $len) = unpack('x8n2N', $$segDataPt);
+                # assume that the segments are in order and just concatinate them
+                $scalado = '' unless defined $scalado;
+                $scalado .= substr($$segDataPt, 16);
+                if ($idx == $num - 1) {
+                    if ($len != length $scalado) {
+                        $self->Warn('Possibly corrupted APP4 SCALADO data', 1);
+                    }
+                    my %dirInfo = (
+                        Parent => $markerName,
+                        DataPt => \$scalado,
+                    );
+                    my $tagTablePtr = GetTagTable('Image::ExifTool::JPEG::Scalado');
+                    $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                    undef $scalado;
+                }
+            } elsif ($$segDataPt =~ /^FPXR\0/) {
+                next if $fast and $fast > 1;    # skip processing for very fast
+                $dumpType = 'FPXR';
+                my $tagTablePtr = GetTagTable('Image::ExifTool::FlashPix::Main');
+                my %dirInfo = (
+                    DataPt   => $segDataPt,
+                    DataPos  => $segPos,
+                    DataLen  => $length,
+                    DirStart => 0,
+                    DirLen   => $length,
+                    Parent   => $markerName,
+                    # set flag if this is the last FPXR segment
+                    LastFPXR => not ($nextMarker==$marker and $$nextSegDataPt=~/^FPXR\0/),
+                );
+                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            } elsif ($preview) {
+                # continued Samsung S1060 preview from APP3
+                $preview .= $$segDataPt;
+                # (not sure if next part would be APP5 or APP4 again, but assume APP4)
+                if ($nextMarker ne $marker) {
+                    $self->FoundTag('PreviewImage', $preview);
+                    undef $preview;
+                }
             }
         } elsif ($marker == 0xe5) {         # APP5 (Ricoh "RMETA")
@@ -3108 +4709 @@
                 $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
             }
-        } elsif ($marker == 0xe6) {         # APP6 (Toshiba EPPIM)
+        } elsif ($marker == 0xe6) {         # APP6 (Toshiba EPPIM, NITF, HP_TDHD)
             if ($$segDataPt =~ /^EPPIM\0/) {
                 undef $dumpType;    # (will be dumped here)
@@ -3119 +4720 @@
                 );
                 if ($htmlDump) {
-                    $self->HtmlDump($segPos-4, 10, 'APP6 EPPIM header');
+                    $self->HDump($segPos-4, 10, 'APP6 EPPIM header');
                     $dumpEnd = $segPos + $length;
                 }
                 my $tagTablePtr = GetTagTable('Image::ExifTool::JPEG::EPPIM');
                 $self->ProcessTIFF(\%dirInfo, $tagTablePtr);
+            } elsif ($$segDataPt =~ /^NITF\0/) {
+                $dumpType = 'NITF';
+                SetByteOrder('MM');
+                my $tagTablePtr = GetTagTable('Image::ExifTool::JPEG::NITF');
+                my %dirInfo = (
+                    DataPt   => $segDataPt,
+                    DataPos  => $segPos,
+                    DirStart => 5,
+                    DirLen   => $length - 5,
+                );
+                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+            } elsif ($$segDataPt =~ /^TDHD\x01\0\0\0/ and $length > 12) {
+                # HP Photosmart R837 APP6 "TDHD" segment
+                $dumpType = 'TDHD';
+                my $tagTablePtr = GetTagTable('Image::ExifTool::HP::TDHD');
+                my %dirInfo = (
+                    DataPt   => $segDataPt,
+                    DataPos  => $segPos,
+                    DirStart => 12, # (ignore first TDHD element because size includes 12-byte tag header)
+                    DirLen   => $length - 12,
+                );
+                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
             }
         } elsif ($marker == 0xe8) {         # APP8 (SPIFF)
@@ -3141 +4764 @@
             if ($$segDataPt =~ /^UNICODE\0/) {
                 $dumpType = 'PhotoStudio';
-                my $comment = $self->Unicode2Charset(substr($$segDataPt,8), 'MM');
+                my $comment = $self->Decode(substr($$segDataPt,8), 'UCS2', 'MM');
                 $self->FoundTag('Comment', $comment);
             }
@@ -3165 +4788 @@
                 $dumpType = 'Photoshop';
                 # add this data to the combined data if it exists
+                my $dataPt = $segDataPt;
                 if (defined $combinedSegData) {
                     $combinedSegData .= substr($$segDataPt,length($psAPP13hdr));
-                    $segDataPt = \$combinedSegData;
-                    $length = length $combinedSegData;  # update length
+                    $dataPt = \$combinedSegData;
                 }
                 # peek ahead to see if the next segment is photoshop data too
@@ -3174 +4797 @@
                     # initialize combined data if necessary
                     $combinedSegData = $$segDataPt unless defined $combinedSegData;
-                    next;   # will handle the combined data the next time around
+                    # (will handle the Photoshop data the next time around)
+                } else {
+                    my $hdrlen = $isOld ? 27 : 14;
+                    # process APP13 Photoshop record
+                    my $tagTablePtr = GetTagTable('Image::ExifTool::Photoshop::Main');
+                    my %dirInfo = (
+                        DataPt   => $dataPt,
+                        DataPos  => $segPos,
+                        DataLen  => length $$dataPt,
+                        DirStart => $hdrlen,    # directory starts after identifier
+                        DirLen   => length($$dataPt) - $hdrlen,
+                        Parent   => $markerName,
+                    );
+                    $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
+                    undef $combinedSegData;
                 }
-                my $hdrlen = $isOld ? 27 : 14;
-                # process APP13 Photoshop record
-                my $tagTablePtr = GetTagTable('Image::ExifTool::Photoshop::Main');
-                my %dirInfo = (
-                    DataPt   => $segDataPt,
-                    DataPos  => $segPos,
-                    DataLen  => $length,
-                    DirStart => $hdrlen,    # directory starts after identifier
-                    DirLen   => $length - $hdrlen,
-                    Parent   => $markerName,
-                );
-                $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
-                undef $combinedSegData;
             } elsif ($$segDataPt =~ /^Adobe_CM/) {
                 $dumpType = 'Adobe_CM';
@@ -3222 +4846 @@
         } elsif ($marker == 0xfe) {         # COM (JPEG comment)
             $dumpType = 'Comment';
+            $$segDataPt =~ s/\0+$//;    # some dumb softwares add null terminators
             $self->FoundTag('Comment', $$segDataPt);
         } elsif (($marker & 0xf0) != 0xe0) {
@@ -3227 +4852 @@
         }
         if (defined $dumpType) {
-            if (not $dumpType and $self->{OPTIONS}->{Unknown}) {
+            if (not $dumpType and $self->{OPTIONS}{Unknown}) {
                 $self->Warn("Unknown $markerName segment", 1);
             }
             if ($htmlDump) {
                 my $desc = $markerName . ($dumpType ? " $dumpType" : '') . ' segment';
-                $self->HtmlDump($segPos-4, $length+4, $desc, undef, 0x08);
+                $self->HDump($segPos-4, $length+4, $desc, undef, 0x08);
                 $dumpEnd = $segPos + $length;
             }
@@ -3238 +4863 @@
         undef $$segDataPt;
     }
-    $/ = $oldsep;     # restore separator to original value
+    # calculate JPEGDigest if requested
+    if (@dqt and $subSampling) {
+        require Image::ExifTool::JPEGDigest;
+        Image::ExifTool::JPEGDigest::Calculate($self, \@dqt, $subSampling);
+    }
+    $self->Warn('Error reading PreviewImage', 1) if $$self{PreviewError};
+    $self->Warn('Invalid extended XMP') if %extendedXMP;
     $success or $self->Warn('JPEG format error');
+    pop @$path if @$path > $pn;
     return 1;
 }
 
 #------------------------------------------------------------------------------
-# Process TIFF data
-# Inputs: 0) ExifTool object reference, 1) directory information reference
-#         2) optional tag table reference
+# Process EXIF file
+# Inputs/Returns: same as ProcessTIFF
+sub ProcessEXIF($$;$)
+{
+    my ($self, $dirInfo, $tagTablePtr) = @_;
+    return $self->ProcessTIFF($dirInfo, $tagTablePtr);
+}
+
+#------------------------------------------------------------------------------
+# Process TIFF data (wrapper for DoProcessTIFF to allow re-entry)
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) optional tag table ref
 # Returns: 1 if this looked like a valid EXIF block, 0 otherwise, or -1 on write error
 sub ProcessTIFF($$;$)
+{
+    my ($self, $dirInfo, $tagTablePtr) = @_;
+    my $exifData = $$self{EXIF_DATA};
+    my $exifPos = $$self{EXIF_POS};
+    my $rtnVal = $self->DoProcessTIFF($dirInfo, $tagTablePtr);
+    # restore original EXIF information (in case ProcessTIFF is nested)
+    if (defined $exifData) {
+        $$self{EXIF_DATA} = $exifData;
+        $$self{EXIF_POS} = $exifPos;
+    }
+    return $rtnVal;
+}
+
+#------------------------------------------------------------------------------
+# Process TIFF data
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) optional tag table ref
+# Returns: 1 if this looked like a valid EXIF block, 0 otherwise, or -1 on write error
+sub DoProcessTIFF($$;$)
 {
     my ($self, $dirInfo, $tagTablePtr) = @_;
@@ -3256 +4914 @@
     my $base = $$dirInfo{Base} || 0;
     my $outfile = $$dirInfo{OutFile};
-    my ($length, $err, $canonSig);
-
-    # read the image file header and offset to 0th IFD if necessary
+    my ($err, $canonSig, $otherSig);
+
+    # attempt to read TIFF header
+    $self->{EXIF_DATA} = '';
     if ($raf) {
         if ($outfile) {
@@ -3269 +4928 @@
             $raf->Seek($base, 0) or return 0;
         }
-        $raf->Read($self->{EXIF_DATA}, 8) == 8 or return 0;
-    } elsif ($dataPt) {
+        # extract full EXIF block (for block copy) from EXIF file
+        my $amount = $fileType eq 'EXIF' ? 65536 * 8 : 8;
+        my $n = $raf->Read($self->{EXIF_DATA}, $amount);
+        if ($n < 8) {
+            return 0 if $n or not $outfile or $fileType ne 'EXIF';
+            # create EXIF file from scratch
+            delete $self->{EXIF_DATA};
+            undef $raf;
+        }
+        if ($n > 8) {
+            $raf->Seek(8, 0);
+            if ($n == $amount) {
+                $self->{EXIF_DATA} = substr($self->{EXIF_DATA}, 0, 8);
+                $self->Warn('EXIF too large to extract as a block'); #(shouldn't happen)
+            }
+        }
+    } elsif ($dataPt and length $$dataPt) {
         # save a copy of the EXIF data
         my $dirStart = $$dirInfo{DirStart} || 0;
-        $self->{EXIF_DATA} = substr(${$$dirInfo{DataPt}}, $dirStart);
+        my $dirLen = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
+        $self->{EXIF_DATA} = substr($$dataPt, $dirStart, $dirLen);
+        $self->VerboseDir('TIFF') if $self->{OPTIONS}{Verbose} and length($$self{INDENT}) > 2;
     } elsif ($outfile) {
-        # create TIFF information from scratch
-        $self->{EXIF_DATA} = "MM\0\x2a\0\0\0\x08";
+        delete $self->{EXIF_DATA};  # create from scratch
     } else {
         $self->{EXIF_DATA} = '';
     }
+    unless (defined $self->{EXIF_DATA}) {
+        # create TIFF information from scratch
+        if ($self->SetPreferredByteOrder() eq 'MM') {
+            $self->{EXIF_DATA} = "MM\0\x2a\0\0\0\x08";
+        } else {
+            $self->{EXIF_DATA} = "II\x2a\0\x08\0\0\0";
+        }
+    }
     $$self{FIRST_EXIF_POS} = $base + $$self{BASE} unless defined $$self{FIRST_EXIF_POS};
-    $$self{EXIF_POS} = $base;
+    $$self{EXIF_POS} = $base + $$self{BASE};
     $dataPt = \$self->{EXIF_DATA};
 
     # set byte ordering
-    SetByteOrder(substr($$dataPt,0,2)) or return 0;
-    # save EXIF byte ordering
-    $self->{EXIF_BYTE_ORDER} = GetByteOrder();
+    my $byteOrder = substr($$dataPt,0,2);
+    SetByteOrder($byteOrder) or return 0;
 
     # verify the byte ordering
     my $identifier = Get16u($dataPt, 2);
     # identifier is 0x2a for TIFF (but 0x4f52, 0x5352 or ?? for ORF)
-  # no longer do this because ORF files use different values
+  # no longer do this because various files use different values
+  # (TIFF=0x2a, RW2/RWL=0x55, HDP=0xbc, BTF=0x2b, ORF=0x4f52/0x5352/0x????)
   #  return 0 unless $identifier == 0x2a;
 
@@ -3305 +4988 @@
             $raf->Read($canonSig, 8) == 8 or return 0;
             $$dataPt .= $canonSig;
-            if ($canonSig =~ /^CR\x02\0/) {
-                $fileType = 'CR2';
-                $self->HtmlDump($base+8, 8, '[CR2 header]') if $self->{HTML_DUMP};
+            if ($canonSig =~ /^(CR\x02\0|\xba\xb0\xac\xbb)/) {
+                $fileType = $canonSig =~ /^CR/ ? 'CR2' : 'Canon 1D RAW';
+                $self->HDump($base+8, 8, "[$fileType header]") if $self->{HTML_DUMP};
             } else {
                 undef $canonSig;
             }
-        } elsif ($identifier == 0x55 and $fileType =~ /^(RAW|TIFF)$/) {
-            $fileType = 'RAW';  # Panasonic RAW file
-            $tagTablePtr = GetTagTable('Image::ExifTool::Panasonic::Raw');
+        } elsif ($identifier == 0x55 and $fileType =~ /^(RAW|RW2|RWL|TIFF)$/) {
+            # panasonic RAW, RW2 or RWL file
+            my $magic;
+            # test for RW2/RWL magic number
+            if ($offset >= 0x18 and $raf->Read($magic, 16) and
+                $magic eq "\x88\xe7\x74\xd8\xf8\x25\x1d\x4d\x94\x7a\x6e\x77\x82\x2b\x5d\x6a")
+            {
+                $fileType = 'RW2' unless $fileType eq 'RWL';
+                $self->HDump($base + 8, 16, '[RW2/RWL header]') if $$self{HTML_DUMP};
+                $otherSig = $magic; # save signature for writing
+            } else {
+                $fileType = 'RAW';
+            }
+            $tagTablePtr = GetTagTable('Image::ExifTool::PanasonicRaw::Main');
         } elsif ($identifier == 0x2b and $fileType eq 'TIFF') {
             # this looks like a BigTIFF image
@@ -3319 +5013 @@
             require Image::ExifTool::BigTIFF;
             return 1 if Image::ExifTool::BigTIFF::ProcessBTF($self, $dirInfo);
-        } elsif (Get8u($dataPt, 2) == 0xbc and $fileType eq 'TIFF') {
-            $fileType = 'WDP';  # Windows Media Photo file
+        } elsif (Get8u($dataPt, 2) == 0xbc and $byteOrder eq 'II' and $fileType eq 'TIFF') {
+            $fileType = 'HDP';  # Windows HD Photo file
+            # check version number
+            my $ver = Get8u($dataPt, 3);
+            if ($ver > 1) {
+                $self->Error("Windows HD Photo version $ver files not yet supported");
+                return 1;
+            }
+        } elsif ($identifier == 0x4352 and $fileType eq 'TIFF') {
+            $fileType = 'DCP';
         }
         # we have a valid TIFF (or whatever) file
-        if ($fileType and not $self->{VALUE}->{FileType}) {
-            $self->SetFileType($fileType);
-        }
-    }
-    $self->FoundTag('ExifByteOrder', GetByteOrder());
+        if ($fileType and not $self->{VALUE}{FileType}) {
+            my $lookup = $fileTypeLookup{$fileType};
+            $lookup = $fileTypeLookup{$lookup} unless ref $lookup or not $lookup;
+            # use file extension to pre-determine type if extension is TIFF-based or type is RAW
+            my $t = (($lookup and $$lookup[0] eq 'TIFF') or $fileType =~ /RAW/) ? $fileType : undef;
+            $self->SetFileType($t);
+        }
+    }
+    my $ifdName = 'IFD0';
+    if (not $tagTablePtr or $$tagTablePtr{GROUPS}{0} eq 'EXIF') {
+        $self->FoundTag('ExifByteOrder', $byteOrder);
+    } else {
+        $ifdName = $$tagTablePtr{GROUPS}{1};
+    }
     if ($self->{HTML_DUMP}) {
-        my $o = (GetByteOrder() eq 'II') ? 'Little' : 'Big';
-        $self->HtmlDump($base, 4, "TIFF header", "Byte order: $o endian", 0);
-        $self->HtmlDump($base+4, 4, "IFD0 pointer", sprintf("Offset: 0x%.4x",$offset), 0);
+        my $tip = sprintf("Byte order: %s endian\nIdentifier: 0x%.4x\n$ifdName offset: 0x%.4x",
+                          ($byteOrder eq 'II') ? 'Little' : 'Big', $identifier, $offset);
+        $self->HDump($base, 8, 'TIFF header', $tip, 0);
     }
     # remember where we found the TIFF data (APP1, APP3, TIFF, NEF, etc...)
@@ -3346 +5057 @@
         DataPos  => 0,
         DirStart => $offset,
-        DirLen   => length $$dataPt,
+        DirLen   => length($$dataPt) - $offset,
         RAF      => $raf,
-        DirName  => 'IFD0',
+        DirName  => $ifdName,
         Parent   => $fileType,
-        ImageData=> 1, # set flag to get information to copy image data later
+        ImageData=> 'Main', # set flag to get information to copy main image data later
+        Multi    => $$dirInfo{Multi},
     );
 
@@ -3358 +5070 @@
         $self->ProcessDirectory(\%dirInfo, $tagTablePtr);
         # process GeoTiff information if available
-        if ($self->{VALUE}->{GeoTiffDirectory}) {
+        if ($self->{VALUE}{GeoTiffDirectory}) {
             require Image::ExifTool::GeoTiff;
             Image::ExifTool::GeoTiff::ProcessGeoTiff($self);
@@ -3369 +5081 @@
                 $self->ProcessTrailers($trailInfo);
             }
+            # dump any other known trailer (ie. A100 RAW Data)
+            if ($$self{HTML_DUMP} and $$self{KnownTrailer}) {
+                my $known = $$self{KnownTrailer};
+                $raf->Seek(0, 2);
+                my $len = $raf->Tell() - $$known{Start};
+                $len -= $$trailInfo{Offset} if $trailInfo;  # account for other trailers
+                $self->HDump($$known{Start}, $len, "[$$known{Name}]") if $len > 0;
+           }
+        }
+        # update FileType if necessary now that we know more about the file
+        if ($$self{DNGVersion} and $self->{VALUE}{FileType} ne 'DNG') {
+            # override whatever FileType we set since we now know it is DNG
+            $self->OverrideFileType('DNG');
         }
         return 1;
@@ -3388 +5113 @@
         Image::ExifTool::CanonRaw::WriteCR2($self, \%dirInfo, $tagTablePtr) or $err = 1;
     } else {
-        # write TIFF header (8 bytes to be immediately followed by IFD)
-        $dirInfo{NewDataPos} = 8;
+        # write TIFF header (8 bytes [plus optional signature] followed by IFD)
+        $otherSig = '' unless defined $otherSig;
+        my $offset = 8 + length($otherSig);
+        # construct tiff header
+        my $header = substr($$dataPt, 0, 4) . Set32u($offset) . $otherSig;
+        $dirInfo{NewDataPos} = $offset;
+        $dirInfo{HeaderPtr} = \$header;
         # preserve padding between image data blocks in ORF images
         # (otherwise dcraw has problems because it assumes fixed block spacing)
@@ -3397 +5127 @@
             $err = 1;
         } elsif (length($newData)) {
-            my $offset = 8;
-            my $header = substr($$dataPt, 0, 4) . Set32u($offset);
-            Write($outfile, $header, $newData) or $err = 1;
+            # update header length in case more was added
+            my $hdrLen = length $header;
+            if ($hdrLen != 8) {
+                Set32u($hdrLen, \$header, 4);
+                # also update preview fixup if necessary
+                my $pi = $$self{PREVIEW_INFO};
+                $$pi{Fixup}{Start} += $hdrLen - 8 if $pi and $$pi{Fixup};
+            }
+            if ($$self{TIFF_TYPE} eq 'ARW' and not $err) {
+                # write any required ARW trailer and patch other ARW quirks
+                require Image::ExifTool::Sony;
+                my $errStr = Image::ExifTool::Sony::FinishARW($self, $dirInfo, \$newData, 
+                                                              $dirInfo{ImageData});
+                $errStr and $self->Error($errStr);
+                delete $dirInfo{ImageData}; # (was copied by FinishARW)
+            } else {
+                Write($outfile, $header, $newData) or $err = 1;
+            }
             undef $newData; # free memory
         }
@@ -3408 +5153 @@
         }
     }
+    # make local copy of TIFF_END now (it may be reset when processing trailers)
+    my $tiffEnd = $self->{TIFF_END};
+    delete $self->{TIFF_END};
+
     # rewrite trailers if they exist
-    if ($raf and $self->{TIFF_END} and not $err) {
+    if ($raf and $tiffEnd and not $err) {
         my ($buf, $trailInfo);
         $raf->Seek(0, 2) or $err = 1;
-        my $extra = $raf->Tell() - $self->{TIFF_END};
+        my $extra = $raf->Tell() - $tiffEnd;
         # check for trailer and process if possible
         for (;;) {
             last unless $extra > 12;
-            $raf->Seek($self->{TIFF_END});  # seek back to end of image
+            $raf->Seek($tiffEnd);  # seek back to end of image
             $trailInfo = IdentifyTrailer($raf);
             last unless $trailInfo;
@@ -3429 +5178 @@
             }
             # calculate unused bytes before trailer
-            $extra = $$trailInfo{DataPos} - $self->{TIFF_END};
+            $extra = $$trailInfo{DataPos} - $tiffEnd;
             last; # yes, the 'for' loop was just a cheap 'goto'
         }
         # ignore a single zero byte if used for padding
-        # (note that Photoshop CS adds a trailer with 2 zero bytes
-        #  for some reason, and these will be preserved)
-        if ($extra > 0 and $self->{TIFF_END} & 0x01) {
-            $raf->Seek($self->{TIFF_END}, 0) or $err = 1;
+        if ($extra > 0 and $tiffEnd & 0x01) {
+            $raf->Seek($tiffEnd, 0) or $err = 1;
             $raf->Read($buf, 1) or $err = 1;
-            $buf eq "\0" and --$extra, ++$self->{TIFF_END};
+            defined $buf and $buf eq "\0" and --$extra, ++$tiffEnd;
         }
         if ($extra > 0) {
-            if ($self->{DEL_GROUP}->{Trailer}) {
+            my $known = $$self{KnownTrailer};
+            if ($self->{DEL_GROUP}{Trailer} and not $known) {
                 $self->VPrint(0, "  Deleting unknown trailer ($extra bytes)\n");
                 ++$self->{CHANGED};
+            } elsif ($known) {
+                $self->VPrint(0, "  Copying $$known{Name} ($extra bytes)\n");
+                $raf->Seek($tiffEnd, 0) or $err = 1;
+                CopyBlock($raf, $outfile, $extra) or $err = 1;
             } else {
-                $self->VPrint(0, "  Preserving unknown trailer ($extra bytes)\n");
-                $raf->Seek($self->{TIFF_END}, 0) or $err = 1;
-                while ($extra) {
-                    my $n = $extra < 65536 ? $extra : 65536;
+                $raf->Seek($tiffEnd, 0) or $err = 1;
+                # preserve unknown trailer only if it contains non-null data
+                # (Photoshop CS adds a trailer with 2 null bytes)
+                my $size = $extra;
+                for (;;) {
+                    my $n = $size > 65536 ? 65536 : $size;
                     $raf->Read($buf, $n) == $n or $err = 1, last;
-                    Write($outfile, $buf) or $err = 1, last;
-                    $extra -= $n;
+                    if ($buf =~ /[^\0]/) {
+                        $self->VPrint(0, "  Preserving unknown trailer ($extra bytes)\n");
+                        # copy the trailer since it contains non-null data
+                        Write($outfile, "\0"x($extra-$size)) or $err = 1, last if $size != $extra;
+                        Write($outfile, $buf) or $err = 1, last;
+                        CopyBlock($raf, $outfile, $size-$n) or $err = 1 if $size > $n;
+                        last;
+                    }
+                    $size -= $n;
+                    next if $size > 0;
+                    $self->VPrint(0, "  Deleting blank trailer ($extra bytes)\n");
+                    last;
                 }
             }
@@ -3461 +5225 @@
         Write($outfile, $$trailPt) or $err = 1 if $trailPt;
     }
-    delete $self->{TIFF_END};
+    # check DNG version
+    if ($$self{DNGVersion}) {
+        my $ver = $$self{DNGVersion};
+        # currently support up to DNG version 1.2
+        unless ($ver =~ /^(\d+) (\d+)/ and "$1.$2" <= 1.3) {
+            $ver =~ tr/ /./;
+            $self->Error("DNG Version $ver not yet supported", 1);
+        }
+    }
     return $err ? -1 : 1;
 }
@@ -3495 +5267 @@
 {
     my $tableName = shift or return undef;
-
     my $table = $allTables{$tableName};
 
@@ -3504 +5275 @@
             if ($tableName =~ /(.*)::/) {
                 my $module = $1;
-                unless (eval "require $module") {
+                if (eval "require $module") {
+                    # load additional XMP modules if required
+                    if (not %$tableName and $module eq 'Image::ExifTool::XMP') {
+                        require 'Image/ExifTool/XMP2.pl';
+                    }
+                } else {
                     $@ and warn $@;
                 }
@@ -3516 +5292 @@
         $table = \%$tableName;
         use strict 'refs';
+        $$table{TABLE_NAME} = $tableName;   # set table name
+        ($$table{SHORT_NAME} = $tableName) =~ s/^Image::ExifTool:://;
         # set default group 0 and 1 from module name unless already specified
         my $defaultGroups = $$table{GROUPS};
@@ -3529 +5307 @@
         }
         $$defaultGroups{2} = 'Other' unless $$defaultGroups{2};
+        if ($$defaultGroups{0} eq 'XMP' or $$table{NAMESPACE}) {
+            # initialize some XMP table defaults
+            require Image::ExifTool::XMP;
+            Image::ExifTool::XMP::RegisterNamespace($table); # register all table namespaces
+            # set default write/check procs
+            $$table{WRITE_PROC} = \&Image::ExifTool::XMP::WriteXMP unless $$table{WRITE_PROC};
+            $$table{CHECK_PROC} = \&Image::ExifTool::XMP::CheckXMP unless $$table{CHECK_PROC};
+            $$table{LANG_INFO} = \&Image::ExifTool::XMP::GetLangInfo unless $$table{LANG_INFO};
+        }
         # generate a tag prefix for unknown tags if necessary
         unless ($$table{TAG_PREFIX}) {
@@ -3545 +5332 @@
             my $tagID;
             foreach $tagID (TagTableKeys($UserDefined{$tableName})) {
-                my $tagInfo = $UserDefined{$tableName}->{$tagID};
+                my $tagInfo = $UserDefined{$tableName}{$tagID};
                 if (ref $tagInfo eq 'HASH') {
                     $$tagInfo{Name} or $$tagInfo{Name} = ucfirst($tagID);
@@ -3560 +5347 @@
             }
         }
-        # generate tag ID's if necessary
-        GenerateTagIDs($table) if $didTagID;
         # remember order we loaded the tables in
         push @tableOrder, $tableName;
@@ -3577 +5362 @@
 sub ProcessDirectory($$$;$)
 {
-    my ($self, $dirInfo, $tagTablePtr, $processProc) = @_;
+    my ($self, $dirInfo, $tagTablePtr, $proc) = @_;
 
     return 0 unless $tagTablePtr and $dirInfo;
-    # use default proc from tag table if no proc specified
-    $processProc or $processProc = $$tagTablePtr{PROCESS_PROC};
+    # use default proc from tag table or EXIF proc as fallback if no proc specified
+    $proc or $proc = $$tagTablePtr{PROCESS_PROC} || \&Image::ExifTool::Exif::ProcessExif;
     # set directory name from default group0 name if not done already
-    $$dirInfo{DirName} or $$dirInfo{DirName} = $tagTablePtr->{GROUPS}->{0};
+    $$dirInfo{DirName} or $$dirInfo{DirName} = $tagTablePtr->{GROUPS}{0};
     # guard against cyclical recursion into the same directory
     if (defined $$dirInfo{DirStart} and defined $$dirInfo{DataPos}) {
         my $addr = $$dirInfo{DirStart} + $$dirInfo{DataPos} + ($$dirInfo{Base}||0);
-        if ($self->{PROCESSED}->{$addr}) {
-            $self->Warn("$$dirInfo{DirName} pointer references previous $self->{PROCESSED}->{$addr} directory");
+        if ($self->{PROCESSED}{$addr}) {
+            $self->Warn("$$dirInfo{DirName} pointer references previous $self->{PROCESSED}{$addr} directory");
             return 0;
         }
-        $self->{PROCESSED}->{$addr} = $$dirInfo{DirName};
-    }
-    # otherwise process as an EXIF directory
-    $processProc or $processProc = \&Image::ExifTool::Exif::ProcessExif;
+        $self->{PROCESSED}{$addr} = $$dirInfo{DirName};
+    }
     my $oldOrder = GetByteOrder();
     my $oldIndent = $self->{INDENT};
     my $oldDir = $self->{DIR_NAME};
+    $self->{LIST_TAGS} = { };  # don't build lists across different directories
     $self->{INDENT} .= '| ';
     $self->{DIR_NAME} = $$dirInfo{DirName};
-    my $rtnVal = &$processProc($self, $dirInfo, $tagTablePtr);
+    push @{$self->{PATH}}, $$dirInfo{DirName};
+
+    # process the directory
+    my $rtnVal = &$proc($self, $dirInfo, $tagTablePtr);
+
+    pop @{$self->{PATH}};
     $self->{INDENT} = $oldIndent;
     $self->{DIR_NAME} = $oldDir;
@@ -3608 +5397 @@
 
 #------------------------------------------------------------------------------
+# Get Metadata path
+# Inputs: 0) Exiftool object ref
+# Return: Metadata path string
+sub MetadataPath($)
+{
+    my $self = shift;
+    return join '-', @{$$self{PATH}}
+}
+
+#------------------------------------------------------------------------------
 # Get standardized file extension
 # Inputs: 0) file name
-# Returns: standardized extension (all uppercase)
+# Returns: standardized extension (all uppercase), or undefined if no extension
 sub GetFileExtension($)
 {
@@ -3669 +5468 @@
             return '' if $condition =~ /\$(valPt|format|count)\b/ and not defined $valPt;
             # set old value for use in condition if needed
-            my $oldVal = $self->{VALUE}->{$$tagInfo{Name}};
-            #### eval Condition ($self, $oldVal, [$valPt, $format, $count])
+            local $SIG{'__WARN__'} = \&SetWarning;
+            undef $evalWarning;
+            #### eval Condition ($self, [$valPt, $format, $count])
             unless (eval $condition) {
-                $@ and warn "Condition $$tagInfo{Name}: $@";
+                $@ and $evalWarning = $@;
+                $self->Warn("Condition $$tagInfo{Name}: " . CleanWarning()) if $evalWarning;
                 next;
             }
         }
-        if ($$tagInfo{Unknown} and not $self->{OPTIONS}->{Unknown}) {
+        if ($$tagInfo{Unknown} and not $$self{OPTIONS}{Unknown} and not $$self{OPTIONS}{Verbose}) {
             # don't return Unknown tags unless that option is set
             return undef;
@@ -3684 +5485 @@
     }
     # generate information for unknown tags (numerical only) if required
-    if (not $tagInfo and $self->{OPTIONS}->{Unknown} and $tagID =~ /^\d+$/ and
-        not $$self{NO_UNKNOWN})
+    if (not $tagInfo and ($$self{OPTIONS}{Unknown} or $$self{OPTIONS}{Verbose}) and
+        $tagID =~ /^\d+$/ and not $$self{NO_UNKNOWN})
     {
         my $printConv;
@@ -3714 +5515 @@
 # Add new tag to table (must use this routine to add new tags to a table)
 # Inputs: 0) reference to tag table, 1) tag ID
-#         2) reference to tag information hash
+#         2) [optional] reference to tag information hash
 # Notes: - will not overwrite existing entry in table
 # - info need contain no entries when this routine is called
-sub AddTagToTable($$$)
+sub AddTagToTable($$;$)
 {
     my ($tagTablePtr, $tagID, $tagInfo) = @_;
+    $tagInfo or $tagInfo = { };
 
     # define necessary entries in information hash
@@ -3725 +5527 @@
         # fill in default groups from table GROUPS
         foreach (keys %{$$tagTablePtr{GROUPS}}) {
-            next if $tagInfo->{Groups}->{$_};
-            $tagInfo->{Groups}->{$_} = $tagTablePtr->{GROUPS}->{$_};
+            next if $tagInfo->{Groups}{$_};
+            $tagInfo->{Groups}{$_} = $tagTablePtr->{GROUPS}{$_};
         }
     } else {
-        $$tagInfo{Groups} = $$tagTablePtr{GROUPS};
+        $$tagInfo{Groups} = { %{$$tagTablePtr{GROUPS}} };
     }
     $$tagInfo{Flags} and ExpandFlags($tagInfo);
@@ -3736 +5538 @@
     $$tagInfo{TagID} = $tagID;
 
-    unless ($$tagInfo{Name}) {
+    my $name = $$tagInfo{Name};
+    if (defined $name) {
+        $name =~ tr/-_a-zA-Z0-9//dc;    # remove illegal characters
+    } else {
+        # construct a name from the tag ID
+        $name = $tagID;
+        $name =~ tr/-_a-zA-Z0-9//dc;    # remove illegal characters
+        $name = ucfirst $name;          # start with uppercase
+        # make sure name is a reasonable length
         my $prefix = $$tagTablePtr{TAG_PREFIX};
-        $$tagInfo{Name} = "${prefix}_$tagID";
-        # make description to prevent tagID from getting mangled by MakeDescription()
-        $$tagInfo{Description} = MakeDescription($prefix, $tagID);
-    }
+        if ($prefix) {
+            # make description to prevent tagID from getting mangled by MakeDescription()
+            $$tagInfo{Description} = MakeDescription($prefix, $name);
+            $name = "${prefix}_$name";
+        }
+    }
+    # tag names must be at least 2 characters long and begin with a letter
+    $name = "Tag$name" if length($name) <= 1 or $name !~ /^[A-Z]/i;
+    $$tagInfo{Name} = $name;
     # add tag to table, but never overwrite existing entries (could potentially happen
     # if someone thinks there isn't any tagInfo because a condition wasn't satisfied)
@@ -3751 +5566 @@
 # Inputs: 0) ExifTool object ref, 1) tag table reference, 2) tagID, 3) value,
 #         4-N) parameters hash: Index, DataPt, DataPos, Start, Size, Parent,
-#              TagInfo, ProcessProc
+#              TagInfo, ProcessProc, RAF
 # Returns: tag key or undef if tag not found
+# Notes: if value is not defined, it is extracted from DataPt using TagInfo
+#        Format and Count if provided
 sub HandleTag($$$$;%)
 {
     my ($self, $tagTablePtr, $tag, $val, %parms) = @_;
-    my $verbose = $self->{OPTIONS}->{Verbose};
-    my $tagInfo = $parms{TagInfo} || $self->GetTagInfo($tagTablePtr, $tag);
+    my $verbose = $self->{OPTIONS}{Verbose};
+    my $tagInfo = $parms{TagInfo} || $self->GetTagInfo($tagTablePtr, $tag, \$val);
     my $dataPt = $parms{DataPt};
-    my $subdir;
+    my ($subdir, $format, $count, $size, $noTagInfo);
 
     if ($tagInfo) {
@@ -3765 +5582 @@
     } else {
         return undef unless $verbose;
+        $tagInfo = { Name => "tag $tag" };  # create temporary tagInfo hash
+        $noTagInfo = 1;
     }
     # read value if not done already (not necessary for subdir)
-    unless (defined $val or $subdir) {
+    unless (defined $val or ($subdir and not $$tagInfo{Writable})) {
         my $start = $parms{Start} || 0;
         my $size = $parms{Size} || 0;
         # read from data in memory if possible
         if ($dataPt and $start >= 0 and $start + $size <= length($$dataPt)) {
-            $val = substr($$dataPt, $start, $size);
+            $format = $$tagInfo{Format} || $$tagTablePtr{FORMAT};
+            if ($format) {
+                $val = ReadValue($dataPt, $start, $format, $$tagInfo{Count}, $size);
+            } else {
+                $val = substr($$dataPt, $start, $size);
+            }
         } else {
-            my $name = $tagInfo ? $$tagInfo{Name} : "tag $tag";
-            $self->Warn("Error extracting value for $name");
+            $self->Warn("Error extracting value for $$tagInfo{Name}");
             return undef;
         }
@@ -3781 +5604 @@
     # do verbose print if necessary
     if ($verbose) {
+        undef $tagInfo if $noTagInfo;
         $parms{Value} = $val;
         $parms{Table} = $tagTablePtr;
+        if ($format) {
+            $count or $count = int(($parms{Size} || 0) / ($formatSize{$format} || 1));
+            $parms{Format} = $format . "[$count]";
+        }
         $self->VerboseInfo($tag, $tagInfo, %parms);
     }
     if ($tagInfo) {
         if ($subdir) {
+            my $subdirStart = $parms{Start};
+            my $subdirLen = $parms{Size};
+            if ($$subdir{Start}) {
+                my $valuePtr = 0;
+                #### eval Start ($valuePtr)
+                my $off = eval $$subdir{Start};                
+                $subdirStart += $off;
+                $subdirLen -= $off;
+            }
             $dataPt or $dataPt = \$val;
             # process subdirectory information
             my %dirInfo = (
-                DirName  => $$tagInfo{Name},
+                DirName  => $$subdir{DirName} || $$tagInfo{Name},
                 DataPt   => $dataPt,
                 DataLen  => length $$dataPt,
                 DataPos  => $parms{DataPos},
-                DirStart => $parms{Start},
-                DirLen   => $parms{Size},
+                DirStart => $subdirStart,
+                DirLen   => $subdirLen,
                 Parent   => $parms{Parent},
+                Base     => $parms{Base},
+                Multi    => $$subdir{Multi},
+                TagInfo  => $tagInfo,
+                RAF      => $parms{RAF},
             );
+            my $oldOrder = GetByteOrder();
+            SetByteOrder($$subdir{ByteOrder}) if $$subdir{ByteOrder};
             my $subTablePtr = GetTagTable($$subdir{TagTable}) || $tagTablePtr;
-            $self->ProcessDirectory(\%dirInfo, $subTablePtr, $$subdir{ProcessProc});
-        } else {
-            return $self->FoundTag($tagInfo, $val);
-        }
+            $self->ProcessDirectory(\%dirInfo, $subTablePtr, $$subdir{ProcessProc} || $parms{ProcessProc});
+            SetByteOrder($oldOrder);
+            # return now unless directory is writable as a block
+            return undef unless $$tagInfo{Writable};
+        }
+        return $self->FoundTag($tagInfo, $val);
     }
     return undef;
@@ -3809 +5654 @@
 #------------------------------------------------------------------------------
 # Add tag to hash of extracted information
-# Inputs: 0) reference to ExifTool object
+# Inputs: 0) ExifTool object reference
 #         1) reference to tagInfo hash or tag name
-#         2) data value (or reference to require hash if composite)
+#         2) data value (or reference to require hash if Composite)
 # Returns: tag key or undef if no value
 sub FoundTag($$$)
@@ -3828 +5673 @@
         # (not advised to do this since the tag won't show in list)
         $tagInfo or $tagInfo = { Name => $tag, Groups => \%allGroupsExifTool };
-        $self->{OPTIONS}->{Verbose} and $self->VerboseInfo(undef, $tagInfo, Value => $value);
+        $self->{OPTIONS}{Verbose} and $self->VerboseInfo(undef, $tagInfo, Value => $value);
     }
     my $rawValueHash = $self->{VALUE};
     if ($$tagInfo{RawConv}) {
-        my $conv = $$tagInfo{RawConv};
-        my $val = $value;   # must do this in case eval references $val
         # initialize @val for use in Composite RawConv expressions
         my @val;
-        if (ref $val eq 'HASH') {
-            foreach (keys %$val) { $val[$_] = $$rawValueHash{$$val{$_}}; }
-        }
+        if (ref $value eq 'HASH') {
+            foreach (keys %$value) { $val[$_] = $$rawValueHash{$$value{$_}}; }
+        }
+        my $conv = $$tagInfo{RawConv};
+        local $SIG{'__WARN__'} = \&SetWarning;
+        undef $evalWarning;
         if (ref $conv eq 'CODE') {
-            $value = &$conv($val, $self);
+            $value = &$conv($value, $self);
         } else {
-            #### eval RawConv ($self, $val)
+            my $val = $value;   # must do this in case eval references $val
+            # NOTE: RawConv is also evaluated in Writer.pl
+            #### eval RawConv ($self, $val, $tag, $tagInfo)
             $value = eval $conv;
-            $@ and warn "RawConv: $@\n";
-        }
+            $@ and $evalWarning = $@;
+        }
+        $self->Warn("RawConv $tag: " . CleanWarning()) if $evalWarning;
         return undef unless defined $value;
     }
     # get tag priority
     my $priority = $$tagInfo{Priority};
-    defined $priority or $priority = $tagInfo->{Table}->{PRIORITY};
+    defined $priority or $priority = $tagInfo->{Table}{PRIORITY};
     # handle duplicate tag names
-    if (defined $rawValueHash->{$tag}) {
-        if ($$tagInfo{List} and $tagInfo eq $self->{TAG_INFO}->{$tag} and
-            not $self->{NO_LIST})
-        {
-            # use a list reference for multiple values
-            if (ref $rawValueHash->{$tag} ne 'ARRAY') {
-                $rawValueHash->{$tag} = [ $rawValueHash->{$tag} ];
-            }
-            push @{$rawValueHash->{$tag}}, $value;
+    if (defined $$rawValueHash{$tag}) {
+        # add to list if there is an active list for this tag
+        if ($self->{LIST_TAGS}{$tagInfo}) {
+            $tag = $self->{LIST_TAGS}{$tagInfo};  # use key from previous list tag
+            if (ref $$rawValueHash{$tag} ne 'ARRAY') {
+                $$rawValueHash{$tag} = [ $$rawValueHash{$tag} ];
+            }
+            push @{$$rawValueHash{$tag}}, $value;
             return $tag;    # return without creating a new entry
         }
         # get next available tag key
-        my $nextTag = NextTagKey($rawValueHash, $tag);
+        my $nextInd = $self->{DUPL_TAG}{$tag} = ($self->{DUPL_TAG}{$tag} || 0) + 1;
+        my $nextTag = "$tag ($nextInd)";
 #
 # take tag with highest priority
 #
         # promote existing 0-priority tag so it takes precedence over a new 0-tag
-        my $oldPriority = $self->{PRIORITY}->{$tag} || 1;
-        # set priority for this tag (default is 1)
-        $priority = 1 if not defined $priority or
+        # (unless old tag was a sub-document and new tag isn't)
+        my $oldPriority = $self->{PRIORITY}{$tag};
+        unless ($oldPriority) {
+            if ($self->{DOC_NUM} or not $self->{TAG_EXTRA}{$tag} or
+                                    not $self->{TAG_EXTRA}{$tag}{G3})
+            {
+                $oldPriority = 1;
+            } else {
+                $oldPriority = 0; # don't promote sub-document tag over main document
+            }
+        }
+        # set priority for this tag
+        if (defined $priority) {
             # increase 0-priority tags if this is the priority directory
-            ($priority == 0 and $self->{DIR_NAME} and $self->{PRIORITY_DIR} and
-            $self->{DIR_NAME} eq $self->{PRIORITY_DIR});
-        if ($priority >= $oldPriority) {
+            $priority = 1 if not $priority and $$self{DIR_NAME} and
+                             $$self{DIR_NAME} eq $$self{PRIORITY_DIR};
+        } elsif ($$self{DIR_NAME} and $$self{LOW_PRIORITY_DIR}{$$self{DIR_NAME}}) {
+            $priority = 0;  # default is 0 for a LOW_PRIORITY_DIR
+        } else {
+            $priority = 1;  # the normal default
+        }
+        if ($priority >= $oldPriority and not $self->{DOC_NUM}) {
+            # move existing tag out of the way since this tag is higher priority
             $self->{MOVED_KEY} = $nextTag;  # used in BuildCompositeTags()
-            $self->{PRIORITY}->{$nextTag} = $self->{PRIORITY}->{$tag};
-            $rawValueHash->{$nextTag} = $rawValueHash->{$tag};
-            $self->{FILE_ORDER}->{$nextTag} = $self->{FILE_ORDER}->{$tag};
-            $self->{TAG_INFO}->{$nextTag} = $self->{TAG_INFO}->{$tag};
-            if ($self->{GROUP1}->{$tag}) {
-                $self->{GROUP1}->{$nextTag} = $self->{GROUP1}->{$tag};
-                delete $self->{GROUP1}->{$tag};
-            }
+            $self->{PRIORITY}{$nextTag} = $self->{PRIORITY}{$tag};
+            $$rawValueHash{$nextTag} = $$rawValueHash{$tag};
+            $self->{FILE_ORDER}{$nextTag} = $self->{FILE_ORDER}{$tag};
+            my $oldInfo = $self->{TAG_INFO}{$nextTag} = $self->{TAG_INFO}{$tag};
+            if ($self->{TAG_EXTRA}{$tag}) {
+                $self->{TAG_EXTRA}{$nextTag} = $self->{TAG_EXTRA}{$tag};
+                delete $self->{TAG_EXTRA}{$tag};
+            }
+            # update tag key for list if necessary
+            $self->{LIST_TAGS}{$oldInfo} = $nextTag if $self->{LIST_TAGS}{$oldInfo};
         } else {
             $tag = $nextTag;        # don't override the existing tag
         }
-        $self->{PRIORITY}->{$tag} = $priority;
+        $self->{PRIORITY}{$tag} = $priority;
     } elsif ($priority) {
         # set tag priority (only if exists and non-zero)
-        $self->{PRIORITY}->{$tag} = $priority;
-    }
-
-    # save the raw value, file order, tagInfo ref and group1 name if necessary
-    $rawValueHash->{$tag} = $value;
-    $self->{FILE_ORDER}->{$tag} = ++$self->{NUM_FOUND};
-    $self->{TAG_INFO}->{$tag} = $tagInfo;
-    $self->{GROUP1}->{$tag} = $self->{SET_GROUP1} if $self->{SET_GROUP1};
+        $self->{PRIORITY}{$tag} = $priority;
+    }
+
+    # save the raw value, file order, tagInfo ref, group1 name,
+    # and tag key for lists if necessary
+    $$rawValueHash{$tag} = $value;
+    $self->{FILE_ORDER}{$tag} = ++$self->{NUM_FOUND};
+    $self->{TAG_INFO}{$tag} = $tagInfo;
+    # set dynamic groups 1 and 3 if necessary
+    $self->{TAG_EXTRA}{$tag}{G1} = $self->{SET_GROUP1} if $self->{SET_GROUP1};
+    if ($self->{DOC_NUM}) {
+        $self->{TAG_EXTRA}{$tag}{G3} = $self->{DOC_NUM};
+        if ($self->{DOC_NUM} =~ /^(\d+)/) {
+            # keep track of maximum 1st-level sub-document number
+            $self->{DOC_COUNT} = $1 unless $self->{DOC_COUNT} >= $1;
+        }
+    }
+    # save path if requested
+    $self->{TAG_EXTRA}{$tag}{G5} = $self->MetadataPath() if $self->{OPTIONS}{SavePath};
+
+    # remember this tagInfo if we will be accumulating values in a list
+    $self->{LIST_TAGS}{$tagInfo} = $tag if $$tagInfo{List} and not $$self{NO_LIST};
 
     return $tag;
@@ -3904 +5785 @@
 
 #------------------------------------------------------------------------------
-# Get next available tag key
-# Inputs: 0) hash reference (keys are tag keys), 1) tag name
-# Returns: next available tag key
-sub NextTagKey($$)
-{
-    my ($info, $tag) = @_;
-    if (exists $$info{$tag}) {
-        my $name = $tag;
-        my $i;
-        for ($i=1; ; ++$i) {
-            $tag = "$name ($i)";
-            last unless exists $$info{$tag};
-        }
-    }
-    return $tag;
-}
-
-#------------------------------------------------------------------------------
 # Make current directory the priority directory if not set already
-# Inputs: 0) reference to ExifTool object
+# Inputs: 0) ExifTool object reference
 sub SetPriorityDir($)
 {
@@ -3931 +5794 @@
 
 #------------------------------------------------------------------------------
-# Set family 1 group name specific to this tag instance
-# Inputs: 0) reference to ExifTool object, 1) tag key, 2) group name
-sub SetGroup1($$$)
-{
-    my ($self, $tagKey, $extra) = @_;
-    $self->{GROUP1}->{$tagKey} = $extra;
-}
-
-#------------------------------------------------------------------------------
-# Set ID's for all tags in specified table
-# Inputs: 0) tag table reference
-sub GenerateTagIDs($)
-{
-    my $table = shift;
-
-    unless ($$table{DID_TAG_ID}) {
-        $$table{DID_TAG_ID} = 1;    # set flag so we won't do this table again
-        my ($tagID, $tagInfo);
-        foreach $tagID (keys %$table) {
-            next if $specialTags{$tagID};
-            # define tag ID in each element of conditional array
-            my @infoArray = GetTagInfoList($table,$tagID);
-            foreach $tagInfo (@infoArray) {
-                # define tag ID's in info hash
-                $$tagInfo{TagID} = $tagID;
-            }
-        }
-    }
-}
-
-#------------------------------------------------------------------------------
-# Generate TagID's for all loaded tables
-# Inputs: None
-# Notes: Causes subsequently loaded tables to automatically generate TagID's too
-sub GenerateAllTagIDs()
-{
-    unless ($didTagID) {
-        my $tableName;
-        foreach $tableName (keys %allTables) {
-            # generate tag ID's for all tags in this table
-            GenerateTagIDs($allTables{$tableName});
-        }
-        $didTagID = 1;
-    }
+# Set family 0 or 1 group name specific to this tag instance
+# Inputs: 0) ExifTool ref, 1) tag key, 2) group name, 3) family (default 1)
+sub SetGroup($$$;$)
+{
+    my ($self, $tagKey, $extra, $fam) = @_;
+    $self->{TAG_EXTRA}{$tagKey}{defined $fam ? "G$fam" : 'G1'} = $extra;
 }
 
 #------------------------------------------------------------------------------
 # Delete specified tag
-# Inputs: 0) reference to ExifTool object
-#         1) tag key
+# Inputs: 0) ExifTool object ref, 1) tag key
 sub DeleteTag($$)
 {
     my ($self, $tag) = @_;
-    delete $self->{VALUE}->{$tag};
-    delete $self->{FILE_ORDER}->{$tag};
-    delete $self->{TAG_INFO}->{$tag};
-    delete $self->{GROUP1}->{$tag};
+    delete $self->{VALUE}{$tag};
+    delete $self->{FILE_ORDER}{$tag};
+    delete $self->{TAG_INFO}{$tag};
+    delete $self->{TAG_EXTRA}{$tag};
+}
+
+#------------------------------------------------------------------------------
+# Escape all elements of a value
+# Inputs: 0) value, 1) escape proc
+sub DoEscape($$)
+{
+    my ($val, $key);
+    if (not ref $_[0]) {
+        $_[0] = &{$_[1]}($_[0]);
+    } elsif (ref $_[0] eq 'ARRAY') {
+        foreach $val (@{$_[0]}) {
+            DoEscape($val, $_[1]);
+        }
+    } elsif (ref $_[0] eq 'HASH') {
+        foreach $key (keys %{$_[0]}) {
+            DoEscape($_[0]{$key}, $_[1]);
+        }
+    }
 }
 
@@ -3994 +5837 @@
 # Inputs: 0) ExifTool object reference
 #         1) Optional file type (uses FILE_TYPE if not specified)
-sub SetFileType($;$)
-{
-    my $self = shift;
-    my $baseType = $self->{FILE_TYPE};
-    my $fileType = shift || $baseType;
-    my $mimeType = $mimeType{$fileType};
-    # use base file type if necessary (except if 'TIFF', which is a special case)
-    $mimeType = $mimeType{$baseType} unless $mimeType or $baseType eq 'TIFF';
-    $self->FoundTag('FileType', $fileType);
-    $self->FoundTag('MIMEType', $mimeType || 'application/unknown');
+#         2) Optional MIME type (uses our lookup if not specified)
+# Notes:  Will NOT set file type twice (subsequent calls ignored)
+sub SetFileType($;$$)
+{
+    my ($self, $fileType, $mimeType) = @_;
+    unless ($self->{VALUE}{FileType}) {
+        my $baseType = $self->{FILE_TYPE};
+        $fileType or $fileType = $baseType;
+        $mimeType or $mimeType = $mimeType{$fileType};
+        # use base file type if necessary (except if 'TIFF', which is a special case)
+        $mimeType = $mimeType{$baseType} unless $mimeType or $baseType eq 'TIFF';
+        $self->FoundTag('FileType', $fileType);
+        $self->FoundTag('MIMEType', $mimeType || 'application/unknown');
+    }
+}
+
+#------------------------------------------------------------------------------
+# Override the FileType and MIMEType tags
+# Inputs: 0) ExifTool object ref, 1) file type
+# Notes:  does nothing if FileType was not previously defined (ie. when writing)
+sub OverrideFileType($$)
+{
+    my ($self, $fileType) = @_;
+    if (defined $$self{VALUE}{FileType} and $fileType ne $$self{VALUE}{FileType}) {
+        $$self{VALUE}{FileType} = $fileType;
+        $$self{VALUE}{MIMEType} = $mimeType{$fileType} || 'application/unknown';
+        if ($$self{OPTIONS}{Verbose}) {
+            $self->VPrint(0,"$$self{INDENT}FileType [override] = $fileType\n");
+            $self->VPrint(0,"$$self{INDENT}MIMEType [override] = $$self{VALUE}{MIMEType}\n");
+        }
+    }
 }
 
@@ -4014 +5878 @@
     my ($self, $mime) = @_;
     $mime =~ m{/} or $mime = $mimeType{$mime} or return;
-    my $old = $self->{VALUE}->{MIMEType};
+    my $old = $self->{VALUE}{MIMEType};
     if (defined $old) {
         my ($a, $b) = split '/', $old;
         my ($c, $d) = split '/', $mime;
         $d =~ s/^x-//;
-        $self->{VALUE}->{MIMEType} = "$c/$b-$d";
+        $self->{VALUE}{MIMEType} = "$c/$b-$d";
         $self->VPrint(0, "  Modified MIMEType = $c/$b-$d\n");
     } else {
@@ -4033 +5897 @@
     my $self = shift;
     my $level = shift;
-    if ($self->{OPTIONS}->{Verbose} and $self->{OPTIONS}->{Verbose} > $level) {
-        my $out = $self->{OPTIONS}->{TextOut};
+    if ($self->{OPTIONS}{Verbose} and $self->{OPTIONS}{Verbose} > $level) {
+        my $out = $self->{OPTIONS}{TextOut};
         print $out @_;
     }
@@ -4046 +5910 @@
     my $self = shift;
     my $dataPt = shift;
-    if ($self->{OPTIONS}->{Verbose} and $self->{OPTIONS}->{Verbose} > 2) {
-        HexDump($dataPt, undef,
-            Out => $self->{OPTIONS}->{TextOut},
-            MaxLen => $self->{OPTIONS}->{Verbose} < 4 ? 96 : undef,
-            @_
+    if ($self->{OPTIONS}{Verbose} and $self->{OPTIONS}{Verbose} > 2) {
+        my %parms = (
+            Prefix => $self->{INDENT},
+            Out    => $self->{OPTIONS}{TextOut},
+            MaxLen => $self->{OPTIONS}{Verbose} < 4 ? 96 : undef,
         );
+        HexDump($dataPt, undef, %parms, @_);
     }
 }
@@ -4064 +5929 @@
 {
     my ($self, $offset, $length, $tag) = @_;
-
-    if ($tag and not $self->{OPTIONS}->{Binary} and
-        not $self->{REQ_TAG_LOOKUP}->{lc($tag)})
+    my ($isPreview, $buff);
+
+    if ($tag and $tag eq 'PreviewImage') {
+        # save PreviewImage start/length in case we want to dump trailer
+        $$self{PreviewImageStart} = $offset;
+        $$self{PreviewImageLength} = $length;
+        $isPreview = 1;
+    }
+    if ($tag and not $self->{OPTIONS}{Binary} and not $self->{OPTIONS}{Verbose} and
+        not $self->{REQ_TAG_LOOKUP}{lc($tag)})
     {
         return "Binary data $length bytes";
     }
-    my $buff;
     unless ($self->{RAF}->Seek($offset,0)
         and $self->{RAF}->Read($buff, $length) == $length)
     {
         $tag or $tag = 'binary data';
-        $self->Warn("Error reading $tag from file");
+        if ($isPreview and not $$self{BuildingComposite}) {
+            $$self{PreviewError} = 1;
+        } else {
+            $self->Warn("Error reading $tag from file", $isPreview);
+        }
         return undef;
     }
@@ -4083 +5958 @@
 #------------------------------------------------------------------------------
 # Process binary data
-# Inputs: 0) ExifTool object reference, 1) directory information reference
-#         2) tag table reference
+# Inputs: 0) ExifTool object ref, 1) directory information ref, 2) tag table ref
 # Returns: 1 on success
+# Notes: dirInfo may contain VarFormatData (reference to empty list) to return
+#        details about any variable-length-format tags in the table (used when writing)
 sub ProcessBinaryData($$$)
 {
@@ -4093 +5969 @@
     my $size = $$dirInfo{DirLen} || (length($$dataPt) - $offset);
     my $base = $$dirInfo{Base} || 0;
-    my $verbose = $self->{OPTIONS}->{Verbose};
-    my $unknown = $self->{OPTIONS}->{Unknown};
-    my $dataPos;
+    my $verbose = $self->{OPTIONS}{Verbose};
+    my $unknown = $self->{OPTIONS}{Unknown};
+    my $dataPos = $$dirInfo{DataPos} || 0;
 
     # get default format ('int8u' unless specified)
@@ -4110 +5986 @@
         # scan through entire binary table
         @tags = ($$tagTablePtr{FIRST_ENTRY}..(int($size/$increment) - 1));
+        # add in floating point tag ID's if they exist
+        my @ftags = grep /\./, TagTableKeys($tagTablePtr);
+        @tags = sort { $a <=> $b } @tags, @ftags if @ftags;
     } elsif ($$dirInfo{DataMember}) {
         @tags = @{$$dirInfo{DataMember}};
@@ -4117 +5996 @@
         @tags = sort { $a <=> $b } TagTableKeys($tagTablePtr);
     }
-    if ($verbose) {
-        $self->VerboseDir('BinaryData', undef, $size);
-        $dataPos = $$dirInfo{DataPos} || 0;
-    }
-    my $index;
+    $self->VerboseDir('BinaryData', undef, $size) if $verbose;
+    # avoid creating unknown tags for tags that fail condition if Unknown is 1
+    $$self{NO_UNKNOWN} = 1 if $unknown < 2;
+    my ($index, %val);
     my $nextIndex = 0;
-    my %val;
+    my $varSize = 0;
     foreach $index (@tags) {
-        my $tagInfo;
+        my ($tagInfo, $val, $saveNextIndex, $len, $mask, $wasVar);
         if ($$tagTablePtr{$index}) {
-            $tagInfo = $self->GetTagInfo($tagTablePtr, $index) or next;
+            $tagInfo = $self->GetTagInfo($tagTablePtr, $index);
+            unless ($tagInfo) {
+                next unless defined $tagInfo;
+                my $entry = int($index) * $increment + $varSize;
+                next if $entry >= $size;
+                my $more = $size - $entry;
+                $more = 128 if $more > 128;
+                my $v = substr($$dataPt, $entry+$offset, $more);
+                $tagInfo = $self->GetTagInfo($tagTablePtr, $index, \$v);
+                next unless $tagInfo;
+            }
             next if $$tagInfo{Unknown} and
                    ($$tagInfo{Unknown} > $unknown or $index < $nextIndex);
@@ -4137 +6025 @@
             $$tagInfo{Unknown} = 2;    # set unknown to 2 for binary unknowns
         }
+        # get relative offset of this entry
+        my $entry = int($index) * $increment + $varSize;
+        my $more = $size - $entry;
+        last if $more <= 0;     # all done if we have reached the end of data
         my $count = 1;
         my $format = $$tagInfo{Format};
-        my $entry = $index * $increment;        # relative offset of this entry
-        if ($format) {
+        if (not $format) {
+            $format = $defaultFormat;
+        } elsif ($format eq 'string') {
+            # string with no specified count runs to end of block
+            $count = $more;
+        } elsif ($format eq 'pstring') {
+            $format = 'string';
+            $count = Get8u($dataPt, ($entry++)+$offset);
+            --$more;
+        } elsif (not $formatSize{$format}) {
             if ($format =~ /(.*)\[(.*)\]/) {
+                # handle format count field
                 $format = $1;
                 $count = $2;
                 # evaluate count to allow count to be based on previous values
-                #### eval Format (%val, $size)
+                #### eval Format size (%val, $size, $self)
                 $count = eval $count;
                 $@ and warn("Format $$tagInfo{Name}: $@"), next;
                 next if $count < 0;
-            } elsif ($format eq 'string') {
-                # allow string with no specified count to run to end of block
-                $count = ($size > $entry) ? $size - $entry : 0;
-            }
-        } else {
-            $format = $defaultFormat;
+                # allow a variable-length of any format type (with base $count = 1)
+                if ($format =~ s/^var_//) {
+                    $varSize += ($count - 1) * ($formatSize{$format} || 1);
+                    # save variable size data if required for writing
+                    if ($$dirInfo{VarFormatData}) {
+                        push @{$$dirInfo{VarFormatData}}, $index, $varSize;
+                    }
+                }
+            } elsif ($format =~ /^var_/) {
+                # handle variable-length string formats
+                $format = substr($format, 4);
+                pos($$dataPt) = $entry + $offset;
+                undef $count;
+                if ($format eq 'ustring') {
+                    $count = pos($$dataPt) - ($entry+$offset) if $$dataPt =~ /\G(..)*?\0\0/sg;
+                    $varSize -= 2;  # ($count includes base size of 2 bytes)
+                } elsif ($format eq 'pstring') {
+                    $count = Get8u($dataPt, ($entry++)+$offset);
+                    --$more;
+                } elsif ($format eq 'pstr32') {
+                    last if $more < 4;
+                    $count = Get32u($dataPt, $entry + $offset);
+                    $entry += 4;
+                    $more -= 4;
+                } elsif ($format eq 'int16u') {
+                    # int16u size of binary data to follow
+                    last if $more < 2;
+                    $count = Get16u($dataPt, $entry + $offset) + 2;
+                    $varSize -= 2;  # ($count includes size word)
+                    $format = 'undef';
+                } elsif ($$dataPt =~ /\0/g) {
+                    $count = pos($$dataPt) - ($entry+$offset);
+                    --$varSize;     # ($count includes base size of 1 byte)
+                }
+                $count = $more if not defined $count or $count > $more;
+                $varSize += $count; # shift subsequent indices
+                $val = substr($$dataPt, $entry+$offset, $count);
+                $val = $self->Decode($val, 'UCS2') if $format eq 'ustring';
+                $val =~ s/\0.*//s unless $format eq 'undef';  # truncate at null
+                $wasVar = 1;
+                # save variable size data if required for writing
+                if ($$dirInfo{VarFormatData}) {
+                    push @{$$dirInfo{VarFormatData}}, $index, $varSize;
+                }
+            }
+        }
+        # hook to allow format, etc to be set dynamically
+        if (defined $$tagInfo{Hook}) {
+            #### eval Hook ($format, $varSize)
+            eval $$tagInfo{Hook};
+            # save variable size data if required for writing (in case changed by Hook)
+            if ($$dirInfo{VarFormatData}) {
+                $#{$$dirInfo{VarFormatData}} -= 2 if $wasVar; # remove previous entries for this tag
+                push @{$$dirInfo{VarFormatData}}, $index, $varSize;
+            }
         }
         if ($unknown > 1) {
             # calculate next valid index for unknown tag
-            my $ni = $index + ($formatSize{$format} * $count) / $increment;
+            my $ni = int $index;
+            $ni += (($formatSize{$format} || 1) * $count) / $increment unless $wasVar;
+            $saveNextIndex = $nextIndex;
             $nextIndex = $ni unless $nextIndex > $ni;
         }
-        my $val = ReadValue($dataPt, $entry+$offset, $format, $count, $size-$entry);
-        next unless defined $val;
-        if ($verbose) {
-            my $len = $count * ($formatSize{$format} || 1);
-            $len > $size - $entry and $len = $size - $entry;
+        # read value now if necessary
+        unless (defined $val and not $$tagInfo{SubDirectory}) {
+            $val = ReadValue($dataPt, $entry+$offset, $format, $count, $more);
+            $mask = $$tagInfo{Mask};
+            $val &= $mask if $mask;
+        }
+        if ($verbose and not $$tagInfo{Hidden}) {
+            if (not $$tagInfo{SubDirectory} or $$tagInfo{Format}) {
+                $len = $count * ($formatSize{$format} || 1);
+                $len = $more if $len > $more;
+            } else {
+                $len = $more;
+            }
             $self->VerboseInfo($index, $tagInfo,
                 Table  => $tagTablePtr,
@@ -4175 +6135 @@
                 Format => $format,
                 Count  => $count,
+                Extra  => $mask ? sprintf(', mask 0x%.2x',$mask) : undef,
             );
         }
-        $val += $base + $$self{BASE} if $$tagInfo{IsOffset};
+        # parse nested BinaryData directories
+        if ($$tagInfo{SubDirectory}) {
+            my $subTablePtr = GetTagTable($tagInfo->{SubDirectory}{TagTable});
+            # use specified subdirectory length if given
+            if ($$tagInfo{Format} and $formatSize{$format}) {
+                $len = $count * $formatSize{$format};
+                $len = $more if $len > $more;
+            } else {
+                $len = $more;
+                if ($$subTablePtr{PROCESS_PROC} and
+                    $$subTablePtr{PROCESS_PROC} eq \&ProcessBinaryData)
+                {
+                    # the rest of the data will be printed in the subdirectory
+                    $nextIndex = $size / $increment;
+                }
+            }
+            my %subdirInfo = (
+                DataPt   => $dataPt,
+                DataPos  => $dataPos,
+                DirStart => $entry + $offset,
+                DirLen   => $len,
+                Base     => $base,
+            );
+            $self->ProcessDirectory(\%subdirInfo, $subTablePtr);
+            next;
+        }
+        if ($$tagInfo{IsOffset} and $$tagInfo{IsOffset} ne '3') {
+            my $exifTool = $self;
+            #### eval IsOffset ($val, $exifTool)
+            $val += $base + $$self{BASE} if eval $$tagInfo{IsOffset};
+        }
         $val{$index} = $val;
-        $self->FoundTag($tagInfo,$val);
-    }
+        unless ($self->FoundTag($tagInfo,$val)) {
+            # don't increment nextIndex if we didn't extract a tag
+            $nextIndex = $saveNextIndex if defined $saveNextIndex;
+        }
+    }
+    delete $$self{NO_UNKNOWN};
     return 1;
 }
 
 #..............................................................................
-# Load .ExifTool_config file from user's home directory (unless 'noConfig' set)
-unless ($Image::ExifTool::noConfig) {
-    my $config = '.ExifTool_config';
-    # get our home directory (HOMEDRIVE and HOMEPATH are used in Windows cmd shell)
-    my $home = $ENV{EXIFTOOL_HOME} || $ENV{HOME} ||
-               ($ENV{HOMEDRIVE} || '') . ($ENV{HOMEPATH} || '') || '.';
-    # look for the config file in 1) the home directory, 2) the program dir
-    my $file = "$home/$config";
-    -r $file or $file = ($0 =~ /(.*[\\\/])/ ? $1 : './') . $config;
-    if (-r $file) {
-        eval "require '$file'"; # load the config file
-        # print warning (minus "Compilation failed" part)
-        $@ and $_=$@, s/Compilation failed.*//s, warn $_;
-    }
+# Load .ExifTool_config file from user's home directory
+# (use of noConfig is now deprecated, use configFile = '' instead)
+until ($Image::ExifTool::noConfig) {
+    my $file = $Image::ExifTool::configFile;
+    if (not defined $file) {
+        my $config = '.ExifTool_config';
+        # get our home directory (HOMEDRIVE and HOMEPATH are used in Windows cmd shell)
+        my $home = $ENV{EXIFTOOL_HOME} || $ENV{HOME} ||
+                   ($ENV{HOMEDRIVE} || '') . ($ENV{HOMEPATH} || '') || '.';
+        # look for the config file in 1) the home directory, 2) the program dir
+        $file = "$home/$config";
+        -r $file or $file = ($0 =~ /(.*[\\\/])/ ? $1 : './') . $config;
+        -r $file or last;
+    } else {
+        length $file or last;   # filename of "" disables configuration
+        -r $file or warn("Config file not found\n"), last;
+    }
+    eval "require '$file'"; # load the config file
+    # print warning (minus "Compilation failed" part)
+    $@ and $_=$@, s/Compilation failed.*//s, warn $_;
+    if (@Image::ExifTool::UserDefined::Lenses) {
+        foreach (@Image::ExifTool::UserDefined::Lenses) {
+            $Image::ExifTool::userLens{$_} = 1;
+        }
+    }
+    last;
 }