root/branches/lodepng/trunk/png.d

/**
LodePNG version 20070102

Copyright (c) 2005-2007 Lode Vandevenne
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
  * Neither the name of Lode Vandevenne nor the names of his contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Port to D by Lutger Blijdestijn on 5 januari 2007.<br>
The port is close to the original, but the api has changed. I have taken out the class and made the api into two functions instead.
Also, the Encoder is (not yet) ported. Implementation-wise zlib routines are replaced by std.zlib, but the rest is the same.
Here follows part of the original documentation, slightly modified to reflect the D port.<br>
You can email me at: lutger dot blijdenstijn at gmail dot com

About:

PNG is a file format to store raster images losslessly with good compression,
supporting different color types. It's patent-free. Because the compression is
lossless and it supports an alpha channel, PNG is a very good file format
to store textures and tilesets for computer games.

LodePNG is a PNG codec according to the Portable Network Graphics (PNG)
Specification (Second Edition) - W3C Recommendation 10 November 2003. The
specification can be found on line at http://www.w3.org/TR/2003/REC-PNG-20031110

The most recent version of LodePNG can currently be found at http://student.kuleuven.be/~m0216922/pngloader/
However, this location is temporary and won't exist anymore in 2007.

LodePNG exists out of the source code file lodepng.d

LodePNG is simple but only supports the basic requirements. In the tradeoff
between functionality and simplicity, LodePNG is on the side of simplicity.
To achieve this simplicity, the following design choices were made: There
are no dependencies on any external library. To decode PNGs, there's a Decoder
class (edit: in D port no class) that can convert any PNG file data into an RGBA image buffer with a single
function call.

This all makes LodePNG suitable for loading textures in games, raytracers,
intros, or for loading images into programs that require them only for simple
usage. It's less suitable for full fledged image editors, loading PNGs over
network (since this decoder requires all the image data to be available before
the decoding can begin), life-critical systems, ... Even though it contains
a conformant decoder and encoder (not ported for D yet), it's still not a conformant editor,
because unknown chunks are discarded.

Because LodePNG is BSD licensed, it's allowed to use these source files in any
project, as long as you include the above copyright message and conditions
somewhere in the release of your program.

<b>Supported features</b><br>
The following features are supported by the decoder:
<UL>
  <li> conformant decoding of PNGs with any color type, bit depth and interlace mode</li>
  <li> converting the result to 32-bit RGBA pixel data</li>
  <li> decoding a png image from a buffer.</li>
  <li> support for translucent PNG's, including translucent palettes and color key</li>
  <li> zlib decompression (inflate) (via phobos in D)</li>
  <li> 64 bit color (untested due to lack of such images)</li>
  <li> the following chunks are interpreted by the decoder
  <ul>
    <li>IHDR (header information)</li>
    <li>PLTE (color palette)</li>
    <li>IDAT (pixel data)</li>
    <li>IEND (the final chunk)</li>
    <li>tRNS (transparency for palettized images)</li>
    <li>bKGD (suggested background color)</li>
    </ul>
   </li>
</UL>

<b>Features not supported</b><br>
The following features are _not_ supported.
<ul>
<li> editing a PNG image (unless you use the decoder, then edit it, then use the
    encoder, but ignored chunks will then be gone from the original image)
<li> CRC checks of chunks
<li> ADLER32 checksum of zlib data
<li> partial loading. All data must be available and is processed in one call.
<li> The following optional chunk types are not interpreted by the decoder <ul>
    <li>cHRM (device independent color info)
    <li>gAMA (device independent color info)
    <li>iCCP (device independent color info)
    <li>sBIT (original number of significant bits)
    <li>sRGB (device independent color info)
    <li>tEXt (textual information)
    <li>zTXt (compressed textual information)
    <li>iTXt (international textual information)
    <li>hIST (palette histogram)
    <li>pHYs (physical pixel dimensions)
    <li>sPLT (suggested reduced palette)
    <li>tIME (last image modification time)
    </ul>
</ul>

Usage:

The basic steps of decoding a PNG file with LodePNG are as follows:
<OL>
<LI> Load the PNG image file from harddisk and store the bytes of the file in an ubyte[]
 with the same size as the file.
<LI> Declare another ubyte[] that will contain the pixel data.
<LI> Call the decode function of it with the above arrays as parameters and store the
resulting Info struct.
<LI> Check for errors with in Info.error.
<LI> If no error occurred, the raw pixel data is now stored in the output array.
</OL>

To decode a PNG file, you can use one of the two decode functions.
The function decode32 will store the pixel data in 32 bit RGBA format, no
matter what color format was used in the PNG file. The function decodeGeneric
will store the pixel data in the same color format as in the file. A more
detailed description of both functions, as well as the optional loadFile
function, is given below.
*/
module png;
import std.zlib;

/**Information about the PNG image is returned in the form of an Info struct.

After using decodeGeneric or decode32, please always check the error value
to see if everything went ok.
*/
struct Info
{
    /** Below is a table that gives the meaning of the different values.

    In the port to D, some of these errors have become obsolete as zlib has replaced a few routines and will spit out
    exceptions instead. I have not yet removed these.

<li> 0: no error, everything went ok
<li> 1: there is no PNG loaded yet, so it makes no sense trying to read any information values
<li> 10: while huffman decoding: end of input memory reached without endcode
<li> 11: while huffman decoding: error in code tree made it jump outside of tree
<li> 13: problem while processing dynamic deflate block
<li> 14: problem while processing dynamic deflate block
<li> 15: problem while processing dynamic deflate block
<li> 16: unexisting code while processing dynamic deflate block
<li> 17: while inflating: end of out buffer memory reached
<li> 18: while inflating: invalid distance code
<li> 19: while inflating: end of out buffer memory reached
<li> 20: invalid deflate block BTYPE encountered
<li> 21: NLEN is not ones complement of LEN in a deflate block
<li> 22: while inflating: end of out buffer memory reached.
   This can happen if the inflated deflate data is longer than the amount of bytes required to fill up
   all the pixels of the image, given the color depth and image dimensions. Something that doesn't
   happen in a normal, well encoded, PNG image.
<li> 23: while inflating: end of in buffer memory reached
<li> 24: invalid FCHECK in zlib header
<li> 25: invalid compression method in zlib header
<li> 26: FDICT encountered in zlib header while it's not used for PNG
<li> 27: PNG file is smaller than a PNG header
<li> 28: incorrect PNG signature (the first 8 bytes of the PNG file)
   Maybe it's not a PNG, or a PNG file that got corrupted so that the header indicates the corruption.
<li> 29: first chunk is not the header chunk
<li> 30: chunk length too large, chunk broken off at end of file
<li> 31: illegal PNG color type
<li> 32: illegal PNG compression method
<li> 33: illegal PNG filter method
<li> 34: illegal PNG interlace method
<li> 35: chunk length of a chunk is too large or the chunk too small
<li> 36: illegal PNG filter type encountered
<li> 37: illegal bit depth for this color type given
<li> 38: the palette is too big (more than 256 colors)
<li> 39: more palette alpha values given in tRNS, than there are colors in the palette
<li> 40: tRNS chunk has wrong size for greyscale image
<li> 41: tRNS chunk has wrong size for RGB image
<li> 42: tRNS chunk appeared while it was not allowed for this color type
<li> 43: bKGD chunk has wrong size for palette image
<li> 44: bKGD chunk has wrong size for greyscale image
<li> 45: bKGD chunk has wrong size for RGB image
<li> 46: value encountered in indexed image is larger than the palette size (bitdepth == 8)
<li> 47: value encountered in indexed image is larger than the palette size (bitdepth < 8)
<li> 48: the input data is empty. Maybe a PNG file you tried to load doesn't exist or is in the wrong path.
<li> 49: jumped past memory while generating dynamic huffman tree
<li> 50: jumped past memory while generating dynamic huffman tree
<li> 51: jumped past memory while inflating huffman block
<li> 52: jumped past memory while inflating
<li> 53: size of zlib data too small to contain header
<li> 54: CHAR_BITS is smaller than 8 on this platform, an 8-bit datatype is needed to store the file and pixel data
<li>55: jumped past tree while generating huffman tree, this could be when the code
       lengths are not of an optimal_ tree, which causes there to be more nodes than
       the arrays used can support (e.g. if there are 19 codes a tree has 18 nodes,
       but if all 19 code lengths are 7, there will be much more nodes), this may be a
       BUG that has to be fixed though I haven't actually encountered PNGs causing
       this problem outside the experimentation environment
<li> 56: As of LodePNG version 20061209, the input and output parameter of the decode functions got swapped!
       Try to swap the input and output parameter in the decode function call. (first out, then in)
       If they are already correct and you get this error, then see description of error 48.
    */
    int error = 1; //the error value of the decode attempt

    // dimensions of the image
    size_t w; /// width of the image in pixels
    size_t h; /// height of the image in pixels

    //pixel color info
    uint bitDepth;      /// bits per sample
    uint bpp;           /// bits per pixel
    uint colorChannels; /// amount of channels

    //palette info
    uint paletteSize; /// size of the palette (palette.size() / 4)
    ubyte[] palette;  /// palette in RGBARGBA... order

    //transparent color key info
    bool  colorKey; /// is a transparent color key given?
    ubyte keyR;     /// red/greyscale component of color key
    ubyte keyG;     /// green component of color key
    ubyte keyB;     /// blue component of color key

    //PNG specific information (general)
    uint colorType;         /// color type of the original PNG file
    uint compressionMethod; /// compression method of the original file
    uint filterMethod;      /// filter method of the original file
    uint interlaceMethod;   /// interlace method of the original file

    //PNG specific information (bKGD chunk)
    bool  backgroundColor; /// is a suggested background color given?
    ubyte backgroundR;     /// red component of sugg. background color
    ubyte backgroundG;     /// green component of sugg. background color
    ubyte backgroundB;     /// blue component of sugg. background color
}
/**This function converts the given compressed PNG data into uncompressed pixel
data. The original color type is preserved, which can make it more difficult
to interpret the pixel data since you have to take into account what color
type it is.

For normal usage of LodePNG, this function is *not* recommended, but in special
cases where you know beforehand what color type the PNG image has it can provide
an increase in efficiency. Use decode32 instead if you want any type of PNG
to be easily displayed! The decode32 function first calls decodeGeneric
and then does the job of converting all possible color types to RGBA.

Params:
_in = This is used to give the original file data.
 Provide a vector filled with the contents of a PNG file. The contents of
 this buffer will be modified during the decoding process, so it cannot be
 reused. If you need the file contents a second time, make a copy before
 decoding the PNG or reload the file.

_out = This is used to return the pixel data.
 Provide an empty vector. The vector will be resized and the uncompressed
 pixel data will be stored in the buffer. The image data will be of the same
 color type as the PNG image. Pixels are always stored row by row. The first
 byte of the data contains the first byte of the pixel of the top left of
 the image. 1-bit images or other formats with less than one byte per pixel
 will be stored bit per bit. In that case, scanlines don't necessarily start
 at the boundary of a  byte. If RGB or RGBA is used, color components per pixel
 are successive bits/bytes in the order R, G, B, A.
*/
Info decodeGeneric(inout ubyte[] _out, inout ubyte[] _in)
{
    Info info;
  //read the information from the header and store it in the Info
    void readPngHeader(ubyte* _in, size_t inlength)
    {
      if(inlength < 29) { info.error = 27; return; } //error: the data length is smaller than the length of the header

      if(_in[0] != 137 || _in[1] != 80 || _in[2] != 78 || _in[3] != 71 || _in[4] != 13 || _in[5] != 10 || _in[6] != 26 || _in[7] != 10) { info.error = 28; return; } //error: the first 8 bytes are not the correct PNG signature
      if(_in[12] != 73 || _in[13] != 72 || _in[14] != 68 || _in[15] != 82) { info.error = 29; return; } //error: it doesn't start with a IHDR chunk!

      //read the values given in the header
      info.w = 256 * 256 * 256 * _in[16] + 256 * 256 * _in[17] + 256 * _in[18] + _in[19];
      info.h = 256 * 256 * 256 * _in[20] + 256 * 256 * _in[21] + 256 * _in[22] + _in[23];
      info.bitDepth = _in[24];
      info.colorType = _in[25];
      info.compressionMethod = _in[26];
      info.filterMethod = _in[27];
      info.interlaceMethod = _in[28];
      //The 4 CRC bytes are ignored

      if(info.compressionMethod != 0) { info.error = 32; return; } //error: only compression method 0 is allowed in the specification
      if(info.filterMethod != 0)      { info.error = 33; return; } //error: only filter method 0 is allowed in the specification
      if(info.interlaceMethod > 1)    { info.error = 34; return; } //error: only interlace methods 0 and 1 exist in the specification

      //check if bit depth is valid for this color type, if not give error 37 "illegal bit depth for this color type given"
      uint bd = info.bitDepth; //longer variable name makes code below more easily readable
      switch(info.colorType)
      {
        case 0: if(bd != 1 && bd != 2 && bd != 4 && bd != 8 && bd != 16) { info.error = 37; return; } break;
        case 2: if(                                 bd != 8 && bd != 16) { info.error = 37; return; } break;
        case 3: if(bd != 1 && bd != 2 && bd != 4 && bd != 8            ) { info.error = 37; return; } break;
        case 4: if(                                 bd != 8 && bd != 16) { info.error = 37; return; } break;
        case 6: if(                                 bd != 8 && bd != 16) { info.error = 37; return; } break;
        default: { info.error = 31; return; } break; //error: invalid color type
      }
    }

    //filter a PNG image scanline by scanline. when the pixels are smaller than 1 byte, the filter works byte per byte (bytewidth = 1)
    //precon is the previous filtered scanline, recon the result, scanline the current one
    void unFilterScanline(ubyte[] recon, ubyte[] scanline, ubyte[] precon, bool top, size_t bytewidth, uint filterType, size_t length)
    {
      switch(filterType)
      {
        case 0:
          for(size_t i = 0; i < length; i++) recon[i] = scanline[i];
          break;
        case 1:
          if(top)
          {
            for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i];
            for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth];
          }
          else
          {
            for(size_t i =         0; i < bytewidth; i++) recon[i] = scanline[i];
            for(size_t i = bytewidth; i < length   ; i++) recon[i] = scanline[i] + recon[i - bytewidth];
          }
          break;
        case 2:
          if(top) for(size_t i = 0; i < length; i++) recon[i] = scanline[i];
          else for(size_t i = 0; i < length; i++) recon[i] = scanline[i] + precon[i];
          break;
        case 3:
          if(top)
          {
            for(size_t i = 0; i < length; i++) recon[i] = scanline[i];
            for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + recon[i - bytewidth] >> 1;
          }
          else
          {
            for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i] + precon[i] / 2;
            for(size_t i = bytewidth; i < length; i++) recon[i] = scanline[i] + ((recon[i - bytewidth] + precon[i]) >> 1);
          }
          break;
        case 4:
          if(top)
          {
            for(size_t i = 0; i < bytewidth; i++) recon[i] = scanline[i];
            for(size_t i = bytewidth; i < length; i++) recon[i] = cast(ubyte)(scanline[i] + paethPredictor(recon[i - bytewidth], 0, 0));
          }
          else
          {
            for(size_t i = 0; i < bytewidth; i++) recon[i] = cast(ubyte)(scanline[i] + paethPredictor(0, precon[i], 0));
            for(size_t i = bytewidth; i < length; i++) recon[i] = cast(ubyte)(scanline[i] + paethPredictor(recon[i - bytewidth], precon[i], precon[i - bytewidth]));
          }
          break;
      default: info.error = 36; return; //error: unexisting filter type given
      }
    }

    //filter and reposition the pixels into the output when the image is Adam7 interlaced. This function can only do it after the full image is already decoded. The out buffer must have the correct allocated memory size already.
    void adam7Pass(ubyte[] _out, ubyte[] _in, ubyte[] scanlinen, ubyte[] scanlineo, size_t w, size_t bytewidth, size_t passleft, size_t passtop, size_t spacex, size_t spacey, size_t passw, size_t passh, uint bpp)
    {
      for(uint s = 0; s < passh; s++)
      {
        size_t linelength = 1 + ((bpp * passw + 7) >> 3);
        size_t linestart = s * linelength; //position where we read the filterType: at the start of the scanline
        uint filterType = _in[linestart];

        unFilterScanline(scanlinen, _in[linestart + 1..$], scanlineo, (s < 1), bytewidth, filterType, (w * bpp + 7) >> 3);
        if(info.error) return;

        //put the filtered pixels in the output image
        if(bpp >= 8)
        {
          for(size_t i = 0; i < passw; i++)
          for(size_t b = 0; b < bytewidth; b++) //b = current byte of this pixel
          {
            _out[bytewidth * w * (passtop + spacey * s) + bytewidth * (passleft + spacex * i) + b] = scanlinen[bytewidth * i + b];
          }
        }
        else
        {
          for(size_t i = 0; i < passw; i++)
          {
            size_t outbitp = bpp * w * (passtop + spacey * s) + bpp * (passleft + spacex * i);
            for(size_t b = 0; b < bpp; b++) //b = current bit of this pixel
            {
              size_t obp = outbitp + b;
              size_t obitpos = 7 - (obp & 0x7); //where bitpos 0 refers to the LSB, bitpot 7 to the MSB of a byte
              size_t bp = i * bpp + b;
              size_t bitpos = 7 - (bp & 0x7); //where bitpos 0 refers to the LSB, bitpot 7 to the MSB of a byte
              uint _bit = (scanlinen[bp >> 3] >> bitpos) & 1;
              _out[obp >> 3] = cast(ubyte)((_out[obp >> 3] & ~(1 << obitpos)) | (_bit << obitpos));
            }
          }
        }

        //swap the two buffer pointers "scanline old" and "scanline new"
        ubyte[] temp = scanlinen;
        scanlinen = scanlineo;
        scanlineo = temp;
      }
    }

    void resetParameters()
    {
      info.error = 0; //initially no error happened yet
      info.paletteSize = info.backgroundColor = info.colorKey = 0; //initialize info variables that aren't necessarily set later on
    }

  //if(CHAR_BIT < 8) { info.error = 54; return; } // not relevant in D, type sizes are guaranteed
  if(_in.length == 0 && _out.length > 0) { info.error = 56; return info; } //the given input data is empty but the output data not
  if(_in.length == 0) { info.error = 48; return info; } //the given data is empty

  resetParameters(); //when decoding a new PNG image, make sure all parameters created after previous decoding are reset

  readPngHeader(_in.ptr, _in.length);
  if(info.error) return info;

  size_t pos = 33; //first byte of the first chunk after the header
  size_t dataPos = 0; //at this position in the in buffer the new data will be stored.
  size_t dataStart = 0;

  bool IEND = 0;
  while(!IEND) //loop through the chunks, ignoring unknown chunks and stopping at IEND chunk. IDAT data is put at the start of the in buffer
  {
    //get chunk length
    if(pos + 8 >= _in.length) { info.error = 30; return info; } //error: size of the in buffer too small to contain next chunk
    size_t chunkLength = 256 * 256 * 256 * _in[pos] + 256 * 256 * _in[pos + 1] + 256 * _in[pos + 2] + _in[pos + 3]; pos += 4;
    if(pos + chunkLength >= _in.length) { info.error = 35; return info; } //error: size of the in buffer too small to contain next chunk

    //IDAT chunk, containing compressed image data
    if(_in[pos + 0] == 'I' && _in[pos + 1] == 'D' && _in[pos + 2] == 'A' && _in[pos + 3] == 'T')
    {
      pos += 4;
      if(dataPos == 0) { dataStart = pos; dataPos = dataStart + chunkLength; pos += chunkLength; } //possible efficiency increase by not copying data from first chunk
      else for(size_t i = 0; i < chunkLength; i++) _in[dataPos++] = _in[pos++]; //multiple data chunks are added behind each other this way
    }
    //IEND chunk
    else if(_in[pos + 0] == 'I' && _in[pos + 1] == 'E' && _in[pos + 2] == 'N' && _in[pos + 3] == 'D')
    {
      IEND = 1;
    }
    //palette chunk (PLTE)
    else if(_in[pos + 0] == 'P' && _in[pos + 1] == 'L' && _in[pos + 2] == 'T' && _in[pos + 3] == 'E')
    {
      pos += 4; //go after the 4 letters
      info.paletteSize = chunkLength / 3;
      if(info.paletteSize > 256) { info.error = 38; return info; } //error: palette too big
      info.palette.length = 4 * info.paletteSize;
      for(size_t i = 0; i < info.paletteSize; i++)
      {
        info.palette[i * 4 + 0] = _in[pos++]; //R
        info.palette[i * 4 + 1] = _in[pos++]; //G
        info.palette[i * 4 + 2] = _in[pos++]; //B
        info.palette[i * 4 + 3] = 255; //alpha
      }
    }
    //palette transparency chunk (tRNS)
    else if(_in[pos + 0] == 't' && _in[pos + 1] == 'R' && _in[pos + 2] == 'N' && _in[pos + 3] == 'S')
    {
      pos += 4; //go after the 4 letters
      if(info.colorType == 3)
      {
        if(chunkLength > info.paletteSize) { info.error = 39; return info; } //error: more alpha values given than there are palette entries
        for(size_t i = 0; i < chunkLength; i++) info.palette[i * 4 + 3] = _in[pos++];
      }
      else if(info.colorType == 0)
      {
        if(chunkLength != 2) { info.error = 40; return info; } //error: this chunk must be 2 bytes for greyscale image
        info.colorKey = 1;
        info.keyR = 256 * _in[pos] + _in[pos + 1]; pos += 2;
      }
      else if(info.colorType == 2)
      {
        if(chunkLength != 6) { info.error = 41; return info; } //error: this chunk must be 6 bytes for RGB image
        info.colorKey = 1;
        info.keyR = 256 * _in[pos] + _in[pos + 1]; pos += 2;
        info.keyG = 256 * _in[pos] + _in[pos + 1]; pos += 2;
        info.keyB = 256 * _in[pos] + _in[pos + 1]; pos += 2;
      }
      else { info.error = 42; return info; } //error: tRNS chunk not allowed for other color models
    }
    //background color chunk (bKGD)
    else if(_in[pos + 0] == 'b' && _in[pos + 1] == 'K' && _in[pos + 2] == 'G' && _in[pos + 3] == 'D')
    {
      pos += 4; //go after the 4 letters
      if(info.colorType == 3)
      {
        if(chunkLength != 1) { info.error = 43; return info; } //error: this chunk must be 1 byte for indexed color image
        info.backgroundColor = 1;
        info.backgroundR = _in[pos++];
      }
      else if(info.colorType == 0 || info.colorType == 4)
      {
        if(chunkLength != 2) { info.error = 44; return info; } //error: this chunk must be 2 bytes for greyscale image
        info.backgroundColor = 1;
        info.backgroundR = 256 * _in[pos] + _in[pos + 1]; pos += 2;
      }
      else if(info.colorType == 2 || info.colorType == 6)
      {
        if(chunkLength != 6) { info.error = 45; return info; } //error: this chunk must be 6 bytes for greyscale image
        info.backgroundColor = 1;
        info.backgroundR = 256 * _in[pos] + _in[pos + 1]; pos += 2;
        info.backgroundG = 256 * _in[pos]