RubyGems - exiftool_vendored - Versions diffs - 10.31.0 → 10.40.0 - Mend

exiftool_vendored 10.31.0 → 10.40.0

Potentially problematic release.

This version of exiftool_vendored might be problematic. Click here for more details.

Files changed (1296) hide show

data/bin/Image-ExifTool-10.31/html/install.html DELETED Viewed

@@ -1,259 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-        "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-<title>Installing ExifTool</title>
-<link rel=stylesheet type='text/css' href='style.css' title='Style'>
-<style type="text/css">
-<!--
-li      { margin-top: .5em }
-.attn   { padding: 0.5em; border: 1px solid gray; background: #fee }
-div.rt  { float: right; clear: both }
--->
-</style></head>
-<body>
-<div class='rt'>
-(<a href="install-fr.pdf">PDF en fran&ccedil;ais</a>)
-</div>
-<h1 class='up'>Installing ExifTool</h1>
-<blockquote class=attn><b class=red>Note:</b> ExifTool <b>does <u>not</u> need
-to be installed</b> to run.  Just download and extract either the full Perl
-distribution on Mac/Linux, or the Windows EXE version on Windows, and run it
-directly.  <i class=lt>[But note that if you move the Perl "exiftool"
-application, you must also move its "lib" directory to the same location. This
-doesn't apply to the Windows version which unpacks the libraries into a
-temporary directory.]</i><br><br>However, the benefits of installation are:
-<ul><li>Makes ExifTool available to all users.</li>
-<li>Saves typing on the command line (by placing "exiftool" in your PATH).</li>
-<li>Installs the ExifTool documentation and API libraries (full Perl version only).</li>
-</ul></blockquote>
-<p>See the appropriate section below with instructions for installing or
-uninstalling ExifTool on your specific platform:</p>
-<ul>
-<li><a href="#Windows">Windows</a></li>
-<li><a href="#OSX">Macintosh OS X</a></li>
-<li><a href="#Unix">Unix Platforms</a></li>
-</ul>
-<p>Also see <a href="index.html#running">these instructions</a> for help running
-ExifTool.</p>
-<hr>
-<h2><a name="Windows">Windows</a></h2>
-<p>In Windows, there is a choice of two different versions of ExifTool to
-install.  The Perl distribution requires Perl to be installed on your system.
-(A good, free Perl interpreter can be downloaded from
-<a href="http://www.activestate.com/activeperl/">activeperl.com</a>.)</p>
-<p>If you don't already have Perl, it is easier to install the stand-alone ExifTool
-executable, but note that the stand-alone version doesn't include the HTML
-documentation or some other files of the full distribution.</p>
-<h3>Stand-Alone Executable</h3>
-<ol>
-<li><b>Download</b> the <b>Windows Executable</b> from the <a href="index.html">ExifTool home page</a>.
-<br><span class=lt>(The file you download will have a name like "<code>exiftool-10.31.zip</code>".)</span></li>
-<li><b>Extract "<code>exiftool(-k).exe</code>"</b> from the
-"<code>.zip</code>" file, and place it <b>on your Desktop</b>.
-<br><span class=lt>(Double-click on "<code>exiftool-10.31.zip</code>" to open
-the archive, then drag "<code>exiftool(-k).exe</code>" to your Desktop.)</span></li>
-</ol>
-<p>You can now double-click on "<code>exiftool(-k).exe</code>" to read the
-application documentation, or drag-and-drop files and folders to run exiftool on
-selected files. To install exiftool for <b>use from the command line</b>,
-continue with the following steps:</p>
-<ol start=3>
-<li><b>Rename</b> "<code>exiftool(-k).exe</code>" to <b>"<code>exiftool.exe</code>"</b>.
-<br><span class=lt>(or "<code>exiftool(-k)</code>" to "<code>exiftool</code>" if file name
-extensions are hidden on your system)</span></li>
-<li><b>Move "<code>exiftool.exe</code>"</b> to the "<code>C:\WINDOWS</code>" directory
-(or any other directory in your PATH).</li>
-</ol>
-<p>You can now run exiftool by typing "<code>exiftool</code>" at the command
-prompt.  (To get to the command prompt, select "Run..." from the Windows "Start"
-menu, then type "<code>cmd</code>" and press Return.)</p>
-<p><b>Notes:</b></p>
-<ol type='a'>
-<li>In Windows 7, running exiftool requires administrator privileges.  If
-necessary, this may be enabled by right clicking on exiftool, then selecting
-<b>"Run this program as administrator"</b> from the Compatibility settings.</li>
-<li>Occasionally users have reported that exiftool gives errors when running
-this version for this first time.  It is possible this may happen if a file gets
-corrupted during the download/installation process.  In this case, follow the
-Uninstalling instructions below then re-install exiftool. Be sure that you have
-sufficient disk space in your TEMP directory for exiftool to unpack about 12 MB
-of temporary files -- these are the Perl libraries used by the exiftool
-application which are unpacked the first time exiftool is run.</li>
-</ol>
-<p><b>Uninstalling:</b></p>
-<ol type='i'>
-<li>Drag "<code>exiftool(-k).exe</code>" (or "<code>C:\WINDOWS\exiftool.exe</code>")
-into the Recycle bin.</li>
-<li>Drag the directory "<code>par-XXX</code>" from your temporary directory to
-the Recycle bin.  Here "<code>XXX</code>" is your user name (in ASCII-hex for
-ExifTool 10.21 or later) and the location of the temporary directory depends on
-the value of the TEMP environment variable (typically
-"<code>C:\Documents and Settings\USER\Local Settings\Temp</code>"
-for Windows XP, or "<code>C:\Users\USER\AppData\Local\Temp</code>" for Windows 7
-or later).</li>
-</ol>
-<h3>Full Perl Distribution</h3>
-<p>You must have Perl installed to use this version.  (A free version of Perl
-can be downloaded from
-<a href="http://www.activestate.com/activeperl/">activeperl.com</a>.)</p>
-<ol>
-<li><b>Download</b> the <b>Image-ExifTool distribution</b> from the <a href="index.html">ExifTool home page</a>
-<br><span class=lt>(The file you download will have a name like "<code>Image-ExifTool-10.31.tar.gz</code>".)</span></li>
-<li><b>Extract the ExifTool files</b> from the archive.
-<br><span class=lt>(The archive is a gzipped tar file, and can be opened with
-various Windows utilities, including WinZip.)</span></li>
-<li><b>Rename</b> "<code>exiftool</code>" to <b>"<code>exiftool.pl</code>"</b>
-in the exiftool distribution.</li>
-<li><b>Move "<code>exiftool.pl</code>"</b> and the <b>"<code>lib</code>"</b>
-directory from the exiftool distribution to "<code>C:\WINDOWS</code>"
-(or any other directory in your PATH).</li>
-</ol>
-<p>Now, if you have made the proper Windows associations for the
-"<code>.pl</code>" extension (an option in the ActivePerl installation), you
-can run exiftool by typing "<code>exiftool.pl</code>" at the
-"<code>cmd.exe</code>" prompt.  Otherwise you should type
-"<code>perl c:\windows\exiftool.pl</code>".</p>
-<p><b>Uninstalling:</b></p>
-<ol type='i'>
-<li>Drag "<code>C:\WINDOWS\exiftool.pl</code>" and
-"<code>C:\WINDOWS\lib</code>" into the Recycle bin.  You should first confirm
-that "<code>C:\WINDOWS\lib</code>" contains only the "<code>File</code>"
-and "<code>Image</code>" sub-directories.  Do not delete it if it
-contains anything else.</li>
-</ol>
-<hr>
-<h2><a name="OSX">Macintosh OS X</a></h2>
-<p>If you have installed the BSDSDK package from the Xcode Developer Tools
-(<i>ie. if you have the</i> "<code>make</code>" <i>utility</i>), you should
-follow the install procedure for <a href="#Unix">Unix platforms</a> in the next
-section instead of the steps below. The Unix install has the advantage of making
-the ExifTool library available for your Perl scripts, as well as installing the
-man pages and POD documentation.</p>
-<p>Otherwise, you have a choice of two packages to install: The OS X package, or
-the full Perl distribution.  Both of the procedures below install the ExifTool
-files in the same location.  Installing from the OS X package is easier, but the
-full distribution includes HTML documentation and some other files not included
-in the OS X package.  Both versions run natively on PPC and Intel Macs.</p>
-<h3>OS X Package</h3>
-<ol>
-<li><b>Download</b> the <b>ExifTool OS X Package</b> from the <a href="index.html">ExifTool home page</a>.
-<br><span class=lt>(The file you download will have a name like "<code>ExifTool-10.31.dmg</code>".)</span></li>
-<li><b>Install</b> as a normal <b>OS X package</b>.
-<br><span class=lt>(Open the disk image, double-click on the install package, and follow the instructions.)
-</span></li>
-</ol>
-<p>You can now run exiftool by typing "<code>exiftool</code>" in a Terminal window.</p>
-<p>If this doesn't work, then it is likely you have an older version of OS X for which
-/usr/local/bin isn't in the default PATH.  To fix this, add the following line to your
-~/.profile settings using a text editor:</p>
-<blockquote><code>export PATH=$PATH:/usr/local/bin</code></blockquote>
-<h3>Full Perl Distribution</h3>
-<ol>
-<li><b>Download</b> the <b>Image-ExifTool distribution</b> from the <a href="index.html">ExifTool home page</a>
-to your Desktop.
-<br><span class=lt>(The file you download will have a name like "<code>Image-ExifTool-10.31.tar.gz</code>".)</span></li>
-<li><b>Launch</b> the <b>Terminal</b> application from the Utilities folder in your Applications folder.</li>
-<li>In the Terminal window, <b>type the following</b>:
-<pre class='code'>    cd ~/Desktop
-    tar -xzf Image-ExifTool-10.31.tar.gz
-    cd Image-ExifTool-10.31
-    sudo cp -r exiftool lib /usr/local/bin
-</pre>
-<span class=lt>(Note: The last step above will require you to enter your
-password.)</span></li>
-</ol>
-<p>You can now run exiftool by typing "<code>exiftool</code>" in a Terminal window.</p>
-<p class=lt><b>Notes:</b></p><ul class=lt><li>Both OS X installation techniques outlined above place
-exiftool and its lib directory in /usr/local/bin, while the standard Unix
-"<code>make install</code>" described below puts "<code>exiftool</code>" in
-/usr/local/bin and the individual libraries in /Library/Perl/#.#.#, where "#.#.#" is
-your Perl version. If both sets of libraries exist, /usr/local/bin/lib takes
-precedence for exiftool, but /Library/Perl/#.#.# is the default for any other
-Perl scripts.</li>
-<li>In OS X 10.8 or later, you may see this message when you try to open the install package:
-<blockquote class=red>"ExifTool-10.31.pkg" can't be opened because it is from an
-unidentified developer.</blockquote> The solution is to set "Allow applications downloaded
-from" to "Anywhere" in the General "Security &amp; Privacy" System Preferences.
-(<a href="http://news.softpedia.com/news/Fix-OS-X-Error-Application-Can-t-Be-Opened-Because-it-Is-from-an-Unidentified-Developer-407375.shtml">Read
-here</a> for a full description.)</li></ul>
-<h3>Uninstalling</h3>
-<ol type='i'>
-<li>Launch the "Terminal" application from the Applications Utilities folder.</li>
-<li>Type "<code>open /usr/local/bin</code>" (without the quotes) in the Terminal
-window, then press RETURN. (This opens a folder that you normally can't access
-from OS X.)</li>
-<li>Drag "<code>exiftool</code>" and "<code>lib</code>" into the trash from the
-"<code>bin</code>" folder you opened. You should first confirm that
-"<code>lib</code>" contains only two sub-folders: "<code>File</code>" and
-"<code>Image</code>". If it contains anything else, don't trash it because you
-have the wrong "<code>lib</code>" folder.</li>
-</ol>
-<hr>
-<h2><a name="Unix">Unix Platforms</a></h2>
-<ol>
-<li><b>Download</b> the <b>Image-ExifTool distribution</b> from the <a href="index.html">ExifTool home page</a>
-<br><span class=lt>(The file you download will have a name like "<code>Image-ExifTool-10.31.tar.gz</code>".)</span></li>
-<li><b>Unpack the distribution</b> and <b>make it your current directory</b> by typing:
-<pre class='code'>    cd <i>&lt;your download directory&gt;</i>
-    gzip -dc Image-ExifTool-10.31.tar.gz | tar -xf -
-    cd Image-ExifTool-10.31
-</pre>
-<span class=lt>(At this point you may run exiftool by typing
-"<code>exiftool <i>&lt;image file name&gt;</i></code>".)</span></li>
-<li><b>Test and install ExifTool</b> by typing:
-<pre class='code'>
-    perl Makefile.PL
-    make test
-    sudo make install
-</pre>
-<span class=lt>(Note: The "<code>make test</code>" step is not required, but
-useful because it runs a full suite of tests to verify that ExifTool is working
-properly on your system.  The "<code>sudo make install</code>" command requires
-that you have su access, and will prompt for your password.  This will make
-ExifTool and its documentation accessible to all users on your system. If you
-don't have su access, you can run ExifTool in your own account by moving
-"<code>exiftool</code>" and its "<code>lib</code>" directory to any convienient
-location, preferably somewhere in your PATH.)</span></li>
-</ol>
-<p>You can now run exiftool by typing "<code>exiftool</code>".  Also, you can
-consult the ExifTool documentation with commands like:</p>
-<blockquote><pre class='code'>perldoc exiftool
-perldoc Image::ExifTool
-perldoc Image::ExifTool::TagNames
-</pre></blockquote>
-<p>or</p>
-<blockquote><pre class='code'>man exiftool
-man Image::ExifTool
-man Image::ExifTool::TagNames
-</pre></blockquote>
-<h3>Uninstalling</h3>
-<ol type='i'>
-<li>Type "<code>sudo make uninstall</code>" from the distribution directory.
-<br><span class=lt>(Note: Unfortunately, newer systems may give an <i>"Uninstall
-is unsafe and deprecated"</i> message even though uninstalling ExifTool is safe
-because it has no dependencies.  If this happens, the necessary commands to
-remove the installed files will be listed, and these commands must be run
-manually.)</span></li>
-</ol>
-<hr>
-<p class='lf'><a href="index.html">&lt;-- Back to ExifTool home page</a></p>
-</body>
-</html>

data/bin/Image-ExifTool-10.31/html/under.html DELETED Viewed

@@ -1,128 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-        "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd">
-<html>
-<head>
-  <title>Under the Hood</title>
-<link rel=stylesheet type='text/css' href='style.css' title='Style'>
-<style type="text/css">
-<!--
-pre         { margin: 0 }
-ol.index    { margin: 0; padding: 0 0 0 2em }
--->
-</style>
-</head>
-<body>
-<div class='index'>
-<a href="#overview">Overview</a>
-<br><a href="#conversions">Value Conversions</a>
-<br><a href="#philophies">Underlying Philosophies</a>
-</div>
-<h1 class='up'>"Under the Hood" of ExifTool</h1>
-<p>This page is a work in progress, and will be used to explain some details
-of ExifTool's inner workings.</p>
-<a name="overview"></a>
-<h2>Overview of ExifTool</h2>
-<p>Below is a diagram showing the flow of information for the exiftool
-application.  Indicated outside the boxes on the diagram are some command-line
-options associated with the various stages of processing.  All of these options
-are directly associated with options or function calls available via the API
-(Application Programming Interface), with the exception of the output text
-formatting which is handled at the application level.</p>
-<center><img src="overview.png" alt="ExifTool Overview" width="680" height="460"></center>
-<p>The information flow is separated into two distinct modes: 1)
-<span class=blu>Reading or extracting information</span>, and 2)
-<span class=red>Writing or editing</span>.  The application runs in
-<b class=blu>read</b> mode by default, but switches to <b class=red>write</b> mode
-if a new value is assigned to any tag (via "<code>-TAG=</code>",
-"<code>-tagsFromFile</code>", "<code>-geotag</code>", "<code>-csv=</code>" or
-"<code>-json=</code>" on the command line).</p>
-<a name="conversions"></a>
-<h2>Value Conversions</h2>
-<p>When ExifTool reads or writes the value of a tag, there are 3 separate
-conversions applied to each value, resulting in 4 different levels for the value
-of each tag.  By default, users interact only with the human-readable
-("<b>PrintConv</b>") value, but other levels are exposed through various exiftool
-options:</p>
-<ol start=3><li>The "<b>PrintConv</b>" value is the final human-readable value
-which has been converted for display.  Often, the "PrintConv" conversion will
-translate numbers into words for better readability.  The <code>-lang</code>
-(Lang) option is used to specify the language for this conversion, and the
-<code>-c</code> and <code>-d</code> (CoordFormat and DateFormat) options specify
-this formatting for GPS coordinates and date/time values.</li></ol>
-<ol start=2><li>The "<b>ValueConv</b>" value is a numerical value, suitable for
-use in calculations.  Typically, this value is converted to standard units (eg.
-degrees, meters, or seconds) to make calculations simpler.  This value is
-returned for all tags when the <code>-n</code> option is used, or for individual
-tags by suffixing the tag name with a <code>#</code> character.</li></ol>
-<ol start=1><li>The "<b>Raw</b>" value is the value after initial formatting is
-applied to the binary data from the file.  Most tags have no separate "ValueConv"
-conversion, so for these tags the "Raw" value is the same as the "ValueConv"
-value.  This value may be seen by using the <code>-v</code> option.</li></ol>
-<ol start=0><li>The "<b>Binary</b>" value is actual binary data stored in the
-file.  This data is displayed in hexadecimal form with the <code>-v3</code>
-option, or by using the <code>-htmlDump</code> feature.  Note that this value is
-not related to the <code>-b</code> (<code>-binary</code>) option, which actually
-returns the "ValueConv" value and is used for tags where this value can not be
-presented in a simple text format.  The Writable column in the
-<a href="TagNames/index.html">Tag Name documentation</a>
-gives the format of this binary data for writable tags.</li></ol>
-<p>Below are some examples of these different values for a few tags:</p>
-<blockquote><table class=norm>
-<tr><th>Tag</th><th>3.&nbsp;PrintConv</th><th>2.&nbsp;ValueConv</th><th>1.&nbsp;Raw</th><th>0.&nbsp;Binary</th></tr>
-<tr align='center'><td>Orientation</td><td>Horizontal (normal)</td><td>1</td><td>1</td><td><pre>00 01</pre></td></tr>
-<tr align='center'><td>GPSLatitude</td><td>45 deg 20' 11.00"</td><td>45.3363888888889</td><td>45 20 11<br>(45/1 20/1 11/1)</td>
-  <td><pre>00 00 00 2d 00 00 00 01<br>00 00 00 14 00 00 00 01<br>00 00 00 0b 00 00 00 01</pre></td></tr>
-<tr align='center'><td>ExposureTime</td><td>1/30</td><td>0.03333333333</td><td>0.03333333333<br>(1/30)</td>
-  <td><pre>00 00 00 01 00 00 00 1e</pre></td></tr>
-<tr align='center'><td>ShutterSpeedValue</td><td>1/30</td><td>0.0333333334629176</td><td>4.90689059<br>(19868/4049)</td>
-  <td><pre>00 00 4d 9c 00 00 0f d1</pre></td></tr>
-</table></blockquote>
-<a name="philophies"></a>
-<h2>Underlying Philosophies</h2>
-<p>You have the right to know about the metadata contained in your images.  A main
-goal of the Exiftool project is to make this information freely available, both to
-the general public and as a resource for other developers.</p>
-<p>In the design of exiftool, there have been a number of underlying philosophies
-which have helped to influence the overall development:</p>
-<ol>
-<li>Make <a href="ExifTool.html">Image::ExifTool</a> as independent as possible
-    from other libraries to make it portable and easy to install.  (Portable to
-    a wide range of systems and Perl versions.)</li>
-<li>Keep the interface simple for simple tasks (sometimes at the expense of making
-    it more complicated for complex tasks).</li>
-<li>The <a href="ExifTool.html#Methods">API functions</a> should be isolated from
-    the details of the metadata formats (otherwise the interface turns into a giant
-    hairball, like the metadata).</li>
-<li>Maintain flexibility to allow users the freedom to do what they want.</li>
-<li>Design the code to be efficient for batch processing, even if it increases the
-    initial overhead.</li>
-<li>When writing files, remember 3 things: 1) data integrity, 2) data integrity, and
-    3) data integrity.  If you can't do it right, don't do it at all.</li>
-<li>If possible, recognize file types by their structure, not by their extension.</li>
-<li>Maintain backward compatibility when making changes to the ExifTool API or
-    command line application.</li>
-</ol>
-<hr>
-<i>Created Jun. 24, 2009</i><br>
-<i>Last revised Dec. 24, 2013</i>
-<p class='lf'><a href="index.html">&lt;-- Back to ExifTool home page</a></p>
-</body>
-</html>

data/bin/Image-ExifTool-10.31/lib/File/RandomAccess.pm DELETED Viewed

@@ -1,378 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         RandomAccess.pm
-#
-# Description:  Buffer to support random access reading of sequential file
-#
-# Revisions:    02/11/2004 - P. Harvey Created
-#               02/20/2004 - P. Harvey Added flag to disable SeekTest in new()
-#               11/18/2004 - P. Harvey Fixed bug with seek relative to end of file
-#               01/02/2005 - P. Harvey Added DEBUG code
-#               01/09/2006 - P. Harvey Fixed bug in ReadLine() when using
-#                            multi-character EOL sequences
-#               02/20/2006 - P. Harvey Fixed bug where seek past end of file could
-#                            generate "substr outside string" warning
-#               06/10/2006 - P. Harvey Decreased $CHUNK_SIZE from 64k to 8k
-#               11/23/2006 - P. Harvey Limit reads to < 0x80000000 bytes
-#               11/26/2008 - P. Harvey Fixed bug in ReadLine when reading from a
-#                            scalar with a multi-character newline
-#               01/24/2009 - PH Protect against reading too much at once
-#
-# Notes:        Calls the normal file i/o routines unless SeekTest() fails, in
-#               which case the file is buffered in memory to allow random access.
-#               SeekTest() is called automatically when the object is created
-#               unless specified.
-#
-#               May also be used for string i/o (just pass a scalar reference)
-#
-# Legal:        Copyright (c) 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.
-#------------------------------------------------------------------------------
-package File::RandomAccess;
-use strict;
-require 5.002;
-require Exporter;
-use vars qw($VERSION @ISA @EXPORT_OK);
-$VERSION = '1.10';
-@ISA = qw(Exporter);
-sub Read($$$);
-# constants
-my $CHUNK_SIZE = 8192;  # size of chunks to read from file (must be power of 2)
-my $SLURP_CHUNKS = 16;  # read this many chunks at a time when slurping
-#------------------------------------------------------------------------------
-# Create new RandomAccess object
-# Inputs: 0) reference to RandomAccess object or RandomAccess class name
-#         1) file reference or scalar reference
-#         2) flag set if file is already random access (disables automatic SeekTest)
-sub new($$;$)
-{
-    my ($that, $filePt, $isRandom) = @_;
-    my $class = ref($that) || $that;
-    my $self;
-    if (ref $filePt eq 'SCALAR') {
-        # string i/o
-        $self = {
-            BUFF_PT => $filePt,
-            POS => 0,
-            LEN => length($$filePt),
-            TESTED => -1,
-        };
-        bless $self, $class;
-    } else {
-        # file i/o
-        my $buff = '';
-        $self = {
-            FILE_PT => $filePt, # file pointer
-            BUFF_PT => \$buff,  # reference to file data
-            POS => 0,           # current position in file
-            LEN => 0,           # data length
-            TESTED => 0,        # 0=untested, 1=passed, -1=failed (requires buffering)
-        };
-        bless $self, $class;
-        $self->SeekTest() unless $isRandom;
-    }
-    return $self;
-}
-#------------------------------------------------------------------------------
-# Enable DEBUG code
-# Inputs: 0) reference to RandomAccess object
-sub Debug($)
-{
-    my $self = shift;
-    $self->{DEBUG} = { };
-}
-#------------------------------------------------------------------------------
-# Perform seek test and turn on buffering if necessary
-# Inputs: 0) reference to RandomAccess object
-# Returns: 1 if seek test passed (ie. no buffering required)
-# Notes: Must be done before any other i/o
-sub SeekTest($)
-{
-    my $self = shift;
-    unless ($self->{TESTED}) {
-        my $fp = $self->{FILE_PT};
-        if (seek($fp, 1, 1) and seek($fp, -1, 1)) {
-            $self->{TESTED} = 1;    # test passed
-        } else {
-            $self->{TESTED} = -1;   # test failed (requires buffering)
-        }
-    }
-    return $self->{TESTED} == 1 ? 1 : 0;
-}
-#------------------------------------------------------------------------------
-# Get current position in file
-# Inputs: 0) reference to RandomAccess object
-# Returns: current position in file
-sub Tell($)
-{
-    my $self = shift;
-    my $rtnVal;
-    if ($self->{TESTED} < 0) {
-        $rtnVal = $self->{POS};
-    } else {
-        $rtnVal = tell($self->{FILE_PT});
-    }
-    return $rtnVal;
-}
-#------------------------------------------------------------------------------
-# Seek to position in file
-# Inputs: 0) reference to RandomAccess object
-#         1) position, 2) whence (0 or undef=from start, 1=from cur pos, 2=from end)
-# Returns: 1 on success
-# Notes: When buffered, this doesn't quite behave like seek() since it will return
-#        success even if you seek outside the limits of the file.  However if you
-#        do this, you will get an error on your next Read().
-sub Seek($$;$)
-{
-    my ($self, $num, $whence) = @_;
-    $whence = 0 unless defined $whence;
-    my $rtnVal;
-    if ($self->{TESTED} < 0) {
-        my $newPos;
-        if ($whence == 0) {
-            $newPos = $num;                 # from start of file
-        } elsif ($whence == 1) {
-            $newPos = $num + $self->{POS};  # relative to current position
-        } else {
-            $self->Slurp();                 # read whole file into buffer
-            $newPos = $num + $self->{LEN};  # relative to end of file
-        }
-        if ($newPos >= 0) {
-            $self->{POS} = $newPos;
-            $rtnVal = 1;
-        }
-    } else {
-        $rtnVal = seek($self->{FILE_PT}, $num, $whence);
-    }
-    return $rtnVal;
-}
-#------------------------------------------------------------------------------
-# Read from the file
-# Inputs: 0) reference to RandomAccess object, 1) buffer, 2) bytes to read
-# Returns: Number of bytes read
-sub Read($$$)
-{
-    my $self = shift;
-    my $len = $_[1];
-    my $rtnVal;
-    # protect against reading too much at once
-    # (also from dying with a "Negative length" error)
-    if ($len & 0xf8000000) {
-        return 0 if $len < 0;
-        # read in smaller blocks because Windows attempts to pre-allocate
-        # memory for the full size, which can lead to an out-of-memory error
-        my $maxLen = 0x4000000; # (MUST be less than bitmask in "if" above)
-        my $num = Read($self, $_[0], $maxLen);
-        return $num if $num < $maxLen;
-        for (;;) {
-            $len -= $maxLen;
-            last if $len <= 0;
-            my $l = $len < $maxLen ? $len : $maxLen;
-            my $buff;
-            my $n = Read($self, $buff, $l);
-            last unless $n;
-            $_[0] .= $buff;
-            $num += $n;
-            last if $n < $l;
-        }
-        return $num;
-    }
-    # read through our buffer if necessary
-    if ($self->{TESTED} < 0) {
-        my $buff;
-        my $newPos = $self->{POS} + $len;
-        # number of bytes to read from file
-        my $num = $newPos - $self->{LEN};
-        if ($num > 0 and $self->{FILE_PT}) {
-            # read data from file in multiples of $CHUNK_SIZE
-            $num = (($num - 1) | ($CHUNK_SIZE - 1)) + 1;
-            $num = read($self->{FILE_PT}, $buff, $num);
-            if ($num) {
-                ${$self->{BUFF_PT}} .= $buff;
-                $self->{LEN} += $num;
-            }
-        }
-        # number of bytes left in data buffer
-        $num = $self->{LEN} - $self->{POS};
-        if ($len <= $num) {
-            $rtnVal = $len;
-        } elsif ($num <= 0) {
-            $_[0] = '';
-            return 0;
-        } else {
-            $rtnVal = $num;
-        }
-        # return data from our buffer
-        $_[0] = substr(${$self->{BUFF_PT}}, $self->{POS}, $rtnVal);
-        $self->{POS} += $rtnVal;
-    } else {
-        # read directly from file
-        $_[0] = '' unless defined $_[0];
-        $rtnVal = read($self->{FILE_PT}, $_[0], $len) || 0;
-    }
-    if ($self->{DEBUG}) {
-        my $pos = $self->Tell() - $rtnVal;
-        unless ($self->{DEBUG}->{$pos} and $self->{DEBUG}->{$pos} > $rtnVal) {
-            $self->{DEBUG}->{$pos} = $rtnVal;
-        }
-    }
-    return $rtnVal;
-}
-#------------------------------------------------------------------------------
-# Read a line from file (end of line is $/)
-# Inputs: 0) reference to RandomAccess object, 1) buffer
-# Returns: Number of bytes read
-sub ReadLine($$)
-{
-    my $self = shift;
-    my $rtnVal;
-    my $fp = $self->{FILE_PT};
-    if ($self->{TESTED} < 0) {
-        my ($num, $buff);
-        my $pos = $self->{POS};
-        if ($fp) {
-            # make sure we have some data after the current position
-            while ($self->{LEN} <= $pos) {
-                $num = read($fp, $buff, $CHUNK_SIZE);
-                return 0 unless $num;
-                ${$self->{BUFF_PT}} .= $buff;
-                $self->{LEN} += $num;
-            }
-            # scan and read until we find the EOL (or hit EOF)
-            for (;;) {
-                $pos = index(${$self->{BUFF_PT}}, $/, $pos);
-                if ($pos >= 0) {
-                    $pos += length($/);
-                    last;
-                }
-                $pos = $self->{LEN};    # have scanned to end of buffer
-                $num = read($fp, $buff, $CHUNK_SIZE) or last;
-                ${$self->{BUFF_PT}} .= $buff;
-                $self->{LEN} += $num;
-            }
-        } else {
-            # string i/o
-            $pos = index(${$self->{BUFF_PT}}, $/, $pos);
-            if ($pos < 0) {
-                $pos = $self->{LEN};
-                $self->{POS} = $pos if $self->{POS} > $pos;
-            } else {
-                $pos += length($/);
-            }
-        }
-        # read the line from our buffer
-        $rtnVal = $pos - $self->{POS};
-        $_[0] = substr(${$self->{BUFF_PT}}, $self->{POS}, $rtnVal);
-        $self->{POS} = $pos;
-    } else {
-        $_[0] = <$fp>;
-        if (defined $_[0]) {
-            $rtnVal = length($_[0]);
-        } else {
-            $rtnVal = 0;
-        }
-    }
-    if ($self->{DEBUG}) {
-        my $pos = $self->Tell() - $rtnVal;
-        unless ($self->{DEBUG}->{$pos} and $self->{DEBUG}->{$pos} > $rtnVal) {
-            $self->{DEBUG}->{$pos} = $rtnVal;
-        }
-    }
-    return $rtnVal;
-}
-#------------------------------------------------------------------------------
-# Read whole file into buffer (without changing read pointer)
-# Inputs: 0) reference to RandomAccess object
-sub Slurp($)
-{
-    my $self = shift;
-    my $fp = $self->{FILE_PT} || return;
-    # read whole file into buffer (in large chunks)
-    my ($buff, $num);
-    while (($num = read($fp, $buff, $CHUNK_SIZE * $SLURP_CHUNKS)) != 0) {
-        ${$self->{BUFF_PT}} .= $buff;
-        $self->{LEN} += $num;
-    }
-}
-#------------------------------------------------------------------------------
-# set binary mode
-# Inputs: 0) reference to RandomAccess object
-sub BinMode($)
-{
-    my $self = shift;
-    binmode($self->{FILE_PT}) if $self->{FILE_PT};
-}
-#------------------------------------------------------------------------------
-# close the file and free the buffer
-# Inputs: 0) reference to RandomAccess object
-sub Close($)
-{
-    my $self = shift;
-    if ($self->{DEBUG}) {
-        local $_;
-        if ($self->Seek(0,2)) {
-            $self->{DEBUG}->{$self->Tell()} = 0;    # set EOF marker
-            my $last;
-            my $tot = 0;
-            my $bad = 0;
-            foreach (sort { $a <=> $b } keys %{$self->{DEBUG}}) {
-                my $pos = $_;
-                my $len = $self->{DEBUG}->{$_};
-                if (defined $last and $last < $pos) {
-                    my $bytes = $pos - $last;
-                    $tot += $bytes;
-                    $self->Seek($last);
-                    my $buff;
-                    $self->Read($buff, $bytes);
-                    my $warn = '';
-                    if ($buff =~ /[^\0]/) {
-                        $bad += ($pos - $last);
-                        $warn = ' - NON-ZERO!';
-                    }
-                    printf "0x%.8x - 0x%.8x (%d bytes)$warn\n", $last, $pos, $bytes;
-                }
-                my $cur = $pos + $len;
-                $last = $cur unless defined $last and $last > $cur;
-            }
-            print "$tot bytes missed";
-            $bad and print ", $bad non-zero!";
-            print "\n";
-        } else {
-            warn "File::RandomAccess DEBUG not working (file already closed?)\n";
-        }
-        delete $self->{DEBUG};
-    }
-    # close the file
-    if ($self->{FILE_PT}) {
-        close($self->{FILE_PT});
-        delete $self->{FILE_PT};
-    }
-    # reset the buffer
-    my $emptyBuff = '';
-    $self->{BUFF_PT} = \$emptyBuff;
-    $self->{LEN} = 0;
-    $self->{POS} = 0;
-}
-#------------------------------------------------------------------------------
-1;  # end