#------------------------------------------------------------------------------
# File: Sony.pm
#
# Description: Sony EXIF Maker Notes tags
#
# Revisions: 04/06/2004 - P. Harvey Created
#
# References: 1) http://www.cybercom.net/~dcoffin/dcraw/
# 2) http://homepage3.nifty.com/kamisaka/makernote/makernote_sony.htm (2006/08/06)
# 3) Thomas Bodenmann private communication
# 4) Philippe Devaux private communication (A700)
# 5) Marcus Holland-Moritz private communication (A700)
# JD) Jens Duttke private communication
#------------------------------------------------------------------------------
package Image::ExifTool::Sony;
use strict;
use vars qw($VERSION);
use Image::ExifTool qw(:DataAccess :Utils);
use Image::ExifTool::Exif;
use Image::ExifTool::Minolta;
$VERSION = '1.19';
sub ProcessSRF($$$);
sub ProcessSR2($$$);
my %sonyLensTypes; # filled in based on Minolta LensType's
%Image::ExifTool::Sony::Main = (
WRITE_PROC => \&Image::ExifTool::Exif::WriteExif,
CHECK_PROC => \&Image::ExifTool::Exif::CheckExif,
GROUPS => { 0 => 'MakerNotes', 2 => 'Camera' },
0x0e00 => {
Name => 'PrintIM',
Description => 'Print Image Matching',
SubDirectory => {
TagTable => 'Image::ExifTool::PrintIM::Main',
},
},
0x0102 => { #5/JD
Name => 'Quality',
Writable => 'int32u',
PrintConv => {
0 => 'RAW',
1 => 'Super Fine',
2 => 'Fine',
3 => 'Standard',
4 => 'Economy',
5 => 'Extra Fine',
6 => 'RAW + JPEG',
7 => 'Compressed RAW',
8 => 'Compressed RAW + JPEG',
},
},
0x0104 => { #5/JD
Name => 'FlashExposureComp',
Description => 'Flash Exposure Compensation',
Writable => 'rational64s',
},
0x0105 => { #5/JD
Name => 'Teleconverter',
Writable => 'int32u',
PrintHex => 1,
PrintConv => {
0 => 'None',
72 => 'Minolta AF 2x APO (D)',
80 => 'Minolta AF 2x APO II',
136 => 'Minolta AF 1.4x APO (D)',
144 => 'Minolta AF 1.4x APO II',
},
},
0x2001 => { #PH (A700)
Name => 'PreviewImage',
Writable => 'undef',
DataTag => 'PreviewImage',
WriteCheck => 'return $val=~/^(none|.{32}\xff\xd8\xff)/s ? undef : "Not a valid image"',
RawConv => q{
return $val if $val =~ /^Binary/;
$val = substr($val,0x20) if length($val) > 0x20;
return $self->ValidateImage(\$val,$tag);
},
# must construct 0x20-byte header which contains length, width and height
ValueConvInv => q{
return 'none' unless $val;
my $e = new Image::ExifTool;
my $info = $e->ImageInfo(\$val,'ImageWidth','ImageHeight');
return undef unless $$info{ImageWidth} and $$info{ImageHeight};
my $size = Set32u($$info{ImageWidth}) . Set32u($$info{ImageHeight});
return Set32u(length $val) . $size . ("\0" x 8) . $size . ("\0" x 4) . $val;
},
},
0xb020 => { #2
Name => 'ColorReproduction',
# observed values: None, Standard, Vivid, Real, AdobeRGB - PH
Writable => 'string',
},
0xb021 => { #2
Name => 'ColorTemperature',
Writable => 'int32u',
PrintConv => '$val ? $val : "Auto"',
PrintConvInv => '$val=~/Auto/i ? 0 : $val',
},
0xb023 => { #PH (A100)
Name => 'SceneMode',
Writable => 'int32u',
PrintConv => \%Image::ExifTool::Minolta::minoltaSceneMode,
},
0xb024 => { #PH (A100)
Name => 'ZoneMatching',
Writable => 'int32u',
PrintConv => {
0 => 'ISO Setting Used',
1 => 'High Key',
2 => 'Low Key',
},
},
0xb025 => { #PH (A100)
Name => 'DynamicRangeOptimizer',
Writable => 'int32u',
PrintConv => {
0 => 'Off',
1 => 'Standard',
2 => 'Advanced Auto',
8 => 'Advanced Lv1', #JD
9 => 'Advanced Lv2', #JD
10 => 'Advanced Lv3', #JD
11 => 'Advanced Lv4', #JD
12 => 'Advanced Lv5', #JD
},
},
0xb026 => { #PH (A100)
Name => 'ImageStabilization',
Writable => 'int32u',
PrintConv => { 0 => 'Off', 1 => 'On' },
},
0xb027 => { #2
Name => 'LensType',
Writable => 'int32u',
Notes => q{
decimal values differentiate lenses which would otherwise have the same
LensType, and are used by the Composite LensID tag when attempting to
identify the specific lens model
},
PrintConv => \%sonyLensTypes,
},
0xb028 => { #2
# (used by the DSLR-A100)
Name => 'MinoltaMakerNote',
# must check for zero since apparently a value of zero indicates the IFD doesn't exist
# (dumb Sony -- they shouldn't write this tag if the IFD is missing!)
Condition => '$$valPt ne "\0\0\0\0"',
Flags => 'SubIFD',
SubDirectory => {
TagTable => 'Image::ExifTool::Minolta::Main',
Start => '$val',
},
},
0xb029 => { #2
Name => 'ColorMode',
Writable => 'int32u',
PrintConv => \%Image::ExifTool::Minolta::sonyColorMode,
},
0xb040 => { #2
Name => 'Macro',
Writable => 'int16u',
PrintConv => { 0 => 'Off', 1 => 'On' },
},
0xb041 => { #2
Name => 'ExposureMode',
Writable => 'int16u',
PrintConv => {
0 => 'Auto',
5 => 'Landscape',
6 => 'Program',
7 => 'Aperture Priority',
8 => 'Shutter Priority',
9 => 'Night Scene',
15 => 'Manual',
},
},
0xb047 => { #2
Name => 'Quality',
Writable => 'int16u',
PrintConv => {
0 => 'Normal',
1 => 'Fine',
},
},
0xb04b => { #2/PH
Name => 'Anti-Blur',
Writable => 'int16u',
PrintConv => {
0 => 'Off',
1 => 'On (Continuous)', #PH (NC)
2 => 'On (Shooting)', #PH (NC)
65535 => 'n/a',
},
},
0xb04e => { #2
Name => 'LongExposureNoiseReduction',
Writable => 'int16u',
PrintConv => { 0 => 'Off', 1 => 'On' },
},
);
# tag table for Sony RAW Format
%Image::ExifTool::Sony::SRF = (
PROCESS_PROC => \&ProcessSRF,
GROUPS => { 0 => 'MakerNotes', 1 => 'SRF#', 2 => 'Camera' },
NOTES => q{
The maker notes in SRF (Sony Raw Format) images contain 7 IFD's (with family
1 group names SRF0 through SRF6). SRF0 through SRF5 use these Sony tags,
while SRF6 uses standard EXIF tags. All information other than SRF0 is
encrypted, but thanks to Dave Coffin the decryption algorithm is known.
},
0 => {
Name => 'SRF2_Key',
Notes => 'key to decrypt maker notes from the start of SRF2',
RawConv => '$self->{SRF2_Key} = $val',
},
1 => {
Name => 'DataKey',
Notes => 'key to decrypt the rest of the file from the end of the maker notes',
RawConv => '$self->{SRFDataKey} = $val',
},
);
# tag table for Sony RAW 2 Format Private IFD (ref 1)
%Image::ExifTool::Sony::SR2Private = (
PROCESS_PROC => \&ProcessSR2,
GROUPS => { 0 => 'MakerNotes', 1 => 'SR2', 2 => 'Camera' },
NOTES => q{
The SR2 format uses the DNGPrivateData tag to reference a private IFD
containing these tags.
},
0x7200 => {
Name => 'SR2SubIFDOffset',
# (adjusting offset messes up calculations for AdobeSR2 in DNG images)
# Flags => 'IsOffset',
OffsetPair => 0x7201,
RawConv => '$self->{SR2SubIFDOffset} = $val',
},
0x7201 => {
Name => 'SR2SubIFDLength',
OffsetPair => 0x7200,
RawConv => '$self->{SR2SubIFDLength} = $val',
},
0x7221 => {
Name => 'SR2SubIFDKey',
Format => 'int32u',
Notes => 'key to decrypt SR2SubIFD',
RawConv => '$self->{SR2SubIFDKey} = $val',
},
0x7250 => { #1
Name => 'MRWInfo',
SubDirectory => {
TagTable => 'Image::ExifTool::MinoltaRaw::Main',
},
},
);
%Image::ExifTool::Sony::SR2SubIFD = (
GROUPS => { 0 => 'MakerNotes', 1 => 'SR2SubIFD', 2 => 'Camera' },
SET_GROUP1 => 1, # set group1 name to directory name for all tags in table
NOTES => 'Tags in the encrypted SR2SubIFD',
0x7303 => 'WB_GRBGLevels', #1
0x74c0 => { #PH
Name => 'SR2DataIFD',
Groups => { 1 => 'SR2DataIFD' }, # (needed to set SubIFD DirName)
Flags => 'SubIFD',
SubDirectory => {
TagTable => 'Image::ExifTool::Sony::SR2DataIFD',
Start => '$val',
MaxSubdirs => 20, # an A700 ARW has 14 of these! - PH
},
},
0x74a0 => 'MaxApertureAtMaxFocal', #PH
0x74a1 => 'MaxApertureAtMinFocal', #PH
);
%Image::ExifTool::Sony::SR2DataIFD = (
GROUPS => { 0 => 'MakerNotes', 1 => 'SR2DataIFD', 2 => 'Camera' },
SET_GROUP1 => 1, # set group1 name to directory name for all tags in table
0x7770 => { #PH
Name => 'ColorMode',
Priority => 0,
},
);
# fill in Sony LensType lookup based on Minolta values
{
%sonyLensTypes = %Image::ExifTool::Minolta::minoltaLensTypes;
my $id;
foreach $id (sort { $a <=> $b } keys %Image::ExifTool::Minolta::minoltaLensTypes) {
# higher numbered lenses are missing last digit of ID for some Sony models
next if $id < 10000;
my $sid = int($id/10);
my $i;
my $lens = $Image::ExifTool::Minolta::minoltaLensTypes{$id};
if ($sonyLensTypes{$sid}) {
# put lens name with "or" first in list
if ($lens =~ / or /) {
my $tmp = $sonyLensTypes{$sid};
$sonyLensTypes{$sid} = $lens;
$lens = $tmp;
}
for (;;) {
$i = ($i || 0) + 1;
$sid = int($id/10) . ".$i";
last unless $sonyLensTypes{$sid};
}
}
$sonyLensTypes{$sid} = $lens;
}
}
#------------------------------------------------------------------------------
# decrypt Sony data (ref 1)
# Inputs: 0) data reference, 1) start offset, 2) data length, 3) decryption key
# Returns: nothing (original data buffer is updated with decrypted data)
sub Decrypt($$$$)
{
my ($dataPt, $start, $len, $key) = @_;
my ($i, $j, @pad);
my $words = $len / 4;
for ($i=0; $i<4; ++$i) {
my $lo = ($key & 0xffff) * 0x0edd + 1;
my $hi = ($key >> 16) * 0x0edd + ($key & 0xffff) * 0x02e9 + ($lo >> 16);
$pad[$i] = $key = (($hi & 0xffff) << 16) + ($lo & 0xffff);
}
$pad[3] = ($pad[3] << 1 | ($pad[0]^$pad[2]) >> 31) & 0xffffffff;
for ($i=4; $i<0x7f; ++$i) {
$pad[$i] = (($pad[$i-4]^$pad[$i-2]) << 1 |
($pad[$i-3]^$pad[$i-1]) >> 31) & 0xffffffff;
}
my @data = unpack("x$start N$words", $$dataPt);
for ($i=0x7f,$j=0; $j<$words; ++$i,++$j) {
$data[$j] ^= $pad[$i & 0x7f] = $pad[($i+1) & 0x7f] ^ $pad[($i+65) & 0x7f];
}
substr($$dataPt, $start, $words*4) = pack('N*', @data);
}
#------------------------------------------------------------------------------
# Process SRF maker notes
# Inputs: 0) ExifTool object reference, 1) reference to directory information
# 2) pointer to tag table
# Returns: 1 on success
sub ProcessSRF($$$)
{
my ($exifTool, $dirInfo, $tagTablePtr) = @_;
my $dataPt = $$dirInfo{DataPt};
my $dirLen = $$dirInfo{DirLen};
my $start = $$dirInfo{DirStart};
my $verbose = $exifTool->Options('Verbose');
# process IFD chain
my ($ifd, $success);
for ($ifd=0; ; ) {
my $srf = $$dirInfo{DirName} = "SRF$ifd";
my $srfTable = $tagTablePtr;
# SRF6 uses standard EXIF tags
$srfTable = GetTagTable('Image::ExifTool::Exif::Main') if $ifd == 6;
$exifTool->{SET_GROUP1} = $srf;
$success = Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $srfTable);
delete $exifTool->{SET_GROUP1};
last unless $success;
#
# get pointer to next IFD
#
my $count = Get16u($dataPt, $$dirInfo{DirStart});
my $dirEnd = $$dirInfo{DirStart} + 2 + $count * 12;
last if $dirEnd + 4 > length($$dataPt);
my $nextIFD = Get32u($dataPt, $dirEnd);
last unless $nextIFD;
$nextIFD -= $$dirInfo{DataPos}; # adjust for position of makernotes data
$$dirInfo{DirStart} = $nextIFD;
#
# decrypt next IFD data if necessary
#
++$ifd;
my ($key, $len);
if ($ifd == 1) {
# get the key to decrypt IFD1
my $cp = $start + 0x8ddc; # why?
my $ip = $cp + 4 * unpack("x$cp C", $$dataPt);
$key = unpack("x$ip N", $$dataPt);
$len = $cp + $nextIFD; # decrypt up to $cp
} elsif ($ifd == 2) {
# get the key to decrypt IFD2
$key = $exifTool->{SRF2_Key};
$len = length($$dataPt) - $nextIFD; # decrypt rest of maker notes
} else {
next; # no decryption needed
}
# decrypt data
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);
my %parms = (
Prefix => "$exifTool->{INDENT} ",
Start => $nextIFD,
DataPos => $$dirInfo{DataPos},
Out => $exifTool->Options('TextOut'),
);
$parms{MaxLen} = 96 unless $verbose > 3;
Image::ExifTool::HexDump($dataPt, $len, %parms);
}
}
#------------------------------------------------------------------------------
# Process SR2 data
# Inputs: 0) ExifTool object reference, 1) reference to directory information
# 2) pointer to tag table
# Returns: 1 on success
sub ProcessSR2($$$)
{
my ($exifTool, $dirInfo, $tagTablePtr) = @_;
my $raf = $$dirInfo{RAF};
my $dataPt = $$dirInfo{DataPt};
my $dataPos = $$dirInfo{DataPos};
my $dataLen = $$dirInfo{DataLen} || length $$dataPt;
my $base = $$dirInfo{Base} || 0;
# make sure we have the first 4 bytes available to test directory type
my $buff;
if ($dataLen < 4 and $raf) {
my $pos = $dataPos + ($$dirInfo{DirStart}||0) + $base;
if ($raf->Seek($pos, 0) and $raf->Read($buff, 4) == 4) {
$dataPt = \$buff;
undef $$dirInfo{DataPt}; # must load data from file
$raf->Seek($pos, 0);
}
}
# this may either be a normal IFD, or a MRW-file-like data block in newer ARW images
if ($dataPt and $$dataPt =~ /^\0MR[IM]/) {
require Image::ExifTool::MinoltaRaw;
return Image::ExifTool::MinoltaRaw::ProcessMRW($exifTool, $dirInfo);
}
my $dirLen = $$dirInfo{DirLen};
my $verbose = $exifTool->Options('Verbose');
my $result = Image::ExifTool::Exif::ProcessExif($exifTool, $dirInfo, $tagTablePtr);
return $result unless $result;
# only take first offset value if more than one!
my @offsets = split ' ', $exifTool->{SR2SubIFDOffset};
my $offset = shift @offsets;
my $length = $exifTool->{SR2SubIFDLength};
my $key = $exifTool->{SR2SubIFDKey};
if ($offset and $length and defined $key) {
my $buff;
# read encrypted SR2SubIFD from file
if (($raf and $raf->Seek($offset+$base, 0) and
$raf->Read($buff, $length) == $length) or
# or read from data (when processing Adobe DNGPrivateData)
($offset - $dataPos >= 0 and $offset - $dataPos + $length < $dataLen and
($buff = substr($$dataPt, $offset - $dataPos, $length))))
{
Decrypt(\$buff, 0, $length, $key);
# display decrypted data in verbose mode
if ($verbose > 2) {
$exifTool->VerboseDir("Decrypted SR2SubIFD", 0, $length);
my %parms = (
Out => $exifTool->{OPTIONS}->{TextOut},
Prefix => $exifTool->{INDENT},
Addr => $offset + $base,
);
$parms{MaxLen} = 96 unless $verbose > 3;
Image::ExifTool::HexDump(\$buff, $length, %parms);
}
my $num = '';
my $dPos = $offset;
for (;;) {
my %dirInfo = (
Base => $base,
DataPt => \$buff,
DataLen => length $buff,
DirStart => $offset - $dPos,
DirName => "SR2SubIFD$num",
DataPos => $dPos,
);
my $subTable = Image::ExifTool::GetTagTable('Image::ExifTool::Sony::SR2SubIFD');
$result = $exifTool->ProcessDirectory(\%dirInfo, $subTable);
last unless @offsets;
$offset = shift @offsets;
$num = ($num || 1) + 1;
}
} else {
$exifTool->Warn('Error reading SR2 data');
}
}
delete $exifTool->{SR2SubIFDOffset};
delete $exifTool->{SR2SubIFDLength};
delete $exifTool->{SR2SubIFDKey};
return $result;
}
1; # end
__END__
=head1 NAME
Image::ExifTool::Sony - Sony EXIF maker notes tags
=head1 SYNOPSIS
This module is loaded automatically by Image::ExifTool when required.
=head1 DESCRIPTION
This module contains definitions required by Image::ExifTool to
interpret Sony maker notes EXIF meta information.
=head1 NOTES
The Sony maker notes use the standard EXIF IFD structure, but unfortunately
the entries are large blocks of binary data for which I can find no
documentation. You can use "exiftool -v3" to dump these blocks in hex.
=head1 AUTHOR
Copyright 2003-2008, Phil Harvey (phil at owl.phy.queensu.ca)
This library is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
=head1 REFERENCES
=over 4
=item L
=item L
=back
=head1 ACKNOWLEDGEMENTS
Thanks to Thomas Bodenmann, Philippe Devaux, JensDuttke and Marcus
Holland-Moritz for help decoding some tags.
=head1 SEE ALSO
L,
L
=cut