<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en" dir="ltr">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
  <meta name="verify-v1" content="g222frIIxcQTrvDR3NBRUSKP3AnMNoqxOkIniCEkV7U="/>
  <title>ImageMagick: Magick Image File Format</title/>
  <meta http-equiv="Content-Language" content="en-US"/>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  <meta http-equiv="Reply-to" content="magick-users@imagemagick.org"/>
  <meta name="Application-name" content="ImageMagick"/>
  <meta name="Description" content="ImageMagick® is a software suite to create, edit, and compose bitmap images. It can read, convert and write images in a variety of formats (about 100) including GIF, JPEG, JPEG-2000, PNG, PDF, PhotoCD, TIFF, and DPX. Use ImageMagick to translate, flip, mirror, rotate, scale, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.  ImageMagick is free software delivered as a ready-to-run binary distribution or as source code that you can freely use, copy, modify, and distribute. Its license is compatible with the GPL. It runs on all major operating systems.  The functionality of ImageMagick is typically utilized from the command line or you can use the features from programs written in your favorite programming language. Choose from these interfaces: MagickCore (C), MagickWand (C), ChMagick (Ch), Magick++ (C++), JMagick (Java), L-Magick (Lisp), PascalMagick (Pascal), PerlMagick (Perl), MagickWand for PHP (PHP), PythonMagick (Python), RMagick (Ruby), or TclMagick (Tcl/TK). With a language interface, use ImageMagick to modify or create images automagically and dynamically."/>
  <meta name="Application-url" content="http://www.imagemagick.org"/>
  <meta name="Generator" content="PHP"/>
  <meta name="Keywords" content="magick, image, file, format, ImageMagick, ImageMagic, MagickCore, MagickWand, PerlMagick, Magick++, RMagick, PythonMagick, JMagick, TclMagick, Image, Magick, Magic, Wand, ImageMagickObject, Swiss, Army, Knife, Image, Processing"/>
  <meta name="Rating" content="GENERAL"/>
  <meta name="Robots" content="INDEX, FOLLOW"/>
  <meta name="Generator" content="ImageMagick Studio LLC"/>
  <meta name="Author" content="ImageMagick Studio LLC"/>
  <meta name="Revisit-after" content="2 DAYS"/>
  <meta name="Resource-type" content="document"/>
  <meta name="Copyright" content="Copyright (c) 1999-2010 ImageMagick Studio LLC"/>
  <meta name="Distribution" content="Global"/>
  <link rel="icon" href="../images/wand.png"  sizes="32x32"/>
  <link rel="shortcut icon" href="../images/wand.ico"  type="images/x-icon"/>
  <link rel="meta" type="application/rdf+xml" title="ICI" href="http://imagemagick.org/ici.rdf"/>
  <style type="text/css" media="all">
    @import url("../www/magick.css");
  </style>
</head>

<body id="www-imagemagick-org">
<div class="titlebar">
<a href="../index.html">
  <img src="../images/script.png" alt="[ImageMagick]"
  style="width: 350px; height: 60px; margin: 28px auto; float: left;" /></a>
<a href="http://www.networkredux.com">
  <img src="../images/networkredux.png" alt="[sponsor]"
  style="margin: 45px auto; border: 0px; float: left;" /></a>
<a href="http://www.imagemagick.org/discourse-server/">
  <img src="../images/logo.jpg" alt=""
  style="width: 114px; height: 118px; border: 0px; float: right;" /></a>
<a href="../index.html">
  <img src="../images/sprite.jpg" alt=""
  style="width: 114px; height: 118px; border: 0px; float: right;" /></a>
</div>

<div class="westbar">

<div class="menu">
  <a title="About ImageMagick" href="../index.html">About ImageMagick</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a title="Binary Releases" href="../www/binary-releases.html">Binary Releases</a>
</div>
<div class="sub">
    <a title="Binary Release: Unix" href="../www/binary-releases.html#unix">Unix</a>
</div>
<div class="sub">
    <a title="Binary Release: MacOS X" href="../www/binary-releases.html#macosx">Mac OS X</a>
</div>
<div class="sub">
    <a title="Binary Release: Windows" href="../www/binary-releases.html#windows">Windows</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a title="Command-line Tools" href="../www/command-line-tools.html">Command-line Tools</a>
</div>
<div class="sub">
    <a title="Command-line Tools: Processing" href="../www/command-line-processing.html">Processing</a>
</div>
<div class="sub">
    <a title="Command-line Tools: Options" href="../www/command-line-options.html">Options</a>
</div>
<div class="sub">
    <a title="Command-line Tools: Usage" href="http://www.imagemagick.org/Usage/">Usage</a>
</div>
<div class="menu">
  <a title="Program Interfaces" href="../www/api.html">Program Interfaces</a>
</div>
<div class="sub">
    <a title="Program Interface: MagickWand" href="../www/magick-wand.html">MagickWand</a>
</div>
<div class="sub">
    <a title="Program Interface: MagickCore" href="../www/magick-core.html">MagickCore</a>
</div>
<div class="sub">
    <a title="Program Interface: PerlMagick" href="../www/perl-magick.html">PerlMagick</a>
</div>
<div class="sub">
    <a title="Program Interface: Magick++" href="../Magick++/">Magick++</a>
</div>
<div class="sep"></div>
<div  class="menu">
   <a title="Install from Source" href="../www/install-source.html">Install from Source</a>
</div>
<div class="sub">
    <a title="Install from Source: Unix" href="../www/install-source.html#unix">Unix</a>
</div>
<div class="sub">
    <a title="Install from Source: Windows" href="../www/install-source.html#windows">Windows</a>
 </div>
<div class="menu">
  <a title="Resources" href="../www/resources.html">Resources</a>
</div>
<div class="menu">
  <a title="Architecture" href="../www/architecture.html">Architecture</a>
</div>
<div class="menu">
  <a title="Download" href="../www/download.html">Download</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a title="Search" href="http://www.imagemagick.org/script/search.php">Search</a>
</div>
<div class="sep"></div>
<div class="menu">
  <a title="Site Map"href="../www/sitemap.html">Site Map</a>
</div>
<div  class="sub">
    <a title="Site Map: Links"href="../www/links.html">Links</a>
</div>
<div class="sep"></div>
<div  class="menu">
  <a title="Sponsors" href="../www/sponsors.html">Sponsors:</a>

<div class="sponsbox">
<div  class="sponsor">
   <a title="Sponsor: Atlas Multimedia" href="http://www.atlas-multimedia.de/">Atlas Multimedia</a><!-- 20101201000025 tanju.temurbas-->
</div>
<div  class="sponsor">
  <a title="Sponsor: Druckerei" href="http://print24.com/de/">Druckerei</a><!-- 201110010720 -->
</div>
<div  class="sponsor">
  <a title="Sponsor: Image Converter" href="http://www.batchphoto.com">Image Converter</a><!-- 201103010900 Bits Coffee-->
</div>
<div  class="sponsor">
  <a title="Sponsor: Flyer drucken" href="http://www.online-druck.biz">Flyer drucken</a><!-- 201109010900 Floeter-->
</div>
<div  class="sponsor">
  <a title="Sponsor: Webdesign Agentur" href="http://www.ventzke-partner.de">Webdesign Agentur</a><!-- 201101010480 invendio.de-->
</div>
<div  class="sponsor">
  <a title="Sponsor: LVM Versicherung" href="http://www.neu-reich.de">LVM Versicherung</a><!-- 201101010480 -->
</div>
<div  class="sponsor">
  <a title="Sponsor: Diamonds are a Girls Best Friend" href="http://www.schmuck.org">Diamonds are a Girls Best Friend</a><!-- 201101010600 Peterssen-->
</div>
<div  class="sponsor">
   <a title="Sponsor: Druckerei Online" href="http://www.allesdruck.de">Druckerei Online</a><!-- 201012011200 allesdruck.de-->
</div>
</div>
</div>
</div>

<div class="eastbar">
  <script type="text/javascript">
  <!--
    google_ad_client = "pub-3129977114552745";
    google_ad_slot = "0574824969";
    google_ad_width = 160;
    google_ad_height = 600;
  //-->
  </script>
  <script type="text/javascript"
    src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
  </script>
</div>

<div class="main">

<p class="navigation-index">[<a href="#header">MIFF Header</a> &bull; <a href="#binary">MIFF Binary Data</a>]</p>

<div class="doc-section">
<p>The Magick Image File Format (MIFF) is ImageMagick's own platform-independent format for storing bitmap images.  It has an advantage over other image formats in that it stores all metadata known to ImageMagick (e.g. image color profiles, comments, author, copyright, etc.), whereas, other formats may only support a small portion of available metadata or none at all.  A MIFF image file consist of two sections.  The first section is a header composed of keys describing the image in text form.  The next section is the binary image data.  We discuss these sections in detail below.</p>
</div>

<h2><a name="header"></a>MIFF Header</h2>
<div class="doc-section">


<p>The MIFF header is composed entirely of ISO-8859-1 characters.  The fields
in the header are key and value combination in the <em>key = value</em> format, with each key and value separated by an equal sign (<kbd>=</kbd>).  Each <em>key = value</em> combination is delimited by at least one control or whitespace character.  Comments may appear in the header section and are always delimited by braces.  The MIFF header always ends with a colon (<kbd>:</kbd>) character, followed by a <em>ctrl-Z</em> character.  It is also common to proceed the colon with a <em>formfeed</em> and a <em>newline</em> character.  The <em>formfeed</em> prevents the listing of binary data when using the <kbd>more</kbd> Unix program, whereas, the <em>ctrl-Z</em> has the same effect with the <kbd>type</kbd> command on the Windows command line.</p>

<p>The following is a partial list of <em> key = value</em> combinations that are typically be found in a MIFF file:</p>

<dl class="doc">
<dt class="doc">background-color = <em class="option">color</em></dt>
<dt class="doc">border-color = <em class="option">color</em></dt>
<dt class="doc">matte-color = <em class="option">color</em></dt>
  <dd>these optional keys reflect the image background, border, and matte colors respectively.  A <a href="../www/color.html">color</a> can be a name (e.g. white) or a hex value (e.g. #ccc).</dd>
<dt class="doc">class = DirectClass</dt>
<dt class="doc">class = PseudoClass</dt>
  <dd>the type of binary pixel data stored in the MIFF file.  If this key is not present, DirectClass pixel data is assumed.</dd>
<dt class="doc">colors = <em class="option"> value</em></dt>
  <dd>the number of colors in a DirectClass image. For a PseudoClass image, this key specifies the number of entires in the colormap.  If this key is not present in the header, and the image is PseudoClass, a linear 256 color grayscale colormap is assumed.  The maximum number of colormap entries is 65536.</dd>
<dt class="doc">colorspace = RGB</dt>
<dt class="doc">colorspace = CMYK</dt>
  <dd>the colorspace of the pixel data.  The default is RGB.</dd>
<dt class="doc">columns = value</dt>
  <dd>the width of the image in pixels.  This a required key and has no default value.</dd>
<dt class="doc">compression = BZip</dt>
<dt class="doc">compression = Fax</dt>
<dt class="doc">compression = None</dt>
<dt class="doc">compression = RLE</dt>
<dt class="doc">compression = Zip</dt>
  <dd>the type of algorithm used to compress the image data.  If this key is not present, the pixel data is assumed to be uncompressed.</dd>
<dt class="doc">delay = <em class="option">microseconds</em></dt>
 <dd>the interframe delay in an image sequence in microseconds.</dd>
<dt class="doc">depth = 8</dt>
<dt class="doc">depth = 16</dt>
<dt class="doc">depth = 32</dt>
  <dd>the depth of a single color value representing values from 0 to 255 (depth 8), 0 - 65535 (depth 16), or 0 - 4294967295 (depth 32).  If this key is absent, a depth of 8 is assumed.</dd>
<dt class="doc">dispose = <em class="option">value</em></dt>
  <dd>layer disposal method.</dd>
  <dd>Here are the valid values:

	<dl>
	  <dd>0. No disposal specified.</dd>
	  <dd>1. Do not dispose between frames.</dd>
	  <dd>2. Overwrite frame with background color from header.</dd>
	  <dd>3. Overwrite with previous frame.</dd>
	</dl>
</dd>

<dt class="doc">gamma = <em class="option">value</em></dt>
  <dd>the gamma of the image.  If it is not specified, a gamma of 1.0 (linear brightness response) is assumed.</dd>

<dt class="doc">id = ImageMagick</dt>
  <dd>identifies the file as a MIFF-format image file.  This key is required and has no default.  Although this key can appear anywhere in the header, it should start as the first key of the header in column 1.  This will allow programs like <kbd>file</kbd>(1) to easily identify the file as MIFF.</dd>

<dt class="doc">iterations = <em class="option">value</em></dt>
  <dd>the number of times an image sequence loops before stopping.</dd>

<dt class="doc">label = { <em class="option">string </em>]</dt>
  <dd>defines a short title or caption for the image.  If any whitespace appears in the label, it must be enclosed within braces.</dd>

<dt class="doc">matte = True</dt>
<dt class="doc">matte = False</dt>
  <dd>specifies whether a the image has matte data.  Matte data is generally useful for image compositing.</dd>

<dt class="doc">montage = <em class="option">&lt;width&gt;x&lt;height&gt;[+-]&lt;x offset&gt;[+-]&lt;y offset&gt;</em></dt>
  <dd>size and location of the individual tiles of a composite image.</dd>

  <dd>Use this key when the image is a composite of a number of different tiles.  A tile consists of an image and optionally a border and a label.  <em>Width</em> is the size in pixels of each individual tile in the horizontal direction and <em>height</em> is the size in the vertical direction.  Each tile must have an equal number of pixels in width and equal in height.  However, the width can differ from the height.  <em>X offset</em> is the offset in number of pixels from the vertical edge of the composite image where the first tile of a row begins and <em>y offset</em> is the offset from the horizontal edge where the first tile of a column begins.</dd>

  <dd>If this key is specified, a directory of tile names must follow the image header.  The format of the directory is explained below.</dd>

<dt class="doc">page = <em class="option">value</em></dt>
  <dd>preferred size and location of an image canvas.</dd>

<dt class="doc">profile-icc = <em class="option">value</em></dt>
  <dd>the number of bytes in the International Color Consortium color profile.  The profile is defined by the ICC profile specification located at <a href="http://www.color.org/icc_specs2.html">http://www.color.org/icc_specs2.html</a>.</dd>

<dt class="doc">red-primary = <em class="option">x,y</em></dt>
<dt class="doc">green-primary = <em class="option">x,y</em></dt>
<dt class="doc">blue-primary = <em class="option">x,y</em></dt>
<dt class="doc">white-point = <em class="option">x,y</em></dt>
  <dd>this optional key reflects the chromaticity primaries and white point.</dd>

<dt class="doc">rendering-intent = <em class="option">saturation</em></dt>
<dt class="doc">rendering-intent = <em class="option">perceptual</em></dt>
<dt class="doc">rendering-intent = <em class="option">absolute</em></dt>
<dt class="doc">rendering-intent = <em class="option">relative</em></dt>
  <dd>Rendering intent is the CSS-1 property that has been defined by the International Color Consortium (<a href="http://www.color.org">http://www.color.org</a>).</dd>

<dt class="doc">resolution = <em class="option">&lt;x-resolution&gt;x&lt;y-resolution&gt;</em></dt>
  <dd>vertical and horizontal resolution of the image.  See units for the specific resolution units (e.g. pixels per inch).</dd>

<dt class="doc">rows = <em class="option">value</em></dt>
  <dd>the height of the image in pixels.  This a required key and has no default value.</dd>

<dt class="doc">scene = <em class="option">value</em></dt>
  <dd>the sequence number for this MIFF image file.  This optional key is useful when a MIFF image file is one in a sequence of files used in an animation.</dd>

<dt class="doc">signature = <em class="option">value</em></dt>
  <dd>this optional key contains a string that uniquely identifies the image pixel contents.  NIST's SHA-256 message digest algorithm is recommended.</dd>

<dt class="doc">units = pixels-per-inch</dt>
<dt class="doc">units = pixels-per-centimeter</dt>
  <dd>image resolution units.</dd>
</dl>

<p>Other key value pairs are permitted.  If a value contains whitespace it must be enclosed with braces as illustrated here:</p>

<pre class="text">
  id=ImageMagick
  class=PseudoClass  colors=256  matte=False
  columns=1280  rows=1024  depth=8
  compression=RLE
  colorspace=RGB
  copyright={Copyright (c) 1999-2007 ImageMagick Studio LLC}
  &#8942;
</pre>

<p>Note that <em>key = value</em> combinations may be separated by <em>newlines</em> or spaces and may occur in any order within the header.  Comments (within braces) may appear anywhere before the colon.</p>

<p>If you specify the montage key in the header, follow the header with a directory of image tiles.  This directory consists of a name for each tile of the composite image separated by a <em>newline</em> character.  The list is terminated with a NULL character.</p>

<p>If you specify the color-profile key in the header, follow the header (or montage directory if the montage key is in the header) with the binary color profile.</p>

<p>The header is separated from the image data by a <kbd>:</kbd> character immediately followed by a <em>newline</em>.</p>

</div>

<h2><a name="binary"></a>MIFF Binary Data</h2>
<div class="doc-section">

<p>Next comes the binary image data itself.  How the image data is formatted depends upon the class of the image as specified (or not specified) by the value of the class key in the header.</p>

<p>DirectClass images are continuous-tone, images stored as RGB (red, green, blue), RGBA (red, green, blue, alpha), CMYK (cyan, yellow, magenta, black), or CMYKA (cyan, yellow, magenta, black, alpha)  intensity values as defined by the colorspace key. Each intensity value is one byte in length for images of depth 8 (0..255), two bytes for a depth of 16 (0..65535), and images of depth 32 (0..4294967295) require four bytes in most significant byte first order.</p>

<p>PseudoClass images are colormapped RGB images. The colormap is stored as a series of red, green, and blue pixel values, each value being a byte in size. If the image depth is 16, each colormap entry consumes two bytes with the most significant byte being first. The number of colormap entries is defined by the colors key.  The colormap data occurs immediately following the header (or image directory if the montage key is in the header). PseudoClass image data is an array of index values into the color map. If there are 256
or fewer colors in the image, each byte of image data contains an index value. If the image contains more than 256 colors or the image depth is 16, the index value is stored as two contiguous bytes with the most significant byte being first. If matte is true, each colormap index is followed by a 1 or 2-byte alpha value.</p>

<p>The image pixel data in a MIFF file may be uncompressed, runlength encoded, Zip compressed, or BZip compressed. The compression key in the header defines how the image data is compressed. Uncompressed pixels are stored one scanline at a time in row order. Runlength-encoded compression counts runs of identical adjacent pixels and stores the pixels followed by a length byte (the number of identical pixels minus 1). Zip and BZip compression compresses each row of an image and precedes the compressed row with the length of compressed pixel bytes as a word in most significant byte first order.</p>

<p>MIFF files may contain more than one image.  Simply concatenate each individual image (composed of a header and image data) into one file.</p>

</div>

</div>

<div id="linkbar">
    <span id="linkbar-west">&nbsp;</span>
    <span id="linkbar-center">
      <a href="http://www.imagemagick.org/discourse-server/">Discourse Server</a> &bull;
      <a href="http://www.imagemagick.org/MagickStudio/scripts/MagickStudio.cgi">Studio</a>
    </span>
    <span id="linkbar-east">&nbsp;</span>
  </div>
  <div class="footer">
    <span id="footer-west">&copy; 1999-2010 ImageMagick Studio LLC</span>
    <span id="footer-east"> <a href="http://www.imagemagick.org/script/contact.php">Contact the Wizards</a></span>
  </div>
  <div style="clear: both; margin: 0; width: 100%; "></div>
  <script type="text/javascript">
    var _gaq = _gaq || [];
    _gaq.push(['_setAccount', 'UA-17690367-1']);
    _gaq.push(['_trackPageview']);

    (function() {
      var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
      ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
      var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
    })();
  </script>
</body>
</html>
