[Lprof-devel] lprof/src/3rdparty/vigra/src/impex auto_file.hxx, NONE, 1.1.2.1 bmp.cxx, NONE, 1.1.2.

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/lprof/lprof/src/3rdparty/vigra/src/impex
In directory sc8-pr-cvs6.sourceforge.net:/tmp/cvs-serv25248/src/3rdparty/vigra/src/impex

Added Files:
      Tag: Qt4-port
	auto_file.hxx bmp.cxx bmp.hxx byteorder.cxx byteorder.hxx 
	codecmanager.cxx codecmanager.hxx error.hxx gif.cxx gif.hxx 
	hdr.cxx hdr.hxx iccjpeg.c iccjpeg.h imageinfo.cxx jpeg.cxx 
	jpeg.hxx png.cxx png.hxx pnm.cxx pnm.hxx rgbe.c rgbe.h sun.cxx 
	sun.hxx tiff.cxx tiff.hxx viff.cxx viff.hxx void_vector.cxx 
	void_vector.hxx 
Log Message:
- Import vigra impex into the repository to make builds easier especially on non-linux platforms.
- Alter cmake code to look for system vigra impex and build a local one if not found
- Don't set include directories globally in top-level cmakelists.txt ; it's already done more specifically in
  individual subdir build code.


--- NEW FILE: jpeg.hxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 2002 by Gunnar Kedenburg                     */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
/*                                                                      */
/************************************************************************/

#ifndef VIGRA_IMPEX_JPEG_HXX
#define VIGRA_IMPEX_JPEG_HXX

#include <vector>
#include "vigra/codec.hxx"

namespace vigra {

    struct JPEGCodecFactory : public CodecFactory
    {
        CodecDesc getCodecDesc() const;
        std::auto_ptr<Decoder> getDecoder() const;
        std::auto_ptr<Encoder> getEncoder() const;
    };

    struct JPEGDecoderImpl;
    struct JPEGEncoderImpl;

    class JPEGDecoder : public Decoder
    {
        JPEGDecoderImpl * pimpl;

    public:

        JPEGDecoder() : pimpl(0) {}

        ~JPEGDecoder();

        std::string getFileType() const;
        unsigned int getWidth() const;
        unsigned int getHeight() const;
        unsigned int getNumBands() const;

        const void * currentScanlineOfBand( unsigned int ) const;
        void nextScanline();

        std::string getPixelType() const;
        unsigned int getOffset() const;

        void init( const std::string & );
        void close();
        void abort();

    };

    class JPEGEncoder : public Encoder
    {
        JPEGEncoderImpl * pimpl;

    public:

        JPEGEncoder() : pimpl(0) {}

        ~JPEGEncoder();

        std::string getFileType() const;
        void setWidth( unsigned int );
        void setHeight( unsigned int );
        void setNumBands( unsigned int );

        void setICCProfile(const ICCProfile & data);

        void setCompressionType( const std::string &, int = -1 );
        void setPixelType( const std::string & );
        unsigned int getOffset() const;

        void finalizeSettings();

        void * currentScanlineOfBand( unsigned int );
        void nextScanline();

        void init( const std::string & );
        void close();
        void abort();
    };
}

#endif // VIGRA_IMPEX_JPEG_HXX

--- NEW FILE: byteorder.hxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 2002 by Gunnar Kedenburg                     */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */                
/*                                                                      */
/************************************************************************/

#ifndef VIGRA_BYTEORDER_HXX
#define VIGRA_BYTEORDER_HXX

#include <vector>
#include <memory>
#include <string>
#include <fstream>
#include <algorithm>
#include "vigra/sized_int.hxx"

namespace vigra
{
    class byteorder
    {
        class host
        {
            std::string m_string;

        public:
            
            // ctor, dtor

            host();

            // methods

            const std::string & get() const;
        };

        // attributes

        static const host m_host;

        // data byte order, can be changed

        std::string m_string;
        bool native;

        // delegation methods

        template< class T >
        void reversebytes( T & x ) const
        {
            const size_t n = sizeof(T);
            UInt8 t[n];
            UInt8 * c = reinterpret_cast< UInt8 * >(&x);
            size_t i;
            for( i = 0; i < n; ++i )
                t[i] = c[ n - 1 - i ];
            for( i = 0; i < n; ++i )
                c[i] = t[i];
        }

    public:

        // ctor, dtor

        byteorder(); // uses the host byteorder
        byteorder( const std::string & );

        // methods

        void set( const std::string & );
        const std::string & get() const;
        const std::string & get_host_byteorder() const;

        template< class T >
        void convert_to_host( T & x ) const
        {
            if (!native)
                reversebytes(x);
        }

        template< class T >
        void convert_to_host( T * x, size_t num ) const
        {
            if (!native)
                for( size_t i = 0; i < num; ++i )
                    reversebytes(x[i]);
        }

        template< class T >
        void convert_from_host( T & x ) const
        {
            if (!native)
                reversebytes(x);
        }

        template< class T >
        void convert_from_host( T * x, size_t num ) const
        {
            if (!native)
                for( size_t i = 0; i < num; ++i )
                    reversebytes(x[i]);
        }

        void convert_to_host( char & x ) const {}
        void convert_to_host( Int8 & x ) const {}
        void convert_to_host( UInt8 & x ) const {}

        void convert_to_host( char * x , size_t) const {}
        void convert_to_host( Int8 * x, size_t) const {}
        void convert_to_host( UInt8 * x, size_t) const {}

        void convert_from_host( char & x ) const {}
        void convert_from_host( Int8 & x ) const {}
        void convert_from_host( UInt8 & x ) const {}

        void convert_from_host( char * x , size_t) const {}
        void convert_from_host( Int8 * x, size_t) const {}
        void convert_from_host( UInt8 * x, size_t) const {}
    };

    template< class T >
    void read_field( std::ifstream & stream, const byteorder & bo, T & x )
    {
        stream.read( reinterpret_cast< char * >(&x), sizeof(T) );
        bo.convert_to_host(x);
    }

    template< class T >
    void read_array( std::ifstream & stream, const byteorder & bo, T * x,
                     size_t num )
    {
        stream.read( reinterpret_cast< char * >(x), static_cast<std::streamsize>(sizeof(T) * num) );
        bo.convert_to_host( x, num );
    }

    template< class T >
    void write_field( std::ofstream & stream, const byteorder & bo, T t )
    {
        bo.convert_from_host(t);
        stream.write( reinterpret_cast< char * >(&t), sizeof(T) );
    }

    template< class T >
    void write_array( std::ofstream & stream, const byteorder & bo,
                      const T * x, size_t num )
    {
        for( size_t i = 0; i < num; ++i )
            write_field( stream, bo, x[i] );
    }

} // namespace vigra

#endif // VIGRA_BYTEORDER_HXX

--- NEW FILE: viff.cxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 2002 by Gunnar Kedenburg                     */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
[...1051 lines suppressed...]
            bands_type & castbands = static_cast< bands_type & >(pimpl->bands);
            write_array( pimpl->stream, pimpl->bo,
                         castbands.data(), bands_size );
        } else if ( pimpl->header.data_storage_type == VFF_TYP_FLOAT ) {
            typedef void_vector<float> bands_type;
            bands_type & castbands = static_cast< bands_type & >(pimpl->bands);
            write_array( pimpl->stream, pimpl->bo,
                         castbands.data(), bands_size );
        } else if ( pimpl->header.data_storage_type == VFF_TYP_DOUBLE ) {
            typedef void_vector<double> bands_type;
            bands_type & castbands = static_cast< bands_type & >(pimpl->bands);
            write_array( pimpl->stream, pimpl->bo,
                         castbands.data(), bands_size );
        } else
            vigra_precondition( false, "storage type unsupported" );
    }

    void ViffEncoder::abort() {}

} // namespace vigra

--- NEW FILE: byteorder.cxx ---
/************************************************************************/
/*                                                                      */
/*      Copyright 2002-2004 by Ullrich Koethe and Gunnar Kedenburg      */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */                
/*                                                                      */
/************************************************************************/

#include <algorithm>
#include <stdexcept>
#include "byteorder.hxx"
#include "vigra/sized_int.hxx"

namespace vigra
{
    const byteorder::host byteorder::m_host;

    byteorder::host::host()
    {
        // byteorder check: if the first byte is the least significant,
        // we have little endian byteorder.
        UIntBiggest testint = 0x01;
        UInt8 * testchar = reinterpret_cast< UInt8 * >(&testint);
        if ( testchar[0] == 0x01 )
            m_string = "little endian";
        else
            m_string = "big endian";
    }

    const std::string & byteorder::host::get() const
    {
        return m_string;
    }

    const std::string & byteorder::get_host_byteorder() const
    {
        return m_host.get();
    }

    byteorder::byteorder()
    {
        set( m_host.get() );
    }

    byteorder::byteorder( const std::string & s )
    {
        set(s);
    }

    const std::string & byteorder::get() const
    {
        return m_string;
    }

    void byteorder::set( const std::string & s )
    {
        m_string = s;
        native = get_host_byteorder() == s;
    }
}

--- NEW FILE: jpeg.cxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 2001-2002 by Gunnar Kedenburg                */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
/*                                                                      */
/************************************************************************/
/* Modifications by Pablo d'Angelo
 * as of 4 March 2006:
 *  - Added support for x and y resolution fields.
 *  - Added ICC support.
 */

#ifdef HasJPEG

#include <stdexcept>
#include <csetjmp>
#include "vigra/config.hxx"
#include "void_vector.hxx"
#include "error.hxx"
#include "auto_file.hxx"
#include "jpeg.hxx"

extern "C" {

#include <jpeglib.h>
#include "iccjpeg.h"

} // extern "C"

namespace {

struct JPEGCodecErrorManager
{
    jpeg_error_mgr pub;
    std::jmp_buf buf;
};

} // namespace

extern "C"
{

static void JPEGCodecLongjumper( j_common_ptr info )
{
    (*info->err->output_message)(info);
    JPEGCodecErrorManager * error = reinterpret_cast< JPEGCodecErrorManager * >(info->err);
    std::longjmp( error->buf, 1 );
}

} // extern "C"

namespace vigra
{
    CodecDesc JPEGCodecFactory::getCodecDesc() const
    {
        CodecDesc desc;

        // init file type
        desc.fileType = "JPEG";

        // init pixel types
        desc.pixelTypes.resize(1);
        desc.pixelTypes[0] = "UINT8";

        // init compression types
        desc.compressionTypes.resize(1);
        desc.compressionTypes[0] = "JPEG";

        // init magic strings
        desc.magicStrings.resize(1);
        desc.magicStrings[0].resize(3);
        desc.magicStrings[0][0] = '\377';
        desc.magicStrings[0][1] = '\330';
        desc.magicStrings[0][2] = '\377';

        // init file extensions
        desc.fileExtensions.resize(2);
        desc.fileExtensions[0] = "jpg";
        desc.fileExtensions[1] = "jpeg";

        desc.bandNumbers.resize(2);
        desc.bandNumbers[0] = 1;
        desc.bandNumbers[1] = 3;

        return desc;
    }

    std::auto_ptr<Decoder> JPEGCodecFactory::getDecoder() const
    {
        return std::auto_ptr<Decoder>( new JPEGDecoder() );
    }

    std::auto_ptr<Encoder> JPEGCodecFactory::getEncoder() const
    {
        return std::auto_ptr<Encoder>( new JPEGEncoder() );
    }

    class JPEGCodecImpl
    {
        // extend the jpeg_error_mgr by a jump buffer

    public:

        // attributes

        JPEGCodecErrorManager err;

    };

    class JPEGDecoderImplBase : public JPEGCodecImpl
    {
    public:

        // attributes
        jpeg_decompress_struct info;

        JPEGDecoderImplBase()
        {
            // create the decompression struct
            jpeg_create_decompress(&info);
        }

        virtual ~JPEGDecoderImplBase()
        {
            // delete the decompression struct
            jpeg_destroy_decompress(&info);
        }
    };

    class JPEGEncoderImplBase : public JPEGCodecImpl
    {
    public:

        // attributes
        jpeg_compress_struct info;

        JPEGEncoderImplBase()
        {
            // create the decompression struct
            jpeg_create_compress(&info);
        }

        virtual ~JPEGEncoderImplBase()
        {
            // delete the decompression struct
            jpeg_destroy_compress(&info);
        }
    };

    struct JPEGDecoderImpl : public JPEGDecoderImplBase
    {
        // attributes

        auto_file file;
        void_vector<JSAMPLE> bands;
        unsigned int width, height, components, scanline;

        // icc profile, if available
        UInt32 iccProfileLength;
        const unsigned char *iccProfilePtr;

        // ctor, dtor
        JPEGDecoderImpl( const std::string & filename );
        ~JPEGDecoderImpl();

        // methods

        void init();
    };

    JPEGDecoderImpl::JPEGDecoderImpl( const std::string & filename )
#ifdef VIGRA_NEED_BIN_STREAMS
        : file( filename.c_str(), "rb" ),
#else
        : file( filename.c_str(), "r" ),
#endif
          bands(0), scanline(0), iccProfileLength(0), iccProfilePtr(NULL)
    {
        // setup setjmp() error handling
        info.err = jpeg_std_error( ( jpeg_error_mgr * ) &err );
        err.pub.error_exit = &JPEGCodecLongjumper;

        // setup the data source
        if (setjmp(err.buf)) {
            vigra_fail( "error in jpeg_stdio_src()" );
        }
        jpeg_stdio_src( &info, file.get() );
        // prepare for icc profile
        setup_read_icc_profile(&info);
    }

    void JPEGDecoderImpl::init()
    {
        // read the header
        if (setjmp(err.buf))
            vigra_fail( "error in jpeg_read_header()" );
        jpeg_read_header( &info, TRUE );

        // extract ICC profile
        JOCTET *iccBuf;
        UInt32 iccLen;
        if (read_icc_profile(&info, &iccBuf, &iccLen)) {
            iccProfileLength = iccLen;
            iccProfilePtr = iccBuf;
        }

        // start the decompression
        if (setjmp(err.buf))
            vigra_fail( "error in jpeg_start_decompress()" );
        jpeg_start_decompress(&info);

        // transfer interesting header information
        width = info.output_width;
        height = info.output_height;
        components = info.output_components;

        // alloc memory for a single scanline
        bands.resize( width * components );

        // set colorspace
        info.jpeg_color_space = components == 1 ? JCS_GRAYSCALE : JCS_RGB;
    }

    JPEGDecoderImpl::~JPEGDecoderImpl()
    {
        if (iccProfilePtr && iccProfileLength)
            free((void *)iccProfilePtr);
    }

    void JPEGDecoder::init( const std::string & filename )
    {
        pimpl = new JPEGDecoderImpl(filename);
        pimpl->init();
        if(pimpl->iccProfileLength)
        {
            Decoder::ICCProfile iccData(
                pimpl->iccProfilePtr,
                pimpl->iccProfilePtr + pimpl->iccProfileLength);
            iccProfile_.swap(iccData);
        }
    }

    JPEGDecoder::~JPEGDecoder()
    {
        delete pimpl;
    }

    std::string JPEGDecoder::getFileType() const
    {
        return "JPEG";
    }

    unsigned int JPEGDecoder::getWidth() const
    {
        return pimpl->width;
    }

    unsigned int JPEGDecoder::getHeight() const
    {
        return pimpl->height;
    }

    unsigned int JPEGDecoder::getNumBands() const
    {
        return pimpl->components;
    }

    std::string JPEGDecoder::getPixelType() const
    {
        return "UINT8";
    }

    unsigned int JPEGDecoder::getOffset() const
    {
        return pimpl->components;
    }

    const void * JPEGDecoder::currentScanlineOfBand( unsigned int band ) const
    {
        return pimpl->bands.data() + band;
    }

    void JPEGDecoder::nextScanline()
    {
        // check if there are scanlines left at all, eventually read one
        JSAMPLE * band = pimpl->bands.data();
        if ( pimpl->info.output_scanline < pimpl->info.output_height ) {
            if (setjmp(pimpl->err.buf))
                vigra_fail( "error in jpeg_read_scanlines()" );
            jpeg_read_scanlines( &pimpl->info, &band, 1 );
        }
    }

    void JPEGDecoder::close()
    {
        // finish any pending decompression
        if (setjmp(pimpl->err.buf))
            vigra_fail( "error in jpeg_finish_decompress()" );
        jpeg_finish_decompress(&pimpl->info);
    }

    void JPEGDecoder::abort() {}

    struct JPEGEncoderImpl : public JPEGEncoderImplBase
    {
        // attributes

        auto_file file;
        void_vector<JSAMPLE> bands;
        unsigned int width, height, components, scanline;
        int quality;

        // icc profile, if available
        Encoder::ICCProfile iccProfile;

        // state
        bool finalized;

        // ctor, dtor

        JPEGEncoderImpl( const std::string & filename );
        ~JPEGEncoderImpl();

        // methods

        void finalize();
    };

    JPEGEncoderImpl::JPEGEncoderImpl( const std::string & filename )
#ifdef VIGRA_NEED_BIN_STREAMS
        : file( filename.c_str(), "wb" ),
#else
        : file( filename.c_str(), "w" ),
#endif
          scanline(0), quality(-1), finalized(false)
    {
        // setup setjmp() error handling
        info.err = jpeg_std_error( ( jpeg_error_mgr * ) &err );
        err.pub.error_exit = &JPEGCodecLongjumper;

        // setup the data dest
        if (setjmp(err.buf)) {
            vigra_fail( "error in jpeg_stdio_dest()" );
        }
        jpeg_stdio_dest( &info, file.get() );
    }

    JPEGEncoderImpl::~JPEGEncoderImpl()
    {
    }

    void JPEGEncoderImpl::finalize()
    {
        VIGRA_IMPEX_FINALIZED(finalized);

        // alloc memory for a single scanline
        bands.resize( width * components );
        finalized = true;

        // init the compression
        info.image_width = width;
        info.image_height = height;
        info.input_components = components;

        // rgb or gray can be assumed here
        info.in_color_space = components == 1 ? JCS_GRAYSCALE : JCS_RGB;
        info.X_density = 100;
        info.Y_density = 100;

        // set defaults based upon the set values
        if (setjmp(err.buf))
            vigra_fail( "error in jpeg_set_defaults()" );
        jpeg_set_defaults(&info);

        // set the quality level
        if ( quality != -1 ) {
            if (setjmp(err.buf))
                vigra_fail( "error in jpeg_set_quality()" );
            jpeg_set_quality( &info, quality, TRUE );
        }

        // enhance the quality a little bit
        for ( unsigned int i = 0; i < MAX_COMPONENTS; ++i ) {
            info.comp_info[i].h_samp_factor = 1;
            info.comp_info[i].v_samp_factor = 1;
        }
#ifdef C_ARITH_CODING_SUPPORTED
        info.arith_code = TRUE;
#endif
#ifdef ENTROPY_OPT_SUPPORTED
        info.optimize_coding = TRUE;
#endif
        info.dct_method = JDCT_FLOAT;

        // start the compression
        if (setjmp(err.buf))
            vigra_fail( "error in jpeg_start_compress()" );
        jpeg_start_compress( &info, TRUE );

        if (iccProfile.size()) {
            write_icc_profile(&info, iccProfile.begin(), iccProfile.size());
        }
    }

    void JPEGEncoder::init( const std::string & filename )
    {
        pimpl = new JPEGEncoderImpl(filename);
    }

    JPEGEncoder::~JPEGEncoder()
    {
        delete pimpl;
    }

    std::string JPEGEncoder::getFileType() const
    {
        return "JPEG";
    }

    void JPEGEncoder::setWidth( unsigned int width )
    {
        VIGRA_IMPEX_FINALIZED(pimpl->finalized);
        pimpl->width = width;
    }

    void JPEGEncoder::setHeight( unsigned int height )
    {
        VIGRA_IMPEX_FINALIZED(pimpl->finalized);
        pimpl->height = height;
    }

    void JPEGEncoder::setNumBands( unsigned int bands )
    {
        VIGRA_IMPEX_FINALIZED(pimpl->finalized);
        pimpl->components = bands;
    }

    void JPEGEncoder::setCompressionType( const std::string & comp,
                                          int quality )
    {
        VIGRA_IMPEX_FINALIZED(pimpl->finalized);
        if ( comp == "LOSSLESS" )
            vigra_fail( "lossless encoding is not supported by"
                        " the jpeg implementation impex uses." );
        pimpl->quality = quality;
    }

    void JPEGEncoder::setPixelType( const std::string & pixelType )
    {
        VIGRA_IMPEX_FINALIZED(pimpl->finalized);
        if ( pixelType != "UINT8" )
            vigra_precondition( false, "only UINT8 pixels are supported." );
    }

    unsigned int JPEGEncoder::getOffset() const
    {
        return pimpl->components;
    }

    void JPEGEncoder::setICCProfile(const ICCProfile & data)
    {
        pimpl->iccProfile = data;
    }

    void JPEGEncoder::finalizeSettings()
    {
        pimpl->finalize();
    }

    void * JPEGEncoder::currentScanlineOfBand( unsigned int band )
    {
        return pimpl->bands.data() + band;
    }

    void JPEGEncoder::nextScanline()
    {
        // check if there are scanlines left at all, eventually write one
        JSAMPLE * band = pimpl->bands.data();
        if ( pimpl->info.next_scanline < pimpl->info.image_height ) {
            if (setjmp(pimpl->err.buf))
                vigra_fail( "error in jpeg_write_scanlines()" );
            jpeg_write_scanlines( &pimpl->info, &band, 1 );
        }
    }

    void JPEGEncoder::close()
    {
        // finish any pending compression
        if (setjmp(pimpl->err.buf))
            vigra_fail( "error in jpeg_finish_compress()" );
        jpeg_finish_compress( &pimpl->info );
    }

    void JPEGEncoder::abort() {}
}

#endif // HasJPEG

--- NEW FILE: bmp.cxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 2002-2004 by Gunnar Kedenburg                */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
[...1082 lines suppressed...]
        const unsigned int row_stride = pimpl->info_header.width;
        return pimpl->pixels.data() + ( row_stride * pimpl->scanline );
    } else {
        const unsigned int row_stride = 3 * pimpl->info_header.width;
        return pimpl->pixels.data() + ( row_stride * pimpl->scanline ) + band;
    }
}

void BmpEncoder::nextScanline()
{
    ++(pimpl->scanline);
}

void BmpEncoder::close()
{
    pimpl->write();
}

void BmpEncoder::abort() {}
}

--- NEW FILE: error.hxx ---
/************************************************************************/
/*                                                                      */
/*      Copyright 2002-2004 by Ullrich Koethe and Gunnar Kedenburg      */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */                
/*                                                                      */
/************************************************************************/

#ifndef VIGRA_IMPEX_ERROR_HXX
#define VIGRA_IMPEX_ERROR_HXX

#include "vigra/error.hxx"

#define VIGRA_IMPEX_FINALIZED(p) { if (p) \
    vigra_precondition( false, "encoder settings were already finalized" ); }

#endif // VIGRA_IMPEX_ERROR_HXX

--- NEW FILE: hdr.hxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 1998-2001 by Pablo d'Angelo                  */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    ( Version 1.4.0, Dec 21 2005 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
/*                                                                      */
/************************************************************************/


#ifndef VIGRA_IMPEX_HDR_HXX
#define VIGRA_IMPEX_HDR_HXX

#include <vector>
#include "vigra/diff2d.hxx"
#include "vigra/codec.hxx"

namespace vigra {

    struct HDRCodecFactory : public CodecFactory
    {
        CodecDesc getCodecDesc() const;
        std::auto_ptr<Decoder> getDecoder() const;
        std::auto_ptr<Encoder> getEncoder() const;
    };

    class HDRDecoderImpl;
    class HDREncoderImpl;

    class HDRDecoder : public Decoder
    {
        HDRDecoderImpl * pimpl;

    public:

        HDRDecoder() : pimpl(0) {}

        ~HDRDecoder();

        std::string getFileType() const;
        unsigned int getWidth() const;
        unsigned int getHeight() const;
        unsigned int getNumBands() const;

        const void * currentScanlineOfBand( unsigned int ) const;
        void nextScanline();

        std::string getPixelType() const;
        unsigned int getOffset() const;

        void init( const std::string & );
        void close();
        void abort();
    };

    class HDREncoder : public Encoder
    {
        HDREncoderImpl * pimpl;

    public:

        HDREncoder() : pimpl(0) {}

        ~HDREncoder();

        std::string getFileType() const;
        void setWidth( unsigned int );
        void setHeight( unsigned int );
        void setNumBands( unsigned int );

        void setCompressionType( const std::string &, int = -1 );
        void setPixelType( const std::string & );

        void setPosition( const vigra::Diff2D & pos );
        void setXResolution( float xres );
        void setYResolution( float yres );

        unsigned int getOffset() const;

        void finalizeSettings();

        void * currentScanlineOfBand( unsigned int );
        void nextScanline();

        void init( const std::string & );
        void close();
        void abort();
    };
}

#endif // VIGRA_IMPEX_HDR_HXX

--- NEW FILE: png.cxx ---
/************************************************************************/
/*                                                                      */
/*               Copyright 2001-2002 by Gunnar Kedenburg                */
/*       Cognitive Systems Group, University of Hamburg, Germany        */
/*                                                                      */
/*    This file is part of the VIGRA computer vision library.           */
/*    ( Version 1.5.0, Dec 07 2006 )                                    */
/*    The VIGRA Website is                                              */
/*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
/*    Please direct questions, bug reports, and contributions to        */
/*        ko...@in...          or                  */
/*        vi...@ko...                         */
/*                                                                      */
/*    Permission is hereby granted, free of charge, to any person       */
/*    obtaining a copy of this software and associated documentation    */
/*    files (the "Software"), to deal in the Software without           */
/*    restriction, including without limitation the rights to use,      */
/*    copy, modify, merge, publish, distribute, sublicense, and/or      */
/*    sell copies of the Software, and to permit persons to whom the    */
/*    Software is furnished to do so, subject to the following          */
/*    conditions:                                                       */
/*                                                                      */
/*    The above copyright notice and this permission notice shall be    */
/*    included in all copies or substantial portions of the             */
/*    Software.                                                         */
/*                                                                      */
/*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
/*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
/*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
/*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
/*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
/*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
/*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
/*    OTHER DEALINGS IN THE SOFTWARE.                                   */
/*                                                                      */
/************************************************************************/
/* Modifications by Pablo d'Angelo
 * updated to vigra 1.4 by Douglas Wilkins
 * as of 18 Febuary 2006:
 *  - Changed INT16 -> UINT16 pixel type.
 *  - Added support for obtaining extra bands beyond RGB.
 *  - Added support for a position field that indicates the start of this
 *    image relative to some global origin.
 *  - Added support for x and y resolution fields.
 */

#ifdef HasPNG

#include "vigra/config.hxx"
#include "vigra/sized_int.hxx"
#include "void_vector.hxx"
#include "auto_file.hxx"
#include "png.hxx"
#include "byteorder.hxx"
#include "error.hxx"
#include <stdexcept>
#include <iostream>

extern "C"
{
#include <png.h>
}

#if PNG_LIBPNG_VER < 10201
#error "please update your libpng to at least 1.2.1"
#endif

// TODO: per-scanline reading/writing

namespace {
    std::string png_error_message;
}

extern "C" {

// called on fatal errors
static void PngError( png_structp png_ptr, png_const_charp error_msg )
{
    png_error_message = std::string(error_msg);
    longjmp( png_ptr->jmpbuf, 1 );
}

// called on non-fatal errors
static void PngWarning( png_structp, png_const_charp warning_msg )
{
    std::cerr << warning_msg << std::endl;
}

} // extern "C"

namespace vigra {

    CodecDesc PngCodecFactory::getCodecDesc() const
    {
        CodecDesc desc;

        // init file type
        desc.fileType = "PNG";

        // init pixel types
        desc.pixelTypes.resize(2);
        desc.pixelTypes[0] = "UINT8";
        desc.pixelTypes[1] = "UINT16";

        // init compression types
        desc.compressionTypes.resize(1);
        desc.compressionTypes[0] = "LOSSLESS";

        // init magic strings
        desc.magicStrings.resize(1);
        desc.magicStrings[0].resize(4);
        desc.magicStrings[0][0] = '\x89';
        desc.magicStrings[0][1] = 'P';
        desc.magicStrings[0][2] = 'N';
        desc.magicStrings[0][3] = 'G';

        // init file extensions
        desc.fileExtensions.resize(1);
        desc.fileExtensions[0] = "png";

        desc.bandNumbers.resize(4);
        desc.bandNumbers[0] = 1;
        desc.bandNumbers[1] = 2;
        desc.bandNumbers[2] = 3;
        desc.bandNumbers[3] = 4;

        return desc;
    }

    std::auto_ptr<Decoder> PngCodecFactory::getDecoder() const
    {
        return std::auto_ptr<Decoder>( new PngDecoder() );
    }

    std::auto_ptr<Encoder> PngCodecFactory::getEncoder() const
    {
        return std::auto_ptr<Encoder>( new PngEncoder() );
    }

    struct PngDecoderImpl
    {
        // data source
        auto_file file;

        // data container
        void_vector_base bands;

        // this is where libpng stores its state
        png_structp png;
        png_infop info;

        // image header fields
        png_uint_32 width, height, components;
        png_uint_32 extra_components;
        Diff2D position;
        int bit_depth, color_type;

        // icc profile, if available
        // the memory is owned by libpng
        UInt32 iccProfileLength;
        const unsigned char *iccProfilePtr;

        // scanline counter
        int scanline;

        float x_resolution, y_resolution;

        // number of passes needed during reading each scanline
        int interlace_method, n_interlace_passes;

        // number of channels in png (or what libpng get_channels returns)
        int n_channels;

        // size of one row
        int rowsize;
        void_vector<unsigned char> row_data;

        // ctor, dtor
        PngDecoderImpl( const std::string & filename );
        ~PngDecoderImpl();

        // methods
        void init();
        void nextScanline();
    };

    PngDecoderImpl::PngDecoderImpl( const std::string & filename )
#ifdef VIGRA_NEED_BIN_STREAMS
        // Returns the layer
        : file( filename.c_str(), "rb" ),
#else
        : file( filename.c_str(), "r" ),
#endif
          bands(0), iccProfileLength(0), iccProfilePtr(0),
          scanline(-1), x_resolution(0), y_resolution(0),
          n_interlace_passes(0), n_channels(0)
    {
        png_error_message = "";
        // check if the file is a png file
        const unsigned int sig_size = 8;
        png_byte sig[sig_size];
        std::fread( sig, sig_size, 1, file.get() );
        const int no_png = png_sig_cmp( sig, 0, sig_size );
        vigra_precondition( !no_png, "given file is not a png file.");

        // create png read struct with user defined handlers
        png = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL,
                                      &PngError, &PngWarning );
        vigra_postcondition( png != 0, "could not create the read struct." );

        // create info struct
        if (setjmp(png->jmpbuf)) {
            png_destroy_read_struct( &png, &info, NULL );
            vigra_postcondition( false, png_error_message.insert(0, "error in png_create_info_struct(): ").c_str() );
        }
        info = png_create_info_struct(png);
        vigra_postcondition( info != 0, "could not create the info struct." );

        // init png i/o
        if (setjmp(png->jmpbuf)) {
            png_destroy_read_struct( &png, &info, NULL );
            vigra_postcondition( false, png_error_message.insert(0, "error in png_init_io(): ").c_str() );
        }
        png_init_io( png, file.get() );

        // specify that the signature was already read
        if (setjmp(png->jmpbuf)) {
            png_destroy_read_struct( &png, &info, NULL );
            vigra_postcondition( false, png_error_message.insert(0, "error in png_set_sig_bytes(): ").c_str() );
        }
        png_set_sig_bytes( png, sig_size );

    }

    PngDecoderImpl::~PngDecoderImpl()
    {
        png_destroy_read_struct( &png, &info, NULL );
    }

    void PngDecoderImpl::init()
    {
        // read all chunks up to the image data
        if (setjmp(png->jmpbuf))
            vigra_postcondition( false, png_error_message.insert(0, "error in png_read_info(): ").c_str() );
        png_read_info( png, info );

        // pull over the header fields
        int interlace_method, compression_method, filter_method;
        if (setjmp(png->jmpbuf))
            vigra_postcondition( false, png_error_message.insert(0, "error in png_get_IHDR(): ").c_str() );
        png_get_IHDR( png, info, &width, &height, &bit_depth, &color_type,
                      &interlace_method, &compression_method, &filter_method );

        // check whether byteorder must be swapped (png files are big-endian)
        byteorder bo;
        if(bit_depth == 16 && bo.get_host_byteorder() == "little endian")
        {
            png_set_swap(png);
        }

        // transform palette to rgb
        if ( color_type == PNG_COLOR_TYPE_PALETTE) {
            if (setjmp(png->jmpbuf))
                vigra_postcondition( false, png_error_message.insert(0, "error in png_palette_to_rgb(): ").c_str() );
            png_set_palette_to_rgb(png);
            color_type = PNG_COLOR_TYPE_RGB;
            bit_depth = 8;
        }

        // expand gray values to at least one byte size
        if ( color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8 ) {
            if (setjmp(png->jmpbuf))
                vigra_postcondition( false,png_error_message.insert(0, "error in png_set_gray_1_2_4_to_8(): ").c_str());
            png_set_gray_1_2_4_to_8(png);
            bit_depth = 8;
        }


#if 0
        // strip alpha channel
        if ( color_type & PNG_COLOR_MASK_ALPHA ) {
            if (setjmp(png->jmpbuf))
                vigra_postcondition( false, png_error_message.insert(0, "error in png_set_strip_alpha(): ").c_str() );
            png_set_strip_alpha(png);
            color_type ^= PNG_COLOR_MASK_ALPHA;
        }
#endif /* #if 0 */


        // find out the number of components
        switch (color_type) {
        case PNG_COLOR_TYPE_GRAY:
            components = 1;
            extra_components = 0;
            break;
        case PNG_COLOR_TYPE_GRAY_ALPHA:
            components = 2;
            extra_components = 1;
            break;
        case PNG_COLOR_TYPE_RGB:
            components = 3;
            extra_components = 0;
            break;
        case PNG_COLOR_TYPE_RGB_ALPHA:
            components = 4;
            extra_components = 1;
            break;
        default:
            vigra_fail( "internal error: illegal color type." );
        }

        // read resolution
        x_resolution = png_get_x_pixels_per_meter( png, info ) / 254.0;
        y_resolution = png_get_y_pixels_per_meter( png, info ) / 254.0;

        // read offset
        position.x = png_get_x_offset_pixels( png, info );
        position.y = png_get_y_offset_pixels( png, info );

        // read icc profile
#if (PNG_LIBPNG_VER > 10008) && defined(PNG_READ_iCCP_SUPPORTED)
        char * dummyName;
        int dummyCompType;
        char * profilePtr;
        png_uint_32 profileLen;
        if (info->valid & PNG_INFO_iCCP) {
            png_get_iCCP(png, info, &dummyName, &dummyCompType, &profilePtr, &profileLen) ;
            iccProfilePtr = (unsigned char *) profilePtr;
            iccProfileLength = profileLen;
        }
#endif

#if 0
        // gamma correction changes the pixels, this is unwanted.

        // image gamma
        double image_gamma = 0.45455;
        if ( png_get_valid( png, info, PNG_INFO_gAMA ) ) {
            if (setjmp(png->jmpbuf))
                vigra_postcondition( false, png_error_message.insert(0, "error in png_get_gAMA(): ").c_str() );
            png_get_gAMA( png, info, &image_gamma );
        }

        // screen gamma
        double screen_gamma = 2.2;

        // set gamma correction
        if (setjmp(png->jmpbuf))
            vigra_postcondition( false, png_error_message.insert(0, "error in png_set_gamma(): ").c_str() );
        png_set_gamma( png, screen_gamma, image_gamma );
#endif

        // interlace handling, get number of read passes needed
        if (setjmp(png->jmpbuf))
            vigra_postcondition( false,png_error_message.insert(0, "error in png_set_interlace_handling(): ").c_str());
        n_interlace_passes = png_set_interlace_handling(png);

        // update png library state to reflect any changes that were made
        if (setjmp(png->jmpbuf))
            vigra_postcondition( false, png_error_message.insert(0, "error in png_read_update_info(): ").c_str() );
        png_read_update_info( png, info );

        if (setjmp(png->jmpbuf))
            vigra_postcondition( false,png_error_message.insert(0, "error in png_get_channels(): ").c_str());
        n_channels = png_get_channels(png, info);

        if (setjmp(png->jmpbuf))
            vigra_postcondition( false,png_error_message.insert(0, "error in png_get_rowbytes(): ").c_str());
        rowsize = png_get_rowbytes(png, info);

        // allocate data buffers
        row_data.resize(rowsize);
    }

    void PngDecoderImpl::nextScanline()
    {
        for (int i=0; i < n_interlace_passes; i++) {
        if (setjmp(png->jmpbuf))
                vigra_postcondition( false,png_error_message.insert(0, "error in png_read_row(): ").c_str());
            png_read_row(png, row_data.begin(), NULL);
        }
    }

    void PngDecoder::init( const std::string & filename )
    {
        pimpl = new PngDecoderImpl(filename);
        pimpl->init();
        if(pimpl->iccProfileLength)
        {
            Decoder::ICCProfile iccData(
                pimpl->iccProfilePtr,
                pimpl->iccProfilePtr + pimpl->iccProfileLength);
            iccProfile_.swap(iccData);
        }
    }

    PngDecoder::~PngDecoder()
    {
        delete pimpl;
    }

    std::string PngDecoder::getFileType() const
    {
        return "PNG";
    }

    unsigned int PngDecoder::getWidth() const
    {
        return pimpl->width;
    }

    unsigned int PngDecoder::getHeight() const
    {
        return pimpl->height;
    }

    unsigned int PngDecoder::getNumBands() const
    {
        return pimpl->components;
    }

    unsigned int PngDecoder::getNumExtraBands() const
    {
        return pimpl->extra_components;
    }

    float PngDecoder::getXResolution() const
    {
        return pimpl->x_resolution;
    }

    float PngDecoder::getYResolution() const
    {
        return pimpl->y_resolution;
    }

    Diff2D PngDecoder::getPosition() const
    {
        return pimpl->position;
    }

    std::string PngDecoder::getPixelType() const
    {
        switch (pimpl->bit_depth) {
        case 8:
            return "UINT8";
        case 16:
            return "UINT16";
        default:
            vigra_fail( "internal error: illegal pixel type." );
        }
        return "";
    }

    unsigned int PngDecoder::getOffset() const
    {
        return pimpl->components;
    }

    const void * PngDecoder::currentScanlineOfBand( unsigned int band ) const
    {
        switch (pimpl->bit_depth) {
        case 8:
            {
                return pimpl->row_data.begin() + band;
            }
        case 16:
            {
                return pimpl->row_data.begin() + 2*band;
            }
        default:
            vigra_fail( "internal error: illegal bit depth." );
        }
        return 0;
    }

    void PngDecoder::nextScanline()
    {
        pimpl->nextScanline();
    }

    void PngDecoder::close() {}

    void PngDecoder::abort() {}

    struct PngEncoderImpl
    {
        // data sink
        auto_file file;

        // data container
        void_vector_base bands;

        // this is where libpng stores its state
        png_structp png;
        png_infop info;

        // image header fields
        png_uint_32 width, height, components;
        png_uint_32 extra_components;
        int bit_depth, color_type;

        // icc profile, if available
        Encoder::ICCProfile iccProfile;

        // scanline counter
        int scanline;

        // state
        bool finalized;

        // image layer position
        Diff2D position;

        // resolution
        float x_resolution, y_resolution;

        // ctor, dtor
        PngEncoderImpl( const std::string & filename );
        ~PngEncoderImpl();

        // methods
        void finalize();
        void write();
    };

    PngEncoderImpl::PngEncoderImpl( const std::string & filename )
#ifdef VIGRA_NEED_BIN_STREAMS
        : file( filename.c_str(), "wb" ),
#else
        : file( filename.c_str(), "w" ),
#endif
          bands(0),
          scanline(0), finalized(false),
          x_resolution(0), y_resolution(0)
    {
        png_error_message = "";
        // create png struct with user defined handlers
        png = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL,
                                       &PngError, &PngWarning );
        vigra_postcondition( png != 0, "could not create the write struct." );

        // create info struct
        if (setjmp(png->jmpbuf)) {
            png_destroy_write_struct( &png, &info );
            vigra_postcondition( false, png_error_message.insert(0, "error in png_info_struct(): ").c_str() );
        }
        info = png_create_info_struct(png);
        if ( !info ) {
            png_destroy_write_struct( &png, &info );
            vigra_postcondition( false, png_error_message.insert(0, "could not create the info struct.: ").c_str() );
        }

        // init png i/o
        if (setjmp(png->jmpbuf)) {
            png_destroy_write_struct( &png, &info );
            vigra_postcondition( false, png_error_message.insert(0, "error in png_init_io(): ").c_str() );
        }
      ...
 
[truncated message content]