Interchange File Format

related topics
{math, number, function}
{system, computer, user}
{group, member, jewish}
{work, book, publish}

Interchange File Format (IFF), is a generic container file format originally introduced by the Electronic Arts company in 1985 (in cooperation with Commodore-Amiga) in order to ease transfer of data between software produced by different companies.

IFF files do not have any common extension. Most files with .iff extension are in fact ILBM files, wrongly named so because they are the most common IFF files and most assume that they are the only type of IFF files (on many systems that generate IFF files, file extensions are not important).


An IFF file is built up from chunks. Each chunk begins with what the spec calls a "Type ID" (what the Macintosh called an OSType and Windows developers might call a FourCC). This is followed by a 32-bit unsigned integer (all integers in IFF files' structure are big-endian) specifying the size of the following data (the chunk content) in bytes. Because the spec includes explicit lengths for each chunk, it is possible for a parser to skip over chunks which it either can't or doesn't care to process.

There are predefined group chunks, with type IDs ‘FORM’, ‘LIST’ and ‘CAT ’. A FORM chunk is like a record structure, containing a type ID (indicating the record type) followed by nested chunks specifying the record fields. A LIST is a factoring structure containing a series of ‘PROP’ (property) chunks plus nested group chunks to which those properties apply. A CAT  is just a collection of nested chunks with no special semantics. Group chunks can contain other group chunks, depending on the needs of the application. Group chunks, like their simpler counterparts, contain a length element. Skipping over a group can thus be done with a simple Unix-style relative seek operation.

Chunks must begin on even file offsets, as befits the origins of IFF on the Motorola 68000 processor, which couldn't address quantities larger than a byte on odd addresses. Thus a chunk following an odd-length chunk will be preceded by a pad byte.

The top-level structure of an IFF file consists of exactly one of the group chunks: FORM, LIST or CAT , where FORM is by far the most common one.

Each type of chunk typically has different internal structure, that could be numerical data, text, or raw data. It is also possible to include other IFF files as if they are chunks (note that they have the same structure: four letters followed with length) and some formats use this. There are standard chunks that could be present in any IFF file, such as ‘AUTH’ (containing text with information about author of the file), ‘ANNO’ (containing text with annotation, usually name of the program that created the file), ‘NAME’ (containing text with name of the work in the file), ‘VERS’ (containing file version), ‘(c) ’ (containing text with copyright information). There are also chunks that are common among a number of formats, such as ‘CMAP’ which holds color palette in ILBM, ANIM and DR2D files (pictures, animations and vector pictures). There are chunks that have common name but hold different data such as ‘BODY’ which could store image in an ILBM file and sound in an 8SVX file. And finally, there are chunks unique to their file type. Some programs that create IFF files add to them chunks with their internal data; these same files can later be read by other programs without any disruption (because their parsers could skip uninteresting chunks) which is a great advantage of IFF and similar formats.

As a nestable, descriptive file format, there are architectural similarities to XML. XML, however, is primarily a text format, whereas all IFF contains at least some binary data (the length fields). It is possible to mechanically convert IFF to an XML equivalent; however, XML has additional features such as descriptive data and metadata (attributes, entities, DTD's and schemas) and navigational features (XPath) which cannot be trivially mapped back to IFF.

Full article ▸

related documents
MOO (programming language)
Blowfish (cipher)
Dynamic HTML
Mercury (programming language)
Rich Text Format
Lex programming tool
C shell
Data structure
Search engine (computing)
Turing completeness
Java API for XML Processing
Code refactoring
Non-deterministic Turing machine
Abstract factory pattern
GNU Octave
Static code analysis
Atlas Autocode
Dublin Core
Java applet
Differential cryptanalysis
Fibonacci coding
Byte-order mark
Data integrity
Dekker's algorithm
Zeta distribution
Degenerate distribution