timo.menzel
/
test_pie
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
test_pie/external/exiftool/lib/Image/ExifTool/CanonVRD.pm

2261 lines
74 KiB
Perl
Raw Normal View History

Add texturemerge code.
2023-09-14 11:12:02 +02:00
#------------------------------------------------------------------------------
# File: CanonVRD.pm
#
# Description: Read/write Canon VRD and DR4 information
#
# Revisions: 2006/10/30 - P. Harvey Created
# 2007/10/23 - PH Added new VRD 3.0 tags
# 2008/08/29 - PH Added new VRD 3.4 tags
# 2008/12/02 - PH Added new VRD 3.5 tags
# 2010/06/18 - PH Support variable-length CustomPictureStyle data
# 2010/09/14 - PH Added r/w support for XMP in VRD
# 2015/05/16 - PH Added DR4 support (DPP 4.1.50.0)
# 2018/03/13 - PH Update to DPP 4.8.20
#
# References: 1) Bogdan private communication (Canon DPP v3.4.1.1)
# 2) Gert Kello private communiation (DPP 3.8)
#------------------------------------------------------------------------------
package Image::ExifTool::CanonVRD;
use strict;
use vars qw($VERSION);
use Image::ExifTool qw(:DataAccess :Utils);
use Image::ExifTool::Canon;
$VERSION = '1.32';
sub ProcessCanonVRD($$;$);
sub WriteCanonVRD($$;$);
sub ProcessEditData($$$);
sub ProcessIHL($$$);
sub ProcessIHLExif($$$);
sub ProcessDR4($$;$);
sub SortDR4($$);
# map for adding directories to VRD
my %vrdMap = (
XMP => 'CanonVRD',
CanonVRD => 'VRD',
);
my %noYes = (
PrintConvColumns => 2,
PrintConv => { 0 => 'No', 1 => 'Yes' },
);
# DR4 format codes
my %vrdFormat = (
1 => 'int32u',
2 => 'string',
8 => 'int32u',
9 => 'int32s',
13 => 'double',
33 => 'int32u', # (array)
38 => 'double', # (array)
# 254 => 'undef', ?
255 => 'undef',
);
# empty VRD header/footer for creating VRD from scratch
my $blankHeader = "CANON OPTIONAL DATA\0\0\x01\0\0\0\0\0\0";
my $blankFooter = "CANON OPTIONAL DATA\0" . ("\0" x 42) . "\xff\xd9";
# main tag table blocks in CanonVRD trailer (ref PH)
%Image::ExifTool::CanonVRD::Main = (
WRITE_PROC => \&WriteCanonVRD,
PROCESS_PROC => \&ProcessCanonVRD,
NOTES => q{
Canon Digital Photo Professional writes VRD (Recipe Data) information as a
trailer record to JPEG, TIFF, CRW and CR2 images, or as stand-alone VRD or
DR4 files. The tags listed below represent information found in these
records. The complete VRD/DR4 data record may be accessed as a block using
the Extra 'CanonVRD' or 'CanonDR4' tag, but this tag is not extracted or
copied unless specified explicitly.
},
0xffff00f4 => {
Name => 'EditData',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::Edit' },
},
0xffff00f5 => {
Name => 'IHLData',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::IHL' },
},
0xffff00f6 => {
Name => 'XMP',
Flags => [ 'Binary', 'Protected' ],
Writable => 'undef', # allow writing/deleting as a block
SubDirectory => {
DirName => 'XMP',
TagTable => 'Image::ExifTool::XMP::Main',
},
},
0xffff00f7 => {
Name => 'Edit4Data',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::Edit4' },
},
);
# the VRD edit information is divided into sections
%Image::ExifTool::CanonVRD::Edit = (
WRITE_PROC => \&ProcessEditData,
PROCESS_PROC => \&ProcessEditData,
VARS => { ID_LABEL => 'Index' }, # change TagID label in documentation
NOTES => 'Canon VRD edit information.',
0 => {
Name => 'VRD1',
Size => 0x272, # size of version 1.0 edit information in bytes
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::Ver1' },
},
1 => {
Name => 'VRDStampTool',
Size => 0, # size is variable, and obtained from int32u at directory start
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::StampTool' },
},
2 => {
Name => 'VRD2',
Size => undef, # size is the remaining edit data
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::Ver2' },
},
);
# Canon DPP version 4 edit information
%Image::ExifTool::CanonVRD::Edit4 = (
WRITE_PROC => \&ProcessEditData,
PROCESS_PROC => \&ProcessEditData,
VARS => { ID_LABEL => 'Index' }, # change TagID label in documentation
NOTES => 'Canon DPP version 4 edit information.',
0 => {
Name => 'DR4',
Size => undef, # size is the remaining edit data
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::DR4' },
},
);
# "IHL Created Optional Item Data" tags (not yet writable)
%Image::ExifTool::CanonVRD::IHL = (
PROCESS_PROC => \&ProcessIHL,
TAG_PREFIX => 'VRD_IHL',
GROUPS => { 2 => 'Image' },
1 => [
# this contains edited TIFF-format data, with an original IFD at 0x0008
# and an edited IFD with offset given in the TIFF header.
{
Name => 'IHL_EXIF',
Condition => '$self->Options("ExtractEmbedded")',
SubDirectory => {
TagTable => 'Image::ExifTool::Exif::Main',
ProcessProc => \&ProcessIHLExif,
},
},{
Name => 'IHL_EXIF',
Notes => q{
extracted as a block if the Unknown option is used, or processed as the
first sub-document with the ExtractEmbedded option
},
Binary => 1,
Unknown => 1,
},
],
# 2 - written by DPP 3.0.2.6, and it looks something like edit data,
# but I haven't decoded it yet - PH
3 => {
# (same size as the PreviewImage with DPP 3.0.2.6)
Name => 'ThumbnailImage',
Groups => { 2 => 'Preview' },
Binary => 1,
},
4 => {
Name => 'PreviewImage',
Groups => { 2 => 'Preview' },
Binary => 1,
},
5 => {
Name => 'RawCodecVersion',
ValueConv => '$val =~ s/\0.*//s; $val', # truncate string at null
},
6 => {
Name => 'CRCDevelParams',
Binary => 1,
Unknown => 1,
},
);
# VRD version 1 tags (ref PH)
%Image::ExifTool::CanonVRD::Ver1 = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 0,
GROUPS => { 2 => 'Image' },
DATAMEMBER => [ 0x002 ], # necessary for writing
#
# RAW image adjustment
#
0x002 => {
Name => 'VRDVersion',
Format => 'int16u',
Writable => 0,
DataMember => 'VRDVersion',
RawConv => '$$self{VRDVersion} = $val',
PrintConv => '$val =~ s/^(\d)(\d*)(\d)$/$1.$2.$3/; $val',
},
0x006 => {
Name => 'WBAdjRGGBLevels',
Format => 'int16u[4]',
},
0x018 => {
Name => 'WhiteBalanceAdj',
Format => 'int16u',
PrintConvColumns => 2,
PrintConv => {
0 => 'Auto',
1 => 'Daylight',
2 => 'Cloudy',
3 => 'Tungsten',
4 => 'Fluorescent',
5 => 'Flash',
8 => 'Shade',
9 => 'Kelvin',
30 => 'Manual (Click)',
31 => 'Shot Settings',
},
},
0x01a => {
Name => 'WBAdjColorTemp',
Format => 'int16u',
},
# 0x01c similar to 0x006
0x024 => {
Name => 'WBFineTuneActive',
Format => 'int16u',
%noYes,
},
0x028 => {
Name => 'WBFineTuneSaturation',
Format => 'int16u',
},
0x02c => {
Name => 'WBFineTuneTone',
Format => 'int16u',
},
0x02e => {
Name => 'RawColorAdj',
Format => 'int16u',
PrintConv => {
0 => 'Shot Settings',
1 => 'Faithful',
2 => 'Custom',
},
},
0x030 => {
Name => 'RawCustomSaturation',
Format => 'int32s',
},
0x034 => {
Name => 'RawCustomTone',
Format => 'int32s',
},
0x038 => {
Name => 'RawBrightnessAdj',
Format => 'int32s',
ValueConv => '$val / 6000',
ValueConvInv => 'int($val * 6000 + ($val < 0 ? -0.5 : 0.5))',
PrintConv => 'sprintf("%.2f",$val)',
PrintConvInv => '$val',
},
0x03c => {
Name => 'ToneCurveProperty',
Format => 'int16u',
PrintConvColumns => 2,
PrintConv => {
0 => 'Shot Settings',
1 => 'Linear',
2 => 'Custom 1',
3 => 'Custom 2',
4 => 'Custom 3',
5 => 'Custom 4',
6 => 'Custom 5',
},
},
# 0x040 usually "10 9 2"
0x07a => {
Name => 'DynamicRangeMin',
Format => 'int16u',
},
0x07c => {
Name => 'DynamicRangeMax',
Format => 'int16u',
},
# 0x0c6 usually "10 9 2"
#
# RGB image adjustment
#
0x110 => {
Name => 'ToneCurveActive',
Format => 'int16u',
%noYes,
},
0x113 => {
Name => 'ToneCurveMode',
PrintConv => { 0 => 'RGB', 1 => 'Luminance' },
},
0x114 => {
Name => 'BrightnessAdj',
Format => 'int8s',
},
0x115 => {
Name => 'ContrastAdj',
Format => 'int8s',
},
0x116 => {
Name => 'SaturationAdj',
Format => 'int16s',
},
0x11e => {
Name => 'ColorToneAdj',
Notes => 'in degrees, so -1 is the same as 359',
Format => 'int32s',
},
0x126 => {
Name => 'LuminanceCurvePoints',
Format => 'int16u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
0x150 => {
Name => 'LuminanceCurveLimits',
Notes => '4 numbers: input and output highlight and shadow points',
Format => 'int16u[4]',
},
0x159 => {
Name => 'ToneCurveInterpolation',
PrintConv => { 0 => 'Curve', 1 => 'Straight' },
},
0x160 => {
Name => 'RedCurvePoints',
Format => 'int16u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
# 0x193 same as 0x159
0x19a => {
Name => 'GreenCurvePoints',
Format => 'int16u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
# 0x1cd same as 0x159
0x1d4 => {
Name => 'BlueCurvePoints',
Format => 'int16u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
0x18a => {
Name => 'RedCurveLimits',
Format => 'int16u[4]',
},
0x1c4 => {
Name => 'GreenCurveLimits',
Format => 'int16u[4]',
},
0x1fe => {
Name => 'BlueCurveLimits',
Format => 'int16u[4]',
},
# 0x207 same as 0x159
0x20e => {
Name => 'RGBCurvePoints',
Format => 'int16u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
0x238 => {
Name => 'RGBCurveLimits',
Format => 'int16u[4]',
},
# 0x241 same as 0x159
0x244 => {
Name => 'CropActive',
Format => 'int16u',
%noYes,
},
0x246 => {
Name => 'CropLeft',
Notes => 'crop coordinates in original unrotated image',
Format => 'int16u',
},
0x248 => {
Name => 'CropTop',
Format => 'int16u',
},
0x24a => {
Name => 'CropWidth',
Format => 'int16u',
},
0x24c => {
Name => 'CropHeight',
Format => 'int16u',
},
0x25a => {
Name => 'SharpnessAdj',
Format => 'int16u',
},
0x260 => {
Name => 'CropAspectRatio',
Format => 'int16u',
PrintConv => {
0 => 'Free',
1 => '3:2',
2 => '2:3',
3 => '4:3',
4 => '3:4',
5 => 'A-size Landscape',
6 => 'A-size Portrait',
7 => 'Letter-size Landscape',
8 => 'Letter-size Portrait',
9 => '4:5',
10 => '5:4',
11 => '1:1',
12 => 'Circle',
65535 => 'Custom',
},
},
0x262 => {
Name => 'ConstrainedCropWidth',
Format => 'float',
PrintConv => 'sprintf("%.7g",$val)',
PrintConvInv => '$val',
},
0x266 => {
Name => 'ConstrainedCropHeight',
Format => 'float',
PrintConv => 'sprintf("%.7g",$val)',
PrintConvInv => '$val',
},
0x26a => {
Name => 'CheckMark',
Format => 'int16u',
PrintConv => {
0 => 'Clear',
1 => 1,
2 => 2,
3 => 3,
},
},
0x26e => {
Name => 'Rotation',
Format => 'int16u',
PrintConv => {
0 => 0,
1 => 90,
2 => 180,
3 => 270,
},
},
0x270 => {
Name => 'WorkColorSpace',
Format => 'int16u',
PrintConv => {
0 => 'sRGB',
1 => 'Adobe RGB',
2 => 'Wide Gamut RGB',
3 => 'Apple RGB',
4 => 'ColorMatch RGB',
},
},
# (VRD 1.0.0 edit data ends here -- 0x272 bytes)
);
# VRD Stamp Tool tags (ref PH)
%Image::ExifTool::CanonVRD::StampTool = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
GROUPS => { 2 => 'Image' },
0x00 => {
Name => 'StampToolCount',
Format => 'int32u',
},
);
# VRD version 2 and 3 tags (ref PH)
%Image::ExifTool::CanonVRD::Ver2 = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 0,
FORMAT => 'int16s',
DATAMEMBER => [ 0x58, 0xdc, 0xdf, 0xe0 ], # (required for DataMember and var-format tags)
IS_SUBDIR => [ 0xe0 ],
GROUPS => { 2 => 'Image' },
NOTES => 'Tags added in DPP version 2.0 and later.',
0x02 => {
Name => 'PictureStyle',
PrintConvColumns => 2,
PrintConv => {
0 => 'Standard',
1 => 'Portrait',
2 => 'Landscape',
3 => 'Neutral',
4 => 'Faithful',
5 => 'Monochrome',
6 => 'Unknown?', # PH (maybe in-camera custom picture style?)
7 => 'Custom',
},
},
0x03 => { Name => 'IsCustomPictureStyle', %noYes },
# 0x08: 3
# 0x09: 4095
# 0x0a: 0
# 0x0b: 4095
# 0x0c: 0
0x0d => 'StandardRawColorTone',
0x0e => 'StandardRawSaturation',
0x0f => 'StandardRawContrast',
0x10 => { Name => 'StandardRawLinear', %noYes },
0x11 => 'StandardRawSharpness',
0x12 => 'StandardRawHighlightPoint',
0x13 => 'StandardRawShadowPoint',
0x14 => 'StandardOutputHighlightPoint', #2
0x15 => 'StandardOutputShadowPoint', #2
0x16 => 'PortraitRawColorTone',
0x17 => 'PortraitRawSaturation',
0x18 => 'PortraitRawContrast',
0x19 => { Name => 'PortraitRawLinear', %noYes },
0x1a => 'PortraitRawSharpness',
0x1b => 'PortraitRawHighlightPoint',
0x1c => 'PortraitRawShadowPoint',
0x1d => 'PortraitOutputHighlightPoint',
0x1e => 'PortraitOutputShadowPoint',
0x1f => 'LandscapeRawColorTone',
0x20 => 'LandscapeRawSaturation',
0x21 => 'LandscapeRawContrast',
0x22 => { Name => 'LandscapeRawLinear', %noYes },
0x23 => 'LandscapeRawSharpness',
0x24 => 'LandscapeRawHighlightPoint',
0x25 => 'LandscapeRawShadowPoint',
0x26 => 'LandscapeOutputHighlightPoint',
0x27 => 'LandscapeOutputShadowPoint',
0x28 => 'NeutralRawColorTone',
0x29 => 'NeutralRawSaturation',
0x2a => 'NeutralRawContrast',
0x2b => { Name => 'NeutralRawLinear', %noYes },
0x2c => 'NeutralRawSharpness',
0x2d => 'NeutralRawHighlightPoint',
0x2e => 'NeutralRawShadowPoint',
0x2f => 'NeutralOutputHighlightPoint',
0x30 => 'NeutralOutputShadowPoint',
0x31 => 'FaithfulRawColorTone',
0x32 => 'FaithfulRawSaturation',
0x33 => 'FaithfulRawContrast',
0x34 => { Name => 'FaithfulRawLinear', %noYes },
0x35 => 'FaithfulRawSharpness',
0x36 => 'FaithfulRawHighlightPoint',
0x37 => 'FaithfulRawShadowPoint',
0x38 => 'FaithfulOutputHighlightPoint',
0x39 => 'FaithfulOutputShadowPoint',
0x3a => {
Name => 'MonochromeFilterEffect',
PrintConv => {
-2 => 'None',
-1 => 'Yellow',
0 => 'Orange',
1 => 'Red',
2 => 'Green',
},
},
0x3b => {
Name => 'MonochromeToningEffect',
PrintConv => {
-2 => 'None',
-1 => 'Sepia',
0 => 'Blue',
1 => 'Purple',
2 => 'Green',
},
},
0x3c => 'MonochromeContrast',
0x3d => { Name => 'MonochromeLinear', %noYes },
0x3e => 'MonochromeSharpness',
0x3f => 'MonochromeRawHighlightPoint',
0x40 => 'MonochromeRawShadowPoint',
0x41 => 'MonochromeOutputHighlightPoint',
0x42 => 'MonochromeOutputShadowPoint',
0x45 => { Name => 'UnknownContrast', Unknown => 1 },
0x46 => { Name => 'UnknownLinear', %noYes, Unknown => 1 },
0x47 => { Name => 'UnknownSharpness', Unknown => 1 },
0x48 => { Name => 'UnknownRawHighlightPoint', Unknown => 1 },
0x49 => { Name => 'UnknownRawShadowPoint', Unknown => 1 },
0x4a => { Name => 'UnknownOutputHighlightPoint',Unknown => 1 },
0x4b => { Name => 'UnknownOutputShadowPoint', Unknown => 1 },
0x4c => 'CustomColorTone',
0x4d => 'CustomSaturation',
0x4e => 'CustomContrast',
0x4f => { Name => 'CustomLinear', %noYes },
0x50 => 'CustomSharpness',
0x51 => 'CustomRawHighlightPoint',
0x52 => 'CustomRawShadowPoint',
0x53 => 'CustomOutputHighlightPoint',
0x54 => 'CustomOutputShadowPoint',
0x58 => {
Name => 'CustomPictureStyleData',
Format => 'var_int16u',
Binary => 1,
Notes => 'variable-length data structure',
Writable => 0,
RawConv => 'length($val) == 2 ? undef : $val', # ignore if no data
},
# (VRD 2.0.0 edit data ends here: 178 bytes, index 0x59)
0x5e => [{
Name => 'ChrominanceNoiseReduction',
Condition => '$$self{VRDVersion} < 330',
Notes => 'VRDVersion prior to 3.3.0',
PrintConv => {
0 => 'Off',
58 => 'Low',
100 => 'High',
},
},{ #1
Name => 'ChrominanceNoiseReduction',
Notes => 'VRDVersion 3.3.0 or later',
PrintHex => 1,
PrintConvColumns => 4,
PrintConv => {
0x00 => 0,
0x10 => 1,
0x21 => 2,
0x32 => 3,
0x42 => 4,
0x53 => 5,
0x64 => 6,
0x74 => 7,
0x85 => 8,
0x96 => 9,
0xa6 => 10,
0xa7 => 11,
0xa8 => 12,
0xa9 => 13,
0xaa => 14,
0xab => 15,
0xac => 16,
0xad => 17,
0xae => 18,
0xaf => 19,
0xb0 => 20,
},
}],
0x5f => [{
Name => 'LuminanceNoiseReduction',
Condition => '$$self{VRDVersion} < 330',
Notes => 'VRDVersion prior to 3.3.0',
PrintConv => {
0 => 'Off',
65 => 'Low',
100 => 'High',
},
},{ #1
Name => 'LuminanceNoiseReduction',
Notes => 'VRDVersion 3.3.0 or later',
PrintHex => 1,
PrintConvColumns => 4,
PrintConv => {
0x00 => 0,
0x41 => 1,
0x64 => 2,
0x6e => 3,
0x78 => 4,
0x82 => 5,
0x8c => 6,
0x96 => 7,
0xa0 => 8,
0xaa => 9,
0xb4 => 10,
0xb5 => 11,
0xb6 => 12,
0xb7 => 13,
0xb8 => 14,
0xb9 => 15,
0xba => 16,
0xbb => 17,
0xbc => 18,
0xbd => 19,
0xbe => 20,
},
}],
0x60 => [{
Name => 'ChrominanceNR_TIFF_JPEG',
Condition => '$$self{VRDVersion} < 330',
Notes => 'VRDVersion prior to 3.3.0',
PrintConv => {
0 => 'Off',
33 => 'Low',
100 => 'High',
},
},{ #1
Name => 'ChrominanceNR_TIFF_JPEG',
Notes => 'VRDVersion 3.3.0 or later',
PrintHex => 1,
PrintConvColumns => 4,
PrintConv => {
0x00 => 0,
0x10 => 1,
0x21 => 2,
0x32 => 3,
0x42 => 4,
0x53 => 5,
0x64 => 6,
0x74 => 7,
0x85 => 8,
0x96 => 9,
0xa6 => 10,
0xa7 => 11,
0xa8 => 12,
0xa9 => 13,
0xaa => 14,
0xab => 15,
0xac => 16,
0xad => 17,
0xae => 18,
0xaf => 19,
0xb0 => 20,
},
}],
# 0x61: 1
# (VRD 3.0.0 edit data ends here: 196 bytes, index 0x62)
0x62 => { Name => 'ChromaticAberrationOn', %noYes },
0x63 => { Name => 'DistortionCorrectionOn', %noYes },
0x64 => { Name => 'PeripheralIlluminationOn', %noYes },
0x65 => { Name => 'ColorBlur', %noYes },
0x66 => {
Name => 'ChromaticAberration',
ValueConv => '$val / 0x400',
ValueConvInv => 'int($val * 0x400 + 0.5)',
PrintConv => 'sprintf("%.0f%%", $val * 100)',
PrintConvInv => 'ToFloat($val) / 100',
},
0x67 => {
Name => 'DistortionCorrection',
ValueConv => '$val / 0x400',
ValueConvInv => 'int($val * 0x400 + 0.5)',
PrintConv => 'sprintf("%.0f%%", $val * 100)',
PrintConvInv => 'ToFloat($val) / 100',
},
0x68 => {
Name => 'PeripheralIllumination',
ValueConv => '$val / 0x400',
ValueConvInv => 'int($val * 0x400 + 0.5)',
PrintConv => 'sprintf("%.0f%%", $val * 100)',
PrintConvInv => 'ToFloat($val) / 100',
},
0x69 => {
Name => 'AberrationCorrectionDistance',
Notes => '100% = infinity',
RawConv => '$val == 0x7fff ? undef : $val',
ValueConv => '1 - $val / 0x400',
ValueConvInv => 'int((1 - $val) * 0x400 + 0.5)',
PrintConv => 'sprintf("%.0f%%", $val * 100)',
PrintConvInv => 'ToFloat($val) / 100',
},
0x6a => 'ChromaticAberrationRed',
0x6b => 'ChromaticAberrationBlue',
0x6d => { #1
Name => 'LuminanceNR_TIFF_JPEG',
Notes => 'val = raw / 10',
ValueConv => '$val / 10',
ValueConvInv => 'int($val * 10 + 0.5)',
},
# (VRD 3.4.0 edit data ends here: 220 bytes, index 0x6e)
0x6e => { Name => 'AutoLightingOptimizerOn', %noYes },
0x6f => {
Name => 'AutoLightingOptimizer',
PrintConv => {
100 => 'Low',
200 => 'Standard',
300 => 'Strong',
0x7fff => 'n/a', #1
},
},
# 0x71: 200
# 0x73: 100
# (VRD 3.5.0 edit data ends here: 232 bytes, index 0x74)
0x75 => {
Name => 'StandardRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x76 => {
Name => 'PortraitRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x77 => {
Name => 'LandscapeRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x78 => {
Name => 'NeutralRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x79 => {
Name => 'FaithfulRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x7a => {
Name => 'MonochromeRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x7b => {
Name => 'UnknownRawHighlight',
Unknown => 1,
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x7c => {
Name => 'CustomRawHighlight',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x7e => {
Name => 'StandardRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x7f => {
Name => 'PortraitRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x80 => {
Name => 'LandscapeRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x81 => {
Name => 'NeutralRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x82 => {
Name => 'FaithfulRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x83 => {
Name => 'MonochromeRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x84 => {
Name => 'UnknownRawShadow',
Unknown => 1,
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x85 => {
Name => 'CustomRawShadow',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
},
0x8b => { #2
Name => 'AngleAdj',
Format => 'int32s',
ValueConv => '$val / 100',
ValueConvInv => '$val * 100',
},
0x8e => {
Name => 'CheckMark2',
Format => 'int16u',
PrintConvColumns => 2,
PrintConv => {
0 => 'Clear',
1 => 1,
2 => 2,
3 => 3,
4 => 4,
5 => 5,
},
},
# (VRD 3.8.0 edit data ends here: 286 bytes, index 0x8f)
0x90 => {
Name => 'UnsharpMask',
PrintConv => { 0 => 'Off', 1 => 'On' },
},
0x92 => 'StandardUnsharpMaskStrength',
0x94 => 'StandardUnsharpMaskFineness',
0x96 => 'StandardUnsharpMaskThreshold',
0x98 => 'PortraitUnsharpMaskStrength',
0x9a => 'PortraitUnsharpMaskFineness',
0x9c => 'PortraitUnsharpMaskThreshold',
0x9e => 'LandscapeUnsharpMaskStrength',
0xa0 => 'LandscapeUnsharpMaskFineness',
0xa2 => 'LandscapeUnsharpMaskThreshold',
0xa4 => 'NeutraUnsharpMaskStrength',
0xa6 => 'NeutralUnsharpMaskFineness',
0xa8 => 'NeutralUnsharpMaskThreshold',
0xaa => 'FaithfulUnsharpMaskStrength',
0xac => 'FaithfulUnsharpMaskFineness',
0xae => 'FaithfulUnsharpMaskThreshold',
0xb0 => 'MonochromeUnsharpMaskStrength',
0xb2 => 'MonochromeUnsharpMaskFineness',
0xb4 => 'MonochromeUnsharpMaskThreshold',
0xb6 => 'CustomUnsharpMaskStrength',
0xb8 => 'CustomUnsharpMaskFineness',
0xba => 'CustomUnsharpMaskThreshold',
0xbc => 'CustomDefaultUnsharpStrength',
0xbe => 'CustomDefaultUnsharpFineness',
0xc0 => 'CustomDefaultUnsharpThreshold',
# (VRD 3.9.1 edit data ends here: 392 bytes, index 0xc4)
# 0xc9: 3 - some RawSharpness
# 0xca: 4095 - some RawHighlightPoint
# 0xcb: 0 - some RawShadowPoint
# 0xcc: 4095 - some OutputHighlightPoint
# 0xcd: 0 - some OutputShadowPoint
# 0xd1: 3 - some UnsharpMaskStrength
# 0xd3: 7 - some UnsharpMaskFineness
# 0xd5: 3,4 - some UnsharpMaskThreshold
0xd6 => { Name => 'CropCircleActive', %noYes },
0xd7 => 'CropCircleX',
0xd8 => 'CropCircleY',
0xd9 => 'CropCircleRadius',
# 0xda: 0, 1
# 0xdb: 100
0xdc => {
Name => 'DLOOn',
DataMember => 'DLOOn',
RawConv => '$$self{DLOOn} = $val',
%noYes,
},
0xdd => 'DLOSetting',
# (VRD 3.11.0 edit data ends here: 444 bytes, index 0xde)
0xde => {
Name => 'DLOShootingDistance',
Notes => '100% = infinity',
RawConv => '$val == 0x7fff ? undef : $val',
ValueConv => '1 - $val / 0x400',
ValueConvInv => 'int((1 - $val) * 0x400 + 0.5)',
PrintConv => 'sprintf("%.0f%%", $val * 100)',
PrintConvInv => 'ToFloat($val) / 100',
},
0xdf => {
Name => 'DLODataLength',
DataMember => 'DLODataLength',
Format => 'int32u',
Writable => 0,
RawConv => '$$self{DLODataLength} = $val',
},
0xe0 => { # (yes, this overlaps DLODataLength)
Name => 'DLOInfo',
# - have seen DLODataLengths of 65536,64869 when DLO is Off, so must test DLOOn flag
Condition => '$$self{DLOOn}',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::DLOInfo' },
Hook => '$varSize += $$self{DLODataLength} + 0x16',
},
0xe1 => 'CameraRawColorTone',
# (VRD 3.11.2 edit data ends here: 452 bytes, index 0xe2, unless DLO is on)
0xe2 => 'CameraRawSaturation',
0xe3 => 'CameraRawContrast',
0xe4 => { Name => 'CameraRawLinear', %noYes },
0xe5 => 'CameraRawSharpness',
0xe6 => 'CameraRawHighlightPoint',
0xe7 => 'CameraRawShadowPoint',
0xe8 => 'CameraRawOutputHighlightPoint',
0xe9 => 'CameraRawOutputShadowPoint',
);
# DLO tags (ref PH)
%Image::ExifTool::CanonVRD::DLOInfo = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 1,
FORMAT => 'int16s',
GROUPS => { 2 => 'Image' },
NOTES => 'Tags added when DLO (Digital Lens Optimizer) is on.',
# 0x01 - seen 3112,3140
0x04 => 'DLOSettingApplied',
0x05 => {
Name => 'DLOVersion', #(NC)
Format => 'string[10]',
},
0x0a => {
Name => 'DLOData',
LargeTag => 1, # large tag, so avoid storing unnecessarily
Notes => 'variable-length Digital Lens Optimizer data, stored in JPEG-like format',
Format => 'undef[$$self{DLODataLength}]',
Writable => 0,
Binary => 1,
},
);
# VRD version 4 tags (ref PH)
%Image::ExifTool::CanonVRD::DR4 = (
PROCESS_PROC => \&ProcessDR4,
WRITE_PROC => \&ProcessDR4,
WRITABLE => 1,
GROUPS => { 2 => 'Image' },
VARS => { HEX_ID => 1, SORT_PROC => \&SortDR4 },
NOTES => q{
Tags written by Canon DPP version 4 in CanonVRD trailers and DR4 files. Each
tag has three associated flag words which are stored with the directory
entry, some of which are extracted as a separate tag, indicated in the table
below by a decimal appended to the tag ID (.0, .1 or .2).
},
header => {
Name => 'DR4Header',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::DR4Header' },
},
0x10002 => 'Rotation', # left/right rotation 90,180,270
0x10003 => 'AngleAdj', # crop angle
# 0x10018 - fmt=8: 0
# 0x10020 - fmt=2: ''
0x10021 => 'CustomPictureStyle', # (string)
0x10101 => {
Name => 'CheckMark',
PrintConv => {
0 => 'Clear',
1 => 1,
2 => 2,
3 => 3,
4 => 4,
5 => 5,
},
},
0x10200 => {
Name => 'WorkColorSpace',
PrintConv => {
1 => 'sRGB',
2 => 'Adobe RGB',
3 => 'Wide Gamut RGB',
4 => 'Apple RGB',
5 => 'ColorMatch RGB',
},
},
# 0x10201 - fmt=9: 0
# 0x10f20 - fmt=9: 350
0x20001 => 'RawBrightnessAdj',
0x20101 => {
Name => 'WhiteBalanceAdj',
PrintConvColumns => 2,
PrintConv => {
-1 => 'Manual (Click)',
0 => 'Auto',
1 => 'Daylight',
2 => 'Cloudy',
3 => 'Tungsten',
4 => 'Fluorescent',
5 => 'Flash',
8 => 'Shade',
9 => 'Kelvin',
255 => 'Shot Settings',
},
},
0x20102 => 'WBAdjColorTemp',
0x20105 => 'WBAdjMagentaGreen',
0x20106 => 'WBAdjBlueAmber',
0x20125 => {
Name => 'WBAdjRGGBLevels',
PrintConv => '$val =~ s/^\d+ //; $val', # remove first integer (14: what is this for?)
PrintConvInv => '"14 $val"',
},
0x20200 => { Name => 'GammaLinear', %noYes },
0x20301 => {
Name => 'PictureStyle',
PrintHex => 1,
PrintConv => {
0x81 => 'Standard',
0x82 => 'Portrait',
0x83 => 'Landscape',
0x84 => 'Neutral',
0x85 => 'Faithful',
0x86 => 'Monochrome',
0x87 => 'Auto',
0x88 => 'Fine Detail',
0xf0 => 'Shot Settings',
0xff => 'Custom',
},
},
# 0x20302 - Gamma curve data
0x20303 => 'ContrastAdj',
0x20304 => 'ColorToneAdj',
0x20305 => 'ColorSaturationAdj',
0x20306 => {
Name => 'MonochromeToningEffect',
PrintConv => {
0 => 'None',
1 => 'Sepia',
2 => 'Blue',
3 => 'Purple',
4 => 'Green',
},
},
0x20307 => {
Name => 'MonochromeFilterEffect',
PrintConv => {
0 => 'None',
1 => 'Yellow',
2 => 'Orange',
3 => 'Red',
4 => 'Green',
},
},
0x20308 => 'UnsharpMaskStrength',
0x20309 => 'UnsharpMaskFineness',
0x2030a => 'UnsharpMaskThreshold',
0x2030b => 'ShadowAdj',
0x2030c => 'HighlightAdj',
0x20310 => {
Name => 'SharpnessAdj',
PrintConv => {
0 => 'Sharpness',
1 => 'Unsharp Mask',
},
},
'0x20310.0' => { Name => 'SharpnessAdjOn', %noYes },
0x20311 => 'SharpnessStrength',
0x20400 => {
Name => 'ToneCurve',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::ToneCurve' },
},
'0x20400.1' => { Name => 'ToneCurveOriginal', %noYes },
# 0x20401 - fmt=33 (312 bytes)
0x20410 => 'ToneCurveBrightness',
0x20411 => 'ToneCurveContrast',
0x20500 => {
Name => 'AutoLightingOptimizer',
PrintConv => {
0 => 'Low',
1 => 'Standard',
2 => 'Strong',
},
},
'0x20500.0' => {
Name => 'AutoLightingOptimizerOn',
Notes => 'ignored if gamma is linear',
%noYes,
},
# 0x20501 - fmt=13: 0
# 0x20502 - fmt=13: 0
0x20600 => 'LuminanceNoiseReduction',
0x20601 => 'ChrominanceNoiseReduction',
# 0x20650 - fmt=9: 0 (JPG images)
0x20670 => 'ColorMoireReduction',
'0x20670.0' => { Name => 'ColorMoireReductionOn', %noYes },
0x20701 => {
Name => 'ShootingDistance',
Notes => '100% = infinity',
ValueConv => '$val / 10',
ValueConvInv => '$val * 10',
PrintConv => 'sprintf("%.0f%%", $val * 100)',
PrintConvInv => 'ToFloat($val) / 100',
},
0x20702 => {
Name => 'PeripheralIllumination',
PrintConv => 'sprintf "%g", $val',
PrintConvInv => '$val',
},
'0x20702.0' => { Name => 'PeripheralIlluminationOn', %noYes },
0x20703 => {
Name => 'ChromaticAberration',
PrintConv => 'sprintf "%g", $val',
PrintConvInv => '$val',
},
'0x20703.0' => { Name => 'ChromaticAberrationOn', %noYes },
0x20704 => { Name => 'ColorBlurOn', %noYes },
0x20705 => {
Name => 'DistortionCorrection',
PrintConv => 'sprintf "%g", $val',
PrintConvInv => '$val',
},
'0x20705.0' => { Name => 'DistortionCorrectionOn', %noYes },
0x20706 => 'DLOSetting',
'0x20706.0' => { Name => 'DLOOn', %noYes },
0x20707 => {
Name => 'ChromaticAberrationRed',
PrintConv => 'sprintf "%g", $val',
PrintConvInv => '$val',
},
0x20708 => {
Name => 'ChromaticAberrationBlue',
PrintConv => 'sprintf "%g", $val',
PrintConvInv => '$val',
},
0x20709 => {
Name => 'DistortionEffect',
PrintConv => {
0 => 'Shot Settings',
1 => 'Emphasize Linearity',
2 => 'Emphasize Distance',
3 => 'Emphasize Periphery',
4 => 'Emphasize Center',
},
},
# 0x20800 - fmt=1: 0
# 0x20801 - fmt=1: 0
0x2070b => { Name => 'DiffractionCorrectionOn', %noYes },
0x20900 => 'ColorHue',
0x20901 => 'SaturationAdj',
0x20910 => 'RedHSL',
0x20911 => 'OrangeHSL',
0x20912 => 'YellowHSL',
0x20913 => 'GreenHSL',
0x20914 => 'AquaHSL',
0x20915 => 'BlueHSL',
0x20916 => 'PurpleHSL',
0x20917 => 'MagentaHSL',
0x20a00 => {
Name => 'GammaInfo',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::GammaInfo' },
},
# 0x20a01 - Auto picture style settings
# 0x20a02 - Standard picture style settings
# 0x20a03 - Portrait picture style settings
# 0x20a04 - Landscape picture style settings
# 0x20a05 - Neutral picture style settings
# 0x20a06 - Faithful picture style settings
# 0x20a07 - Monochrome picture style settings
# 0x20a08 - (unknown picture style settings)
# 0x20a09 - Custom picture style settings
# 0x20a20 - Fine Detail picture style settings
0x30101 => {
Name => 'CropAspectRatio',
PrintConv => {
0 => 'Free',
1 => 'Custom',
2 => '1:1',
3 => '3:2',
4 => '2:3',
5 => '4:3',
6 => '3:4',
7 => '5:4',
8 => '4:5',
9 => '16:9',
10 => '9:16',
},
},
0x30102 => 'CropAspectRatioCustom',
# 0x30103 - fmt=33: "0 0 8"
0xf0100 => {
Name => 'CropInfo',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::CropInfo' },
},
0xf0500 => {
Name => 'CustomPictureStyleData',
Binary => 1,
},
0xf0510 => {
Name => 'StampInfo',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::StampInfo' },
},
0xf0511 => {
Name => 'DustInfo',
SubDirectory => { TagTable => 'Image::ExifTool::CanonVRD::DustInfo' },
},
0xf0512 => 'LensFocalLength',
# 0xf0521 - DLO data
# 0xf0520 - DLO data
# 0xf0530 - created when dust delete data applied (4 bytes, all zero)
# 0xf0600 - fmt=253 (2308 bytes, JPG images)
# 0xf0601 - fmt=253 (2308 bytes, JPG images)
# 0x1ff52c - values: 129,130,132 (related to custom picture style somehow)
# to do:
# - find 8-15mm CR2 sample and decode linear distortion effect fine-tune
);
# Version 4 header information (ref PH)
%Image::ExifTool::CanonVRD::DR4Header = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 0,
FORMAT => 'int32u',
GROUPS => { 2 => 'Image' },
# 0 - value: 'IIII' (presumably byte order)
# 1 - value: 0x00040004 (currently use this for magic number)
# 2 - value: 6
3 => {
Name => 'DR4CameraModel',
Writable => 'int32u',
PrintHex => 1,
SeparateTable => 'Canon CanonModelID',
PrintConv => \%Image::ExifTool::Canon::canonModelID,
},
# 4 - value: 3
# 5 - value: 4
# 6 - value: 5
# 7 - DR4 directory entry count
);
# Version 4 RGB tone curve information (ref PH)
%Image::ExifTool::CanonVRD::ToneCurve = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 0,
FORMAT => 'int32u',
GROUPS => { 2 => 'Image' },
0x00 => {
Name => 'ToneCurveColorSpace',
PrintConv => {
0 => 'RGB',
1 => 'Luminance',
},
},
0x01 => {
Name => 'ToneCurveShape',
PrintConv => {
0 => 'Curve',
1 => 'Straight',
},
},
0x03 => { Name => 'ToneCurveInputRange', Format => 'int32u[2]', Notes => '255 max' },
0x05 => { Name => 'ToneCurveOutputRange', Format => 'int32u[2]', Notes => '255 max' },
0x07 => {
Name => 'RGBCurvePoints',
Format => 'int32u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
0x0a => 'ToneCurveX',
0x0b => 'ToneCurveY',
0x2d => {
Name => 'RedCurvePoints',
Format => 'int32u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
0x53 => {
Name => 'GreenCurvePoints',
Format => 'int32u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
0x79 => {
Name => 'BlueCurvePoints',
Format => 'int32u[21]',
PrintConv => 'Image::ExifTool::CanonVRD::ToneCurvePrint($val)',
PrintConvInv => 'Image::ExifTool::CanonVRD::ToneCurvePrintInv($val)',
},
);
# Version 4 gamma curve information (ref PH)
%Image::ExifTool::CanonVRD::GammaInfo = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 0,
FORMAT => 'double',
GROUPS => { 2 => 'Image' },
0x02 => 'GammaContrast',
0x03 => 'GammaColorTone',
0x04 => 'GammaSaturation',
0x05 => 'GammaUnsharpMaskStrength',
0x06 => 'GammaUnsharpMaskFineness',
0x07 => 'GammaUnsharpMaskThreshold',
0x08 => 'GammaSharpnessStrength',
0x09 => 'GammaShadow',
0x0a => 'GammaHighlight',
# 0x0b-0x10 are the same as first 6 doubles of tag DR4_0x20302
# 0x0b - value: 14
0x0c => {
Name => 'GammaBlackPoint',
ValueConv => q{
return 0 if $val <= 0;
$val = log($val / 4.6875) / log(2) + 1;
return abs($val) > 1e-10 ? $val : 0;
},
ValueConvInv => '$val ? exp(($val - 1) * log(2)) * 4.6876 : 0',
PrintConv => 'sprintf("%+.3f", $val)',
PrintConvInv => '$val',
},
0x0d => {
Name => 'GammaWhitePoint',
ValueConv => q{
return $val if $val <= 0;
$val = log($val / 4.6875) / log(2) - 11.77109325169954;
return abs($val) > 1e-10 ? $val : 0;
},
ValueConvInv => '$val ? exp(($val + 11.77109325169954) * log(2)) * 4.6875 : 0',
PrintConv => 'sprintf("%+.3f", $val)',
PrintConvInv => '$val',
},
0x0e => {
Name => 'GammaMidPoint',
ValueConv => q{
return $val if $val <= 0;
$val = log($val / 4.6875) / log(2) - 8;
return abs($val) > 1e-10 ? $val : 0;
},
ValueConvInv => '$val ? exp(($val + 8) * log(2)) * 4.6876 : 0',
PrintConv => 'sprintf("%+.3f", $val)',
PrintConvInv => '$val',
},
0x0f => { Name => 'GammaCurveOutputRange', Format => 'double[2]', Notes => '16383 max' },
);
# Version 4 crop information (ref PH)
%Image::ExifTool::CanonVRD::CropInfo = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
WRITE_PROC => \&Image::ExifTool::WriteBinaryData,
CHECK_PROC => \&Image::ExifTool::CheckBinaryData,
WRITABLE => 1,
FIRST_ENTRY => 0,
FORMAT => 'int32s',
GROUPS => { 2 => 'Image' },
0 => { Name => 'CropActive', %noYes },
1 => 'CropRotatedOriginalWidth',
2 => 'CropRotatedOriginalHeight',
3 => 'CropX',
4 => 'CropY',
5 => 'CropWidth',
6 => 'CropHeight',
8 => {
Name => 'CropRotation',
Format => 'double',
PrintConv => 'sprintf("%.7g",$val)',
PrintConvInv => '$val',
},
0x0a => 'CropOriginalWidth',
0x0b => 'CropOriginalHeight',
# 0x0c double - value: 100
);
# DR4 Stamp Tool tags (ref PH)
%Image::ExifTool::CanonVRD::StampInfo = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
GROUPS => { 2 => 'Image' },
FORMAT => 'int32u',
FIRST_ENTRY => 0,
0x02 => 'StampToolCount',
);
# DR4 dust delete information (ref PH)
%Image::ExifTool::CanonVRD::DustInfo = (
PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
GROUPS => { 2 => 'Image' },
FORMAT => 'int32u',
FIRST_ENTRY => 0,
0x02 => { Name => 'DustDeleteApplied', %noYes },
);
#------------------------------------------------------------------------------
# sort DR4 tag ID's for the documentation
sub SortDR4($$)
{
my ($a, $b) = @_;
my ($aHex, $aDec, $bHex, $bDec);
($aHex, $aDec) = ($1, $2) if $a =~ /^(0x[0-9a-f]+)?\.?(\d*?)$/;
($bHex, $bDec) = ($1, $2) if $b =~ /^(0x[0-9a-f]+)?\.?(\d*?)$/;
if ($aHex) {
return 1 unless defined $bDec; # $b is 'header';
return hex($aHex) <=> hex($bHex) || $aDec <=> $bDec if $bHex;
return hex($aHex) <=> $bDec || 1;
} elsif ($bHex) {
return -1 unless defined $aDec;
return $aDec <=> hex($bHex) || -1;
} else {
return 1 unless defined $bDec;
return -1 unless defined $aDec;
return $aDec <=> $bDec;
}
}
#------------------------------------------------------------------------------
# Tone curve print conversion
sub ToneCurvePrint($)
{
my $val = shift;
my @vals = split ' ', $val;
return $val unless @vals == 21;
my $n = shift @vals;
return $val unless $n >= 2 and $n <= 10;
$val = '';
while ($n--) {
$val and $val .= ' ';
$val .= '(' . shift(@vals) . ',' . shift(@vals) . ')';
}
return $val;
}
#------------------------------------------------------------------------------
# Inverse print conversion for tone curve
sub ToneCurvePrintInv($)
{
my $val = shift;
my @vals = ($val =~ /\((\d+),(\d+)\)/g);
return undef unless @vals >= 4 and @vals <= 20 and not @vals & 0x01;
unshift @vals, scalar(@vals) / 2;
while (@vals < 21) { push @vals, 0 }
return join(' ',@vals);
}
#------------------------------------------------------------------------------
# Read/Write VRD edit data
# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
# Returns: Reading: 1 on success; Writing: modified edit data, or undef if nothing changed
sub ProcessEditData($$$)
{
my ($et, $dirInfo, $tagTablePtr) = @_;
$et or return 1; # allow dummy access
my $dataPt = $$dirInfo{DataPt};
my $pos = $$dirInfo{DirStart};
my $dataPos = $$dirInfo{DataPos};
my $outfile = $$dirInfo{OutFile};
my $dirLen = $$dirInfo{DirLen};
my $verbose = $et->Options('Verbose');
my $out = $et->Options('TextOut');
my $oldChanged = $$et{CHANGED};
$et->VerboseDir('VRD Edit Data', 0, $dirLen) unless $outfile;
if ($outfile) {
# make a copy for editing in place
my $buff = substr($$dataPt, $pos, $dirLen);
$dataPt = $$dirInfo{DataPt} = \$buff;
$dataPos += $pos;
$pos = $$dirInfo{DirStart} = 0;
}
my $dirEnd = $pos + $dirLen;
# loop through all records in the edit data
my ($recNum, $recLen, $err);
for ($recNum=0;; ++$recNum, $pos+=$recLen) {
if ($pos + 4 > $dirEnd) {
last if $pos == $dirEnd; # all done if we arrived at end
$recLen = 0; # just reset record size (will exit loop on test below)
} else {
$recLen = Get32u($dataPt, $pos);
# (DR4 has a null terminator)
last if $recLen == 0 and $pos + 4 == $dirEnd;
}
$pos += 4; # move to start of record
if ($pos + $recLen > $dirEnd) {
$et->Warn('Possibly corrupt CanonVRD Edit record');
$err = 1;
last;
}
my $saveRecLen = $recLen;
if ($verbose > 1 and not $outfile) {
printf $out "$$et{INDENT}CanonVRD Edit record ($recLen bytes at offset 0x%x)\n",
$pos + $dataPos;
$et->VerboseDump($dataPt, Len => $recLen, Start => $pos, Addr => $pos + $dataPos) if $recNum;
}
# our edit information is the 0th record, so don't process the others
next if $recNum;
# process VRD edit information
my $subTablePtr = $tagTablePtr;
my $index;
my %subdirInfo = (
DataPt => $dataPt,
DataPos => $dataPos,
DirStart => $pos,
DirLen => $recLen,
OutFile => $outfile,
);
my $subStart = 0;
# loop through various sections of the VRD edit data
for ($index=0; ; ++$index) {
my $tagInfo = $$subTablePtr{$index} or last;
my $subLen;
my $maxLen = $recLen - $subStart;
if ($$tagInfo{Size}) {
$subLen = $$tagInfo{Size};
} elsif (defined $$tagInfo{Size}) {
# get size from int32u at $subStart
last unless $subStart + 4 <= $recLen;
$subLen = Get32u($dataPt, $subStart + $pos);
$subStart += 4; # skip the length word
} else {
$subLen = $maxLen;
}
$subLen > $maxLen and $subLen = $maxLen;
if ($subLen) {
my $subTable = GetTagTable($$tagInfo{SubDirectory}{TagTable});
my $subName = $$tagInfo{Name};
$subdirInfo{DirStart} = $subStart + $pos;
$subdirInfo{DirLen} = $subLen;
$subdirInfo{DirName} = $subName;
if ($outfile) {
# rewrite this section of the VRD edit information
$verbose and print $out " Rewriting Canon $subName\n";
my $newVal = $et->WriteDirectory(\%subdirInfo, $subTable);
if ($newVal) {
my $sizeDiff = length($newVal) - $subLen;
substr($$dataPt, $pos+$subStart, $subLen) = $newVal;
if ($sizeDiff) {
$subLen = length $newVal;
$recLen += $sizeDiff;
$dirEnd += $sizeDiff;
$dirLen += $sizeDiff;
}
}
} else {
$et->VPrint(0, "$$et{INDENT}$subName (SubDirectory) -->\n");
$et->VerboseDump($dataPt,
Start => $pos + $subStart,
Addr => $dataPos + $pos + $subStart,
Len => $subLen,
);
# extract tags from this section of the VRD edit information
$et->ProcessDirectory(\%subdirInfo, $subTable);
}
}
# next section starts at the end of this one
$subStart += $subLen;
}
if ($outfile and $saveRecLen ne $recLen) {
# update record length if necessary
Set32u($recLen, $dataPt, $pos - 4)
}
}
if ($outfile) {
return undef if $oldChanged == $$et{CHANGED};
return substr($$dataPt, $$dirInfo{DirStart}, $dirLen);
}
return $err ? 0 : 1;
}
#------------------------------------------------------------------------------
# Process VRD IHL data
# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
# Returns: 1 on success
sub ProcessIHL($$$)
{
my ($et, $dirInfo, $tagTablePtr) = @_;
my $dataPt = $$dirInfo{DataPt};
my $dataPos = $$dirInfo{DataPos};
my $pos = $$dirInfo{DirStart};
my $dirLen = $$dirInfo{DirLen};
my $dirEnd = $pos + $dirLen;
$et->VerboseDir('VRD IHL', 0, $dirLen);
SetByteOrder('II'); # (make up your mind, Canon!)
while ($pos + 48 <= $dirEnd) {
my $hdr = substr($$dataPt, $pos, 48);
unless ($hdr =~ /^IHL Created Optional Item Data\0\0/) {
$et->Warn('Possibly corrupted VRD IHL data');
last;
}
my $tag = Get32u($dataPt, $pos + 36);
my $size = Get32u($dataPt, $pos + 40); # size of data in IHL record
my $next = Get32u($dataPt, $pos + 44); # size of complete IHL record
if ($size > $next or $pos + 48 + $next > $dirEnd) {
$et->Warn(sprintf('Bad size for VRD IHL tag 0x%.4x', $tag));
last;
}
$pos += 48;
$et->HandleTag($tagTablePtr, $tag, substr($$dataPt, $pos, $size),
DataPt => $dataPt,
DataPos => $dataPos,
Start => $pos,
Size => $size
);
$pos += $next;
}
return 1;
}
#------------------------------------------------------------------------------
# Process VRD IHL EXIF data
# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
# Returns: 1 on success
sub ProcessIHLExif($$$)
{
my ($et, $dirInfo, $tagTablePtr) = @_;
$$et{DOC_NUM} = 1;
# the IHL-edited maker notes may look messed up, but the offsets should be OK
my $oldFix = $et->Options(FixBase => 0);
my $rtnVal = $et->ProcessTIFF($dirInfo, $tagTablePtr);
$et->Options(FixBase => $oldFix);
delete $$et{DOC_NUM};
return $rtnVal;
}
#------------------------------------------------------------------------------
# Wrap DR4 data with the VRD header/footer and edit record
# Inputs: 0) DR4 record
# Returns: VRD[Edit[DR4]] data
sub WrapDR4($)
{
my $val = shift;
my $n = length $val;
my $oldOrder = GetByteOrder();
SetByteOrder('MM');
$val = $blankHeader . "\xff\xff\0\xf7" . Set32u($n+8) . Set32u($n) .
$val . "\0\0\0\0" . $blankFooter;
# update the new VRD length in the header/footer
Set32u($n + 16, \$val, 0x18); # (extra 16 bytes for the edit record wrapper)
Set32u($n + 16, \$val, length($val) - 0x2c);
SetByteOrder($oldOrder);
return $val;
}
#------------------------------------------------------------------------------
# Read/Write DPP version 4 edit data or DR4 file
# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
# Returns:
# Reading from memory (not RAF and not IsWriting): 1 on success
# Editing from memory (not RAF and IsWriting): modified edit data, or undef if nothing changed
# Reading file (RAF and not OutFile): 1 if a valid DR4 file, 0 if not
# Writing file (RAF and OutFile): 1 if valid DR4 file, 0 if not, -1 on write error
# (serves me right for not having a consistent interface for the various modes of operation)
sub ProcessDR4($$;$)
{
my ($et, $dirInfo, $tagTablePtr) = @_;
$et or return 1; # allow dummy access
my $dataPt = $$dirInfo{DataPt};
my $raf = $$dirInfo{RAF};
my $outfile = $$dirInfo{OutFile};
my $isWriting = $outfile || $$dirInfo{IsWriting};
my $dataPos = $$dirInfo{DataPos} || 0;
my $verbose = $et->Options('Verbose');
my $unknown = $et->Options('Unknown');
my ($pos, $dirLen, $numEntries, $err, $newTags);
# write CanonDR4 as a block if specified
if ($isWriting) {
my $nvHash;
my $newVal = $et->GetNewValue('CanonDR4', \$nvHash);
if ($newVal) {
$et->VPrint(0, " Writing CanonDR4 as a block\n");
$$et{DidCanonVRD} = 1; # set flag so we don't add this twice
++$$et{CHANGED};
if ($outfile) {
Write($$dirInfo{OutFile}, $newVal) or return -1;
return 1;
} else {
return $newVal;
}
} elsif (not $dataPt and ($nvHash or $$et{DEL_GROUP}{CanonVRD})) {
$et->Error("Can't delete all CanonDR4 information from a DR4 file");
return 1;
}
}
if ($dataPt) {
$pos = $$dirInfo{DirStart} || 0;
$dirLen = $$dirInfo{DirLen} || length($$dataPt) - $pos;
} else {
# load DR4 file into memory
my $buff;
$raf->Read($buff, 8) == 8 and $buff eq "IIII\x04\0\x04\0" or return 0;
$et->SetFileType();
$raf->Seek(0, 2) or return $err = 1;
$dirLen = $raf->Tell();
$raf->Seek(0, 0) or return $err = 1;
$raf->Read($buff, $dirLen) == $dirLen or $err = 1;
$err and $et->Warn('Error reading DR4 file'), return 1;
$tagTablePtr = GetTagTable('Image::ExifTool::CanonVRD::DR4');
$dataPt = \$buff;
$pos = 0;
}
my $dirEnd = $pos + $dirLen;
if (($$et{TAGS_FROM_FILE} and
not $$et{EXCL_TAG_LOOKUP}{canondr4}) or $$et{REQ_TAG_LOOKUP}{canondr4})
{
# extract CanonDR4 block if copying tags, or if requested
$et->FoundTag('CanonDR4', substr($$dataPt, $pos, $dirLen));
}
# version 4 header is 32 bytes (int32u[8])
if ($dirLen < 32) {
$err = 1;
} else {
SetByteOrder(substr($$dataPt, $pos, 2)) or $err = 1;
# process the DR4 header
my %hdrInfo = (
DataPt => $dataPt,
DirStart => $pos,
DirLen => 32,
DirName => 'DR4Header',
);
my $hdrTable = GetTagTable('Image::ExifTool::CanonVRD::DR4Header');
if ($outfile) {
my $hdr = $et->WriteDirectory(\%hdrInfo, $hdrTable);
substr($$dataPt, $pos, 32) = $hdr if $hdr and length $hdr == 32;
} else {
$et->VerboseDir('DR4Header', undef, 32);
$et->ProcessDirectory(\%hdrInfo, $hdrTable);
}
# number of entries in the DR4 directory
$numEntries = Get32u($dataPt, $pos + 28);
$err = 1 if $dirLen < 36 + 28 * $numEntries;
}
$err and $et->Warn('Invalid DR4 directory'), return $outfile ? undef : 0;
if ($outfile) {
$newTags = $et->GetNewTagInfoHash($tagTablePtr);
} else {
$et->VerboseDir('DR4', $numEntries, $dirLen);
}
my $index;
for ($index=0; $index<$numEntries; ++$index) {
my ($val, @flg, $i);
my $entry = $pos + 36 + 28 * $index;
last if $entry + 28 > $dirEnd;
my $tag = Get32u($dataPt, $entry);
my $fmt = Get32u($dataPt, $entry + 4);
$flg[0] = Get32u($dataPt, $entry + 8);
$flg[1] = Get32u($dataPt, $entry + 12);
$flg[2] = Get32u($dataPt, $entry + 16);
my $off = Get32u($dataPt, $entry + 20) + $pos;
my $len = Get32u($dataPt, $entry + 24);
next if $off + $len >= $dirEnd;
my $format = $vrdFormat{$fmt};
if (not $format) {
$val = unpack 'H*', substr($$dataPt, $off, $len);
$format = 'undef';
} elsif ($format eq 'double' and $len eq 8) {
# avoid teeny weeny values
$val = ReadValue($dataPt, $off, $format, undef, $len);
$val = 0 if abs($val) < 1e-100;
}
if ($outfile) {
# write (binary data) subdirectory if it exists
my $tagInfo = $et->GetTagInfo($tagTablePtr, $tag);
if ($tagInfo and $$tagInfo{SubDirectory}) {
my %subdirInfo = (
DataPt => $dataPt,
DirStart => $off,
DirLen => $len,
DirName => $$tagInfo{Name},
);
my $subTablePtr = GetTagTable($$tagInfo{SubDirectory}{TagTable});
my $saveChanged = $$et{CHANGED};
my $dat = $et->WriteDirectory(\%subdirInfo, $subTablePtr);
if (defined $dat and length($dat) == $len) {
substr($$dataPt, $off, $len) = $dat;
} else {
$$et{CHANGED} = $saveChanged; # didn't change anything after all
}
} else {
# loop through main tag and flags (don't yet consider flag 2)
for ($i=-1; $i<2; ++$i) {
$tagInfo = $$newTags{$i>=0 ? sprintf('0x%x.%d',$tag,$i) : $tag};
next unless $tagInfo;
if ($i >= 0) {
$off = $entry + 8 + 4 * $i;
$format = 'int32u';
$len = 4;
undef $val;
}
$val = ReadValue($dataPt, $off, $format, undef, $len) unless defined $val;
my $nvHash;
my $newVal = $et->GetNewValue($tagInfo, \$nvHash);
if ($et->IsOverwriting($nvHash, $val) and defined $newVal) {
my $count = int($len / Image::ExifTool::FormatSize($format));
my $rtnVal = WriteValue($newVal, $format, $count, $dataPt, $off);
if (defined $rtnVal) {
$et->VerboseValue("- CanonVRD:$$tagInfo{Name}", $val);
$et->VerboseValue("+ CanonVRD:$$tagInfo{Name}", $newVal);
++$$et{CHANGED};
}
}
}
}
next;
}
$et->HandleTag($tagTablePtr, $tag, $val,
DataPt => $dataPt,
DataPos => $dataPos,
Start => $off,
Size => $len,
Index => $index,
Format => $format,
# $flg[0] is on/off flag
# $flg[1] "is default" flag?
# $flg[2] changed to 0 when some unsharp mask settings were changed
Extra => ", fmt=$fmt flags=" . join(',', @flg),
);
foreach $i (0..2) {
my $flagID = sprintf('0x%x.%d', $tag, $i);
$et->HandleTag($tagTablePtr, $flagID, $flg[$i]) if $$tagTablePtr{$flagID};
}
}
return 1 unless $isWriting;
return substr($$dataPt, $pos, $dirLen) unless $raf;
return 1 if Write($outfile, substr($$dataPt, $pos, $dirLen));
return -1;
}
#------------------------------------------------------------------------------
# Read/write Canon VRD file
# Inputs: 0) ExifTool object reference, 1) dirInfo reference
# Returns: 1 if this was a Canon VRD file, 0 otherwise, -1 on write error
sub ProcessVRD($$)
{
my ($et, $dirInfo) = @_;
my $raf = $$dirInfo{RAF};
my $buff;
my $num = $raf->Read($buff, 0x1c);
# initialize write directories if necessary
$et->InitWriteDirs(\%vrdMap, 'XMP') if $$dirInfo{OutFile};
if (not $num and $$dirInfo{OutFile}) {
# create new VRD file from scratch
my $newVal = $et->GetNewValue('CanonVRD');
if ($newVal) {
$et->VPrint(0, " Writing CanonVRD as a block\n");
Write($$dirInfo{OutFile}, $newVal) or return -1;
$$et{DidCanonVRD} = 1;
++$$et{CHANGED};
} else {
# allow VRD to be created from individual tags
if ($$et{ADD_DIRS}{CanonVRD}) {
my $newVal = '';
if (ProcessCanonVRD($et, { OutFile => \$newVal }) > 0) {
Write($$dirInfo{OutFile}, $newVal) or return -1;
++$$et{CHANGED};
return 1;
}
}
$et->Error('No CanonVRD information to write');
}
} else {
$num == 0x1c or return 0;
$buff =~ /^CANON OPTIONAL DATA\0/ or return 0;
$et->SetFileType();
$$dirInfo{DirName} = 'CanonVRD'; # set directory name for verbose output
my $result = ProcessCanonVRD($et, $dirInfo);
return $result if $result < 0;
$result or $et->Warn('Format error in VRD file');
}
return 1;
}
#------------------------------------------------------------------------------
# Write VRD data record as a block
# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
# Returns: VRD data block (may be empty if no VRD data)
# Notes: Increments ExifTool CHANGED flag if changed
sub WriteCanonVRD($$;$)
{
my ($et, $dirInfo, $tagTablePtr) = @_;
$et or return 1; # allow dummy access
my $nvHash = $et->GetNewValueHash($Image::ExifTool::Extra{CanonVRD});
my $val = $et->GetNewValue($nvHash);
$val = '' unless defined $val;
return undef unless $et->IsOverwriting($nvHash, $val);
++$$et{CHANGED};
return $val;
}
#------------------------------------------------------------------------------
# Read/write CanonVRD information (from VRD file or VRD trailer)
# Inputs: 0) ExifTool object reference, 1) dirInfo reference
# Returns: 1 on success, 0 not valid VRD, or -1 error writing
# - updates DataPos to point to start of CanonVRD information
# - updates DirLen to existing trailer length
sub ProcessCanonVRD($$;$)
{
my ($et, $dirInfo, $tagTablePtr) = @_;
my $raf = $$dirInfo{RAF};
my $offset = $$dirInfo{Offset} || 0;
my $outfile = $$dirInfo{OutFile};
my $dataPt = $$dirInfo{DataPt};
my $verbose = $et->Options('Verbose');
my $out = $et->Options('TextOut');
my ($buff, $created, $err, $blockLen, $blockType, %didDir, $fromFile);
#
# The CanonVRD trailer has a 0x1c-byte header and a 0x40-byte footer,
# each beginning with "CANON OPTIONAL DATA\0" and containing an int32u
# giving the size of the contained data (at byte 0x18 and 0x14 respectively)
#
if ($raf) {
$fromFile = 1;
} else {
unless ($dataPt) {
return 1 unless $outfile;
# create blank VRD data from scratch
my $blank = $blankHeader . $blankFooter;
$dataPt = \$blank;
$verbose and print $out " Creating CanonVRD trailer\n";
$created = 1;
}
$raf = new File::RandomAccess($dataPt);
}
# read and validate the footer
$raf->Seek(-0x40-$offset, 2) or return 0;
$raf->Read($buff, 0x40) == 0x40 or return 0;
$buff =~ /^CANON OPTIONAL DATA\0(.{4})/s or return 0;
my $dirLen = unpack('N', $1) + 0x5c; # size including header+footer
# read and validate the header
unless ($dirLen < 0x80000000 and
$raf->Seek(-$dirLen, 1) and
$raf->Read($buff, 0x1c) == 0x1c and
$buff =~ /^CANON OPTIONAL DATA\0/ and
$raf->Seek(-0x1c, 1))
{
$et->Warn('Bad CanonVRD trailer');
return 0;
}
# set variables returned in dirInfo hash
$$dirInfo{DataPos} = $raf->Tell();
$$dirInfo{DirLen} = $dirLen;
if ($outfile and ref $outfile eq 'SCALAR' and not length $$outfile) {
# write directly to outfile to avoid duplicating data in memory
$$outfile = $$dataPt unless $fromFile;
# TRICKY! -- copy to outfile memory buffer and edit in place
# (so we must disable all Write() calls for this case)
$dataPt = $outfile;
}
if ($fromFile) {
$dataPt = \$buff unless $dataPt;
# read VRD data into memory if necessary
unless ($raf->Read($$dataPt, $dirLen) == $dirLen) {
$$dataPt = '' if $outfile and $outfile eq $dataPt;
$et->Warn('Error reading CanonVRD data');
return 0;
}
}
# exit quickly if writing and no CanonVRD tags are being edited
if ($outfile and not exists $$et{EDIT_DIRS}{CanonVRD}) {
print $out "$$et{INDENT} [nothing changed]\n" if $verbose;
return 1 if $outfile eq $dataPt;
return Write($outfile, $$dataPt) ? 1 : -1;
}
my $vrdType = 'VRD';
if ($outfile) {
$verbose and not $created and print $out " Rewriting CanonVRD trailer\n";
# delete CanonVRD information if specified
my $doDel = $$et{DEL_GROUP}{CanonVRD};
unless ($doDel) {
$doDel = 1 if $$et{DEL_GROUP}{Trailer} and $$et{FILE_TYPE} ne 'VRD';
unless ($doDel) {
# also delete if writing as a block (will get added back again later)
if ($$et{NEW_VALUE}{$Image::ExifTool::Extra{CanonVRD}}) {
# delete if this isn't version 4
$doDel = 1 unless $$dataPt =~ /^.{28}\xff\xff\0\xf7/s;
}
if ($$et{NEW_VALUE}{$Image::ExifTool::Extra{CanonDR4}} and not $doDel) {
# delete if this is version 4
$doDel = 1 if $$dataPt =~ /^.{28}\xff\xff\0\xf7/s;
}
}
}
if ($doDel) {
if ($$et{FILE_TYPE} eq 'VRD') {
my $newVal = $et->GetNewValue('CanonVRD');
if ($newVal) {
$verbose and print $out " Writing CanonVRD as a block\n";
if ($outfile eq $dataPt) {
$$outfile = $newVal;
} else {
Write($outfile, $newVal) or return -1;
}
$$et{DidCanonVRD} = 1;
++$$et{CHANGED};
} else {
$et->Error("Can't delete all CanonVRD information from a VRD file");
}
} else {
$verbose and print $out " Deleting CanonVRD trailer\n";
$$outfile = '' if $outfile eq $dataPt;
++$$et{CHANGED};
}
return 1;
}
# write now and return if CanonVRD was set as a block
my $val = $et->GetNewValue('CanonVRD');
unless ($val) {
$val = $et->GetNewValue('CanonDR4');
$vrdType = 'DR4' if $val;
}
if ($val) {
$verbose and print $out " Writing Canon$vrdType as a block\n";
# must wrap DR4 data with the VRD header/footer and edit record
$val = WrapDR4($val) if $vrdType eq 'DR4';
if ($outfile eq $dataPt) {
$$outfile = $val;
} else {
Write($outfile, $val) or return -1;
}
$$et{DidCanonVRD} = 1;
++$$et{CHANGED};
return 1;
}
} elsif ($verbose or $$et{HTML_DUMP}) {
$et->DumpTrailer($dirInfo) if $$dirInfo{RAF};
}
$tagTablePtr = GetTagTable('Image::ExifTool::CanonVRD::Main');
# validate VRD trailer and get position and length of edit record
SetByteOrder('MM'); # VRD header/footer is big-endian
my $pos = 0x1c; # start at end of header
# loop through the VRD blocks
for (;;) {
my $end = $dirLen - 0x40; # end of last VRD block (and start of footer)
if ($pos + 8 > $end) {
last if $pos == $end;
$blockLen = $end; # mark as invalid
} else {
$blockType = Get32u($dataPt, $pos);
$blockLen = Get32u($dataPt, $pos + 4);
}
$vrdType = 'DR4' if $blockType eq 0xffff00f7;
$pos += 8; # move to start of block
if ($pos + $blockLen > $end) {
$et->Warn('Possibly corrupt CanonVRD block');
last;
}
if ($verbose > 1 and not $outfile) {
printf $out " CanonVRD block 0x%.8x ($blockLen bytes at offset 0x%x)\n",
$blockType, $pos + $$dirInfo{DataPos};
$et->VerboseDump($dataPt, Len => $blockLen, Start => $pos, Addr => $pos + $$dirInfo{DataPos});
}
my $tagInfo = $$tagTablePtr{$blockType};
unless ($tagInfo) {
unless ($et->Options('Unknown')) {
$pos += $blockLen; # step to next block
next;
}
my $name = sprintf('CanonVRD_0x%.8x', $blockType);
my $desc = $name;
$desc =~ tr/_/ /;
$tagInfo = {
Name => $name,
Description => $desc,
Binary => 1,
};
AddTagToTable($tagTablePtr, $blockType, $tagInfo);
}
if ($$tagInfo{SubDirectory}) {
my $subTablePtr = GetTagTable($$tagInfo{SubDirectory}{TagTable});
my %subdirInfo = (
DataPt => $dataPt,
DataLen => length $$dataPt,
DataPos => $$dirInfo{DataPos},
DirStart => $pos,
DirLen => $blockLen,
DirName => $$tagInfo{Name},
Parent => 'CanonVRD',
OutFile => $outfile,
);
if ($outfile) {
# set flag indicating we did this directory
$didDir{$$tagInfo{Name}} = 1;
my ($dat, $diff);
if ($$et{NEW_VALUE}{$tagInfo}) {
# write as a block
$et->VPrint(0, "Writing $$tagInfo{Name} as a block\n");
$dat = $et->GetNewValue($tagInfo);
$dat = '' unless defined $dat;
++$$et{CHANGED};
} else {
$dat = $et->WriteDirectory(\%subdirInfo, $subTablePtr);
}
# update data with new directory
if (defined $dat) {
if (length $dat or $$et{FILE_TYPE} !~ /^(CRW|VRD)$/) {
# replace with new block (updating the block length word)
substr($$dataPt, $pos-4, $blockLen+4) = Set32u(length $dat) . $dat;
} else {
# remove block totally (CRW/VRD files only)
substr($$dataPt, $pos-8, $blockLen+8) = '';
}
# make necessary adjustments if block changes length
if (($diff = length($$dataPt) - $dirLen) != 0) {
$pos += $diff;
$dirLen += $diff;
# update the new VRD length in the header/footer
Set32u($dirLen - 0x5c, $dataPt, 0x18);
Set32u($dirLen - 0x5c, $dataPt, $dirLen - 0x2c);
}
}
} else {
# extract as a block if requested
$et->ProcessDirectory(\%subdirInfo, $subTablePtr);
}
} else {
$et->HandleTag($tagTablePtr, $blockType, substr($$dataPt, $pos, $blockLen));
}
$pos += $blockLen; # step to next block
}
if ($outfile) {
# create XMP block if necessary (CRW/VRD files only)
if ($$et{ADD_DIRS}{CanonVRD} and not $didDir{XMP}) {
my $subTablePtr = GetTagTable('Image::ExifTool::XMP::Main');
my $dat = $et->WriteDirectory({ Parent => 'CanonVRD' }, $subTablePtr);
if ($dat) {
my $blockLen = length $dat;
substr($$dataPt, -0x40, 0) = Set32u(0xffff00f6) . Set32u(length $dat) . $dat;
$dirLen = length $$dataPt;
# update the new VRD length in the header/footer
Set32u($dirLen - 0x5c, $dataPt, 0x18);
Set32u($dirLen - 0x5c, $dataPt, $dirLen - 0x2c);
}
}
# write CanonVRD trailer unless it is empty
if (length $$dataPt) {
Write($outfile, $$dataPt) or $err = 1 unless $outfile eq $dataPt;
} else {
$verbose and print $out " Deleting CanonVRD trailer\n";
}
} elsif ($vrdType eq 'VRD' and (($$et{TAGS_FROM_FILE} and
not $$et{EXCL_TAG_LOOKUP}{canonvrd}) or $$et{REQ_TAG_LOOKUP}{canonvrd}))
{
# extract CanonVRD block if copying tags, or if requested (and not DR4 info)
$et->FoundTag('CanonVRD', $buff);
}
undef $buff;
return $err ? -1 : 1;
}
1; # end
__END__
=head1 NAME
Image::ExifTool::CanonVRD - Read/write Canon VRD and DR4 information
=head1 SYNOPSIS
This module is used by Image::ExifTool
=head1 DESCRIPTION
This module contains definitions required by Image::ExifTool to read and
write VRD and DR4 Recipe Data information as written by the Canon Digital
Photo Professional software. This information is written to VRD and DR4
files, and as a trailer in JPEG, CRW, CR2 and TIFF images.
=head1 AUTHOR
Copyright 2003-2018, 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 ACKNOWLEDGEMENTS
Thanks to Bogdan and Gert Kello for decoding some tags.
=head1 SEE ALSO
L<Image::ExifTool::TagNames/CanonVRD Tags>,
L<Image::ExifTool(3pm)|Image::ExifTool>
=cut