exiftool_vendored 9.37.0 → 9.41.0

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

@@ -19,6 +19,7 @@
 #               12) Jos Roost private communication (A580)
 #               13) http://www.mi-fo.de/forum/index.php?showtopic=33239
 #                   http://www.dyxum.com/dforum/the-alpha-shutter-count-tool_topic97489_page4.html
+#               14) Iliah Borg private communication
 #               JD) Jens Duttke private communication
 #------------------------------------------------------------------------------
 
@@ -30,7 +31,7 @@ use Image::ExifTool qw(:DataAccess :Utils);
 use Image::ExifTool::Exif;
 use Image::ExifTool::Minolta;
 
-$VERSION = '1.93';
+$VERSION = '1.96';
 
 sub ProcessSRF($$$);
 sub ProcessSR2($$$);
@@ -53,7 +54,12 @@ sub MakeTiffHeader($$$$;$);
 my %sonyLensTypes2 = (
     Notes => 'Lens type numbers for Sony E-Mount lenses used by NEX models.',
     0 => 'Unknown E-Mount lens or other lens',
-    1 => 'A-Mount lens',
+    1 => 'Sony LA-EA1 Adapter',
+    2 => 'Sony LA-EA2 Adapter',
+    3 => 'Sony LA-EA3 Adapter', #(NC) ILCE-7 image with A-mount lens, but also has 0x940e 2nd byte=2
+    6 => 'Sony LA-EA4 Adapter', #(NC) ILCE-7R image with A-mount lens and having phase-detect info blocks in 0x940e AFInfo
+    44 => 'Metabones Canon EF Smart Adapter', # (NC) ILCE-7R with Zeiss Otus 55mm F1.4 ZE via Metabones Smart Adapter
+    239 => 'Metabones Canon EF Speed Booster',# 12
     32784 => 'Sony E 16mm F2.8',
     32785 => 'Sony E 18-55mm F3.5-5.6 OSS',
     32786 => 'Sony E 55-210mm F4.5-6.3 OSS',
@@ -64,11 +70,16 @@ my %sonyLensTypes2 = (
     32791 => 'Sony E 16-70mm F4 ZA OSS',
     32792 => 'Sony E 10-18mm F4 OSS',
     32793 => 'Sony E PZ 16-50mm F3.5-5.6 OSS',
+    32794 => 'Sony FE 35mm F2.8 ZA',
+    32795 => 'Sony FE 24-70mm F4 ZA OSS',
     32797 => 'Sony E 18-200mm F3.5-6.3 OSS LE',
     32798 => 'Sony E 20mm F2.8',
     32799 => 'Sony E 35mm F1.8 OSS',
     32807 => 'Sony E PZ 18-200mm F3.5-6.3 OSS',
+    32808 => 'Sony FE 55mm F1.8 ZA',
+    32813 => 'Sony FE 28-70mm F3.5-5.6 OSS',
 #    32xxx => 'Sony E PZ 18-105mm F4 G OSS',
+#    32xxx => 'Sony FE 70-200mm F4 G OSS',
 );
 
 # ExposureProgram values (ref PH, mainly decoded from A200)
@@ -634,6 +645,8 @@ my %unknownCipherData = (
             1 => 'Low',
             2 => 'Mid',
             3 => 'High',
+            # 0x10001 - seen (ref 12)
+            # 0x10002 - seen for landscape and portrait flash (ref 12)
             0xffffffff => 'n/a', # (A35)
         },
     },
@@ -689,6 +702,10 @@ my %unknownCipherData = (
         Name => 'Tag2010f', # ?
         Condition => '$$self{Model} =~ /^(DSC-(RX100M2|QX10|QX100))$/',
         SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag2010f' },
+    },{
+        Name => 'Tag2010g', # ?
+        Condition => '$$self{Model} =~ /^(DSC-RX10|ILCE-7|ILCE-7R)\b/',
+        SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag2010g' },
     },{
         Name => 'Tag_0x2010',
         %unknownCipherData,
@@ -774,6 +791,7 @@ my %unknownCipherData = (
                 0 => 'Multi',
                 1 => 'Center',
                 3 => 'Flexible Spot',
+                11 => 'Zone', #12 (NC)
             },
         },
     ],
@@ -796,7 +814,7 @@ my %unknownCipherData = (
         Writable => 'int8u',
         PrintConvColumns => 2,
         PrintConv => {
-            0 => 'Auto', # (NC)
+            0 => 'Auto', # (NC) (always 0 for NEX/ILCE unless AFAreaModeSetting is Zone, ref 12)
             1 => 'Center',
             2 => 'Top',
             3 => 'Upper-right',
@@ -853,6 +871,8 @@ my %unknownCipherData = (
     # 0x0a (e) for SLT-A37/A57/A65V/A77V, NEX-F3/5N/5R/5T/6/7/VG20E, DSC-RX100/RX1/RX1R/HX10V/HX20V/HX30V/HX200V/TX200V/TX300V/TX66/WX50/WX100/WX150
     # 0x0c (e) for ILCE-3000, NEX-3N, SLT-A58, DSC-HX50V/HX300/RX100M2/TX30/WX60/WX80/WX200/WX300, DSC-QX10/QX100
     # 0xd0 (e) H90, W650, W690: tag9400 decoding appears not valid/different
+    # 0x23 (e) for DSC-RX10, ILCE-7/7R
+    # first byte decoded: 40, 204, 202, 27, 58, 62 respectively
     {
         Name => 'Tag9400a',
         Condition => q{
@@ -864,6 +884,10 @@ my %unknownCipherData = (
         Name => 'Tag9400b',
         Condition => '$$valPt =~ /^\x0c/',
         SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag9400b' },
+    },{
+        Name => 'Tag9400c',
+        Condition => '$$valPt =~ /^\x23/',
+        SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag9400c' },
     },{
         Name => 'Sony_0x9400',
         %unknownCipherData,
@@ -894,7 +918,8 @@ my %unknownCipherData = (
         #   38 00 32 0e    0x09fc    (l)  SLT-A58, ILCE-3000, NEX-3N, DSC-HX300/HX50V/WX200/WX300/WX60/WX80/TX30
         #   3a 10 3a 0e    0x0a01    (m)  DSC-QX10/QX100
         #   3a 20 47 0e    0x0a01    (m)  DSC-RX100M2
-        # 
+        #   43 00 66 0e    0x0a1b    (n)  ILCE-7/7R, DSC-RX10
+        #
         # 0x0004 - (RX100: 0 or 1. subsequent data valid only if 1 - PH)
         # 0x0007 => {
         #     Name => 'DynamicRangeOptimizer_9401',
@@ -913,9 +938,16 @@ my %unknownCipherData = (
     },
     0x9402 => [{
         Name => 'Tag9402',
-        # only valid for some models:
-        # - first byte must be 0x0f, 0x10 or 0x11 (enciphered 0x8a, 0x70 or 0xb6)
-        Condition => '$$self{DoubleCipher} ? $$valPt =~ /^[\x7e\x46\x1d]/ : $$valPt =~ /^[\x8a\x70\xb6]/',
+        # first 2 bytes deciphered:
+        #   0x00      0x00     SLT-A37/A57/A65/A77
+        #   0x0e      0x00     DSC-HX9V generation
+        #   0x0f      0x01     NEX-5N/7/VG20
+        #   0x10      0x01     DSC-RX100 etc., ILCE-3000, NEX-3N/5R/5T/6/VG30/VG900
+        #   0x11      0x01     DSC-RX100M2/QX10/QX100
+        #   0x12,0x13 0x01     DSC-RX10, ILCE-7/7R
+        #   var       var      SLT-A58/A99V
+        # only valid when first byte 0x0f, 0x10, 0x11, 0x12, 0x13 (enciphered 0x8a, 0x70, 0xb6, 0x69, 0x88)
+        Condition => '$$self{DoubleCipher} ? $$valPt =~ /^[\x7e\x46\x1d\x18\x3a]\x01/ : $$valPt =~ /^[\x8a\x70\xb6\x69\x88]\x01/',
         SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag9402' },
     },{
         Name => 'Sony_0x9402',
@@ -934,10 +966,25 @@ my %unknownCipherData = (
         Name => 'Sony_0x9404',
         %unknownCipherData,
     },
-    0x9405 => {
-        Name => 'Tag9405',
-        SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag9405' },
-    },
+    # 0x9405 first 2 bytes:
+    # SLT, DSC-RX100/RX1, NEX, ILCE-3000  3   0  (0x1b = 27 0 enc.)
+    # DSC-RX1R                            4   0  (0x40 = 64 0 enc.)
+    # DSC-RX100M2                         5   0  (0x7d = 125 0 enc.)
+    # DSC-RX10, ILCE-7/7R               136 var  (0x3a = 58 var enc.)
+    0x9405 => [{
+        Name => 'Tag9405a',
+        # first byte must be 0x1b
+        Condition => '$$valPt =~ /^\x1b/',
+        SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag9405a' },
+    },{
+        Name => 'Tag9405b',
+        # first byte must be 0x3a
+        Condition => '$$valPt =~ /^\x3a/',
+        SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag9405b' },
+    },{
+        Name => 'Sony_0x9405',
+        %unknownCipherData,
+    }],
     0x9406 => [{
         Name => 'Tag9406',
         # - first byte must be 0x01 or 0x02 (enciphered 0x01 or 0x08) and
@@ -973,14 +1020,21 @@ my %unknownCipherData = (
         Name => 'Sony_0x940b',
         %unknownCipherData,
     },
-    0x940c => {
+    0x940c => [{
+        Name => 'Tag940c',
+        Condition => '$$self{Model} !~ /^(SLT-|DSC-)\b/',
+        SubDirectory => { TagTable => 'Image::ExifTool::Sony::Tag940c' },
+    },{
         Name => 'Sony_0x940c',
         %unknownCipherData,
-    },
+    }],
     0x940d => {
         Name => 'Sony_0x940d',
         %unknownCipherData,
     },
+# 0x940e: 2nd byte = 0: no AFInfo, default for NEX
+#         2nd byte = 1: AFInfo for SLT models (also see 1 for DSC-HX20W/WX70)
+#         2nd byte = 2: AFInfo for NEX/ILCE with LA-EA2 Phase-detect AF Adapter
     0x940e => [{
         Name => 'AFInfo',
         Condition => '$$self{Model} =~ /^SLT-/',
@@ -1069,9 +1123,12 @@ my %unknownCipherData = (
             302 => 'ILCE-3000', #12
             303 => 'SLT-A58', #12
             305 => 'NEX-3N', #PH
+            306 => 'ILCE-7', #12
             307 => 'NEX-5T', #12
             308 => 'DSC-RX100M2', #12
+            309 => 'DSC-RX10', #12
             310 => 'DSC-RX1R', #12
+            311 => 'ILCE-7R', #12
         },
     },
     0xb020 => { #2
@@ -1276,7 +1333,7 @@ my %unknownCipherData = (
         # these models give FocusMode in tag 0xb04e, and are excluded here.
         Condition => q{
             ($$self{TagB042} = Get16u($valPt, 0)) and
-            $$self{Model} !~ /^(DSC-HX(7V|9V|100V)|DSC-TX(10|20|55|100|100V)|DSC-WX(7|9|10|30)|HDR-CX(130E|160E|360E|560E|700E)|HDR-PJ(10E|30E))\b/
+            (not $$self{MetaVersion} or $$self{MetaVersion} ne 'DC7303320222000')
         },
         Notes => 'not valid for all models',
         Writable => 'int16u',
@@ -1289,28 +1346,12 @@ my %unknownCipherData = (
             65535 => 'n/a', #PH (A100), also for DSC-W690 panorama shots
         },
     },
-    0xb043 => [{ #12
-        Name => 'AFAreaMode',
-        # AFAreaMode for DSC-HX9V generation, having values that appear to be different from older models.
-        Writable => 'int16u',
-        Condition => '$$self{Model} =~ /^(DSC-HX(7V|9V|100V)|DSC-TX(10|20|55|100|100V)|DSC-WX(7|9|10|30)|HDR-CX(130E|160E|360E|560E|700E)|HDR-PJ(10E|30E))\b/',
-        Notes => 'DSC-HX9V generation cameras',
-        PrintConv => {
-            0 => 'Multi',
-            1 => 'Center',
-            2 => 'Spot', # (NC) seen for DSC-WX9
-            3 => 'Flexible Spot',
-            10 => 'Selective (for Miniature effect)', # seen for Miniature effect of DSC-WX30
-            14 => 'Tracking',
-            15 => 'Face Tracking',
-            255 => 'Manual',
-        },
-    },{ #9
+    0xb043 => [{ #9
         Name => 'AFAreaMode',
         # AFAreaMode only for older models;
         # exclude newest DSC models, which give AFAreaMode in Tag9402 0x0017 (ie. RX100 - PH)
         Writable => 'int16u',
-        Condition => '$$self{TagB042}', #12
+        Condition => 'not $$self{MetaVersion} or $$self{MetaVersion} ne "DC7303320222000"', #12
         RawConv => '$val == 65535 ? undef : $val',
         Notes => 'older models',
         PrintConv => {
@@ -1325,6 +1366,22 @@ my %unknownCipherData = (
             15 => 'Face Tracking', # (not set when in face detect mode and no faces detected)
             65535 => 'n/a', #PH (A100)
         },
+    },{ #12
+        Name => 'AFAreaMode',
+        # AFAreaMode for DSC-HX9V generation, having values that appear to be different from older models.
+        Writable => 'int16u',
+        Condition => '$$self{TagB042} and $$self{TagB042} != 0',
+        Notes => 'DSC-HX9V generation cameras',
+        PrintConv => {
+            0 => 'Multi',
+            1 => 'Center',
+            2 => 'Spot', # (NC) seen for DSC-WX9
+            3 => 'Flexible Spot',
+            10 => 'Selective (for Miniature effect)', # seen for Miniature effect of DSC-WX30
+            14 => 'Tracking',
+            15 => 'Face Tracking',
+            255 => 'Manual',
+        },
     }],
     0xb044 => { #9
         Name => 'AFIlluminator',
@@ -1424,10 +1481,7 @@ my %unknownCipherData = (
     # },
     0xb04e => { #PH (RX100)
         Name => 'FocusMode',
-        Condition => q{
-            not $$self{TagB042} or
-            $$self{Model} =~ /^(DSC-HX(7V|9V|100V)|DSC-TX(10|20|55|100|100V)|DSC-WX(7|9|10|30)|HDR-CX(130E|160E|360E|560E|700E)|HDR-PJ(10E|30E))\b/
-        }, #12
+        Condition => '$$self{MetaVersion} and $$self{MetaVersion} eq "DC7303320222000"', #12
         Notes => 'valid for DSC-HX9V generation and newer',
         Writable => 'int16u',
         PrintConv => {
@@ -1437,7 +1491,7 @@ my %unknownCipherData = (
             3 => 'AF-C',
             # 4 - seen for HDR-CX360E/CX700E
             5 => 'Semi-manual', #12 (HX9V)
-            6 => 'Direct Manual Focus',
+            6 => 'DMF', # "Direct Manual Focus"
         },
     },
     0xb04f => { #PH (TX1)
@@ -1868,9 +1922,9 @@ my %unknownCipherData = (
             TIFF image
         },
         ValueConv => sub {
-            my ($val, $exifTool) = @_;
+            my ($val, $et) = @_;
             return undef unless length $val >= 7200;
-            return \ "Binary data 7404 bytes" unless $exifTool->Options('Binary');
+            return \ "Binary data 7404 bytes" unless $et->Options('Binary');
             my @dat = unpack('v*', $val);
             # TIFF header for a 16-bit RGB 10dpi 40x30 image
             $val = MakeTiffHeader(40,30,3,16,10);
@@ -2203,6 +2257,14 @@ my %unknownCipherData = (
         PrintConv => '$val ? Image::ExifTool::Exif::PrintExposureTime($val) : "Bulb"',
         PrintConvInv => 'lc($val) eq "bulb" ? 0 : Image::ExifTool::Exif::ConvertFraction($val)',
     },
+    0x29 => { # value increase of 16 corresponds to doubling of FocalLength
+        Name => 'FocalLength2',
+        Condition => '$$self{Model} !~ /^(NEX-(3|5)|DSLR-(A450|A500|A550)$)/',
+        ValueConv => '10 * 2 ** (($val-28)/16)',
+        ValueConvInv => '$val>0 ? log($val/10)/log(2) * 16 + 28 : 0',
+        PrintConv => 'sprintf("%.1f mm",$val)',
+        PrintConvInv => '$val=~s/\s*mm$//; $val',
+    },
     0x2a => {
         Name => 'ExposureCompensation2',
         Condition => '$$self{Model} !~ /^(NEX-(3|5)|DSLR-(A450|A500|A550)$)/',
@@ -3080,6 +3142,7 @@ my %faceInfo = (
     GROUPS => { 0 => 'MakerNotes', 2 => 'Camera' },
     FORMAT => 'int8u',
     PRIORITY => 0,
+    DATAMEMBER => [ 0x99 ],
     NOTES => q{
         Camera settings for models such as the A33, A35, A55, A450, A500, A550,
         A560, A580, NEX-3, NEX-5, NEX-C3 and NEX-VG10E.
@@ -3523,6 +3586,8 @@ my %faceInfo = (
     0x99 => { #12
         Name => 'LensMount',
         Condition => '$$self{Model} !~ /^DSLR-(A450|A500|A550)$/',
+        DataMember => 'LensMount',
+        RawConv => '$$self{LensMount} = $val',
         PrintConv => {
             1  => 'Unknown',
             16 => 'A-Mount',
@@ -3658,7 +3723,7 @@ my %faceInfo = (
     },
     0x3f7 => { #12
         Name => 'LensType2',
-        Condition => '$$self{Model} =~ /^NEX-/',
+        Condition => '($$self{Model} =~ /^NEX-/) and ($$self{LensMount} != 1)',
         Format => 'int16u',
         SeparateTable => 1,
         PrintConv => \%sonyLensTypes2,
@@ -3860,6 +3925,7 @@ my %faceInfo = (
     #     240 for DSLR
     0x0011 => {
         Name => 'ImageStabilization',
+        Condition => '$$self{Model} !~ /^(NEX-(3|5|5C|C3|VG10|VG10E))\b/',
         # usually matches 0xb026 ImageStabilization, except some images with SelfTimer and on tripod
         PrintConv => {
             0 => 'Off',
@@ -3959,7 +4025,7 @@ my %faceInfo = (
 %Image::ExifTool::Sony::ShotInfo = (
     %binaryDataAttrs,
     GROUPS => { 0 => 'MakerNotes', 2 => 'Image' },
-    DATAMEMBER => [ 0x02, 0x30, 0x32 ],
+    DATAMEMBER => [ 0x02, 0x30, 0x32, 0x34 ],
     IS_SUBDIR => [ 0x48, 0x5e ],
     # 0x00 - byte order 'II'
     0x02 => {
@@ -3998,12 +4064,16 @@ my %faceInfo = (
         Writable => 0,
         RawConv => '$$self{FaceInfoLength} = $val',
     },
-    #0x34 => {
-    #    # values: 'DC5303320222000', 'DC6303320222000' or 'DC7303320222000'
-    #    Name => 'UnknownString',
-    #    Format => 'string[16]',
-    #    Unknown => 1,
-    #},
+    0x34 => {
+        # oldest/other DSC/other        -
+        # older DSC models              "DC5303320222000" or "DC6303320222000"
+        # DSC-W650/W690/W730            "THm101000000000" or "THm211000000000"
+        # DSC-HX9V generation and newer "DC7303320222000"
+        Name => 'MetaVersion', # (tentative)
+        Format => 'string[16]',
+        DataMember => 'MetaVersion',
+        RawConv => '$$self{MetaVersion} = $val',
+    },
     0x48 => { # (most models: DC5303320222000 and DC6303320222000)
         Name => 'FaceInfo1',
         Condition => q{
@@ -4060,6 +4130,7 @@ my %releaseMode2 = ( #12
         17 => 'Continuous - Burst 2', # (WX7 - PH) (#12 9400-SequenceLength=10 shots)
         19 => 'Continuous - Speed/Advance Priority', #PH/12 (RX100)
         20 => 'Continuous - Multi Frame NR',
+        23 => 'Single-frame - Exposure Bracketing', # (NC, seen for ILCE-7)
         26 => 'Continuous Low', #PH (A77)
         27 => 'Continuous - High Sensitivity',  # seen for DSC-WX60 and WX300
         28 => 'Smile Shutter', #PH (RX100)
@@ -4429,6 +4500,30 @@ my %exposureProgram2010 = (
     #0x1930 => { Name => 'SonyImageHeight', Format => 'int16u' },
 );
 
+%Image::ExifTool::Sony::Tag2010g = ( #12
+    PROCESS_PROC => \&ProcessEnciphered,
+    WRITE_PROC => \&WriteEnciphered,
+    CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
+    FORMAT => 'int8u',
+    NOTES => 'Valid for DSC-RX10, ILCE-7/7R.',
+    WRITABLE => 1,
+    FIRST_ENTRY => 0,
+    GROUPS => { 0 => 'MakerNotes', 2 => 'Image' },
+    0x0004 => { %releaseMode2, Format => 'int32u' }, # NOT at offset 0x08 !
+    0x020c => { %releaseMode2010 },
+    0x0210 => { %releaseMode2 },
+    0x0222 => { %gain2010 },
+    0x0224 => { %brightnessValue2010 },
+    0x0228 => { %dynamicRangeOptimizer2010 },
+    0x022c => { %hdr2010 },
+    0x0230 => { %exposureComp2010 },
+    0x024b => { %effect2010 },
+    0x0258 => { %quality2010 },
+    0x025c => { %meteringMode2010 },
+    0x025d => { %exposureProgram2010 },
+    0x0264 => { Name => 'WB_RGBLevels', Format => 'int16u[3]' },
+);
+
 %Image::ExifTool::Sony::Tag900b = ( #12
     PROCESS_PROC => \&ProcessEnciphered,
     WRITE_PROC => \&WriteEnciphered,
@@ -4520,6 +4615,7 @@ my %exposureProgram2010 = (
     # 0x0104 - same as 0x0105, but has value 3 for DT 18-135mm and for 70-400mm G II: meaning ??
     0x0105 => {
         Name => 'LensMount',
+        DataMember => 'LensMount',
         RawConv => '$$self{LensMount} = $val; $$self{Model} =~ /^DSC-/ ? undef : $val',
         PrintConv => {
             0 => 'Unknown',
@@ -4742,6 +4838,76 @@ my %exposureProgram2010 = (
     },
 );
 
+%Image::ExifTool::Sony::Tag9400c = ( #12
+    PROCESS_PROC => \&ProcessEnciphered,
+    WRITE_PROC => \&WriteEnciphered,
+    CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
+    FORMAT => 'int8u',
+    WRITABLE => 1,
+    NOTES => 'Valid for DSC-RX10, ILCE-7/7R.',
+    FIRST_ENTRY => 0,
+    GROUPS => { 0 => 'MakerNotes', 2 => 'Image' },
+    0x0009 => { %releaseMode2 },
+    0x000a => {
+        Name => 'ShotNumberSincePowerUp',
+        Format => 'int32u',
+    },
+    0x0012 => { %sequenceImageNumber }, # or sequenceFileNumber ?
+    0x0016 => {
+        Name => 'SequenceLength',
+        PrintConv => {
+            0 => 'Continuous',
+            1 => '1 shot',
+            2 => '2 shots',
+            3 => '3 shots',
+            4 => '4 shots',
+            5 => '5 shots',
+            6 => '6 shots',
+            10 => '10 shots',
+            100 => 'Continuous - iSweep Panorama',
+            200 => 'Continuous - Sweep Panorama',
+        },
+    },
+    0x001a => { %sequenceFileNumber },
+    0x001e => {
+        Name => 'SequenceLength',
+        PrintConv => {
+            0 => 'Continuous',
+            1 => '1 shot',
+            2 => '2 shots',
+            3 => '3 shots',
+            4 => '4 shots',
+            5 => '5 shots',
+            6 => '6 shots',
+            10 => '10 shots',
+            100 => 'Continuous - iSweep Panorama',
+            200 => 'Continuous - Sweep Panorama',
+        },
+    },
+    0x0029 => {
+        Name => 'CameraOrientation',
+        PrintConv => {
+            1 => 'Horizontal (normal)',
+            3 => 'Rotate 180',
+            6 => 'Rotate 90 CW',
+            8 => 'Rotate 270 CW',
+        },
+    },
+    0x002a => {
+        Name => 'Quality2',
+        PrintConv => {
+            0 => 'JPEG',
+            1 => 'RAW',
+            2 => 'RAW + JPEG',
+            3 => 'JPEG + MPO', # 3D images
+        },
+    },
+    0x0047 => {
+        Name => 'SonyImageHeight',
+        Format => 'int16u',
+        PrintConv => '$val > 0 ? 8*$val : "n.a."',
+    },
+);
 
 # PH (RX100)
 %Image::ExifTool::Sony::Tag9402 = (
@@ -4767,6 +4933,18 @@ my %exposureProgram2010 = (
         PrintConv => '"$val C"',
         PrintConvInv => '$val=~s/ ?C//; $val',
     },
+    0x16 => { #12
+        Name => 'FocusMode',
+        Mask => 0x7f, # (often +128, not sure what upper bit is for)
+        PrintConv => {
+            0 => 'Manual',
+            2 => 'AF-S',
+            3 => 'AF-C',
+            # 4 => 'AF-A', # not for DSC, NEX, ILCE ...
+            6 => 'DMF',
+            # 7 => 'AF-D', # not for DSC, NEX, ILCE ...
+        },
+    },
     0x17 => {
         Name => 'AFAreaMode',
         PrintConv => {
@@ -4775,6 +4953,7 @@ my %exposureProgram2010 = (
             2 => 'Spot', # (NC) seen for DSC-WX300
             3 => 'Flexible Spot',
             10 => 'Selective (for Miniature effect)', # seen for DSC-HX30V,TX30,WX60,WX100
+            11 => 'Zone', #12 (NC) seen in ILCE-7R images
             14 => 'Tracking',
             15 => 'Face Tracking',
             255 => 'Manual',
@@ -4814,7 +4993,7 @@ my %exposureProgram2010 = (
 );
 
 # Tag9405 (ref 12)
-%Image::ExifTool::Sony::Tag9405 = (
+%Image::ExifTool::Sony::Tag9405a = (
     PROCESS_PROC => \&ProcessEnciphered,
     WRITE_PROC => \&WriteEnciphered,
     CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
@@ -4836,11 +5015,13 @@ my %exposureProgram2010 = (
     },
     0x0604 => {
         Name => 'LensMount',
+        DataMember => 'LensMount',
         RawConv => '$$self{LensMount} = $val; $$self{Model} =~ /^DSC-/ ? undef : $val',
         PrintConv => {
             0 => 'Unknown',
             1 => 'A-Mount',
             2 => 'E-mount',
+            # 6 - seen for A58 panorama image
         },
     },
     0x0605 => {
@@ -4861,6 +5042,53 @@ my %exposureProgram2010 = (
     },
 );
 
+%Image::ExifTool::Sony::Tag9405b = (
+    PROCESS_PROC => \&ProcessEnciphered,
+    WRITE_PROC => \&WriteEnciphered,
+    CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
+    FORMAT => 'int8u',
+    WRITABLE => 1,
+    FIRST_ENTRY => 0,
+    PRIORITY => 0,
+    DATAMEMBER => [ 0x005e ],
+    GROUPS => { 0 => 'MakerNotes', 2 => 'Image' },
+    0x005d => {
+        Name => 'LensFormat',
+        Condition => '$$self{Model} !~ /^DSC-/',
+        PrintConv => {
+            0 => 'Unknown',
+            1 => 'APS-C',
+            2 => 'Full-frame',
+        },
+    },
+    0x005e => {
+        Name => 'LensMount',
+        DataMember => 'LensMount',
+        RawConv => '$$self{LensMount} = $val; $$self{Model} =~ /^DSC-/ ? undef : $val',
+        PrintConv => {
+            0 => 'Unknown',
+            1 => 'A-Mount',
+            2 => 'E-mount',
+        },
+    },
+    0x0060 => {
+        Name => 'LensType2',
+        Condition => '$$self{LensMount} == 2',
+        Format => 'int16u',
+        Notes => 'E-Mount lenses',
+        SeparateTable => 1,
+        PrintConv => \%sonyLensTypes2,
+    },
+    0x0062 => {
+        Name => 'LensType',
+        Condition => '$$self{LensMount} == 1',
+        Format => 'int16u',
+        Notes => 'A-Mount lenses on SLT and NEX',
+        SeparateTable => 1,
+        PrintConv => \%sonyLensTypes,
+    },
+);
+
 # Tag9406 (ref 12)
 %Image::ExifTool::Sony::Tag9406 = (
     PROCESS_PROC => \&ProcessEnciphered,
@@ -4940,6 +5168,45 @@ my %exposureProgram2010 = (
     # 0xa6 - 8 bytes face detection info ?; starts with 1, otherwise all 0
 );
 
+# Tag940c (ref 12)
+%Image::ExifTool::Sony::Tag940c = (
+    PROCESS_PROC => \&ProcessEnciphered,
+    WRITE_PROC => \&WriteEnciphered,
+    CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
+    FORMAT => 'int8u',
+    WRITABLE => 1,
+    FIRST_ENTRY => 0,
+    GROUPS => { 0 => 'MakerNotes', 2 => 'Image' },
+    DATAMEMBER => [ 0x0008 ],
+
+    # 0x0008 - LensMount, but different values from Tag9405-0x0105 and Tag9050-0x0604.
+    # don't know what difference is between values '1' and '5' ...
+    0x0008 => {
+        Name => 'LensMount',
+        RawConv => '$$self{LensMount} = $val',
+        PrintConv => {
+            0 => 'Unknown',
+            1 => 'A-Mount (1)',
+            4 => 'E-mount',
+            5 => 'A-Mount (5)',
+        },
+    },
+    # 0x0009 - LensType2:
+    # This LensType2 tag gives values '1' and '2' for LA-EA1 and LA-EA2 respectively.
+    # Presumably similar to CameraSettings3-0x03f7, where value '1' for A-Mount lenses was observed.
+    # Tag9405-0x0605 and Tag9050-0x0107 always give value '0' for A-Mount lenses.
+    # When LA-EA2 is used, Tag940e AFInfo gives sequential info blocks NEX (Phase-detect AF).
+    # Also seen values '3' and '6' for A-lens on ILCE-7/7R, probably relating to LA-EA3 and LA-EA4 (NC).
+    0x0009 => { #12
+        Name => 'LensType2',
+        Condition => '$$self{LensMount} != 0',
+        Format => 'int16u',
+        SeparateTable => 1,
+        PrintConv => \%sonyLensTypes2,
+    },
+);
+
+
 # AFInfo (SLT models only) (ref PH, decoded mainly from A77)
 %Image::ExifTool::Sony::AFInfo = (
     PROCESS_PROC => \&ProcessEnciphered,
@@ -4959,7 +5226,9 @@ my %exposureProgram2010 = (
     #   0 1 1 0  for A37, A57, A58
     #   0 1 2 0  for A99V
     #   0 0 0 0  for NEX
-    #   0 2 0 0  for a NEX-6 image with A-mount lens via Phase-AF E-A adapter
+    #   2 0 0 0  for NEX
+    #   0 2 0 0  for NEX with A-mount lens via LA-EA2 Phase-AF adapter
+    #   2 2 0 0  for NEX with A-mount lens via LA-EA2 Phase-AF adapter
     0x02 => {
         Name => 'AFType',
         RawConv => '$$self{AFType} = $val',
@@ -4969,6 +5238,8 @@ my %exposureProgram2010 = (
             2 => '19-point',
         },
     },
+    # 0x0004 start 74 Blocks of 164 bytes each for NEX with LA-EA2 15-point Phase-detect AF adapter and A-Mount lens (ref 12).
+    # For the NEX probably only the 11th byte might be the AFPoint.
     0x07 => [ # the active AF sensor
         {
             Name => 'AFPoint',
@@ -5049,7 +5320,6 @@ my %exposureProgram2010 = (
             7 => 'AF-D', # (unique to A99)
         },
     },
-    # 0x014c start 56 Blocks of 164 bytes each for NEX with A-mount lens and Phase-AF adapter (ref 12)
     0x017d => { #PH (verified for the A77/A99; likely valid for other SLT models - ref 12)
         # (different from AFMicroAdjValue because it is 0 when the adjustment is off)
         Name => 'AFMicroAdj',
@@ -5225,12 +5495,12 @@ my %exposureProgram2010 = (
     0 => {
         Name => 'SRF2Key',
         Notes => 'key to decrypt maker notes from the start of SRF2',
-        RawConv => '$self->{SRF2Key} = $val',
+        RawConv => '$$self{SRF2Key} = $val',
     },
     1 => {
         Name => 'DataKey',
         Notes => 'key to decrypt the rest of the file from the end of the maker notes',
-        RawConv => '$self->{SRFDataKey} = $val',
+        RawConv => '$$self{SRFDataKey} = $val',
     },
     # SRF0 contains a single unknown tag with TagID 0x0003
 );
@@ -5323,6 +5593,10 @@ my %exposureProgram2010 = (
     SET_GROUP1 => 1, # set group1 name to directory name for all tags in table
     NOTES => 'Tags in the encrypted SR2SubIFD',
     0x7303 => 'WB_GRBGLevels', #1
+    0x7310 => 'BlackLevel', #14 (divide by 4)
+    0x7313 => 'WB_RGGBLevels', #6
+    0x74a0 => 'MaxApertureAtMaxFocal', #PH
+    0x74a1 => 'MaxApertureAtMinFocal', #PH
     0x74c0 => { #PH
         Name => 'SR2DataIFD',
         Groups => { 1 => 'SR2DataIFD' }, # (needed to set SubIFD DirName)
@@ -5333,15 +5607,22 @@ my %exposureProgram2010 = (
             MaxSubdirs => 20, # an A700 ARW has 14 of these! - PH
         },
     },
-    0x7313 => 'WB_RGGBLevels', #6
-    0x74a0 => 'MaxApertureAtMaxFocal', #PH
-    0x74a1 => 'MaxApertureAtMinFocal', #PH
-    0x7820 => 'WB_RGBLevelsDaylight', #6
-    0x7821 => 'WB_RGBLevelsCloudy', #6
+    0x7800 => 'ColorMatrix', #14 (divide by 1024)
+    0x7820 => 'WB_RGBLevelsDaylight', #6 (or 5300K, ref 14)
+    0x7821 => 'WB_RGBLevelsCloudy', #6 (or 6100K, ref 14)
     0x7822 => 'WB_RGBLevelsTungsten', #6
-    0x7825 => 'WB_RGBLevelsShade', #6
-    0x7826 => 'WB_RGBLevelsFluorescent', #6
-    0x7828 => 'WB_RGBLevelsFlash', #6
+    0x7823 => 'WB_RGBLevelsFlash', #14
+    0x7824 => 'WB_RGBLevels4500K', #14
+    0x7825 => 'WB_RGBLevelsShade', #6 (or 7500K, ref 14)
+    0x7826 => 'WB_RGBLevelsFluorescent', #6 (~4000K)
+    0x7827 => 'WB_RGBLevelsFluorescentP1', #14 (~5000K)
+    0x7828 => 'WB_RGBLevelsFluorescentP2', #14 (~6500K) (was Flash, ref 6)
+    0x7829 => 'WB_RGBLevelsFluorescentM1', #14 (~3500K)
+    0x782a => 'WB_RGBLevels8500K', #14
+    0x782b => 'WB_RGBLevels6000K', #14
+    0x782c => 'WB_RGBLevels3200K', #14
+    0x782d => 'WB_RGBLevels2500K', #14
+    0x787f => 'WhiteLevel', #14 (divide by 4)
 );
 
 %Image::ExifTool::Sony::SR2DataIFD = (
@@ -5515,7 +5796,9 @@ Image::ExifTool::AddCompositeTags('Image::ExifTool::Sony');
 {
     my $minoltaTypes = \%Image::ExifTool::Minolta::minoltaLensTypes;
     %sonyLensTypes = %$minoltaTypes;
+    my $other = $$minoltaTypes{OTHER};
     delete $$minoltaTypes{Notes};   # (temporarily)
+    delete $$minoltaTypes{OTHER};   # (temporarily)
     my $id;
     # 5-digit lens ID's are missing the last digit (usually "1") in the metadata for
     # some Sony models, so generate corresponding 4-digit entries for these cameras
@@ -5540,6 +5823,7 @@ Image::ExifTool::AddCompositeTags('Image::ExifTool::Sony');
         $sonyLensTypes{$sid} = $lens;
     }
     $$minoltaTypes{Notes} = $sonyLensTypes{Notes}; # (restore original Notes)
+    $$minoltaTypes{OTHER} = $other;
 }
 
 #------------------------------------------------------------------------------
@@ -5548,7 +5832,7 @@ Image::ExifTool::AddCompositeTags('Image::ExifTool::Sony');
 # Returns: 1
 sub ProcessSonyPIC($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart} || 0;
     my $len = $$dirInfo{DirLen} || (length($$dataPt) - $start);
@@ -5569,7 +5853,7 @@ sub ProcessSonyPIC($$$)
                 $$dirInfo{DirStart} = $start + 12;
                 $$dirInfo{DirLen} = $len - 12;
                 my $sonyTable = GetTagTable('Image::ExifTool::Sony::Main');
-                Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $sonyTable);
+                Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $sonyTable);
             }
         }
     }
@@ -5584,11 +5868,11 @@ sub ProcessSonyPIC($$$)
         next unless length $1 > 32;
         my ($tag, $val) = ('TextInfo' . (++$i), $1);
         $$tagTablePtr{$tag} or AddTagToTable($tagTablePtr, $tag, { Name => $tag, Binary => 1 });
-        $exifTool->HandleTag($tagTablePtr, $tag, $val);
+        $et->HandleTag($tagTablePtr, $tag, $val);
         # extract interesting tags separately (might want to speed this up)
         foreach $tag (sort { lc $a cmp lc $b } keys %$tagTablePtr) {
             next unless $tag =~ /:$/ and $val =~ /\b$tag\s*([^\s;,:]+)/;
-            $exifTool->HandleTag($tagTablePtr, $tag, $1);
+            $et->HandleTag($tagTablePtr, $tag, $1);
         }
     }
     return 1;
@@ -5668,7 +5952,7 @@ my @lensFeatures = (
     #  Mask   {  Bits     Name    Bits     Name  } Prefix flag
     # ------    ------    -----  ------    -----   -----------
     [ 0x4000, { 0x4000 => 'PZ'                   }, 1 ],
-    [ 0x0300, { 0x0100 => 'DT',  0x0300 => 'E'   }, 1 ], # (will come before preceding prefix)
+    [ 0x0300, { 0x0100 => 'DT',  0x0200 => 'FE', 0x0300 => 'E'   }, 1 ], # (will come before preceding prefix), FE added (ref 12)
     [ 0x000c, { 0x0004 => 'ZA',  0x0008 => 'G'   } ],
     [ 0x00e0, { 0x0020 => 'STF', 0x0040 => 'Reflex', 0x0060 => 'Macro', 0x0080 => 'Fisheye' } ],
     [ 0x0003, { 0x0001 => 'SSM', 0x0002 => 'SAM' } ],
@@ -5731,8 +6015,8 @@ sub PrintInvLensSpec($)
 # Returns: 1 on success when reading, or new directory when writing (IsWriting set)
 sub ProcessMoreInfo($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;    # allow dummy access to write routine
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;    # allow dummy access to write routine
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || length($$dataPt);
@@ -5744,18 +6028,18 @@ sub ProcessMoreInfo($$$)
     my $len = Get16u($dataPt, $start + 2);  # total data length
 
     if ($dirLen < 4 + $num * 4) {
-        $exifTool->Warn('Truncated MoreInfo data', 1);
+        $et->Warn('Truncated MoreInfo data', 1);
         return $rtnVal;
     }
     if ($num > 50) {
-        $exifTool->Warn('Possibly corrupted MoreInfo data', 1);
+        $et->Warn('Possibly corrupted MoreInfo data', 1);
         return $rtnVal;
     }
 
-    $exifTool->VerboseDir('MoreInfo', $num, $len) unless $isWriting;
+    $et->VerboseDir('MoreInfo', $num, $len) unless $isWriting;
 
     if ($len > $dirLen) {
-        $exifTool->Warn('MoreInfo data length too large', 1);
+        $et->Warn('MoreInfo data length too large', 1);
         $len = $dirLen;
     }
     # loop through the MoreInfo index section to get the block offsets and tag ID's
@@ -5766,7 +6050,7 @@ sub ProcessMoreInfo($$$)
         push @tagID, Get16u($dataPt, $entry);
         push @offset, Get16u($dataPt, $entry + 2);
         if ($offset[-1] > $len and $offset[-1] <= $dirLen) {
-            $exifTool->Warn('MoreInfo data length too small', 1);
+            $et->Warn('MoreInfo data length too small', 1);
             $len = $dirLen;
         }
     }
@@ -5789,7 +6073,7 @@ sub ProcessMoreInfo($$$)
     # initialize successful return value
     $rtnVal = $isWriting ? substr($$dataPt, $start, $dirLen) : 1;
     # now process each block
-    my $unknown = $exifTool->{OPTIONS}{Unknown};
+    my $unknown = $$et{OPTIONS}{Unknown};
     for ($i=0; $i<$num; ++$i) {
         next if $offset[$i] > $dirLen;  # ignore bad offsets
         my $tag = $tagID[$i];
@@ -5808,7 +6092,7 @@ sub ProcessMoreInfo($$$)
                 DirLen   => $size,
             );
             my $subTable = GetTagTable($$tagInfo{SubDirectory}{TagTable});
-            my $val = $exifTool->WriteDirectory(\%dirInfo, $subTable);
+            my $val = $et->WriteDirectory(\%dirInfo, $subTable);
             # update this block in the returned MoreInfo data
             substr($rtnVal, $offset, $size) = $val if defined $val;
             next;
@@ -5830,7 +6114,7 @@ sub ProcessMoreInfo($$$)
             );
             AddTagToTable($tagTablePtr, $tag, \%tagInfo);
         }
-        $exifTool->HandleTag($tagTablePtr, $tag, undef,
+        $et->HandleTag($tagTablePtr, $tag, undef,
             Index   => $i,
             DataPt  => $dataPt,
             DataPos => $$dirInfo{DataPos},
@@ -5847,24 +6131,24 @@ sub ProcessMoreInfo($$$)
 # Returns: 1 on success when reading, 0 if this isn't a valid PMP file
 sub ProcessPMP($$)
 {
-    my ($exifTool, $dirInfo) = @_;
+    my ($et, $dirInfo) = @_;
     my $raf = $$dirInfo{RAF};
     my $buff;
     $raf->Read($buff, 128) == 128 or return 0;
     # validate header length (124 bytes)
     $buff =~ /^.{8}\0{3}\x7c.{112}\xff\xd8\xff\xdb$/s or return 0;
-    $exifTool->SetFileType();
+    $et->SetFileType();
     SetByteOrder('MM');
-    $exifTool->FoundTag(Make => 'Sony');
-    $exifTool->FoundTag(Model => 'DSC-F1');
+    $et->FoundTag(Make => 'Sony');
+    $et->FoundTag(Model => 'DSC-F1');
     # extract information from 124-byte header
     my $tagTablePtr = GetTagTable('Image::ExifTool::Sony::PMP');
     my %dirInfo = ( DataPt => \$buff, DirName => 'PMP' );
-    $exifTool->ProcessDirectory(\%dirInfo, $tagTablePtr);
+    $et->ProcessDirectory(\%dirInfo, $tagTablePtr);
     # process JPEG image
     $raf->Seek(124, 0);
     $$dirInfo{Base} = 124;
-    $exifTool->ProcessJPEG($dirInfo);
+    $et->ProcessJPEG($dirInfo);
     return 1;
 }
 
@@ -5874,13 +6158,13 @@ sub ProcessPMP($$)
 # Returns: true if tag 0x14a is a SubIFD, false otherwise
 sub SetARW($$)
 {
-    my ($exifTool, $valPt) = @_;
+    my ($et, $valPt) = @_;
 
     # assume ARW for now -- SR2's get identified when FileFormat is parsed
-    $exifTool->OverrideFileType($$exifTool{TIFF_TYPE} = 'ARW');
+    $et->OverrideFileType($$et{TIFF_TYPE} = 'ARW');
 
     # this should always be a SubIFD for models other than the A100
-    return 1 unless $$exifTool{Model} eq 'DSLR-A100' and length $$valPt == 4;
+    return 1 unless $$et{Model} eq 'DSLR-A100' and length $$valPt == 4;
 
     # for the A100, IFD0 tag 0x14a is either a pointer to the raw data if this is
     # an original image, or a SubIFD offset if the image was edited by Sony IDC,
@@ -5889,7 +6173,7 @@ sub SetARW($$)
     my %subdir = (
         DirStart => Get32u($valPt, 0),
         Base     => 0,
-        RAF      => $$exifTool{RAF},
+        RAF      => $$et{RAF},
         AllowOutOfOrderTags => 1, # doh!
     );
     return Image::ExifTool::Exif::ValidateIFD(\%subdir);
@@ -5902,7 +6186,7 @@ sub SetARW($$)
 # Notes: (it turns that all of this is for the A100 only)
 sub FinishARW($$$$)
 {
-    my ($exifTool, $dirInfo, $dataPt, $imageData) = @_;
+    my ($et, $dirInfo, $dataPt, $imageData) = @_;
 
     # pre-scan IFD0 to get IFD entry offsets for each tag
     my $dataLen = length $$dataPt;
@@ -5915,9 +6199,9 @@ sub FinishARW($$$$)
         $entry{Get16u($dataPt, $entry)} = $entry;
     }
     # fix up SR2Private offset and A100DataOffset (A100 only)
-    if ($entry{0xc634} and $$exifTool{MRWDirData}) {
-        return 'Unexpected MRW block' unless $$exifTool{Model} eq 'DSLR-A100';
-        return 'Missing A100DataOffset' unless $entry{0x14a} and $$exifTool{A100DataOffset};
+    if ($entry{0xc634} and $$et{MRWDirData}) {
+        return 'Unexpected MRW block' unless $$et{Model} eq 'DSLR-A100';
+        return 'Missing A100DataOffset' unless $entry{0x14a} and $$et{A100DataOffset};
         # account for total length of image data
         my $totalLen = 8 + $dataLen;
         if (ref $imageData) {
@@ -5932,19 +6216,19 @@ sub FinishARW($$$$)
         # set offset for the MRW directory data
         Set32u($totalLen, $dataPt, $entry{0xc634} + 8);
         # also pad MRWDirData data to an even 4 bytes (just to be safe)
-        $remain = length($$exifTool{MRWDirData}) & 0x03;
-        $$exifTool{MRWDirData} .= "\0" x (4 - $remain) if $remain;
-        $totalLen += length $$exifTool{MRWDirData};
+        $remain = length($$et{MRWDirData}) & 0x03;
+        $$et{MRWDirData} .= "\0" x (4 - $remain) if $remain;
+        $totalLen += length $$et{MRWDirData};
         # fix up A100DataOffset
-        $dataOffset = $$exifTool{A100DataOffset};
+        $dataOffset = $$et{A100DataOffset};
         Set32u($totalLen, $dataPt, $entry{0x14a} + 8);
     }
     # patch double-referenced and incorrectly-sized A100 PreviewImage
-    if ($entry{0x201} and $$exifTool{A100PreviewStart} and
-        $entry{0x202} and $$exifTool{A100PreviewLength})
+    if ($entry{0x201} and $$et{A100PreviewStart} and
+        $entry{0x202} and $$et{A100PreviewLength})
     {
-        Set32u($$exifTool{A100PreviewStart}, $dataPt, $entry{0x201} + 8);
-        Set32u($$exifTool{A100PreviewLength}, $dataPt, $entry{0x202} + 8);
+        Set32u($$et{A100PreviewStart}, $dataPt, $entry{0x201} + 8);
+        Set32u($$et{A100PreviewLength}, $dataPt, $entry{0x202} + 8);
     }
     # write TIFF IFD structure
     my $outfile = $$dirInfo{OutFile};
@@ -5952,15 +6236,15 @@ sub FinishARW($$$$)
     Write($outfile, $header, $$dataPt) or return 'Error writing';
     # copy over image data
     if (ref $imageData) {
-        $exifTool->CopyImageData($imageData, $outfile) or return 'Error copying image data';
+        $et->CopyImageData($imageData, $outfile) or return 'Error copying image data';
     }
     # write MRW data if necessary
-    if ($$exifTool{MRWDirData}) {
+    if ($$et{MRWDirData}) {
         Write($outfile, "\0" x $pad) if $pad;   # write padding if necessary
-        Write($outfile, $$exifTool{MRWDirData});
-        delete $$exifTool{MRWDirData};
+        Write($outfile, $$et{MRWDirData});
+        delete $$et{MRWDirData};
         # set TIFF_END to copy over the MRW image data
-        $$exifTool{TIFF_END} = $dataOffset if $dataOffset;
+        $$et{TIFF_END} = $dataOffset if $dataOffset;
     }
     return undef;
 }
@@ -6020,7 +6304,7 @@ sub Decipher($;$)
 # 2) A bug in ExifTool 9.04-9.10 could have double-enciphered these blocks
 sub ProcessEnciphered($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
@@ -6032,20 +6316,20 @@ sub ProcessEnciphered($$$)
         DirStart => 0,
     );
     Decipher(\$data);
-    if ($$exifTool{DoubleCipher}) {
+    if ($$et{DoubleCipher}) {
         Decipher(\$data);
-        $exifTool->WarnOnce('Some Sony metadata is double-enciphered. Write any tag to fix',1);
+        $et->WarnOnce('Some Sony metadata is double-enciphered. Write any tag to fix',1);
     }
-    if ($exifTool->Options('Verbose') > 2) {
+    if ($et->Options('Verbose') > 2) {
         my $tagInfo = $$dirInfo{TagInfo} || { Name => 'data' };
-        my $str = $$exifTool{DoubleCipher} ? 'ouble-d' : '';
-        $exifTool->VerboseDir("D${str}eciphered $$tagInfo{Name}");
-        $exifTool->VerboseDump(\$data,
-            Prefix  => $exifTool->{INDENT} . '  ',
+        my $str = $$et{DoubleCipher} ? 'ouble-d' : '';
+        $et->VerboseDir("D${str}eciphered $$tagInfo{Name}");
+        $et->VerboseDump(\$data,
+            Prefix  => $$et{INDENT} . '  ',
             DataPos => $$dirInfo{DirStart} + $$dirInfo{DataPos} + ($$dirInfo{Base} || 0),
         );
     }
-    return $exifTool->ProcessBinaryData(\%dirInfo, $tagTablePtr);
+    return $et->ProcessBinaryData(\%dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -6054,19 +6338,19 @@ sub ProcessEnciphered($$$)
 # Returns: cipherdata block or undefined on error
 sub WriteEnciphered($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;
     my $dataPt = $$dirInfo{DataPt};
     my $dirStart = $$dirInfo{DirStart} || 0;
     my $dirLen = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
     my $data = substr($$dataPt, $dirStart, $dirLen);
-    my $changed = $$exifTool{CHANGED};
+    my $changed = $$et{CHANGED};
     Decipher(\$data);
     # fix double-enciphered data (due to bug in ExifTool 9.04-9.10)
-    if ($$exifTool{DoubleCipher}) {
+    if ($$et{DoubleCipher}) {
         Decipher(\$data);
-        ++$$exifTool{CHANGED};
-        $exifTool->WarnOnce('Fixed double-enciphered Sony metadata',1);
+        ++$$et{CHANGED};
+        $et->WarnOnce('Fixed double-enciphered Sony metadata',1);
     }
     my %dirInfo = (
         %$dirInfo,
@@ -6074,8 +6358,8 @@ sub WriteEnciphered($$$)
         DataPos => $$dirInfo{DataPos} + $dirStart,
         DirStart => 0,
     );
-    $data = $exifTool->WriteBinaryData(\%dirInfo, $tagTablePtr);
-    if ($changed == $$exifTool{CHANGED}) {
+    $data = $et->WriteBinaryData(\%dirInfo, $tagTablePtr);
+    if ($changed == $$et{CHANGED}) {
         # nothing changed, so recover original data
         $data = substr($$dataPt, $dirStart, $dirLen);
     } elsif (defined $data) {
@@ -6090,10 +6374,10 @@ sub WriteEnciphered($$$)
 # Returns: 1 on success
 sub ProcessSRF($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $dataPt = $$dirInfo{DataPt};
     my $start = $$dirInfo{DirStart};
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
 
     # process IFD chain
     my ($ifd, $success);
@@ -6106,9 +6390,9 @@ sub ProcessSRF($$$)
             $tagTablePtr = GetTagTable('Image::ExifTool::Exif::Main');
         }
         my $srf = $$dirInfo{DirName} = "SRF$ifd";
-        $exifTool->{SET_GROUP1} = $srf;
-        $success = Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
-        delete $exifTool->{SET_GROUP1};
+        $$et{SET_GROUP1} = $srf;
+        $success = Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $tagTablePtr);
+        delete $$et{SET_GROUP1};
         last unless $success;
 #
 # get pointer to next IFD
@@ -6133,7 +6417,7 @@ sub ProcessSRF($$$)
             $len = $cp + $nextIFD;  # decrypt up to $cp
         } elsif ($ifd == 2) {
             # get the key to decrypt IFD2
-            $key = $exifTool->{SRF2Key};
+            $key = $$et{SRF2Key};
             $len = length($$dataPt) - $nextIFD; # decrypt rest of maker notes
         } else {
             next;   # no decryption needed
@@ -6142,9 +6426,9 @@ sub ProcessSRF($$$)
         Decrypt($dataPt, $nextIFD, $len, $key) if defined $key;
         next unless $verbose > 2;
         # display decrypted data in verbose mode
-        $exifTool->VerboseDir("Decrypted SRF$ifd", 0, $nextIFD + $len);
-        $exifTool->VerboseDump($dataPt,
-            Prefix => "$exifTool->{INDENT}  ",
+        $et->VerboseDir("Decrypted SRF$ifd", 0, $nextIFD + $len);
+        $et->VerboseDump($dataPt,
+            Prefix => "$$et{INDENT}  ",
             Start => $nextIFD,
             DataPos => $$dirInfo{DataPos},
         );
@@ -6157,11 +6441,11 @@ sub ProcessSRF($$$)
 # Returns: 1 on success when reading, or SR2 directory or undef when writing
 sub WriteSR2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
-    $exifTool or return 1;      # allow dummy access
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    $et or return 1;      # allow dummy access
     my $buff = '';
     $$dirInfo{OutFile} = \$buff;
-    return ProcessSR2($exifTool, $dirInfo, $tagTablePtr);
+    return ProcessSR2($et, $dirInfo, $tagTablePtr);
 }
 
 #------------------------------------------------------------------------------
@@ -6170,7 +6454,7 @@ sub WriteSR2($$$)
 # Returns: 1 on success when reading, or SR2 directory or undef when writing
 sub ProcessSR2($$$)
 {
-    my ($exifTool, $dirInfo, $tagTablePtr) = @_;
+    my ($et, $dirInfo, $tagTablePtr) = @_;
     my $raf = $$dirInfo{RAF};
     my $dataPt = $$dirInfo{DataPt};
     my $dataPos = $$dirInfo{DataPos};
@@ -6179,9 +6463,9 @@ sub ProcessSR2($$$)
     my $outfile = $$dirInfo{OutFile};
 
     # clear SR2 member variables to be safe
-    delete $$exifTool{SR2SubIFDOffset};
-    delete $$exifTool{SR2SubIFDLength};
-    delete $$exifTool{SR2SubIFDKey};
+    delete $$et{SR2SubIFDOffset};
+    delete $$et{SR2SubIFDLength};
+    delete $$et{SR2SubIFDKey};
 
     # make sure we have the first 4 bytes available to test directory type
     my $buff;
@@ -6198,10 +6482,10 @@ sub ProcessSR2($$$)
     my $dataOffset;
     if ($dataPt and $$dataPt =~ /^\0MR[IM]/) {
         my ($err, $srfPos, $srfLen, $dataOffset);
-        $dataOffset = $$exifTool{A100DataOffset};
+        $dataOffset = $$et{A100DataOffset};
         if ($dataOffset) {
             # save information about the RAW data trailer so it will be preserved
-            $$exifTool{KnownTrailer} = { Name => 'A100 RAW Data', Start => $dataOffset };
+            $$et{KnownTrailer} = { Name => 'A100 RAW Data', Start => $dataOffset };
         } else {
             $err = 'A100DataOffset tag is missing from A100 ARW image';
         }
@@ -6214,44 +6498,44 @@ sub ProcessSR2($$$)
             }
         }
         if ($err) {
-            $outfile and $exifTool->Error($err), return undef;
-            $exifTool->Warn($err);
+            $outfile and $et->Error($err), return undef;
+            $et->Warn($err);
             return 0;
         }
         my %dirInfo = ( DataPt => \$buff );
         require Image::ExifTool::MinoltaRaw;
         if ($outfile) {
             # save MRW data to be written last
-            $$exifTool{MRWDirData} = Image::ExifTool::MinoltaRaw::WriteMRW($exifTool, \%dirInfo);
-            return $$exifTool{MRWDirData} ? "\0\0\0\0\0\0" : undef;
+            $$et{MRWDirData} = Image::ExifTool::MinoltaRaw::WriteMRW($et, \%dirInfo);
+            return $$et{MRWDirData} ? "\0\0\0\0\0\0" : undef;
         } else {
-            if (not $outfile and $$exifTool{HTML_DUMP}) {
-                $exifTool->HDump($srfPos, $srfLen, '[A100 SRF Data]');
+            if (not $outfile and $$et{HTML_DUMP}) {
+                $et->HDump($srfPos, $srfLen, '[A100 SRF Data]');
             }
-            return Image::ExifTool::MinoltaRaw::ProcessMRW($exifTool, \%dirInfo);
+            return Image::ExifTool::MinoltaRaw::ProcessMRW($et, \%dirInfo);
         }
-    } elsif ($$exifTool{A100DataOffset}) {
+    } elsif ($$et{A100DataOffset}) {
         my $err = 'Unexpected A100DataOffset tag';
-        $outfile and $exifTool->Error($err), return undef;
-        $exifTool->Warn($err);
+        $outfile and $et->Error($err), return undef;
+        $et->Warn($err);
         return 0;
     }
-    my $verbose = $exifTool->Options('Verbose');
+    my $verbose = $et->Options('Verbose');
     my $result;
     if ($outfile) {
-        $result = Image::ExifTool::Exif::WriteExif($exifTool, $dirInfo, $tagTablePtr);
+        $result = Image::ExifTool::Exif::WriteExif($et, $dirInfo, $tagTablePtr);
         return undef unless $result;
         $$outfile .= $result;
 
     } else {
-        $result = Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
+        $result = Image::ExifTool::Exif::ProcessExif($et, $dirInfo, $tagTablePtr);
     }
-    return $result unless $result and $$exifTool{SR2SubIFDOffset};
+    return $result unless $result and $$et{SR2SubIFDOffset};
     # only take first offset value if more than one!
-    my @offsets = split ' ', $exifTool->{SR2SubIFDOffset};
+    my @offsets = split ' ', $$et{SR2SubIFDOffset};
     my $offset = shift @offsets;
-    my $length = $exifTool->{SR2SubIFDLength};
-    my $key = $exifTool->{SR2SubIFDKey};
+    my $length = $$et{SR2SubIFDLength};
+    my $key = $$et{SR2SubIFDKey};
     my @subifdPos;
     if ($offset and $length and defined $key) {
         my $buff;
@@ -6265,8 +6549,8 @@ sub ProcessSR2($$$)
             Decrypt(\$buff, 0, $length, $key);
             # display decrypted data in verbose mode
             if ($verbose > 2 and not $outfile) {
-                $exifTool->VerboseDir("Decrypted SR2SubIFD", 0, $length);
-                $exifTool->VerboseDump(\$buff, Addr => $offset + $base);
+                $et->VerboseDir("Decrypted SR2SubIFD", 0, $length);
+                $et->VerboseDump(\$buff, Addr => $offset + $base);
             }
             my $num = '';
             my $dPos = $offset;
@@ -6283,16 +6567,16 @@ sub ProcessSR2($$$)
                 if ($outfile) {
                     my $fixup = new Image::ExifTool::Fixup;
                     $dirInfo{Fixup} = $fixup;
-                    $result = $exifTool->WriteDirectory(\%dirInfo, $subTable);
+                    $result = $et->WriteDirectory(\%dirInfo, $subTable);
                     return undef unless $result;
                     # save position of this SubIFD
                     push @subifdPos, length($$outfile);
                     # add this directory to the returned data
                     $$fixup{Start} += length($$outfile);
                     $$outfile .= $result;
-                    $dirInfo->{Fixup}->AddFixup($fixup);
+                    $$dirInfo{Fixup}->AddFixup($fixup);
                 } else {
-                    $result = $exifTool->ProcessDirectory(\%dirInfo, $subTable);
+                    $result = $et->ProcessDirectory(\%dirInfo, $subTable);
                 }
                 last unless @offsets;
                 $offset = shift @offsets;
@@ -6300,7 +6584,7 @@ sub ProcessSR2($$$)
             }
 
         } else {
-            $exifTool->Warn('Error reading SR2 data');
+            $et->Warn('Error reading SR2 data');
         }
     }
     if ($outfile and @subifdPos) {
@@ -6312,9 +6596,9 @@ sub ProcessSR2($$$)
             $$outfile .= ' ' x $pad;
         }
         # save the new SR2SubIFD Length and Key to be used later for encryption
-        $$exifTool{SR2SubIFDLength} = $sr2Len;
-        my $newKey = $$exifTool{VALUE}{SR2SubIFDKey};
-        $$exifTool{SR2SubIFDKey} = $newKey if defined $newKey;
+        $$et{SR2SubIFDLength} = $sr2Len;
+        my $newKey = $$et{VALUE}{SR2SubIFDKey};
+        $$et{SR2SubIFDKey} = $newKey if defined $newKey;
         # update SubIFD pointers manually and add to fixup, and set SR2SubIFDLength
         my $n = Get16u($outfile, 0);
         my ($i, %found);
@@ -6326,7 +6610,7 @@ sub ProcessSR2($$$)
             $found{$tagID} = 1;
             my $fmt = Get16u($outfile, $entry + 2);
             if ($fmt != 0x04) { # must be int32u
-                $exifTool->Error("Unexpected format ($fmt) for SR2SubIFD tag");
+                $et->Error("Unexpected format ($fmt) for SR2SubIFD tag");
                 return undef;
             }
             if ($tagID == 0x7201) { # SR2SubIFDLength
@@ -6338,13 +6622,13 @@ sub ProcessSR2($$$)
             my $pos;
             foreach $pos (@subifdPos) {
                 Set32u($pos, $outfile, $valuePtr);
-                $dirInfo->{Fixup}->AddFixup($valuePtr, $tag);
+                $$dirInfo{Fixup}->AddFixup($valuePtr, $tag);
                 undef $tag;
                 $valuePtr += 4;
             }
         }
         unless ($found{0x7200} and $found{0x7201}) {
-            $exifTool->Error('Missing SR2SubIFD tag');
+            $et->Error('Missing SR2SubIFD tag');
             return undef;
         }
     }