Document: EXIref/ewr
Description: Reference manual for EXIFinfo application version 0.59beta3
Version: 1.10 (Wed, Feb 12, 2003)
Author: © Chris Terran/Lee Montgomerie/Vermilion Sands 2003
Format: EasiWriter/HTML/text
Email: chris@photodesk.iconbar.com
Web: http://www.photodesk.iconbar.com

Important Note
EXIFinfo is a beta program. It is in development and may contain bugs. Feedback is needed, especially if you come across problems or you have suggestions for improving the program.
If a particular image causes difficulties, please send it to the email address above. (Please write first if it's over 1Mb in size.)
**** Remember ****
If you don't tell us about problems, they can't be fixed!

Command line use

EXIFinfo can be used as a Wimp application, or called by external programs much like ChangeFSI can. To use this facility the program must have been previously seen by the Filer so that various paths and variables are set up correctly. The easiest way to do this on RISC OS 4 or above is to add the program to the Boot section of Configure. On earlier versions you can put EXIFinfo in the Apps directory, or explicitly Filer_Boot it in your boot sequence.

The syntax for calling EXIFinfo is as follows:

<EXIFinfo$Dir>.exifinfo <source> <destination> <scriptfile> [options*]

The first three parameters must be supplied. Any images in source will be processed using the scriptfile specified, with the results appearing in destination.

If processing was successfully completed, the system variable EXIFinfo$ReturnCode will not exist, orherwise it will contain a string describing the error that occurred. Note that attempting to process a non-EXIF image is not an error.

`<source>`

The first parameter is either a directory containing EXIFs, or a single EXIF file.

`<destination>`

The second parameter specifies the output destination. It must be a full path, and always overrides any setting of !OutputLeafName in the script file.

`<scriptfile>`

The third parameter specifies which output format to use. If it is a bare leafname it is assumed to exist in the directory <EXIFinfo$Dir>.Formats, otherwise it specifies the location of the scriptfile in full.

Note that you must use the filename of a script file, not the descriptive text which appears in the menu. Note too the cautions concerning using absolute versus relative links when generating HTML files.

The options include:

`-r`

Filer_Run the output on completion. This is equivalent to selecting the Run on completion icon.

`-uN value`

Sets the script variable {UserN} to value, where N is 0...9. The value is GSTransed, so to include spaces you can surround the text with quote marks.

Any such settings override any initialisation values in the script file.

You can use this facility to pass parameters to the script.

`-v`

Verbose mode. Prints progress information while the program is running. This should only normally be necessary when debugging.

Defining and editing output formats

Introduction

Output formats are known as templates. Each is stored as a standard text file inside the !EXIFinfo application, in the Formats directory. The name of a template (as used in the selection menu) is defined inside the file; the actual filenames are unimportant, except in providing a guide to the contents.

The menu is constructed by scanning all the text files in the Formats directory when the program starts. If you edit a template and save it back (with the same filename), you'll need to reload the template for the new definition to take effect. Changes to a template's name (or adding a new one) will have no effect until the program is restarted.

The menu is sorted into alphabetical order, and the program always starts up with the first entry selected and loaded. This means that you can force any particular template to become the default by adding a leading space (or some other low ASCII-value character) to the format's name.

You can look at the current template definition by clicking on the Edit button. Examining these files is probably the easiest way to learn how to create your own templates. If you use the StrongEd editor, your life will be made very slightly easier if you install the editing mode file included in the distribution, and set up the colours to your taste.

Characters are copied from the template to the output, except:

A newline followed by # is ignored (comment line) unless the next character is ! - these are program directives. Directives mark out sections, and specify things like the format's name and the filetype of the output file.
{ and } enclose tags, which are replaced with their value. A typical tag is {ExifImageWidth}, which will insert the horizontal size (in pixels) of the current image into the output. The names of these tags largely correspond to the 'official' TIFF tag names. Currently there are over 400 different tags.
Most tags refer to image properties, but there are also special tags for other purposes; their names start with a ! character. For example, {!LeafName} will insert the name of the current image file, and {!If expression} ... {!Else} ... {!Endif} lets you conditionally change the output.
\ is the single-escape character - the next character is output literally. Only necessary if you want to output a { or a newline/# combination.

The names of all directives and tags are case-insensitive.

Each template can have three sections: a header, an image section, and a footer. Each part is marked by #!section=header/image/footer and continues until the next section starts or the end of the file is reached. #!section=image is the only required part.

When a file is generated, any header specified is first produced. Then the image section is repeated for each image in the directory, and finally any footer section is produced.

Example:

#!exifinfotemplateversion=1.00

# This demonstrates CSV output with quotes and field names

#!formatname=Quoted CSV with column labels

#!outputleafname=CSVdata

#!outputfiletype=DFE

#!outputmode=single

#

#!section=header

# Column labels inserted at start of file

"Name","X","Y","Exposure time","F number"

#!section=image

# The next line is interpreted for every image processed

"{!leafname}","{ExifImageWidth}","{ExifImageHeight}","{ExposureTime}","{FNumber}"

Program directives

Program directives must appear at the start of a line, and are preceded by #!. There should not be any trailing spaces.

Directives marked with Required must be present in the file. Some directives are Optional, in which case suitable default values are used if they are unspecified.

Apart from #!ExifInfoTemplateVersion and the section markers, you can put directives anywhere in the file - their position is unimportant.

It isn't an error to have duplicated entries, but only the first will be used. Note that the values of all these variables are only read once, when the template is first loaded. You cannot change a value by including it in the image section, for example.

Directive names are not case-sensitive; formatname and FormatName are both acceptable. However, case is significant in any values assigned.

`#!ExifInfoTemplateVersion=2.30 Required`

This must appear as the first line of the file (and hence appears first in this otherwise alphabetical listing), and identifies the version of the template file. To take advantage of all the current features it should have a value of 2.30 (version numbers lower than this are also understood).

`#!Comment1=text Optional #!Comment2=text #!Comment3=text`

The program's window has three lines available for status reports and information. When a new output format is selected, any text specified in these directives will appear in the appropriate line. Use them for reminder notes, author credits and so on.

`#!DateFormat=format Optional #!FileDateFormat=format`

If supplied, these specify the format strings which will be used by the {!Date} and {!FileDate} tags respectively. The format value should be a standard RISC OS time format string. They both default to the value:

%z12:%mi:%se%pm, %w3 %zdy %m3 %ce%yr

which gives, for example:

3:46:28pm, Wed 25 Sep 2002

`#!EXIFDateFormat=format Optional`

This specifies a format string to be used for the various date tags stored in the EXIF files. The format value should be a standard RISC OS time format string. If it is unset, the date is printed as it is stored in the file: a 19-character string with the format "YYYY:MM:DD hh:mm:ss". The default format is useful for comparison and sorting, however.

The tags affected by this directive are {DateTimeOriginal}, {DateTimeDigitized}, {Main.DateTime}, and {Thumbnail.DateTime}. The format string is only used if the date in the file is a well-formed, legal date.

`#!FormatName=name Required`

This is used to describe the format in the menu. It should contain fewer than 64 characters. As the menu is sorted alphabetically and the program always starts up with the first entry selected, you can make any entry the default by putting a space as the first character of the format name (or some other character with ASCII code less than 65).

`#!OutputFileType=type Required`

Specifies the filetype of the output file, which can be a hex number or the textual name (as in the Filer's "Set type" option).

`#!OutputLeafName=name Required`

This is the default name used for the file produced. Although this is called a 'leaf' name, it can also contain directories and path modifiers, relative to the directory containing the image being processed. For example:

#!outputleafname=^.infodir.imageinfo

This stores the output (called imageinfo) in the directory infodir in the image directory's parent. Note that any directories named must already exist.

`#!OutputMode=single Required`

The value of this compulsory directive must be single. Other values are reserved for future expansion.

`#!Runnable=truth Optional`

This directive determines whether it is possible to 'run' the output. If it is false, the run-on-completion icon is deselected and greyed out. If it is true, the run-on-completion icon is selectable by the user, and is initially set to the value of the #!RunOnCompletion directive (which defaults to Yes).

The default value of this directive is Yes, so unless otherwise specified all format files are runnable.

Truth can be any of yes or no, Y or N, 1 or 0, true or false, T or F, in any capitalisation.

`#!RunOnCompletion=truth Optional`

This directive determines the initial setting of the run-on-completion icon, which is selectable only if the format is 'runnable' (as specified by the #!Runnable directive). The icon can of course have its status changed by the user.

The default value of this directive is Yes, so unless otherwise specified all format files will run on completion.

Truth can be any of yes or no, Y or N, 0 or 1, true or false, T or F, in any capitalisation.

`#!Section=header Optional`

This marks the start of the output file's header section. It is optional, but if provided must precede the image section. Everything between this and the image section will be placed at the start of the output file.

`#!Section=image Required`

This marks the start of the output file's image section. It must be included (otherwise no output would be produced).

Everything between this marker and either the footer section or the end of the file is output for each image in the source directory. It should contain the information that you want generated for the images.

`#!Section=footer Optional`

This marks the start of the output file's footer section. It is optional, but if provided must follow the image section. Everything between this and the end of the file will be placed at the end of the output file.

`#!TagDelimiters=LR Optional`

Tags are normally surrounded by braces, {...}, but you can change this behaviour if you wish. The value LR must be exactly two non-identical characters, which will be used as the left and right tag delimiters respectively. It is useful if you need to include a lot of braces in the output, for example when producing a DDF file for Impression or EasiWriter. In this case a value of [] (square brackets) might be more readable.

It should be obvious that this facility must be used with extreme caution. Note too that some items will need to be changed if you alter the tag delimiters: for example, the default value of the #!ThumbnailFileName directive assumes braces, so you'll need to specify an alternative value explicitly if you want to generate thumbnails.

`#!ThumbnailFileName=text Optional`

The string text specifies the full name of the file to which thumbnails are saved. It can contain tags. In fact it must, otherwise all thumbnails will have the same name and each will overwrite the previous one.

If this is unspecified, it takes a default value of {!OutputPath}.thumbs.{!LeafName}, which will store thumbnails in a subdirectory (called "thumbs") of the current image directory, each with the same name as their parent image.

Thumbnail images are actually generated by the {!SaveThumbnail} tag, which will also create any directories needed.

`#!ThumpKeywords=list Optional`

The list should be a comma-separated series of keywords suitable for use by the Thump image browser. These are inserted into the text by the {!ThumpKeywords} tag. It must contain fewer than 128 characters.

This keyword is provided because editing the Thump captions format file should be done with caution. You should only change the lines marked in the file.

`#!UnknownString=text Optional`

The string specified by text is printed when a request is made to print a tag's value, but the image file does not contain any corresponding data. If this directive is not given, [No value] is printed.

Note that most images only contain a small subset of the possible tags.

`#!Usern=value Optional`

There are ten user tags available, named !User0 to !User9, which can be initialised by these directives. The value is a string. It should not contain tags, as when the value is assigned no images have been read.

You can also change the values of the user tags within the output by using the special tags {!Usern=expr}. In this case full expressions can be used, which themselves can contain tags.

Of course, you can output the value by using the appropriate {!Usern} tag.

About tags

Tags are enclosed in braces {...} (though this can be changed). When one is seen in a template file, it is replaced by its value.

Case is not significant in tag names.

Unrecognised tags cause an error.

Tags are split into two main types:

EXIF tags represent the data in the image and produce output accordingly. If the data associated with a particular tag is not present in the image, the tag has the value specified by the !#UnknownString directive.
Special tags are for data not stored inside the file, and for miscellaneous items. They all begin with the "!" character. For example, there are tags for the image file's path, name, size and so forth, and for producing a thumbnail image. Ten user tags are available, {!User0} to {!User9}, which can be assigned values from arbitrarily complicated expressions which themselves can contain tags. There is also the {!if expr}... {!else}... {!endif} construct, which can be used to output one thing or another depending on a condition.

Tags exist for all the data in an EXIF file. The most common ones are those associated with the EXIF image, but you can also access the information for other parts of the file: the main section, the thumbnail, and the GPS section. Manufacturer-specific MakerNotes are also supported via this mechanism.

Tag names for these non-EXIF data have the form {Main.tagname}, {Thumbnail.tagname} and {GPS.tagname}. Main is the standard JFIF image header, and contains the make and model of the camera used, and some general image information. Thumbnail tags refer to the associated thumbnail image inside each EXIF file. GPS tags contain location information derived from satellites, and at time of writing are not available in many cameras (if any).

MakerNote tags contain manufacturer-specific information, and have names of the form {Maker.tagname}. For example, {Olympus.SpecialMode} contains panorama information.

Many tags have a printing method associated with them, which allows the meaning of the tag to be better expressed. For example, the value of the {MeteringMode} tag is really just a number, but this is translated into a more understandable value when it is printed: "Average", "Centre-weighted average", "Spot" and so forth.

Currently a tag's print method cannot be changed.

User functions

Because it is possible to evaluate expressions, a facility for user-defined functions is available. The file UserLib in the Formats directory is a BASIC file containing function definitions. These can be called either by assigning their values to a user tag, as follows:

{!User0=FNcommas("{!FileSize}")}

Or by using the {!Eval expr} construct, which will print the value directly:

{!Eval FNcommas("{!FileSize}")}

The (supplied) function FNcommas takes a string as its only parameter (hence the quotes), and inserts commas every three characters, making large numbers more readable.

You can add functions to the UserLib file if you wish. They should return a string, use only LOCAL variables, and have no side-effects. A typical use would be to tailor the output of a particular tag if the program's normal output was unsatisfactory.

When the program starts, the procedure PROCinitialise_user_library (which is in UserLib, of course) is called. This allows you to set up any memory buffers and other resources you may need in subsequent functions.

Special tags

The names of special tags all start with the "!" character. Most produce some text which is inserted into the output file, but some have other effects.

`{!Date}`

This produces the current date and time, in the format specified by the #!DateFormat directive.

`{!Dec Usern}`

This will subtract 1 from the value of user variable n. It produces no output, and is equivalent to (but slightly more convenient than) writing {!Usern={!Usern}-1}. See also {!Inc ...}.

`{!Eval expression}`

This evaluates expression and outputs the result. The expression can contain tags, which are expanded as usual, and anything that could appear in a valid BASIC expression. This is a convenient way of calling user functions and printing the result, or performing small alterations on tag values. For example, if a tag might produce a long string you could limit the length to ten characters by doing:

{!Eval LEFT$("{tag}",10)}

`{!FileDate}`

Produces the date of the actual image file (as seen in Filer windows), in standard 20-character form or that specified by the #!FileDateFormat directive. Note this may differ from the date stored in the EXIF data of the file, which should be the time the picture was actually taken (providing the camera's clock has been set correctly).

`{!FileSize}`

Produces the size of the image file, in bytes.

`{!FileSizeK}`

Produces the size of the image file, in bytes, Kbytes or Mbytes as appropriate.

`{!If expression}...[{!Else}]...{!Endif}`

This construction lets you vary the output produced depending on a condition. The expression can contain tags, which are replaced with their values as normal; the result is then evaluated. If it is true (non-zero), everything up to {!Else} (or {!EndIf}) is output, and interpretation continues following {!Endif}. If the expression is false (zero), the section following {!Else} is output, if present.

Like BASIC, you can omit the {!Else} part if you wish. The {!If} structure can be nested arbitrarily, and the various parts can span over multiple lines.

Because the expression evaluation uses BASIC's EVAL facility, you must be careful about syntax. If you want to compare strings, for example, they must be in double-quotes.

There's a convenient shorthand notation to see if a tag has a value or not. Normally you would check if its value was the same as the current UnknownString value:

{!If "{tag}"<>"[*]"}...output stuff...{!EndIf}

The following has the same effect:

{!If "{tag}"}...output stuff...{!EndIf}

Examples:

{!If {!User1}=0}User1 is now zero{!User1=10}{!ELSE}User1 is {!User1}{!User1={User1}-1}{!ENDIF}

This is a simple counter. If user tag 1 is zero a message is produced and it is reset to 10, otherwise it is decremented by 1.

{!If "{tag}"<>"[N/A]"}Tag is {tag}{!endif}

Providing the #!UnknownString directive has been set to [N/A], this will only print a tag's value if it is present in the file - thus avoiding printing details of of irrelevant tags. Note the quotes! The following statement is equivalent: {!If "{tag}"}Tag is {tag}{!endif}

{!If "{Main.Make}"="FUJIFILM"}...output details...{!Endif}

This will only produce information on photos taken with Fujifilm cameras.

{!If "{DateTimeOriginal}">"2001:00:00 00:00:00"}...output details...{!Endif}

This will only output details of photographs taken since the start of 2001.

`{!ImageNumber}`

The value of this tag starts at 1 and increases by 1 for every image successfully processed. Thus if it is used in the footer section it will produce the total number of images processed.

`{!Inc Usern}`

This will add 1 to the value of user variable n. It produces no output, and is equivalent to (and more convenient than) writing {!Usern={!Usern}+1}. See also {!Dec ...}.

`{!LeafName}`

Produces the name of the image file currently being processed.

`{!MakerNote}`

This uniquely specifies the type of MakerNote present. Identifying this is not straightforward -- all manufacturers use different tags, and they vary even between cameras from the same company. Note this is different from the {MakerNote} tag, which is just an internal file pointer.

It should be used in conjunction with {!If ...} to select the appropriate tags to use when producing MakerNote data. It is either a null string if no MakerNote data is present, or a lowercase string with one of these values:

canon Canon models. Use {Canon.name} tags
casio Casio models (not many) which provide MakerNotes. Use {Casio.name} tags
fuji Fuji models. Use {Fuji.name} tags
olympus All known Olympus cameras. Use {Olympus.name} tags
nikon Some Nikon models. Use {Nikon.name} tags
nikond Alternative Nikon format. Use {NikonD.name} tags
sanyo Sanyo models. Use {Sanyo.name} tags

`{!OutputLeafName}`

Produces the name of the output file being made.

`{!OutputPath}`

Produces the path of the output file being made. This does not include the actual filename, or a trailing "."

`{!Path}`

Produces the path of the image file currently being processed. This does not include the actual filename, or a trailing "."

`{!ProgramCredit}`

Generates some text giving the author details of EXIFinfo.

`{!ProgramVersion}`

Generates the version number of EXIFinfo used to produce the output.

`{!SaveThumbnail}`

This is an unusual tag in that it generates no (text) output. Instead, a thumbnail of the current image is saved to the location specified in the directive #!ThumbnailFileName (see above). It will create any directories if necessary.

Note that this depends on the existence of a thumbnail image inside the EXIF file. As far as we're aware all EXIFs do contain thumbnails, but if none is found no error is generated. Currently only JPEG thumbnails are supported. EXIF thumbnails should theoretically always be the same size, 160×120 pixels.

The thumbnail images generated cannot be read with the RISC OS's built-in routines (so Paint cannot display them), but are fine with most web browsers (WebsterXL. Oregano, Fresco, Opera and Explorer tested).

`{!ThumpName}`

For its caption files, Thump needs to have filenames specified in a certain way. This tag looks after generating the names correctly. It is only useful for Thump caption files.

`{!ThumpDate}`

For its caption files, Thump needs to have file dates specified in a certain way. This tag looks after generating the date correctly. It is only useful for Thump caption files.

`{!ThumpKeywords}`

Thump has the facility to search its database for keywords. Specifying a list of comma-separated words with the #!ThumpKeywords directive will insert the keywords into the caption file produced.

This tag is only useful for Thump caption files.

`{!UnixLeafName}`

Produces the name of the file in UNIX format, with appropriate conversions of "/" characters.

This tag is mainly useful when generating HTML files.

`{!UnixPath}`

Produces the full path of the file in UNIX format, with appropriate conversions of "/" and "." characters. This does not include the actual filename, or a trailing "/".

This tag is mainly useful when generating HTML files.

`{!Usern} {!Usern=expression}`

There are ten user tags available, named !User0 to !User9. They can be given an initial value with the #!Usern=value directives (which see). Including them in the output (as {!User0} for instance) will produce the current value.

You can also change the value within the output sections of the file, by using the special forms {!Usern=expression}. The expression can contain tags, which are expanded as normal; the result is then evaluated and assigned to the appropriate user tag. Note that user tags always contain strings, even when the expression produces a number; conversion to numbers is handled transparently.

For example, to increment the value of user tag 5 you would include {!User5={!User5}+1} within the image section (but see also {!Inc ...} and {!Dec ...}).

This facility is used for keeping a count of the total size of the files processed in some of the format files. !User9 is used, which is first initialised in the header:

#!User9=0

In the image section, the following statement is included:

{!User9={!User9}+{!FileSize}}

which adds the size of the current file to the running total. Finally, in the footer section the result is reported:

{!ImageNumber} files containing {!user9} bytes

User tags are also used for keeping track of the columns in HTML output.

EXIF, Main and Thumbnail tags

This section includes all the tags available, in the EXIF, Main, and Thumbnail parts of the image. Each section is in alphabetical order.

Most images do not contain every tag. Some tags duplicate another's function, which is useful when a particular camera does not provide the 'standard' one. For instance, images from many Fuji cameras do not contain the important {ExposureTime} tag, which gives the length of the exposure - but they do have the alternative {ShutterSpeedValue} tag.

EXIF tags

`{ApertureValue}`

The aperture size of the lens; if present it should be identical to the {FNumber} tag. It is stored internally in APEX form, but is converted to standard notation when printed.

Example: 4.5

`{BrightnessValue}`

[Technical] Brightness of the scene, as judged by the camera.

Example: 431/100

`{CFAPattern}`

[Technical] The filter array used in the camera's sensor chip.

Warning: The values of this tag may not be printed in full.

`{ColourSpace}`

Defines the colour space used, usually sRGB.

Example: sRGB

`{ComponentsConfiguration}`

[Technical] Colour model information.

Warning: The values of this tag may not be printed in full.

`{CompressedBitsPerPixel}`

Estimate of the compression ratio of the main image.

Example: 32/10

`{Contrast}`

Contains the type of contrast adjustment done by the camera.

Example: Hard

`{CustomRendered}`

[Technical] Indicates any special processing done on the image.

Example: Normal

`{DateTimeDigitized}`

When the image was converted. This will nearly always be the same as {DateTimeOriginal}.

The output from this tag is affected by the #!EXIFDateFormat directive.

Example: 2001:12:15 15:46:30

`{DateTimeOriginal}`

This is the date and time the original image was captured, and is the best tag to use when you want this information (others may be modified).

It is normally 19 characters long, with the format "YYYY:MM:DD hh:mm:ss"; this makes it suitable as a basis for sorting.

The output from this tag is affected by the #!EXIFDateFormat directive.

Example: 2001:12:15 15:46:30

`{DeviceSettingDescription}`

[Technical]

Warning: The values of this tag may not be printed in full.

`{DigitalZoomRatio}`

Contains the digital zoom factor used.

Example: Not used

`{ExifImageHeight}`

This is the height of the image, in pixels.

Example: 1200

`{ExifImageWidth}`

This is the width of the image, in pixels.

Example: 1600

`{ExifInteroperabilityOffset}`

[Technical] For internal use.

`{ExifVersion}`

[Technical] The version number of the EXIF format used.

Example: 0210

`{ExposureBiasValue}`

This specifies any exposure compensation used when taking the picture.

Example: 1/3

`{ExposureIndex}`

This duplicates the {ISOSpeedRatings} tag.

`{ExposureMode}`

Indicates the camera's exposure mode.

Example: Manual

`{ExposureProgram}`

The camera setting when the shot was taken, such as "Manual", "Shutter priority" and so on.

Example: Normal

`{ExposureTime}`

The exposure time, in seconds. This is expressed as a fraction.

Note that Fuji cameras do not use this tag; use {ShutterSpeedValue} instead.

Example: 1/6

`{FileSource}`

The device that obtained the image.

Example: Digital still camera

`{Flash}`

Details of any flash used for the image.

Example: Fired

`{FlashEnergy}`

[Technical] Output of the flash, in beam candle power seconds.

`{FlashPixVersion}`

[Technical] Data format version.

Example: 0100

`{FNumber}`

The F stop of the lens used for the image. This should be equivalent to the ApertureValue tag.

Example: 4.00

`{FocalLength}`

The focal length of the camera's lens, in mm.

Example: 10.81

`{FocalLengthIn35mmFilm}`

The focal length equivalent to a 35mm camera. This differs from the {FocalLength} tag.

`{FocalPlaneResolutionUnit}`

[Technical] Unit of FocalPlaneXResolution and FocalPlaneYResolution.

`{FocalPlaneXResolution} {FocalPlaneYResolution}`

[Technical] Pixel density measure.

`{GainControl}`

Indicates the gain adjustment used on the image.

Example: High gain up

`{ImageUniqueID}`

[Technical]

Warning: The values of this tag may not be printed in full.

`{ISOSpeedRatings}`

The speed of the 'film' used.

Example: 400

`{LightSource}`

This is actually the white balance setting.

Example: Daylight

`{MakerNote}`

Manufacturer-specific information.

MakerNotes are not supported in this version of EXIFinfo.

`{MaxApertureValue}`

[Technical] Maximum aperture of lens.

Example: 360/100

`{MeteringMode}`

The method used to meter the exposure, such as "Spot" or "Average".

Example: Multi-segment

`{OECF}`

[Technical] Optoelectric coefficients, specifying the relation between optical input values and the image output.

`{RelatedSoundFile}`

This is the name of any associated sound file (a voice caption, for instance).

Example: DSCF0900.wav

`{Saturation}`

Contains the type of saturation adjustment done by the camera.

Example: Low

`{SceneCaptureType}`

Indicates the type of scene.

Example: Portrait

`{SceneType}`

[Technical] Whether the image was directly photographed.

`{SensingMethod}`

[Technical] What was used to capture the image. Most commercial cameras use a 1-chip sensor.

`{Sharpness}`

Contains the type of sharpness adjustment done by the camera.

Example: Soft

`{ShutterSpeedValue}`

The exposure time, in seconds. This is expressed in decimal.

Note that Fuji does not use the 'correct' {ExposureTime} tag, so you must use this one if you have one of their cameras.

Example: 0.0156

`{SpatialFrequencyResponse}`

[Technical] Frequency response values.

Warning: The values of this tag may not be printed in full.

`{SpectralSensitivity}`

[Technical] Channel sensitivity measures of the camera.

`{SubjectArea}`

[Technical] Location and area of the main subject in the image.

Warning: The values of this tag may not be printed in full.

`{SubjectDistance}`

The distance to the focus point, in metres. Note this is an estimate, and is often highly misleading!

Example: 0.32m

`{SubjectDistanceRange}`

Indicates the range of the subject.

Example: Macro

`{SubjectLocation}`

[Technical] Specifies the location in the image ofthe main subject.

Warning: The values of this tag may not be printed in full.

`{SubsecTime}`

As many cameras can now take more than one picture every second, this tag provides finer resolution for timing photographs. It should be used in conjunction with the {DateTime} tag, where you should put this value after a decimal point.

Example: 230

`{SubsecTimeDigitized}`

As above, but paired with {DateTimeDigitized}

`{SubsecTimeOriginal}`

As above, but paired with {DateTimeOriginal}

`{UserComment}`

Optional description of the image.

This tag is not implemented in this version of EXIFinfo.

`{WhiteBalance}`

Indicates the camera's white balance mode.

Example: Auto

Main tags

`{Main.Copyright}`

The copyright string associated with the image. Some cameras allow you to set this.

Example: Lee and Chris

`{Main.DateTime}`

The time the image was last modified. It is normally 19 characters long, with the format "YYYY:MM:DD hh:mm:ss"; this makes it suitable as a basis for sorting.

The output from this tag is affected by the #!EXIFDateFormat directive.

Example: 2001:12:15 15:46:30

`{Main.ExifOffset}`

[Technical] For internal use.

`{Main.GPSOffset}`

[Technical] For internal use.

`{Main.ImageDescription}`

Often this is empty but it sometimes contains the manufacturer's name, and can be configured on some cameras.

Example: OLYMPUS DIGITAL CAMERA

`{Main.Make}`

The manufacturer's name.

Example: NIKON

`{Main.Model}`

The model of the camera.

Example: C3040Z

`{Main.Orientation}`

Specifies which way up the image is.

Example: x0,y0=left,top

`{Main.PrimaryChromaticities}`

[Technical] Defines the chromaticity of the image's primary colours.

Warning: The values of this tag may not be printed in full.

`{Main.ReferenceBlackWhite}`

[Technical] Defines the reference point of black and white.

Warning: The values of this tag may not be printed in full.

`{Main.ResolutionUnit}`

The unit used by the Main.XResolution and Main.YResolution tags, usually inches or centimetres.

Example: Inches

`{Main.Software}`

Describes the camera's internal software.

Example: Digital Camera FinePix2200 Ver2.10

`{Main.WhitePoint}`

[Technical] Defines the chromaticity of the image's white point.

`{Main.YCbCrCoefficients}`

[Technical] Multipliers for converting YCbCr colours to RGB space.

Warning: The values of this tag may not be printed in full.

`{Main.YCbCrPositioning}`

[Technical] Defines the sample point used for subsampling of the raw data.

`{Main.XResolution} {Main.YResolution}`

The nominal resolution of the image, in pixels per resolution unit (). Not important for most purposes.

Example: 72

Thumbnail tags

`{Thumbnail.Artist}`

Settable in some cameras.

`{Thumbnail.BitsPerSample}`

[Technical] For internal use.

`{Thumbnail.Compression}`

Example: x0,y0=left,top

The EXIF standard reserves an area called the MakerNote for use by camera manufacturers to store extra information which isn't covered by the standard tags. It says nothing about what should be stored there, or in what format. The result is that each company's use of the MakerNote area is different, and sometimes varies between different models from the same manufacturer.

The information is also proprietary, and thus not officially documented anywhere. This makes writing programs to decode MakerNotes rather harder than it needs to be ... but thanks to the reverse-engineering efforts of various people around the world, some progress has been made. Credit is due to all those who have researched and published information (too many to list individually).

MakerNotes are supported for the following manufacturers:

Canon
Casio
Fuji
Nikon (two different formats depending on the camera)
Olympus
Sanyo

Listed here are the tags known to appear in various camera manufacturer's EXIF images. Much of this information is speculative, and if you can add to it please let us know.

Canon MakerNote tags

`{Canon.AFPointSelected}`

Where the auto-focus system was looking.

Example: Left

`{Canon.AFPoint}`

The auto-focus point actually used.

Example: Centre (3 focus points)

`{Canon.ContinuousDriveMode}`

Whether the camera was in single-shot or continuous mode.

Example: Continuous

`{Canon.Contrast}`

Any contrast adjustment applied to the image.

Example: High

`{Canon.DigitalZoom}`

The digital zoom setting of the camera.

Example: 4x

`{Canon.EasyShootMode}`

The shooting mode of the camera.

Examples:

Slow shutter

Sepia

Manual

`{Canon.ExposureMode}`

How the exposure was arrived at.

Example: Program

`{Canon.FirmwareVersion}`

Version number of the camera's software.

Example: Firmware version 1.0

`{Canon.Flash}`

Whether the flash fired or not.

Example: Fired

`{Canon.FlashBias}`

Brightness adjustment applied to the flash, in EV.

Example: -0.67

`{Canon.FlashInfo}`

Detailed flash information.

Example: FP sync, external E-TTL

`{Canon.FlashMode}`

The flash setting of the camera. This does not indicate whether it was fired or not.

Example: Slow synchro

`{Canon.FocusMode}`

The focus setting of the camera.

Example: AI servo

`{Canon.FocusMode2}`

The focus setting of the camera, used by the G1 camera rather than {Canon.FocusMode}.

`{Canon.FocusType}`

The overall focusing method.

Example: Locked (pan mode)

`{Canon.ImageNumber}`

Image sequence number.

Example: 047-1034

`{Canon.ImageSize}`

A description of the image size.

Example: Medium

`{Canon.ImageType}`

The internal image type.

Example: ST*:Stitch assist mode

`{Canon.ISO}`

The camera's ISO setting.

Example: 100

`{Canon.LongFocalLength} {Canon.ShortFocalLength} {Canon.FocalUnitSize}`

Highest and lowest focal length of the lens, and the units per mm.

`{Canon.MacroMode}`

Whether the camera was in macro mode.

Example: Macro

`{Canon.MeteringMode}`

The method of metering in use.

Example: Centre-weighted

`{Canon.Owner}`

Settable in some cameras.

Example: Lee and Chris

`{Canon.Quality}`

Image quality.

Example: Fine

`{Canon.Saturation}`

Any saturation adjustment applied to the image.

Example: Low

`{Canon.SelfTimerDuration}`

Duration of the self-timer, in tenths of a second.

`{Canon.SequenceNumber}`

Number used in continuous shooting to mark the exposures.

Example: 2

`{Canon.SerialNumber}`

The serial number of the camera.

Example: 14AF32561

`{Canon.Sharpness}`

Any sharpness adjustment applied to the image.

Example: Normal

`{Canon.SubjectDistance}`

Estimated distance to the subject of the image. Beware -- the units for this can be either cm or mm, and there appears to be no way to tell which. Use {SubjectDistance} instead.

`{Canon.WhiteBalance}`

`{Canon.0010}`

Purpose unknown.

Casio MakerNote tags

These tags are used in the (rather few) Casio cameras which support MakerNotes, for example the QV-3000EX.

`{Casio.CCDSensitivity}`

Sensitivity of the camera's sensor

Example: +2.0

`{Casio.Contrast}`

Any contrast correction applied.

Example: High

`{Casio.DigitalZoom}`

Any digital zoom used.

Example: 2x

`{Casio.FlashIntensity}`

The strength of any flash used.

Example: Strong

`{Casio.FlashMode}`

Details of any flash used.

Example: Red-eye reduction

`{Casio.FocusingMode}`

The focusing method used.

Example: Auto

`{Casio.ObjectDistance}`

Distance to the subject, converted to metres.

Example: 2.8

`{Casio.Quality}`

Storage quality of the picture.

Example: Economy

`{Casio.RecordingMode}`

The photographic method used.

Examples:

Single shutter

Portrait

`{Casio.Saturation}`

Any saturation correction applied.

Example: Normal

`{Casio.Sharpness}`

Any sharpness correction applied.

Example: Soft

`{Casio.WhiteBalance}`

White balance correction applied.

Purpose unknown.

Fuji MakerNote tags

`{Fuji.AEWarning}`

Whether there was an auto-exposure warning when the photograph was taken.

Example: Yes

`{Fuji.BlurWarning}`

Whether there was a blur warning when the photograph was taken.

Example: Yes

`{Fuji.Colour}`

Saturation setting.

Example: Low

`{Fuji.ContTakeBracket}`

Whether continuous shooting or auto-bracketing was in operation.

Example: Off

`{Fuji.FlashMode}`

The flash setting. Note that this doesn't tell you whether it actually fired or not.

`{Fuji.FlashStrength}`

Strength setting of the flash.

Example: 3/10

`{Fuji.FocusMode}`

Focusing mode setting.

Example: Off

`{Fuji.FocusWarning}`

Whether there was a focusing warning when the photograph was taken.

Example: No

`{Fuji.Macro}`

Macro setting.

Example: On

`{Fuji.PictureMode}`

Photography mode.

Examples:

Portrait

Aperture priority AE

`{Fuji.Quality}`

Picture quality setting.

Example: Fine

`{Fuji.Sharpness}`

Sharpness adjustment setting.

Example: Hard

`{Fuji.SlowSync}`

Slow synchro mode setting. This fires the flash, then keeps the shutter open for a while to register faint detail.

Example: On

`{Fuji.Tone}`

Contrast setting.

Example: Normal

`{Fuji.WhiteBalance}`

White balance setting.

Example: Daylight

`{Fuji.Version}`

Version number of the MakerNote data.

Sensor sensitivity (ISO equivalent).

Example: ISO320

`{Nikon.ColourMode}`

Shows whether the image is in colour or monochrome.

Example: Monochrome

`{Nikon.Converter}`

Whether a fisheye lens was used.

Example: Fisheye

`{Nikon.DigitalZoom}`

Digital zoom factor.

Example: 1.6x digital zoom

`{Nikon.Focus}`

Focus value.

Example: Infinity

`{Nikon.ImageAdjustment}`

Details of any image adjustment applied.

Example: Contrast+

`{Nikon.Quality}`

Quality setting used for the image.

Example: SXGA normal

`{Nikon.WhiteBalance}`

Any white balance correction applied.

Example: Incandescence

`{Nikon.0002}`

Purpose unknown, possibly some kind of version number.

`{Nikon.0009}`

Purpose unknown.

`{Nikon.0F00}`

Purpose unknown.

NikonD MakerNote tags

This is the second of two Nikon MakerNote formats, used in the D1 and other cameras.

`{NikonD.AFFocusPosition}`

Position of the focus point.

`{NikonD.AuxiliaryLens}`

Details of any additional lens used.

Example: Wide adapter

`{NikonD.ColourMode}`

Shows whether the image is in colour or monochrome.

Example: Monochrome

`{NikonD.DataDump}`

Purpose unknown.

`{NikonD.DigitalZoom}`

Digital zoom factor.

Example: 1.4x digital zoom

`{NikonD.FlashSetting}`

Flash mode used.

Example: Red-eye

`{NikonD.FocusMode}`

Shows focusing setting.

Example: AF-C

`{NikonD.ImageAdjustment}`

Details of any image adjustment made.

Example: Contrast+

`{NikonD.ImageSharpening}`

Shows any image sharpening applied.

Example: High

`{NikonD.ISOSelection}`

Whether the ISO speed was set automatically or manually

Example: Auto

`{NikonD.ISOSetting}`

ISO speed setting.

Example: ISO200

`{NikonD.ManualFocusDistance}`

Distance of the focus point, if manually selected. Unit is metres.

Example: 8.00

`{NikonD.NoiseReduction}`

Noise reduction applied (speculative).

`{NikonD.Quality}`

Quality setting used for the image.

Example: Fine

`{NikonD.Saturation}`

Saturation adjustment applied (speculative).

`{NikonD.WhiteBalance}`

Any white balance correction applied.

`{Olympus.DataDump}`

Purpose unknown.

`{Olympus.DigitalZoom}`

The digital zoom setting.

Example: 2x

`{Olympus.JpegQuality}`

The quality setting for storing the picture.

Examples:

SHQ

`{Olympus.Macro}`

Whether the camera was in macro (close-up) mode.

Example: Macro

`{Olympus.PictureInfo}`

This is a relic of pre-EXIF cameras. It's a string containing some very basic information about the picture.

Example: [pictureInfo] Resolution=1 [Camera Info] Type=SX354

`{Olympus.SoftwareRelease}`

Version number of the camera software.

`{Olympus.SpecialMode}`

The photography method used.

Examples:

Normal

Purpose unknown.

Sanyo MakerNote tags

`{Sanyo.CameraID}`

Intended to be used to identify the camera. This can be changed in some cameras.

`{Sanyo.ColourAdjustmentMode}`

Whether the colour has been adjusted.

Example: Off

`{Sanyo.DataDump}`

Purpose unknown.

`{Sanyo.DigitalZoom}`

Digital zoom setting.

Example: 3

`{Sanyo.DigitalZoomMode}`

Whether the digital zoom was used.

Example: Off

`{Sanyo.FlashMode}`

Flash mode setting.

Example: Forced

`{Sanyo.FlickerReduce}`

Used for frames taken from video clips

Example: On

`{Sanyo.JPEGQuality}`

Shows the quality and detail settings.

Example: Medium high (fine)

`{Sanyo.LightSourceSpecial}`

Whether any special white balance setting was used.

Example: Off

`{Sanyo.Macro}`

Whether macro (close-up) mode was in operation.

Example: Manual

`{Sanyo.MakerNoteOffset}`

[Technical] File offset.

`{Sanyo.ManualFocusDistance}`

The focus distance in manual mode.

`{Sanyo.OpticalZoom}`

Whether the optical zoom was used.

Example: On

`{Sanyo.PictureInfo}`

Old-style picture information.

`{Sanyo.PrintIMFlags}`

[Technical] Epson Print Image Matching data.

`{Sanyo.QuickShot}`

Whether quick-shot mode was in operation.

Example: Yes

`{Sanyo.RecordShutterRelease}`

How the shutter switch operates.

Example: Record while held

`{Sanyo.Resaved}`

Indicates whether the image has been processed by the camera in some way, and resaved.

Example: No

`{Sanyo.SceneSelect}`

Scene type setting.

Example: Night

`{Sanyo.SelfTimer}`

Whether the self-timer was used.

Example: No

`{Sanyo.SequentialShotInterval}`

Frames shot per second.

Example: 15 frames/sec

`{Sanyo.SequentialShotMethod}`

Mode for continuous shooting.

Example: Best

`{Sanyo.SoftwareRelease}`

Software version number.

`{Sanyo.SpecialMode}`

Shows any special shooting mode, including panoramas.

Example: Panorama (#3, right to left)

`{Sanyo.Thumbnail}`

[Technical] Alternative thumbnail data.

`{Sanyo.VoiceMemo}`

Whether an associated memo file exists.

Example: No

`{Sanyo.WideRange}`

Meaning unclear.

The Global Positioning System is a network of satellites designed to provide extremely accurate location information to anyone on the planet with a suitable receiver. Currently these are only available as stand-alone units, but will soon be fitted to high-end cameras.

The GPS tags available for use in EXIF files can include the following information:

The latitude and longitude of the observer
The altitude of the observer
The direction and speed of the observer
The direction the camera was pointing
The distance from the camera to the object being photographed

We haven't been able to test any of these as we can't trace any images which use them. If you find one, let us know!

GPS tags

`{GPS.Altitude}`

The altitude, in metres.

`{GPS.AltitudeRef}`

The reference altitude, either sea level or below sea level.

`{GPS.AreaInformation}`

The GPS area name.

`{GPS.DateStamp}`

The date, in UTC form (eg 2002:10:05).

`{GPS.DestBearing}`

The bearing to the destination point, in degrees.

`{GPS.DestBearingRef}`

Reference point for the bearing to the destination point (true or magnetic north).

`{GPS.DestDistance}`

The distance to the destination point.

`{GPS.DestDistanceRef}`

Indicates the unit in which the distance to the destination point is measured (kilometres or miles).

`{GPS.DestLatitude}`

The latitude of the destination point.

`{GPS.DestLatitudeRef}`

Whether the destination point latitude is north or south.

`{GPS.DestLongitude}`

The longitude of the destination point.

`{GPS.DestLongitudeRef}`

Whether the destination point longitude is east or west.

`{GPS.Differential}`

Whether differential correction has been applied.

`{GPS.DOP}`

Indicates the Degree Of Precision for the measurements.

`{GPS.ImgDirection}`

The direction the camera was pointing when the image was taken, in degrees.

`{GPS.ImgDirectionRef}`

Reference point for the direction the camera was pointing in (true or magnetic north).

`{GPS.Latitude}`

The latitude, in degrees, minutes and seconds.

`{GPS.LatitudeRef}`

Whether the latitude is north or south .

`{GPS.Longitude}`

The longitude, in degrees, minutes and seconds.

`{GPS.LongitudeRef}`

Whether the longitude is east or west.

`{GPS.MapDatum}`

Indicates the survey data set used.

`{GPS.MeasureMode}`

Indicates whether 2- or 3-dimensional measurements were used.

`{GPS.ProcessingMethod}`

The name of the method used for location finding.

`{GPS.Satellites}`

The satellites used for the measurements.

`{GPS.Speed}`

The speed of the GPS receiver.

`{GPS.SpeedRef}`

Indicates the unit in which the speed is measured (kph, mph or knots).

`{GPS.Status}`

The status of the GPS receiving system when the image was recorded.

`{GPS.TimeStamp}`

The time in UTC form.

`{GPS.Track}`

Angular direction of movement of the GPS receiver.

`{GPS.TrackRef}`

Reference point for the direction of movement of the GPS receiver (true or magnetic north).

`{GPS.VersionID}`

Version number of the GPS information.