exiftool_vendored 10.04.0 → 10.23.0

data/bin/Image-ExifTool-10.23/lib/Image/ExifTool/FLAC.pm

@@ -0,0 +1,297 @@
+#------------------------------------------------------------------------------
+# File:         FLAC.pm
+#
+# Description:  Read Free Lossless Audio Codec information
+#
+# Revisions:    11/13/2006 - P. Harvey Created
+#
+# References:   1) http://flac.sourceforge.net/
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::FLAC;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+
+$VERSION = '1.07';
+
+sub ProcessBitStream($$$);
+
+# FLAC metadata blocks
+%Image::ExifTool::FLAC::Main = (
+    NOTES => q{
+        Free Lossless Audio Codec (FLAC) meta information.  ExifTool also extracts
+        ID3 information from these files.
+    },
+    0 => {
+        Name => 'StreamInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLAC::StreamInfo' },
+    },
+    1 => { Name => 'Padding',     Binary => 1, Unknown => 1 },
+    2 => { Name => 'Application', Binary => 1, Unknown => 1 },
+    3 => { Name => 'SeekTable',   Binary => 1, Unknown => 1 },
+    4 => {
+        Name => 'VorbisComment',
+        SubDirectory => { TagTable => 'Image::ExifTool::Vorbis::Comments' },
+    },
+    5 => { Name => 'CueSheet',    Binary => 1, Unknown => 1 },
+    6 => {
+        Name => 'Picture',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLAC::Picture' },
+    },
+    # 7-126 - Reserved
+    # 127 - Invalid
+);
+
+%Image::ExifTool::FLAC::StreamInfo = (
+    PROCESS_PROC => \&ProcessBitStream,
+    NOTES => 'FLAC is big-endian, so bit 0 is the high-order bit in this table.',
+    GROUPS => { 2 => 'Audio' },
+    'Bit000-015' => 'BlockSizeMin',
+    'Bit016-031' => 'BlockSizeMax',
+    'Bit032-055' => 'FrameSizeMin',
+    'Bit056-079' => 'FrameSizeMax',
+    'Bit080-099' => 'SampleRate',
+    'Bit100-102' => {
+        Name => 'Channels',
+        ValueConv => '$val + 1',
+    },
+    'Bit103-107' => {
+        Name => 'BitsPerSample',
+        ValueConv => '$val + 1',
+    },
+    'Bit108-143' => 'TotalSamples',
+);
+
+%Image::ExifTool::FLAC::Picture = (
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    GROUPS => { 2 => 'Image' },
+    FORMAT => 'int32u',
+    0 => {
+        Name => 'PictureType',
+        PrintConv => { # (Note: Duplicated in ID3, ASF and FLAC modules!)
+            0 => 'Other',
+            1 => '32x32 PNG Icon',
+            2 => 'Other Icon',
+            3 => 'Front Cover',
+            4 => 'Back Cover',
+            5 => 'Leaflet',
+            6 => 'Media',
+            7 => 'Lead Artist',
+            8 => 'Artist',
+            9 => 'Conductor',
+            10 => 'Band',
+            11 => 'Composer',
+            12 => 'Lyricist',
+            13 => 'Recording Studio or Location',
+            14 => 'Recording Session',
+            15 => 'Performance',
+            16 => 'Capture from Movie or Video',
+            17 => 'Bright(ly) Colored Fish',
+            18 => 'Illustration',
+            19 => 'Band Logo',
+            20 => 'Publisher Logo',
+        },
+    },
+    1 => {
+        Name => 'PictureMIMEType',
+        Format => 'var_pstr32',
+    },
+    2 => {
+        Name => 'PictureDescription',
+        Format => 'var_pstr32',
+        ValueConv => '$self->Decode($val, "UTF8")',
+    },
+    3 => 'PictureWidth',
+    4 => 'PictureHeight',
+    5 => 'PictureBitsPerPixel',
+    6 => 'PictureIndexedColors',
+    7 => 'PictureLength',
+    8 => {
+        Name => 'Picture',
+        Groups => { 2 => 'Preview' },
+        Format => 'undef[$val{7}]',
+        Binary => 1,
+    },
+);
+
+# FLAC composite tags
+%Image::ExifTool::FLAC::Composite = (
+    Duration => {
+        Require => {
+            0 => 'FLAC:SampleRate',
+            1 => 'FLAC:TotalSamples',
+        },
+        ValueConv => '($val[0] and $val[1]) ? $val[1] / $val[0] : undef',
+        PrintConv => 'ConvertDuration($val)',
+    },
+);
+
+# add our composite tags
+Image::ExifTool::AddCompositeTags('Image::ExifTool::FLAC');
+
+
+#------------------------------------------------------------------------------
+# Process information in a bit stream
+# Inputs: 0) ExifTool object ref, 1) dirInfo ref, 2) tag table ref
+# Notes: Byte order is used to determine the ordering of bits in the stream:
+# 'MM' = bit 0 is most significant, 'II' = bit 0 is least significant
+# - can handle arbitrarily wide values (eg. 8-byte or larger integers)
+sub ProcessBitStream($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt   = $$dirInfo{DataPt};
+    my $dataPos  = $$dirInfo{DataPos};
+    my $dirStart = $$dirInfo{DirStart} || 0;
+    my $dirLen   = $$dirInfo{DirLen} || (length($$dataPt) - $dirStart);
+    my $verbose  = $et->Options('Verbose');
+    my $byteOrder = GetByteOrder();
+    my $tag;
+
+    if ($verbose) {
+        $et->VPrint(0, "  + [BitStream directory, $dirLen bytes, '$byteOrder' order]\n");
+    }
+    foreach $tag (sort keys %$tagTablePtr) {
+        next unless $tag =~ /^Bit(\d+)-?(\d+)?/;
+        my ($b1, $b2) = ($1, $2 || $1);     # start/end bit numbers in stream
+        my ($i1, $i2) = (int($b1 / 8), int($b2 / 8)); # start/end byte numbers
+        my ($f1, $f2) = ($b1 % 8, $b2 % 8); # start/end bit numbers within each byte
+        last if $i2 >= $dirLen;
+        my $val = 0;
+        my ($i, $mask, $extra);
+        $extra = ', Mask=0x' if $verbose and ($f1 != 0 or $f2 != 7);
+        if ($byteOrder eq 'MM') {
+            # loop from high byte to low byte
+            for ($i=$i1; $i<=$i2; ++$i) {
+                $mask = 0xff;
+                if ($i == $i1 and $f1) {
+                    # mask off high bits in first word (0 is high bit)
+                    foreach ((8-$f1) .. 7) { $mask ^= (1 << $_) }
+                }
+                if ($i == $i2 and $f2 < 7) {
+                    # mask off low bits in last word (7 is low bit)
+                    foreach (0 .. (6-$f2)) { $mask ^= (1 << $_) }
+                }
+                $val = $val * 256 + ($mask & Get8u($dataPt, $i + $dirStart));
+                $extra .= sprintf('%.2x', $mask) if $extra;
+            }
+        } else {
+            # (FLAC is big-endian, but support little-endian bit streams
+            #  so this routine can be used by other modules)
+            # loop from high byte to low byte
+            for ($i=$i2; $i>=$i1; --$i) {
+                $mask = 0xff;
+                if ($i == $i1 and $f1) {
+                    # mask off low bits in first word (0 is low bit)
+                    foreach (0 .. ($f1-1)) { $mask ^= (1 << $_) }
+                }
+                if ($i == $i2 and $f2 < 7) {
+                    # mask off high bits in last word (7 is high bit)
+                    foreach (($f2+1) .. 7) { $mask ^= (1 << $_) }
+                }
+                $val = $val * 256 + ($mask & Get8u($dataPt, $i + $dirStart));
+                $extra .= sprintf('%.2x', $mask) if $extra;
+            }
+        }
+        # shift word down until low bit is in position 0
+        until ($mask & 0x01) {
+            $val /= 2;
+            $mask >>= 1;
+        }
+        $et->HandleTag($tagTablePtr, $tag, $val,
+            DataPt  => $dataPt,
+            DataPos => $dataPos,
+            Start   => $dirStart + $i1,
+            Size    => $i2 - $i1 + 1,
+            Extra   => $extra,
+        );
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Extract information from an Ogg FLAC file
+# Inputs: 0) ExifTool object reference, 1) dirInfo reference
+# Returns: 1 on success, 0 if this wasn't a valid Ogg FLAC file
+sub ProcessFLAC($$)
+{
+    my ($et, $dirInfo) = @_;
+
+    # must first check for leading/trailing ID3 information
+    unless ($$et{DoneID3}) {
+        require Image::ExifTool::ID3;
+        Image::ExifTool::ID3::ProcessID3($et, $dirInfo) and return 1;
+    }
+    my $raf = $$dirInfo{RAF};
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
+    my ($buff, $err);
+
+    # check FLAC signature
+    $raf->Read($buff, 4) == 4 and $buff eq 'fLaC' or return 0;
+    $et->SetFileType();
+    SetByteOrder('MM');
+    my $tagTablePtr = GetTagTable('Image::ExifTool::FLAC::Main');
+    for (;;) {
+        # read next metadata block header
+        $raf->Read($buff, 4) == 4 or last;
+        my $flag = unpack('C', $buff);
+        my $size = unpack('N', $buff) & 0x00ffffff;
+        $raf->Read($buff, $size) == $size or $err = 1, last;
+        my $last = $flag & 0x80;    # last-metadata-block flag
+        my $tag  = $flag & 0x7f;    # tag bits
+        if ($verbose) {
+            print $out "FLAC metadata block, type $tag:\n";
+            $et->VerboseDump(\$buff, DataPos => $raf->Tell() - $size);
+        }
+        $et->HandleTag($tagTablePtr, $tag, undef,
+            DataPt  => \$buff,
+            DataPos => $raf->Tell() - $size,
+        );
+        last if $last;   # all done if  is set
+    }
+    $err and $et->Warn('Format error in FLAC file');
+    return 1;
+}
+
+1;  # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::FLAC - Read Free Lossless Audio Codec information
+
+=head1 SYNOPSIS
+
+This module is used by Image::ExifTool
+
+=head1 DESCRIPTION
+
+This module contains definitions required by Image::ExifTool to extract meta
+information from Free Lossless Audio Codec (FLAC) audio files.
+
+=head1 AUTHOR
+
+Copyright 2003-2016, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://flac.sourceforge.net/>
+
+=back
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/FLAC Tags>,
+L<Image::ExifTool::TagNames/Ogg Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut
+

data/bin/Image-ExifTool-10.23/lib/Image/ExifTool/FLIR.pm

@@ -0,0 +1,1533 @@
+#------------------------------------------------------------------------------
+# File:         FLIR.pm
+#
+# Description:  Read FLIR meta information
+#
+# Revisions:    2013/03/28 - P. Harvey Created
+#
+# References:   1) http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,4898.0.html
+#               2) http://www.nuage.ch/site/flir-i7-some-analysis/
+#               3) http://www.workswell.cz/manuals/flir/hardware/A3xx_and_A6xx_models/Streaming_format_ThermoVision.pdf
+#               4) http://support.flir.com/DocDownload/Assets/62/English/1557488%24A.pdf
+#               5) http://code.google.com/p/dvelib/source/browse/trunk/flirPublicFormat/fpfConverter/Fpfimg.h?spec=svn3&r=3
+#               6) http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,5538.0.html
+#               JD) Jens Duttke private communication
+#
+# Glossary:     FLIR = Forward Looking Infra Red
+#------------------------------------------------------------------------------
+
+package Image::ExifTool::FLIR;
+
+use strict;
+use vars qw($VERSION);
+use Image::ExifTool qw(:DataAccess :Utils);
+use Image::ExifTool::Exif;
+use Image::ExifTool::GPS;
+
+$VERSION = '1.14';
+
+sub ProcessFLIR($$;$);
+sub ProcessFLIRText($$$);
+sub ProcessMeasInfo($$$);
+sub GetImageType($$$);
+
+my %temperatureInfo = (
+    Writable => 'rational64u',
+    Format => 'rational64s', # (have seen negative values)
+);
+
+# tag information for floating point Kelvin tag
+my %floatKelvin = (
+    Format => 'float',
+    ValueConv => '$val - 273.15',
+    PrintConv => 'sprintf("%.1f C",$val)',
+);
+
+# commonly used tag information elements
+my %float1f = ( Format => 'float', PrintConv => 'sprintf("%.1f",$val)' );
+my %float2f = ( Format => 'float', PrintConv => 'sprintf("%.2f",$val)' );
+my %float6f = ( Format => 'float', PrintConv => 'sprintf("%.6f",$val)' );
+my %float8g = ( Format => 'float', PrintConv => 'sprintf("%.8g",$val)' );
+
+# FLIR makernotes tags (ref PH)
+%Image::ExifTool::FLIR::Main = (
+    WRITE_PROC => \&Image::ExifTool::Exif::WriteExif,
+    CHECK_PROC => \&Image::ExifTool::Exif::CheckExif,
+    GROUPS => { 0 => 'MakerNotes', 2 => 'Camera' },
+    WRITABLE => 1,
+    PRIORITY => 0, # (unreliable)
+    NOTES => q{
+        Information extracted from the maker notes of JPEG images from thermal
+        imaging cameras by FLIR Systems Inc.
+    },
+    0x01 => { #2
+        Name => 'ImageTemperatureMax',
+        %temperatureInfo,
+        Notes => q{
+            these temperatures may be in Celcius, Kelvin or Fahrenheit, but there is no
+            way to tell which
+        },
+    },
+    0x02 => { Name => 'ImageTemperatureMin', %temperatureInfo }, #2
+    0x03 => { #1
+        Name => 'Emissivity',
+        Writable => 'rational64u',
+        PrintConv => 'sprintf("%.2f",$val)',
+        PrintConvInv => '$val',
+    },
+    # 0x04 does not change with temperature units; often 238, 250 or 457
+    0x04 => { Name => 'UnknownTemperature', %temperatureInfo, Unknown => 1 },
+    # 0x05,0x06 are unreliable.  As written by FLIR tools, these are the
+    # CameraTemperatureRangeMax/Min, but the units vary depending on the
+    # options settings.  But as written by some cameras, the values are different.
+    0x05 => { Name => 'CameraTemperatureRangeMax', %temperatureInfo, Unknown => 1 },
+    0x06 => { Name => 'CameraTemperatureRangeMin', %temperatureInfo, Unknown => 1 },
+    # 0x07 - string[33] (some sort of image ID?)
+    # 0x08 - string[33]
+    # 0x09 - undef (tool info)
+    # 0x0a - int32u: 1
+    # 0x0f - rational64u: 0/1000
+    # 0x10,0x11,0x12 - int32u: 0
+    # 0x13 - rational64u: 0/1000
+);
+
+# FLIR FFF tag table (ref PH)
+%Image::ExifTool::FLIR::FFF = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&ProcessFLIR,
+    VARS => { ALPHA_FIRST => 1 },
+    NOTES => q{
+        Information extracted from FLIR FFF images and the FLIR APP1 segment of JPEG
+        images.  These tags may also be extracted from the first frame of an FLIR
+        SEQ file.
+    },
+    "_header" => {
+        Name => 'FFFHeader',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::Header' },
+    },
+    # 0 = free (ref 3)
+    0x01 => {
+        Name => 'RawData',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::RawData' },
+    },
+    # 2 = GainMap (ref 3)
+    # 3 = OffsMap (ref 3)
+    # 4 = DeadMap (ref 3)
+    0x05 => { #6
+        Name => 'GainDeadData',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::GainDeadData' },
+    },
+    0x06 => { #6
+        Name => 'CoarseData',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::CoarseData' },
+    },
+    # 7 = ImageMap (ref 3)
+    0x0e => {
+        Name => 'EmbeddedImage',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::EmbeddedImage' },
+    },
+    0x20 => {
+        Name => 'CameraInfo', # (BasicData - ref 3)
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::CameraInfo' },
+    },
+    0x21 => { #6
+        Name => 'MeasurementInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::MeasInfo' },
+    },
+    0x22 => {
+        Name => 'PaletteInfo', # (ColorPal - ref 3)
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::PaletteInfo' },
+    },
+    0x23 => {
+        Name => 'TextInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::TextInfo' },
+    },
+    0x24 => {
+        Name => 'EmbeddedAudioFile',
+        # (sometimes has an unknown 8-byte header)
+        RawConv => q{
+            return \$val if $val =~ s/^.{0,16}?RIFF/RIFF/s;
+            $self->Warn('Unknown EmbeddedAudioFile format');
+            return undef;
+        },
+    },
+    # 0x27: 01 00 08 00 10 00 00 00
+    0x28 => {
+        Name => 'PaintData',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::PaintData' },
+    },
+    0x2a => {
+        Name => 'PiP',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FLIR::PiP',
+            ByteOrder => 'LittleEndian',
+        },
+    },
+    0x2b => {
+        Name => 'GPSInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::GPSInfo' },
+    },
+    0x2c => {
+        Name => 'MeterLink',
+        SubDirectory => {
+            TagTable => 'Image::ExifTool::FLIR::MeterLink' ,
+            ByteOrder => 'LittleEndian'
+        },
+    },
+    0x2e => {
+        Name => 'ParameterInfo',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::ParamInfo' },
+    },
+);
+
+# FFF file header (ref PH)
+%Image::ExifTool::FLIR::Header = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => 'Tags extracted from the FLIR FFF/AFF header.',
+    4 => { Name => 'CreatorSoftware', Format => 'string[16]' },
+);
+
+# FLIR raw data record (ref PH)
+%Image::ExifTool::FLIR::RawData = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        The thermal image data may be stored either as raw data, or in PNG format.
+        If stored as raw data, ExifTool adds a TIFF header to allow the data to be
+        viewed as a TIFF image.  If stored in PNG format, the PNG image is extracted
+        as-is.  Note that most FLIR cameras using the PNG format seem to write the
+        16-bit raw image data in the wrong byte order.
+    },
+    0x00 => {
+        # use this tag only to determine the byte order of the raw data
+        # (the value should be 0x0002 if the byte order is correct)
+        # - always "II" when RawThermalImageType is "TIFF"
+        # - seen both "II" and "MM" when RawThermalImageType is "PNG"
+        Name => 'RawDataByteOrder',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    0x01 => {
+        Name => 'RawThermalImageWidth',
+        RawConv => '$$self{RawThermalImageWidth} = $val',
+    },
+    0x02 => {
+        Name => 'RawThermalImageHeight',
+        RawConv => '$$self{RawThermalImageHeight} = $val',
+    },
+    # 0x03-0x05: 0
+    # 0x06: raw image width - 1
+    # 0x07: 0
+    # 0x08: raw image height - 1
+    # 0x09: 0,15,16
+    # 0x0a: 0,2,3,11,12,13,30
+    # 0x0b: 0,2
+    # 0x0c: 0 or a large number
+    # 0x0d: 0,3,4,6
+    # 0x0e-0x0f: 0
+    16 => {
+        Name => 'RawThermalImageType',
+        Format => 'undef[$size-0x20]',
+        RawConv => 'Image::ExifTool::FLIR::GetImageType($self, $val, "RawThermalImage")',
+    },
+    16.1 => {
+        Name => 'RawThermalImage',
+        Groups => { 2 => 'Preview' },
+        RawConv => '\$$self{RawThermalImage}',
+    },
+);
+
+# GainDeadMap record (ref 6) (see RawData above)
+%Image::ExifTool::FLIR::GainDeadData = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    NOTES => 'Information found in FFF-format .GAN calibration image files.',
+    0x00 => {
+        Name => 'GainDeadMapByteOrder',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    0x01 => {
+        Name => 'GainDeadMapImageWidth',
+        RawConv => '$$self{GainDeadMapImageWidth} = $val',
+    },
+    0x02 => {
+        Name => 'GainDeadMapImageHeight',
+        RawConv => '$$self{GainDeadMapImageHeight} = $val',
+    },
+    16 => {
+        Name => 'GainDeadMapImageType',
+        Format => 'undef[$size-0x20]',
+        RawConv => 'Image::ExifTool::FLIR::GetImageType($self, $val, "GainDeadMapImage")',
+    },
+    16.1 => {
+        Name => 'GainDeadMapImage',
+        RawConv => '\$$self{GainDeadMapImage}',
+    },
+);
+
+# CoarseMap record (ref 6) (see RawData above)
+%Image::ExifTool::FLIR::CoarseData = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    NOTES => 'Information found in FFF-format .CRS correction image files.',
+    0x00 => {
+        Name => 'CoarseMapByteOrder',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    0x01 => {
+        Name => 'CoarseMapImageWidth',
+        RawConv => '$$self{CoarseMapImageWidth} = $val',
+    },
+    0x02 => {
+        Name => 'CoarseMapImageHeight',
+        RawConv => '$$self{CoarseMapImageHeight} = $val',
+    },
+    16 => {
+        Name => 'CoarseMapImageType',
+        Format => 'undef[$size-0x20]',
+        RawConv => 'Image::ExifTool::FLIR::GetImageType($self, $val, "CoarseMapImage")',
+    },
+    16.1 => {
+        Name => 'CoarseMapImage',
+        RawConv => '\$$self{CoarseMapImage}',
+    },
+);
+
+# "Paint colors" record (ref PH)
+%Image::ExifTool::FLIR::PaintData = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    NOTES => 'Information generated by FLIR Tools "Paint colors" tool.',
+    0x01 => {
+        Name => 'PaintByteOrder',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    0x05 => {
+        Name => 'PaintImageWidth',
+        RawConv => '$$self{PaintImageWidth} = $val',
+    },
+    0x06 => {
+        Name => 'PaintImageHeight',
+        RawConv => '$$self{PaintImageHeight} = $val',
+    },
+    20 => {
+        Name => 'PaintImageType',
+        Format => 'undef[$size-0x28]',
+        RawConv => 'Image::ExifTool::FLIR::GetImageType($self, $val, "PaintImage")',
+    },
+    20.1 => {
+        Name => 'PaintImage',
+        RawConv => '\$$self{PaintImage}',
+    },
+);
+
+# FLIR embedded image (ref 1)
+%Image::ExifTool::FLIR::EmbeddedImage = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    0 => {
+        # use this tag only to determine the byte order
+        # (the value should be 0x0003 if the byte order is correct)
+        Name => 'EmbeddedImageByteOrder',
+        Format => 'int16u',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    1 => 'EmbeddedImageWidth',
+    2 => 'EmbeddedImageHeight',
+    16 => {
+        Name => 'EmbeddedImageType',
+        Format => 'undef[4]',
+        RawConv => '$val =~ /^\x89PNG/s ? "PNG" : ($val =~ /^\xff\xd8\xff/ ? "JPG" : "DAT")',
+        Notes => q{
+            "PNG" for PNG image in Y Cb Cr colors, "JPG" for a JPEG image, or "DAT" for
+            other image data
+        },
+    },
+    16.1 => {
+        Name => 'EmbeddedImage',
+        Groups => { 2 => 'Preview' },
+        Format => 'undef[$size-0x20]',
+        Binary => 1,
+    },
+);
+
+# FLIR camera record (ref PH)
+%Image::ExifTool::FLIR::CameraInfo = (
+    GROUPS => { 0 => 'APP1', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        FLIR camera information.  The Planck tags are variables used in the
+        temperature calculation.  See
+        L<http://u88.n24.queensu.ca/exiftool/forum/index.php?topic=4898.msg23972#msg23972>
+        for details.
+    },
+    0x00 => {
+        # use this tag only to determine the byte order
+        # (the value should be 0x0002 if the byte order is correct)
+        Name => 'CameraInfoByteOrder',
+        Format => 'int16u',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    # 0x02 - int16u: image width
+    # 0x04 - int16u: image height
+    # 0x0c - int32u: image width - 1
+    # 0x10 - int32u: image height - 1
+    0x20 => { Name => 'Emissivity',                   %float2f },
+    0x24 => { Name => 'ObjectDistance', Format => 'float', PrintConv => 'sprintf("%.2f m",$val)' },
+    0x28 => { Name => 'ReflectedApparentTemperature', %floatKelvin },
+    0x2c => { Name => 'AtmosphericTemperature',       %floatKelvin },
+    0x30 => { Name => 'IRWindowTemperature',          %floatKelvin },
+    0x34 => { Name => 'IRWindowTransmission',         %float2f },
+    # 0x38: 0
+    0x3c => {
+        Name => 'RelativeHumidity',
+        Format => 'float',
+        ValueConv => '$val > 2 ? $val / 100 : $val', # have seen value expressed as percent in FFF file
+        PrintConv => 'sprintf("%.1f %%",$val*100)',
+    },
+    # 0x40 - float: 0,6
+    # 0x44,0x48,0x4c: 0
+    # 0x50 - int32u: 1
+    # 0x54: 0
+    0x58 => { Name => 'PlanckR1', %float8g }, #1
+    0x5c => { Name => 'PlanckB',  %float8g }, #1
+    0x60 => { Name => 'PlanckF',  %float8g }, #1
+    # 0x64,0x68,0x6c: 0
+    0x070 => { Name => 'AtmosphericTransAlpha1', %float6f }, #1 (value: 0.006569)
+    0x074 => { Name => 'AtmosphericTransAlpha2', %float6f }, #1 (value: 0.012620)
+    0x078 => { Name => 'AtmosphericTransBeta1',  %float6f }, #1 (value: -0.002276)
+    0x07C => { Name => 'AtmosphericTransBeta2',  %float6f }, #1 (value: -0.006670)
+    0x080 => { Name => 'AtmosphericTransX',      %float6f }, #1 (value: 1.900000)
+    # 0x84,0x88: 0
+    # 0x8c - float: 0,4,6
+    0x90 => { Name => 'CameraTemperatureRangeMax', %floatKelvin },
+    0x94 => { Name => 'CameraTemperatureRangeMin', %floatKelvin },
+    0x98 => { Name => 'UnknownTemperature1', %floatKelvin, Unknown => 1 }, # 50 degrees over camera max
+    0x9c => { Name => 'UnknownTemperature2', %floatKelvin, Unknown => 1 }, # usually 10 or 20 degrees below camera min
+    0xa0 => { Name => 'UnknownTemperature3', %floatKelvin, Unknown => 1 }, # same as camera max
+    0xa4 => { Name => 'UnknownTemperature4', %floatKelvin, Unknown => 1 }, # same as camera min
+    0xa8 => { Name => 'UnknownTemperature5', %floatKelvin, Unknown => 1 }, # usually 50 or 88 degrees over camera max
+    0xac => { Name => 'UnknownTemperature6', %floatKelvin, Unknown => 1 }, # usually 10, 20 or 40 degrees below camera min
+    0xd4 => { Name => 'CameraModel',        Format => 'string[32]' },
+    0xf4 => { Name => 'CameraPartNumber',   Format => 'string[16]' }, #1
+    0x104 => { Name => 'CameraSerialNumber',Format => 'string[16]' }, #1
+    0x114 => { Name => 'CameraSoftware',    Format => 'string[16]' }, #1/PH (NC)
+    0x170 => { Name => 'LensModel',         Format => 'string[32]' },
+    # note: it seems that FLIR updated their lenses at some point, so lenses with the same
+    # name may have different part numbers (eg. the FOL38 is either 1196456 or T197089)
+    0x190 => { Name => 'LensPartNumber',    Format => 'string[16]' },
+    0x1a0 => { Name => 'LensSerialNumber',  Format => 'string[16]' },
+    0x1b4 => { Name => 'FieldOfView',       Format => 'float', PrintConv => 'sprintf("%.1f deg", $val)' }, #1
+    # 0x1d0 - int16u: 0,12,24,25,46
+    # 0x1d2 - int16u: 170,180,190,380,760,52320
+    0x1ec => { Name => 'FilterModel',       Format => 'string[16]' },
+    0x1fc => { Name => 'FilterPartNumber',  Format => 'string[32]' },
+    0x21c => { Name => 'FilterSerialNumber',Format => 'string[32]' },
+    0x308 => { Name => 'PlanckO',           Format => 'int32s' }, #1
+    0x30c => { Name => 'PlanckR2',          %float8g }, #1
+    0x338 => { Name => 'RawValueMedian',    Format => 'int16u', Groups => { 2 => 'Image' } },
+    0x33c => { Name => 'RawValueRange',     Format => 'int16u', Groups => { 2 => 'Image' } },
+    0x384 => {
+        Name => 'DateTimeOriginal',
+        Description => 'Date/Time Original',
+        Format => 'undef[10]',
+        Groups => { 2 => 'Time' },
+        RawConv => q{
+            my $tm = Get32u(\$val, 0);
+            my $ss = Get32u(\$val, 4) & 0xffff;
+            my $tz = Get16s(\$val, 8);
+            ConvertUnixTime($tm - $tz * 60) . sprintf('.%.3d', $ss) . TimeZoneString(-$tz);
+        },
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    0x390 => { Name => 'FocusStepCount', Format => 'int16u' },
+    0x45c => { Name => 'FocusDistance',  Format => 'float', PrintConv => 'sprintf("%.1f m",$val)' },
+    # 0x43c - string: either "Live" or the file name
+);
+
+# FLIR measurement tools record (ref 6)
+%Image::ExifTool::FLIR::MeasInfo = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&ProcessMeasInfo,
+    FORMAT => 'int16u',
+    VARS => { NO_ID => 1 },
+    NOTES => q{
+        Tags listed below are only for the first measurement tool, however multiple
+        measurements may be added, and information is extracted for all of them. 
+        Tags for subsequent measurements are generated as required with the prefixes
+        "Meas2", "Meas3", etc.
+    },
+    Meas1Type => {
+        PrintConv => {
+            1 => 'Spot',
+            2 => 'Area',
+            3 => 'Ellipse',
+            4 => 'Line',
+            5 => 'Endpoint', #PH (NC, FLIR Tools v2.0 for Mac generates an empty one of these after each Line)
+            6 => 'Alarm', #PH seen params: "0 1 0 1 9142 0 9142 0" (called "Isotherm" by Mac version)
+            7 => 'Unused', #PH (NC) (or maybe "Free"?)
+            8 => 'Difference',
+        },
+    },
+    Meas1Params => {
+        Notes => 'Spot=X,Y; Area=X1,Y1,W,H; Ellipse=XC,YC,X1,Y1,X2,Y2; Line=X1,Y1,X2,Y2',
+    },
+    Meas1Label => { },
+);
+
+# FLIR palette record (ref PH/JD)
+%Image::ExifTool::FLIR::PaletteInfo = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    0x00 => { #JD
+        Name => 'PaletteColors',
+        RawConv => '$$self{PaletteColors} = $val',
+    },
+    0x06 => { Name => 'AboveColor',     Format => 'int8u[3]', Notes => 'Y Cr Cb color components' }, #JD
+    0x09 => { Name => 'BelowColor',     Format => 'int8u[3]' }, #JD
+    0x0c => { Name => 'OverflowColor',  Format => 'int8u[3]' }, #JD
+    0x0f => { Name => 'UnderflowColor', Format => 'int8u[3]' }, #JD
+    0x12 => { Name => 'Isotherm1Color', Format => 'int8u[3]' }, #JD
+    0x15 => { Name => 'Isotherm2Color', Format => 'int8u[3]' }, #JD
+    0x1a => { Name => 'PaletteMethod' }, #JD
+    0x1b => { Name => 'PaletteStretch' }, #JD
+    0x30 => {
+        Name => 'PaletteFileName',
+        Format => 'string[32]',
+        # (not valid for all images)
+        RawConv => q{
+            $val =~ s/\0.*//;
+            $val =~ /^[\x20-\x7e]{3,31}$/ ? $val : undef;
+        },
+    },
+    0x50 => {
+        Name => 'PaletteName',
+        Format => 'string[32]',
+        # (not valid for all images)
+        RawConv => q{
+            $val =~ s/\0.*//;
+            $val =~ /^[\x20-\x7e]{3,31}$/ ? $val : undef;
+        },
+    },
+    0x70 => {
+        Name => 'Palette',
+        Format => 'undef[3*$$self{PaletteColors}]',
+        Notes => 'Y Cr Cb byte values for each palette color',
+        Binary => 1,
+    },
+);
+
+# FLIR text information record (ref PH)
+%Image::ExifTool::FLIR::TextInfo = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&ProcessFLIRText,
+    VARS => { NO_ID => 1 },
+    Label0 => { },
+    Value0 => { },
+    Label1 => { },
+    Value1 => { },
+    Label2 => { },
+    Value2 => { },
+    Label3 => { },
+    Value3 => { },
+    # (there could be more, and we will generate these on the fly if necessary)
+);
+
+# FLIR parameter information record (ref PH)
+%Image::ExifTool::FLIR::ParamInfo = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&ProcessFLIRText,
+    VARS => { NO_ID => 1 },
+    Generated => {
+        Name => 'DateTimeGenerated',
+        Description => 'Date/Time Generated',
+        Groups => { 2 => 'Time' },
+        ValueConv => '$val =~ tr/-/:/; $val',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    Param0 => { },
+    Param1 => { },
+    Param2 => { },
+    Param3 => { },
+    # (there could be more, and we will generate these on the fly if necessary)
+);
+
+# FLIR Picture in Picture record (ref 1)
+%Image::ExifTool::FLIR::PiP = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => 'FLIR Picture in Picture tags.',
+    FORMAT => 'int16s',
+    0x00 => {
+        Name => 'Real2IR',
+        Format => 'float',
+    },
+    2 => {
+        Name => 'OffsetX',
+        Notes => 'offset from of insertion point from center',
+        PrintConv => 'sprintf("%+d",$val)', # (add sign for direct use with IM convert)
+    },
+    3 => {
+        Name => 'OffsetY',
+        PrintConv => 'sprintf("%+d",$val)',
+    },
+    4 => {
+        Name => 'PiPX1',
+        Description => 'PiP X1',
+        Notes => 'crop size for radiometric image',
+    },
+    5 => { Name => 'PiPX2', Description => 'PiP X2' },
+    6 => { Name => 'PiPY1', Description => 'PiP Y1' },
+    7 => { Name => 'PiPY2', Description => 'PiP Y2' },
+);
+
+# FLIR GPS record (ref PH/JD)
+%Image::ExifTool::FLIR::GPSInfo = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    0x58 => {
+        Name => 'GPSMapDatum',
+        Format => 'string[16]',
+    },
+);
+
+# humidity meter information
+# (ref http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,5325.0.html)
+# The %Image::ExifTool::UserDefined hash defines new tags to be added to existing tables.
+%Image::ExifTool::FLIR::MeterLink = (
+    GROUPS => { 0 => 'APP1', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => 'Tags containing Meterlink humidity meter information.',
+    26 => {
+        Name => 'Reading1Units',
+        DataMember => 'Reading1Units',
+        RawConv => '$$self{Reading1Units} = $val',
+        PrintHex => 1,
+        PrintConv => {
+            0x0d => 'C',
+            0x1b => '%',
+            0x1d => 'Relative',
+            0x24 => 'g/kg',
+        },
+    },
+    28 => {
+        Name => 'Reading1Description',
+        DataMember => 'Reading1Description',
+        RawConv => '$$self{Reading1Description} = $val',
+        PrintConv => {
+            0 => 'Humidity',
+            3 => 'Moisture', # Pinless Moisture Readings with INTernal sensor
+            7 => 'Dew Point',
+            8 => 'Air Temperature',
+            9 => 'IR Temperature',
+            11 => 'Difference Temperature', # Difference Temp: IR-Temp and DewPoint
+        },
+    },
+    32 => {
+        Name => 'Reading1Device',
+        Format => 'string[16]',
+    },
+    96 => {
+        Name => 'Reading1Value',
+        Format => 'double',
+        # convert Kelvin -> Celcius and kg/kg -> g/kg
+        ValueConv => q{
+            return $val - 273.15 if $$self{Reading1Units} == 0x0d and $$self{Reading1Description} != 11;
+            return $val *= 1000 if $$self{Reading1Units} == 0x24;
+            return $val;
+        },
+    },
+    # add 100 for subsequent readings
+    126 => {
+        Name => 'Reading2Units',
+        DataMember => 'Reading2Units',
+        RawConv => '$$self{Reading2Units} = $val',
+        PrintHex => 1,
+        PrintConv => {
+            0x0d => 'C',
+            0x1b => '%',
+            0x1d => 'rel',
+            0x24 => 'g/kg',
+        },
+    },
+    128 => {
+        Name => 'Reading2Description',
+        DataMember => 'Reading2Description',
+        RawConv => '$$self{Reading2Description} = $val',
+        PrintConv => {
+            0 => 'Humidity',
+            3 => 'Moisture',
+            7 => 'Dew Point',
+            8 => 'Air Temperature',
+            9 => 'IR Temperature',
+            11 => 'Difference Temperature', # Difference Temp: IR-Temp and DewPoint
+        },
+    },
+    132 => {
+        Name => 'Reading2Device',
+        Format => 'string[16]',
+    },
+    196 => {
+        Name => 'Reading2Value',
+        Format => 'double',
+        # convert Kelvin -> Celcius and kg/kg -> g/kg
+        ValueConv => q{
+            return $val - 273.15 if $$self{Reading2Units} == 0x0d and $$self{Reading2Description} != 11;
+            return $val *= 1000 if $$self{Reading2Units} == 0x24;
+            return $val;
+        },
+    },
+    226 => {
+        Name => 'Reading3Units',
+        DataMember => 'Reading3Units',
+        RawConv => '$$self{Reading3Units} = $val',
+        PrintHex => 1,
+        PrintConv => {
+            0x0d => 'C',
+            0x1b => '%',
+            0x1d => 'rel',
+            0x24 => 'g/kg',
+        },
+    },
+    228 => {
+        Name => 'Reading3Description',
+        DataMember => 'Reading3Description',
+        RawConv => '$$self{Reading3Description} = $val',
+        PrintConv => {
+            0 => 'Humidity',
+            3 => 'Moisture',
+            7 => 'Dew Point',
+            8 => 'Air Temperature',
+            9 => 'IR Temperature',
+            11 => 'Difference Temperature', # Difference Temp: IR-Temp and DewPoint
+        },
+    },
+    232 => {
+        Name => 'Reading3Device',
+        Format => 'string[16]',
+    },
+    296 => {
+        Name => 'Reading3Value',
+        Format => 'double',
+        # convert Kelvin -> Celcius and kg/kg -> g/kg
+        ValueConv => q{
+            return $val - 273.15 if $$self{Reading3Units} == 0x0d and $$self{Reading3Description} != 11;
+            return $val *= 1000 if $$self{Reading3Units} == 0x24;
+            return $val;
+        },
+    },
+
+    326 => {
+        Name => 'Reading4Units',
+        DataMember => 'Reading4Units',
+        RawConv => '$$self{Reading4Units} = $val',
+        PrintHex => 1,
+        PrintConv => {
+            0x0d => 'C',
+            0x1b => '%',
+            0x1d => 'rel',
+            0x24 => 'g/kg',
+        },
+    },
+    328 => {
+        Name => 'Reading4Description',
+        DataMember => 'Reading4Description',
+        RawConv => '$$self{Reading4Description} = $val',
+        PrintConv => {
+            0 => 'Humidity',
+            3 => 'Moisture',
+            7 => 'Dew Point',
+            8 => 'Air Temperature',
+            9 => 'IR Temperature',
+            11 => 'Difference Temperature', # Difference Temp: IR-Temp and DewPoint
+        },
+    },
+    332 => {
+        Name => 'Reading4Device',
+        Format => 'string[16]',
+    },
+    396 => {
+        Name => 'Reading4Value',
+        Format => 'double',
+        # convert Kelvin -> Celcius and kg/kg -> g/kg
+        ValueConv => q{
+            return $val - 273.15 if $$self{Reading4Units} == 0x0d and $$self{Reading4Description} != 11;
+            return $val *= 1000 if $$self{Reading4Units} == 0x24;
+            return $val;
+        },
+    },
+);
+
+# FLIR public image format (ref 4/5)
+%Image::ExifTool::FLIR::FPF = (
+    GROUPS => { 0 => 'FLIR', 2 => 'Image' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    NOTES => 'Tags extracted from FLIR Public image Format (FPF) files.',
+    0x20 => { Name => 'FPFVersion',         Format => 'int32u' },
+    0x24 => { Name => 'ImageDataOffset',    Format => 'int32u' },
+    0x28 => {
+        Name => 'ImageType',
+        Format => 'int16u',
+        PrintConv => {
+            0 => 'Temperature',
+            1 => 'Temperature Difference',
+            2 => 'Object Signal',
+            3 => 'Object Signal Difference',
+        },
+    },
+    0x2a => {
+        Name => 'ImagePixelFormat',
+        Format => 'int16u',
+        PrintConv => {
+            0 => '2-byte short integer',
+            1 => '4-byte long integer',
+            2 => '4-byte float',
+            3 => '8-byte double',
+        },
+    },
+    0x2c => { Name => 'ImageWidth',         Format => 'int16u' },
+    0x2e => { Name => 'ImageHeight',        Format => 'int16u' },
+    0x30 => { Name => 'ExternalTriggerCount',Format => 'int32u' },
+    0x34 => { Name => 'SequenceFrameNumber',Format => 'int32u' },
+    0x78 => { Name => 'CameraModel',        Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x98 => { Name => 'CameraPartNumber',   Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0xb8 => { Name => 'CameraSerialNumber', Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0xd8 => { Name => 'CameraTemperatureRangeMin', %floatKelvin,    Groups => { 2 => 'Camera' } },
+    0xdc => { Name => 'CameraTemperatureRangeMax', %floatKelvin,    Groups => { 2 => 'Camera' } },
+    0xe0 => { Name => 'LensModel',          Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x100 => { Name => 'LensPartNumber',    Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x120 => { Name => 'LensSerialNumber',  Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x140 => { Name => 'FilterModel',       Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x150 => { Name => 'FilterPartNumber',  Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x180 => { Name => 'FilterSerialNumber',Format => 'string[32]', Groups => { 2 => 'Camera' } },
+    0x1e0 => { Name => 'Emissivity',        %float2f },
+    0x1e4 => { Name => 'ObjectDistance',    Format => 'float', PrintConv => 'sprintf("%.2f m",$val)' },
+    0x1e8 => { Name => 'ReflectedApparentTemperature', %floatKelvin },
+    0x1ec => { Name => 'AtmosphericTemperature',       %floatKelvin },
+    0x1f0 => { Name => 'RelativeHumidity',  Format => 'float', PrintConv => 'sprintf("%.1f %%",$val*100)' },
+    0x1f4 => { Name => 'ComputedAtmosphericTrans', %float2f },
+    0x1f8 => { Name => 'EstimatedAtmosphericTrans',%float2f },
+    0x1fc => { Name => 'ReferenceTemperature', %floatKelvin },
+    0x200 => { Name => 'IRWindowTemperature',  %floatKelvin, Groups => { 2 => 'Camera' } },
+    0x204 => { Name => 'IRWindowTransmission', %float2f,     Groups => { 2 => 'Camera' } },
+    0x248 => {
+        Name => 'DateTimeOriginal',
+        Description => 'Date/Time Original',
+        Groups => { 2 => 'Time' },
+        Format => 'int32u[7]',
+        ValueConv => 'sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d.%.3d",split(" ",$val))',
+        PrintConv => '$self->ConvertDateTime($val)',
+    },
+    # Notes (based on ref 4):
+    # 1) The above date/time structure is documented to be 32 bytes for FPFVersion 1, but in
+    #    fact it is only 28.  Maybe this is why the full header length of my FPFVersion 2
+    #    sample is 892 bytes instead of 896.  If this was a documentation error, we are OK,
+    #    but if the alignment was really different in version 1, then the temperatures below
+    #    will be mis-aligned.  I don't have any version 1 samples to check this.
+    # 2) The following temperatures may not always be in Kelvin
+    0x2a4 => { Name => 'CameraScaleMin',    %float1f },
+    0x2a8 => { Name => 'CameraScaleMax',    %float1f },
+    0x2ac => { Name => 'CalculatedScaleMin',%float1f },
+    0x2b0 => { Name => 'CalculatedScaleMax',%float1f },
+    0x2b4 => { Name => 'ActualScaleMin',    %float1f },
+    0x2b8 => { Name => 'ActualScaleMax',    %float1f },
+);
+
+# top-level user data written by FLIR cameras in MP4 videos
+%Image::ExifTool::FLIR::UserData = (
+    GROUPS => { 1 => 'FLIR', 2 => 'Camera' },
+    NOTES => q{
+        Tags written by some FLIR cameras in a top-level (!) "udta" atom of MP4
+        videos.
+    },
+    uuid => [
+        {
+            Name => 'FLIR_Parts',
+            Condition => '$$valPt=~/^\x43\xc3\x99\x3b\x0f\x94\x42\x4b\x82\x05\x6b\x66\x51\x3f\x48\x5d/s',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::FLIR::Parts',
+                Start => 16,
+            },
+        },
+        {
+            Name => 'FLIR_Serial',
+            Condition => '$$valPt=~/^\x57\xf5\xb9\x3e\x51\xe4\x48\xaf\xa0\xd9\xc3\xef\x1b\x37\xf7\x12/s',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::FLIR::SerialNums',
+                Start => 16,
+            },
+        },
+        {
+            Name => 'FLIR_Params',
+            Condition => '$$valPt=~/^\x41\xe5\xdc\xf9\xe8\x0a\x41\xce\xad\xfe\x7f\x0c\x58\x08\x2c\x19/s',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::FLIR::Params',
+                Start => 16,
+            },
+        },
+        {
+            Name => 'FLIR_UnknownUUID',
+            Condition => '$$valPt=~/^\x57\x45\x20\x50\x2c\xbb\x44\xad\xae\x54\x15\xe9\xb8\x39\xd9\x03/s',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::FLIR::UnknownUUID',
+                Start => 16,
+            },
+        },
+        {
+            Name => 'FLIR_GPS',
+            Condition => '$$valPt=~/^\x7f\x2e\x21\x00\x8b\x46\x49\x18\xaf\xb1\xde\x70\x9a\x74\xf6\xf5/s',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::FLIR::GPS_UUID',
+                Start => 16,
+            },
+        },
+        {
+            Name => 'FLIR_MoreInfo',
+            Condition => '$$valPt=~/^\x2b\x45\x2f\xdc\x74\x35\x40\x94\xba\xee\x22\xa6\xb2\x3a\x7c\xf8/s',
+            SubDirectory => {
+                TagTable => 'Image::ExifTool::FLIR::MoreInfo',
+                Start => 16,
+            },
+        },
+        {
+            Name => 'SoftwareComponents',
+            Condition => '$$valPt=~/^\x78\x3f\xc7\x83\x0c\x95\x4b\x00\x8c\xc7\xac\xf1\xec\xb4\xd3\x9a/s',
+            Unknown => 1,
+            ValueConv => 'join " ", unpack "x20N4xZ*", $val',
+        },
+        {
+            Name => 'FLIR_Unknown',
+            Condition => '$$valPt=~/^\x52\xae\xda\x45\x17\x1e\x48\xb1\x92\x47\x93\xa4\x21\x4e\x43\xf5/s',
+            Unknown => 1,
+            ValueConv => 'unpack "x20C*", $val',
+        },
+        {
+            Name => 'Units',
+            Condition => '$$valPt=~/^\xf8\xab\x72\x1e\x84\x73\x44\xa0\xb8\xc8\x1b\x04\x82\x6e\x07\x24/s',
+            List => 1,
+            RawConv => 'my @a = split "\0", substr($val, 20); \@a',
+        },
+        {
+            Name => 'ThumbnailImage',
+            Groups => { 2 => 'Preview' },
+            Condition => '$$valPt=~/^\x91\xaf\x9b\x93\x45\x9b\x44\x56\x98\xd1\x5e\x76\xea\x01\x04\xac....\xff\xd8\xff/s',
+            RawConv => 'substr($val, 20)',
+            Binary => 1,
+        },
+    ],
+);
+
+# uuid 43c3993b0f94424b82056b66513f485d box of MP4 videos (ref PH)
+%Image::ExifTool::FLIR::Parts = (
+    GROUPS => { 0 => 'MakerNotes', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'undef',
+    NOTES => q{
+        Tags extracted from the "uuid" box with ID 43c3993b0f94424b82056b66513f485d
+        in FLIR MP4 videos.
+    },
+    4 => [
+        {
+            Name => 'BAHPVer',
+            Condition => '$$valPt =~ /^bahpver\0/',
+            Format => 'undef[$size]',
+            RawConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'BALPVer',
+            Condition => '$$valPt =~ /^balpver\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'Battery',
+            Condition => '$$valPt =~ /^battery\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'BAVPVer',
+            Condition => '$$valPt =~ /^bavpver\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+            # (the first string corresponds with a lens part number)
+        },
+        {
+            Name => 'CamCore',
+            Condition => '$$valPt =~ /^camcore\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'DetectorBoard',
+            Condition => '$$valPt =~ /^det_board\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 10)',
+        },
+        {
+            Name => 'Detector',
+            Condition => '$$valPt =~ /^detector\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 9)',
+        },
+        {
+            Name => 'GIDCVer',
+            Condition => '$$valPt =~ /^gidcver\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'GIDPVer',
+            Condition => '$$valPt =~ /^gidpver\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'GIPC_CPLD',
+            Condition => '$$valPt =~ /^gipccpld\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 9)',
+        },
+        {
+            Name => 'GIPCVer',
+            Condition => '$$valPt =~ /^gipcver\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'GIXIVer',
+            Condition => '$$valPt =~ /^gixiver\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 8)',
+        },
+        {
+            Name => 'MainBoard',
+            Condition => '$$valPt =~ /^mainboard\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 10)',
+        },
+        {
+            Name => 'Optics',
+            Condition => '$$valPt =~ /^optics\0/',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", substr($val, 7)',
+        },
+        {
+            Name => 'PartNumber',
+            Format => 'undef[$size]',
+            ValueConv => 'join " ", split "\0", $val',
+        },
+    ],
+);
+
+# uuid 57f5b93e51e448afa0d9c3ef1b37f712 box of MP4 videos (ref PH)
+%Image::ExifTool::FLIR::SerialNums = (
+    GROUPS => { 0 => 'MakerNotes', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        Tags extracted from the "uuid" box with ID 57f5b93e51e448afa0d9c3ef1b37f712
+        in FLIR MP4 videos.
+    },
+    # (not sure if these offsets are constant)
+    0x0c => { Name => 'UnknownSerial1',     Format => 'string[33]', Unknown => 1 },
+    0x2d => { Name => 'UnknownSerial2',     Format => 'string[33]', Unknown => 1 },
+    0x4e => { Name => 'UnknownSerial3',     Format => 'string[33]', Unknown => 1 },
+    0x6f => { Name => 'UnknownSerial4',     Format => 'string[11]', Unknown => 1 },
+    0x7b => { Name => 'UnknownNumber',      Format => 'string[3]',  Unknown => 1 },
+    0x7e => { Name => 'CameraSerialNumber', Format => 'string[9]' },
+);
+
+# uuid 41e5dcf9e80a41ceadfe7f0c58082c19 box of MP4 videos (ref PH)
+%Image::ExifTool::FLIR::Params = (
+    GROUPS => { 0 => 'MakerNotes', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'float',
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        Tags extracted from the "uuid" box with ID 41e5dcf9e80a41ceadfe7f0c58082c19
+        in FLIR MP4 videos.
+    },
+    1 => { Name => 'ReflectedApparentTemperature', %floatKelvin },
+    2 => { Name => 'AtmosphericTemperature',       %floatKelvin },
+    3 => { Name => 'Emissivity',                   %float2f },
+    4 => { Name => 'ObjectDistance',   PrintConv => 'sprintf("%.2f m",$val)' },
+    5 => { Name => 'RelativeHumidity', PrintConv => 'sprintf("%.1f %%",$val*100)' },
+    6 => { Name => 'EstimatedAtmosphericTrans',    %float2f },
+    7 => { Name => 'IRWindowTemperature',          %floatKelvin },
+    8 => { Name => 'IRWindowTransmission',         %float2f },
+);
+
+# uuid 574520502cbb44adae5415e9b839d903 box of MP4 videos (ref PH)
+%Image::ExifTool::FLIR::UnknownUUID = (
+    GROUPS => { 0 => 'MakerNotes', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'float',
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        Tags extracted from the "uuid" box with ID 574520502cbb44adae5415e9b839d903
+        in FLIR MP4 videos.
+    },
+    # 1 - 1
+    # 2 - 0
+    # 3 - 0
+);
+
+# uuid 7f2e21008b464918afb1de709a74f6f5 box of MP4 videos (ref PH)
+%Image::ExifTool::FLIR::GPS_UUID = (
+    GROUPS => { 0 => 'MakerNotes', 1 => 'FLIR', 2 => 'Location' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'float',
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        Tags extracted from the "uuid" box with ID 7f2e21008b464918afb1de709a74f6f5
+        in FLIR MP4 videos.
+    },
+    1 => {
+        Name => 'GPSLatitude',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "N")',
+    },
+    2 => {
+        Name => 'GPSLongitude',
+        PrintConv => 'Image::ExifTool::GPS::ToDMS($self, $val, 1, "E")',
+    },
+    3 => {
+        Name => 'GPSAltitude',
+        PrintConv => '$val=int($val*100+0.5)/100;"$val m"',
+    },
+    # 4 - int32u: 0x0001bf74
+    # 5 - int32u: 0
+    # 6 - int32u: 1
+);
+
+# uuid 2b452fdc74354094baee22a6b23a7cf8 box of MP4 videos (ref PH)
+%Image::ExifTool::FLIR::MoreInfo = (
+    GROUPS => { 0 => 'MakerNotes', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FIRST_ENTRY => 0,
+    NOTES => q{
+        Tags extracted from the "uuid" box with ID 2b452fdc74354094baee22a6b23a7cf8
+        in FLIR MP4 videos.
+    },
+    5 => { Name => 'LensModel', Format => 'string[6]' },
+    11 => { Name => 'UnknownTemperature1', %floatKelvin, Unknown => 1 }, # (-14.9 C)
+    15 => { Name => 'UnknownTemperature2', %floatKelvin, Unknown => 1 }, # (60.0 C)
+);
+
+# FLIR AFF tag table (ref PH)
+%Image::ExifTool::FLIR::AFF = (
+    GROUPS => { 0 => 'FLIR', 1 => 'FLIR', 2 => 'Image' },
+    NOTES => 'Tags extracted from FLIR "AFF" SEQ images.',
+    VARS => { ALPHA_FIRST => 1 },
+    "_header" => {
+        Name => 'AFFHeader',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::Header' },
+    },
+    0x01 => {
+        Name => 'AFF1',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::AFF1' },
+    },
+    0x05 => {
+        Name => 'AFF5',
+        SubDirectory => { TagTable => 'Image::ExifTool::FLIR::AFF5' },
+    },
+);
+
+# AFF record type 1 (ref forum?topic=4898.msg27627)
+%Image::ExifTool::FLIR::AFF1 = (
+    GROUPS => { 0 => 'FLIR', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    0x00 => {
+        # use this tag only to determine the byte order of the raw data
+        # (the value should be 0x0002 if the byte order is correct)
+        Name => 'RawDataByteOrder',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    0x01 => { Name => 'SensorWidth',  Format => 'int16u' },
+    0x02 => { Name => 'SensorHeight', Format => 'int16u' },
+);
+
+# AFF record type 5 (ref forum?topic=4898.msg27628)
+%Image::ExifTool::FLIR::AFF5 = (
+    GROUPS => { 0 => 'FLIR', 1 => 'FLIR', 2 => 'Camera' },
+    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
+    FORMAT => 'int16u',
+    FIRST_ENTRY => 0,
+    0x12 => {
+        # use this tag only to determine the byte order of the raw data
+        # (the value should be 0x0002 if the byte order is correct)
+        Name => 'RawDataByteOrder',
+        Hidden => 1,
+        RawConv => 'ToggleByteOrder() if $val >= 0x0100; undef',
+    },
+    0x13 => { Name => 'SensorWidth',  Format => 'int16u' },
+    0x14 => { Name => 'SensorHeight', Format => 'int16u' },
+);
+
+# FLIR composite tags (ref 1)
+%Image::ExifTool::FLIR::Composite = (
+    GROUPS => { 1 => 'FLIR', 2 => 'Camera' },
+    PeakSpectralSensitivity => {
+        Require => 'FLIR:PlanckB',
+        ValueConv => '14387.6515/$val',
+        PrintConv => 'sprintf("%.1f um", $val)',
+    },
+);
+
+# add our composite tags
+Image::ExifTool::AddCompositeTags('Image::ExifTool::FLIR');
+
+#------------------------------------------------------------------------------
+# Get image type from raw image data
+# Inputs: 0) ExifTool ref, 1) image data, 2) tag name
+# Returns: image type (PNG, JPG, TIFF or undef)
+# - image itself is stored in $$et{$tag}
+sub GetImageType($$$)
+{
+    my ($et, $val, $tag) = @_;
+    my ($w, $h) = @$et{"${tag}Width","${tag}Height"};
+    my $type = 'DAT';
+    # add TIFF header only if this looks like 16-bit raw data
+    # (note: MakeTiffHeader currently works only for little-endian,
+    #  and I haven't seen any big-endian samples, but check anwyay)
+    if ($val =~ /^\x89PNG\r\n\x1a\n/) {
+        $type = 'PNG';
+    } elsif ($val =~ /^\xff\xd8\xff/) { # (haven't seen this, but just in case - PH)
+        $type = 'JPG';
+    } elsif (length $val != $w * $h * 2) {
+        $et->Warn("Unrecognized FLIR $tag data format");
+    } elsif (GetByteOrder() eq 'II') {
+        require Image::ExifTool::Sony;
+        $val = Image::ExifTool::Sony::MakeTiffHeader($w,$h,1,16) . $val;
+        $type = 'TIFF';
+    } else {
+        $et->Warn("Don't yet support big-endian TIFF $tag");
+    }
+    # save image data
+    $$et{$tag} = $val;
+    return $type;
+}
+
+#------------------------------------------------------------------------------
+# Unescape FLIR Unicode character
+# Inputs: 0) escaped character code
+# Returns: UTF8 character
+sub UnescapeFLIR($)
+{
+    my $char = shift;
+    return $char unless length $char eq 4; # escaped ASCII char (eg. '\\')
+    my $val = hex $char;
+    return chr($val) if $val < 0x80;   # simple ASCII
+    return pack('C0U', $val) if $] >= 5.006001;
+    return Image::ExifTool::PackUTF8($val);
+}
+
+#------------------------------------------------------------------------------
+# Process FLIR text info record (ref PH)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+sub ProcessFLIRText($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirStart = $$dirInfo{DirStart} || 0;
+    my $dirLen = $$dirInfo{DirLen};
+
+    return 0 if $dirLen < 12;
+
+    $et->VerboseDir('FLIR Text');
+
+    my $dat = substr($$dataPt, $dirStart+12, $dirLen-12);
+    $dat =~ s/\0.*//s; # truncate at null
+
+    # the parameter text contains an additional header entry...
+    if ($tagTablePtr eq \%Image::ExifTool::FLIR::ParamInfo and
+        $dat =~ /# (Generated) at (.*?)[\n\r]/)
+    {
+        $et->HandleTag($tagTablePtr, $1, $2);
+    }
+
+    for (;;) {
+        $dat =~ /.(\d+).(label|value|param) (unicode|text) "(.*)"/g or last;
+        my ($tag, $val) = (ucfirst($2) . $1, $4);
+        if ($3 eq 'unicode' and $val =~ /\\/) {
+            # convert escaped Unicode characters (backslash followed by 4 hex digits)
+            $val =~ s/\\([0-9a-fA-F]{4}|.)/UnescapeFLIR($1)/sge;
+            $et->Decode($val, 'UTF8');
+        }
+        $$tagTablePtr{$tag} or AddTagToTable($tagTablePtr, $tag, { Name => $tag });
+        $et->HandleTag($tagTablePtr, $tag, $val);
+    }
+
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process FLIR measurement tool record (ref 6)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 on success
+# (code-driven decoding isn't pretty, but sometimes it is necessary)
+sub ProcessMeasInfo($$$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $dataPt = $$dirInfo{DataPt};
+    my $dirStart = $$dirInfo{DirStart} || 0;
+    my $dataPos = $$dirInfo{DataPos};
+    my $dirEnd = $dirStart + $$dirInfo{DirLen};
+    my $verbose = $et->Options('Verbose');
+
+    my $pos = $dirStart + 12;
+    return 0 if $pos > $dirEnd;
+    ToggleByteOrder() if Get16u($dataPt, $dirStart) >= 0x100;
+    my ($i, $t, $p);
+    for ($i=1; ; ++$i) {
+        last if $pos + 2 > $dirEnd;
+        my $recLen = Get16u($dataPt, $pos);
+        last if $recLen < 0x28 or $pos + $recLen > $dirEnd;
+        my $pre = 'Meas' . $i;
+        $et->VerboseDir("MeasInfo $i", undef, $recLen);
+        if ($verbose > 2) {
+            HexDump($dataPt, $recLen,
+                Start=>$pos, Prefix=>$$et{INDENT}, DataPos=>$dataPos);
+        }
+        my $coordLen = Get16u($dataPt, $pos+4);
+        # generate tag table entries for this tool if necessary
+        foreach $t ('Type', 'Params', 'Label') {
+            my $tag = $pre . $t;
+            last if $$tagTablePtr{$tag};
+            my $tagInfo = { Name => $tag };
+            $$tagInfo{PrintConv} = $$tagTablePtr{"Meas1$t"}{PrintConv};
+            AddTagToTable($tagTablePtr, $tag, $tagInfo);
+        }
+        # extract measurement tool type
+        $et->HandleTag($tagTablePtr, "${pre}Type", undef,
+            DataPt=>$dataPt, DataPos=>$dataPos, Start=>$pos+0x0a, Size=>2);
+        last if $pos + 0x24 + $coordLen > $dirEnd;
+        # extract measurement parameters
+        $et->HandleTag($tagTablePtr, "${pre}Params", undef,
+            DataPt=>$dataPt, DataPos=>$dataPos, Start=>$pos+0x24, Size=>$coordLen);
+        my @uni;
+        # extract label (sometimes-null-terminated Unicode)
+        for ($p=0x24+$coordLen; $p<$recLen-1; $p+=2) {
+            my $ch = Get16u($dataPt, $p+$pos);
+            # FLIR Tools v2.0 for Mac doesn't properly null-terminate these strings,
+            # so end the string at any funny character
+            last if $ch < 0x20 or $ch > 0x7f;
+            push @uni, $ch;
+        }
+        # convert to the ExifTool character set
+        require Image::ExifTool::Charset;
+        my $val = Image::ExifTool::Charset::Recompose($et, \@uni);
+        $et->HandleTag($tagTablePtr, "${pre}Label", $val,
+            DataPt=>$dataPt, DataPos=>$dataPos, Start=>$pos+0x24+$coordLen, Size=>2*scalar(@uni));
+        $pos += $recLen;    # step to next record
+    }
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process FLIR FFF record (ref PH/1/3)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 if this was a valid FFF record
+sub ProcessFLIR($$;$)
+{
+    my ($et, $dirInfo, $tagTablePtr) = @_;
+    my $raf = $$dirInfo{RAF} || new File::RandomAccess($$dirInfo{DataPt});
+    my $verbose = $et->Options('Verbose');
+    my $out = $et->Options('TextOut');
+    my ($i, $hdr, $buff, $rec);
+
+    # read and verify FFF header
+    $raf->Read($hdr, 0x40) == 0x40 and $hdr =~ /^([AF]FF)\0/ or return 0;
+
+    my $type = $1;
+
+    # set file type if reading from FFF or SEQ file ($tagTablePtr will not be defined)
+    $et->SetFileType($type eq 'FFF' ? 'FLIR' : 'SEQ') unless $tagTablePtr;
+
+    # FLIR file header (ref 3)
+    # 0x00 - string[4] file format ID = "FFF\0"
+    # 0x04 - string[16] file creator: seen "\0","MTX IR\0","CAMCTRL\0"
+    # 0x14 - int32u file format version = 100
+    # 0x18 - int32u offset to record directory
+    # 0x1c - int32u number of entries in record directory
+    # 0x20 - int32u next free index ID = 2
+    # 0x24 - int16u swap pattern = 0 (?)
+    # 0x28 - int16u[7] spares
+    # 0x34 - int32u[2] reserved
+    # 0x3c - int32u checksum
+
+    # determine byte ordering by validating version number
+    # (in my samples FLIR APP1 is big-endian, FFF files are little-endian)
+    for ($i=0; ; ++$i) {
+        my $ver = Get32u(\$hdr, 0x14);
+        last if $ver >= 100 and $ver < 200; # (have seen 100 and 101 - PH)
+        ToggleByteOrder();
+        $i and $et->Warn("Unsupported FLIR $type version"), return 1;
+    }
+
+    # read the FLIR record directory
+    my $pos = Get32u(\$hdr, 0x18);
+    my $num = Get32u(\$hdr, 0x1c);
+    unless ($raf->Seek($pos) and $raf->Read($buff, $num * 0x20) == $num * 0x20) {
+        $et->Warn('Truncated FLIR FFF directory');
+        return 1;
+    }
+
+    unless ($tagTablePtr) {
+        $tagTablePtr = GetTagTable("Image::ExifTool::FLIR::$type");
+        $$et{SET_GROUP0} = 'FLIR'; # (set group 0 to 'FLIR' for FFF files)
+    }
+
+    # process the header data
+    $et->HandleTag($tagTablePtr, '_header', $hdr);
+
+    my $oldIndent = $$et{INDENT};
+    $$et{INDENT} .= '| ';
+    $et->VerboseDir($type, $num);
+
+    for ($i=0; $i<$num; ++$i) {
+
+        # FLIR record entry (ref 3):
+        # 0x00 - int16u record type
+        # 0x02 - int16u record subtype: RawData 1=BE, 2=LE, 3=PNG; 1 for other record types
+        # 0x04 - int32u record version: seen 0x64,0x66,0x67,0x68,0x6f,0x104
+        # 0x08 - int32u index id = 1
+        # 0x0c - int32u record offset from start of FLIR data
+        # 0x10 - int32u record length
+        # 0x14 - int32u parent = 0 (?)
+        # 0x18 - int32u object number = 0 (?)
+        # 0x1c - int32u checksum: 0 for no checksum
+
+        my $entry = $i * 0x20;
+        my $recType = Get16u(\$buff, $entry);
+        next if $recType == 0;  # ignore free records
+        my $recPos = Get32u(\$buff, $entry + 0x0c);
+        my $recLen = Get32u(\$buff, $entry + 0x10);
+
+        $verbose and printf $out "%sFLIR Record 0x%.2x, offset 0x%.4x, length 0x%.4x\n",
+                                 $$et{INDENT}, $recType, $recPos, $recLen;
+
+        unless ($raf->Seek($recPos) and $raf->Read($rec, $recLen) == $recLen) {
+            $et->Warn('Invalid FLIR record');
+            last;
+        }
+        if ($$tagTablePtr{$recType}) {
+            $et->HandleTag($tagTablePtr, $recType, undef,
+                DataPt  => \$rec,
+                DataPos => $recPos,
+                Start   => 0,
+                Size    => $recLen,
+                Index => $i,
+            );
+        } elsif ($verbose > 2) {
+            my %parms = ( DataPos => $recPos, Prefix => $$et{INDENT} );
+            $parms{MaxLen} = 96 if $verbose < 4;
+            HexDump(\$rec, $recLen, %parms);
+        }
+    }
+    delete $$et{SET_GROUP0};
+    $$et{INDENT} = $oldIndent;
+    return 1;
+}
+
+#------------------------------------------------------------------------------
+# Process FLIR public image format (FPF) file (ref PH/4)
+# Inputs: 0) ExifTool ref, 1) dirInfo ref, 2) tag table ref
+# Returns: 1 if this was a valid FFF file
+sub ProcessFPF($$)
+{
+    my ($et, $dirInfo) = @_;
+    my $raf = $$dirInfo{RAF};
+    my $buff;
+
+    $raf->Read($buff, 892) == 892 and $buff =~ /^FPF Public Image Format\0/ or return 0;
+
+    # I think these are always little-endian, but check FPFVersion just in case
+    SetByteOrder('II');
+    ToggleByteOrder() unless Get32u(\$buff, 0x20) & 0xffff;
+
+    my $tagTablePtr = GetTagTable('Image::ExifTool::FLIR::FPF');
+    $et->SetFileType();
+    $et->ProcessDirectory( { DataPt => \$buff, Parent => 'FPF' }, $tagTablePtr);
+    return 1;
+}
+
+1; # end
+
+__END__
+
+=head1 NAME
+
+Image::ExifTool::FLIR - Read FLIR meta information
+
+=head1 SYNOPSIS
+
+This module is loaded automatically by Image::ExifTool when required.
+
+=head1 DESCRIPTION
+
+This module contains the definitions to read meta information from FLIR
+Systems Inc. thermal image files (FFF, FPF and JPEG format).
+
+=head1 AUTHOR
+
+Copyright 2003-2016, Phil Harvey (phil at owl.phy.queensu.ca)
+
+This library is free software; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+=head1 REFERENCES
+
+=over 4
+
+=item L<http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,4898.0.html>
+
+=item L<http://www.nuage.ch/site/flir-i7-some-analysis/>
+
+=item L<http://www.workswell.cz/manuals/flir/hardware/A3xx_and_A6xx_models/Streaming_format_ThermoVision.pdf>
+
+=item L<http://support.flir.com/DocDownload/Assets/62/English/1557488%24A.pdf>
+
+=item L<http://code.google.com/p/dvelib/source/browse/trunk/flirPublicFormat/fpfConverter/Fpfimg.h?spec=svn3&r=3>
+
+=item L<http://u88.n24.queensu.ca/exiftool/forum/index.php/topic,5538.0.html>
+
+=back
+
+=head1 ACKNOWLEDGEMENTS
+
+Thanks to Tomas for his hard work in decoding much of this information, and
+to Jens Duttke for getting me started on this format.
+
+=head1 SEE ALSO
+
+L<Image::ExifTool::TagNames/FLIR Tags>,
+L<Image::ExifTool(3pm)|Image::ExifTool>
+
+=cut