Subversion Repositories public

/******************************************************************************

 * $Id: pngdataset.cpp,v 1.31 2005/05/17 19:05:52 fwarmerdam Exp $

 *

 * Project:  PNG Driver

 * Purpose:  Implement GDAL PNG Support

 * Author:   Frank Warmerdam, warmerda@home.com

 *

 ******************************************************************************

 * Copyright (c) 2000, Frank Warmerdam

 *

 * 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.

 ******************************************************************************

 *

 * ISSUES:

 *  o CollectMetadata() will only capture TEXT chunks before the image 

 *    data as the code is currently structured. 

 *  o Interlaced images are read entirely into memory for use.  This is

 *    bad for large images.

 *  o Image reading is always strictly sequential.  Reading backwards will

 *    cause the file to be rewound, and access started again from the

 *    beginning. 

 *  o 1, 2 and 4 bit data promoted to 8 bit. 

 *  o Transparency values not currently read and applied to palette.

 *  o 16 bit alpha values are not scaled by to eight bit. 

 *  o I should install setjmp()/longjmp() based error trapping for PNG calls.

 *    Currently a failure in png libraries will result in a complete

 *    application termination. 

 * 

 * $Log: pngdataset.cpp,v $

 * Revision 1.31  2005/05/17 19:05:52  fwarmerdam

 * Allow flowthrough to pam for geotransform & nodata.

 *

 * Revision 1.30  2005/04/27 16:35:45  fwarmerdam

 * PAM enable

 *

 * Revision 1.29  2004/08/26 21:20:08  warmerda

 * Adjusted so png_access_version_number() is not called for old libpng

 * versions (pre 1.2).

 *

 * Revision 1.28  2004/08/25 13:42:37  warmerda

 * Added png version checking after png_create_read_struct() as per suggestion from

 * Ben Discoe.

 *

 * Revision 1.27  2004/05/28 16:05:54  warmerda

 * fix bug in bGeoTransformValid setting reading worldfiles

 *

 * Revision 1.26  2004/01/29 18:48:01  warmerda

 * Changed to do the swapping ourseleves.  The png_set_swap() function didn't

 * seem to be having the desired effect

 *

 * Revision 1.25  2004/01/29 14:55:26  warmerda

 * ensure 16bit files are byte swapped as needed

 *

 * Revision 1.24  2003/09/15 20:45:00  warmerda

 * add pngw and pgw support

 *

 * Revision 1.23  2003/07/08 21:27:34  warmerda

 * avoid warnings

 *

 * Revision 1.22  2003/01/31 18:08:24  warmerda

 * Added test for broken png_get_channels().  I don't know what is *really*

 * going on here.

 *

 * Revision 1.21  2003/01/25 22:28:18  warmerda

 * improved data type error message a bit

 *

 * Revision 1.20  2003/01/25 22:26:29  warmerda

 * fixed a read, and a write bug with 16bit png files

 *

 * Revision 1.19  2002/11/23 18:54:17  warmerda

 * added CREATIONDATATYPES metadata for drivers

 *

 * Revision 1.18  2002/09/04 06:50:37  warmerda

 * avoid static driver pointers

 *

 * Revision 1.17  2002/07/13 04:16:39  warmerda

 * added WORLDFILE support

 *

 * Revision 1.16  2002/06/18 02:49:23  warmerda

 * fixed multiline string constants

 *

 * Revision 1.15  2002/06/12 21:12:25  warmerda

 * update to metadata based driver info

 *

 * Revision 1.14  2002/04/20 10:12:05  dron

 * Added support for GDALWriteWolrldFile()

 * New option WORLDFILE=YES

 *

 * Revision 1.13  2002/04/20 09:51:03  dron

 * *** empty log message ***

 *

 * Revision 1.12  2001/11/11 23:51:00  warmerda

 * added required class keyword to friend declarations

 *

 * Revision 1.11  2001/09/28 14:30:19  warmerda

 * Ensure num_trans is initialized to zero in case png_get_tRNS fails.

 *

 * Revision 1.10  2001/08/23 03:45:15  warmerda

 * If there is only one transparent color in the color table, also consider

 * it to be the nodata value.

 *

 * Revision 1.9  2001/08/23 03:32:37  warmerda

 * implemented read/write support for transparency (colortable/nodata)

 *

 * Revision 1.8  2001/08/22 17:12:07  warmerda

 * added world file support

 *

 * Revision 1.7  2001/07/18 04:51:57  warmerda

 * added CPL_CVSID

 *

 * Revision 1.6  2000/08/15 19:28:26  warmerda

 * added help topic

 *

 * Revision 1.5  2000/06/05 13:04:15  warmerda

 * Fixed case where png_get_text fails due to no text blocks existing.

 *

 * Revision 1.4  2000/05/15 22:26:42  warmerda

 * Avoid warning.

 *

 * Revision 1.3  2000/04/28 20:57:07  warmerda

 * Removed some unused code.

 *

 * Revision 1.2  2000/04/28 20:56:01  warmerda

 * converted to use CreateCopy() instead of Create()

 *

 * Revision 1.1  2000/04/27 19:39:51  warmerda

 * New

 */

#include <gdal/gdal_pam.h>

#include <png.h>

#include <gdal/cpl_string.h>

CPL_CVSID("$Id: pngdataset.cpp,v 1.31 2005/05/17 19:05:52 fwarmerdam Exp $");

CPL_C_START

void	GDALRegister_PNG(void);

CPL_C_END

/************************************************************************/

/* ==================================================================== */

/*				PNGDataset				*/

/* ==================================================================== */

/************************************************************************/

class PNGRasterBand;

class PNGDataset : public GDALPamDataset

{

    friend class PNGRasterBand;

    FILE        *fpImage;

    png_structp hPNG;

    png_infop   psPNGInfo;

    int         nBitDepth;

    int         nColorType; /* PNG_COLOR_TYPE_* */

    int         bInterlaced;

    int         nBufferStartLine;

    int         nBufferLines;

    int         nLastLineRead;

    GByte      *pabyBuffer;

    GDALColorTable *poColorTable;

    int	   bGeoTransformValid;

    double adfGeoTransform[6];

    int		bHaveNoData;

    double 	dfNoDataValue;

    void        CollectMetadata();

    CPLErr      LoadScanline( int );

    void        Restart();

  public:

                 PNGDataset();

                 ~PNGDataset();

    static GDALDataset *Open( GDALOpenInfo * );

    virtual CPLErr GetGeoTransform( double * );

    virtual void FlushCache( void );

};

/************************************************************************/

/* ==================================================================== */

/*                            PNGRasterBand                             */

/* ==================================================================== */

/************************************************************************/

class PNGRasterBand : public GDALPamRasterBand

{

    friend class PNGDataset;

  public:

                   PNGRasterBand( PNGDataset *, int );

    virtual CPLErr IReadBlock( int, int, void * );

    virtual GDALColorInterp GetColorInterpretation();

    virtual GDALColorTable *GetColorTable();

    virtual double GetNoDataValue( int *pbSuccess = NULL );

};

/************************************************************************/

/*                           PNGRasterBand()                            */

/************************************************************************/

PNGRasterBand::PNGRasterBand( PNGDataset *poDS, int nBand )

{

    this->poDS = poDS;

    this->nBand = nBand;

    if( poDS->nBitDepth == 16 )

        eDataType = GDT_UInt16;

    else

        eDataType = GDT_Byte;

    nBlockXSize = poDS->nRasterXSize;;

    nBlockYSize = 1;

}

/************************************************************************/

/*                             IReadBlock()                             */

/************************************************************************/

CPLErr PNGRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,

                                  void * pImage )

{

    PNGDataset	*poGDS = (PNGDataset *) poDS;

    CPLErr      eErr;

    GByte       *pabyScanline;

    int         i, nPixelSize, nPixelOffset, nXSize = GetXSize();

    CPLAssert( nBlockXOff == 0 );

    if( poGDS->nBitDepth == 16 )

        nPixelSize = 2;

    else

        nPixelSize = 1;

    nPixelOffset = poGDS->nBands * nPixelSize;

/* -------------------------------------------------------------------- */

/*      Load the desired scanline into the working buffer.              */

/* -------------------------------------------------------------------- */

    eErr = poGDS->LoadScanline( nBlockYOff );

    if( eErr != CE_None )

        return eErr;

    pabyScanline = poGDS->pabyBuffer 

        + (nBlockYOff - poGDS->nBufferStartLine) * nPixelOffset * nXSize

        + nPixelSize * (nBand - 1);

/* -------------------------------------------------------------------- */

/*      Transfer between the working buffer the the callers buffer.     */

/* -------------------------------------------------------------------- */

    if( nPixelSize == nPixelOffset )

        memcpy( pImage, pabyScanline, nPixelSize * nXSize );

    else if( nPixelSize == 1 )

    {

        for( i = 0; i < nXSize; i++ )

            ((GByte *) pImage)[i] = pabyScanline[i*nPixelOffset];

    }

    else 

    {

        CPLAssert( nPixelSize == 2 );

        for( i = 0; i < nXSize; i++ )

        {

            ((GUInt16 *) pImage)[i] = 

                *((GUInt16 *) (pabyScanline+i*nPixelOffset));

        }

    }

    return CE_None;

}

/************************************************************************/

/*                       GetColorInterpretation()                       */

/************************************************************************/

GDALColorInterp PNGRasterBand::GetColorInterpretation()

{

    PNGDataset	*poGDS = (PNGDataset *) poDS;

    if( poGDS->nColorType == PNG_COLOR_TYPE_GRAY )

        return GCI_GrayIndex;

    else if( poGDS->nColorType == PNG_COLOR_TYPE_GRAY_ALPHA )

    {

        if( nBand == 1 )

            return GCI_GrayIndex;

        else

            return GCI_AlphaBand;

    }

    else  if( poGDS->nColorType == PNG_COLOR_TYPE_PALETTE )

        return GCI_PaletteIndex;

    else  if( poGDS->nColorType == PNG_COLOR_TYPE_RGB

              || poGDS->nColorType == PNG_COLOR_TYPE_RGB_ALPHA )

    {

        if( nBand == 1 )

            return GCI_RedBand;

        else if( nBand == 2 )

            return GCI_GreenBand;

        else if( nBand == 3 )

            return GCI_BlueBand;

        else 

            return GCI_AlphaBand;

    }

    else

        return GCI_GrayIndex;

}

/************************************************************************/

/*                           GetColorTable()                            */

/************************************************************************/

GDALColorTable *PNGRasterBand::GetColorTable()

{

    PNGDataset	*poGDS = (PNGDataset *) poDS;

    if( nBand == 1 )

        return poGDS->poColorTable;

    else

        return NULL;

}

/************************************************************************/

/*                           GetNoDataValue()                           */

/************************************************************************/

double PNGRasterBand::GetNoDataValue( int *pbSuccess )

{

    PNGDataset *poPDS = (PNGDataset *) poDS;

    if( poPDS->bHaveNoData )

    {

        if( pbSuccess != NULL )

            *pbSuccess = poPDS->bHaveNoData;

        return poPDS->dfNoDataValue;

    }

    else

    {

        return GDALPamRasterBand::GetNoDataValue( pbSuccess );

    }

}

/************************************************************************/

/* ==================================================================== */

/*                             PNGDataset                               */

/* ==================================================================== */

/************************************************************************/

/************************************************************************/

/*                            PNGDataset()                            */

/************************************************************************/

PNGDataset::PNGDataset()

{

    hPNG = NULL;

    psPNGInfo = NULL;

    pabyBuffer = NULL;

    nBufferStartLine = 0;

    nBufferLines = 0;

    nLastLineRead = -1;

    poColorTable = NULL;

    bGeoTransformValid = FALSE;

    adfGeoTransform[0] = 0.0;

    adfGeoTransform[1] = 1.0;

    adfGeoTransform[2] = 0.0;

    adfGeoTransform[3] = 0.0;

    adfGeoTransform[4] = 0.0;

    adfGeoTransform[5] = 1.0;

    bHaveNoData = FALSE;

    dfNoDataValue = -1;

}

/************************************************************************/

/*                           ~PNGDataset()                            */

/************************************************************************/

PNGDataset::~PNGDataset()

{

    FlushCache();

    png_destroy_read_struct( &hPNG, &psPNGInfo, NULL );

    VSIFClose( fpImage );

    if( poColorTable != NULL )

        delete poColorTable;

}

/************************************************************************/

/*                          GetGeoTransform()                           */

/************************************************************************/

CPLErr PNGDataset::GetGeoTransform( double * padfTransform )

{

    if( bGeoTransformValid )

    {

        memcpy( padfTransform, adfGeoTransform, sizeof(double)*6 );

        return CE_None;

    }

    else

        return GDALPamDataset::GetGeoTransform( padfTransform );

}

/************************************************************************/

/*                             FlushCache()                             */

/*                                                                      */

/*      We override this so we can also flush out local tiff strip      */

/*      cache if need be.                                               */

/************************************************************************/

void PNGDataset::FlushCache()

{

    GDALPamDataset::FlushCache();

    if( pabyBuffer != NULL )

    {

        CPLFree( pabyBuffer );

        pabyBuffer = NULL;

        nBufferStartLine = 0;

        nBufferLines = 0;

    }

}

/************************************************************************/

/*                              Restart()                               */

/*                                                                      */

/*      Restart reading from the beginning of the file.                 */

/************************************************************************/

void PNGDataset::Restart()

{

    png_destroy_read_struct( &hPNG, &psPNGInfo, NULL );

    VSIRewind( fpImage );

    hPNG = png_create_read_struct( PNG_LIBPNG_VER_STRING, this, NULL, NULL );

    psPNGInfo = png_create_info_struct( hPNG );

    png_init_io( hPNG, fpImage );

    png_read_info( hPNG, psPNGInfo );

    if( nBitDepth < 8 )

        png_set_packing( hPNG );

    nLastLineRead = -1;

}

/************************************************************************/

/*                            LoadScanline()                            */

/************************************************************************/

CPLErr PNGDataset::LoadScanline( int nLine )

{

    int   i;

    int   nPixelOffset;

    CPLAssert( nLine >= 0 && nLine < GetRasterYSize() );

    if( nLine >= nBufferStartLine && nLine < nBufferStartLine + nBufferLines)

        return CE_None;

    if( nBitDepth == 16 )

        nPixelOffset = 2 * GetRasterCount();

    else

        nPixelOffset = 1 * GetRasterCount();

/* -------------------------------------------------------------------- */

/*      If the file is interlaced, we will load the entire image        */

/*      into memory using the high level API.                           */

/* -------------------------------------------------------------------- */

    if( bInterlaced )

    {

        png_bytep	*png_rows;

        CPLAssert( pabyBuffer == NULL );

        if( nLastLineRead != -1 )

            Restart();

        nBufferStartLine = 0;

        nBufferLines = GetRasterYSize();

        pabyBuffer = (GByte *) 

            VSIMalloc(nPixelOffset*GetRasterXSize()*GetRasterYSize());

        if( pabyBuffer == NULL )

        {

            CPLError( CE_Failure, CPLE_OutOfMemory, 

                      "Unable to allocate buffer for whole interlaced PNG"

                      "image of size %dx%d.\n", 

                      GetRasterXSize(), GetRasterYSize() );

            return CE_Failure;

        }

        png_rows = (png_bytep*)CPLMalloc(sizeof(png_bytep) * GetRasterYSize());

        for( i = 0; i < GetRasterYSize(); i++ )

            png_rows[i] = pabyBuffer + i * nPixelOffset * GetRasterXSize();

        png_read_image( hPNG, png_rows );

        CPLFree( png_rows );

        nLastLineRead = GetRasterYSize() - 1;

        return CE_None;

    }

/* -------------------------------------------------------------------- */

/*      Ensure we have space allocated for one scanline                 */

/* -------------------------------------------------------------------- */

    if( pabyBuffer == NULL )

        pabyBuffer = (GByte *) CPLMalloc(nPixelOffset * GetRasterXSize());

/* -------------------------------------------------------------------- */

/*      Otherwise we just try to read the requested row.  Do we need    */

/*      to rewind and start over?                                       */

/* -------------------------------------------------------------------- */

    if( nLine <= nLastLineRead )

        Restart();

/* -------------------------------------------------------------------- */

/*      Read till we get the desired row.                               */

/* -------------------------------------------------------------------- */

    png_bytep      row;

    row = pabyBuffer;

    while( nLine > nLastLineRead )

    {

        png_read_rows( hPNG, &row, NULL, 1 );

        nLastLineRead++;

    }

    nBufferStartLine = nLine;

    nBufferLines = 1;

/* -------------------------------------------------------------------- */

/*      Do swap on LSB machines.  16bit PNG data is stored in MSB       */

/*      format.                                                         */

/* -------------------------------------------------------------------- */

#ifdef CPL_LSB

    if( nBitDepth == 16 )

        GDALSwapWords( row, 2, GetRasterXSize(), 2 );

#endif

    return CE_None;

}

/************************************************************************/

/*                          CollectMetadata()                           */

/*                                                                      */

/*      We normally do this after reading up to the image, but be       */

/*      forwarned ... we can missing text chunks this way.              */

/*                                                                      */

/*      We turn each PNG text chunk into one metadata item.  It         */

/*      might be nice to preserve language information though we        */

/*      don't try to now.                                               */

/************************************************************************/

void PNGDataset::CollectMetadata()

{

    int   nTextCount;

    png_textp text_ptr;

    if( png_get_text( hPNG, psPNGInfo, &text_ptr, &nTextCount ) == 0 )

        return;

    for( int iText = 0; iText < nTextCount; iText++ )

    {

        char	*pszTag = CPLStrdup(text_ptr[iText].key);

        for( int i = 0; pszTag[i] != '\0'; i++ )

        {

            if( pszTag[i] == ' ' || pszTag[i] == '=' || pszTag[i] == ':' )

                pszTag[i] = '_';

        }

        SetMetadataItem( pszTag, text_ptr[iText].text );

        CPLFree( pszTag );

    }

}

/************************************************************************/

/*                                Open()                                */

/************************************************************************/

GDALDataset *PNGDataset::Open( GDALOpenInfo * poOpenInfo )

{

/* -------------------------------------------------------------------- */

/*	First we check to see if the file has the expected header	*/

/*	bytes.								*/    

/* -------------------------------------------------------------------- */

    if( poOpenInfo->nHeaderBytes < 4 )

        return NULL;

    if( png_sig_cmp(poOpenInfo->pabyHeader, (png_size_t)0, 

                    poOpenInfo->nHeaderBytes) != 0 )

        return NULL;

    if( poOpenInfo->eAccess == GA_Update )

    {

        CPLError( CE_Failure, CPLE_NotSupported, 

                  "The PNG driver does not support update access to existing"

                  " datasets.\n" );

        return NULL;

    }

/* -------------------------------------------------------------------- */

/*      Create a corresponding GDALDataset.                             */

/* -------------------------------------------------------------------- */

    PNGDataset 	*poDS;

    poDS = new PNGDataset();

    poDS->eAccess = poOpenInfo->eAccess;

    poDS->hPNG = png_create_read_struct( PNG_LIBPNG_VER_STRING, poDS, 

                                         NULL, NULL );

    if (poDS->hPNG == NULL)

    {

#if LIBPNG_VER_MINOR >= 2 || LIBPNG_VER_MAJOR > 1

        int version = png_access_version_number();

        CPLError( CE_Failure, CPLE_NotSupported, 

                  "The PNG driver failed to access libpng with version '%s',"

                  " library is actually version '%d'.\n",

                  PNG_LIBPNG_VER_STRING, version);

#else

        CPLError( CE_Failure, CPLE_NotSupported, 

                  "The PNG driver failed to in png_create_read_struct().\n"

                  "This may be due to version compatibility problems." );

#endif

        delete poDS;

        return NULL;

    }

    poDS->psPNGInfo = png_create_info_struct( poDS->hPNG );

/* -------------------------------------------------------------------- */

/*	Read pre-image data after ensuring the file is rewound.         */

/* -------------------------------------------------------------------- */

    /* we should likely do a setjmp() here */

    VSIRewind( poOpenInfo->fp );

    png_init_io( poDS->hPNG, poOpenInfo->fp );

    png_read_info( poDS->hPNG, poDS->psPNGInfo );

/* -------------------------------------------------------------------- */

/*      Capture some information from the file that is of interest.     */

/* -------------------------------------------------------------------- */

    poDS->nRasterXSize = png_get_image_width( poDS->hPNG, poDS->psPNGInfo );

    poDS->nRasterYSize = png_get_image_height( poDS->hPNG, poDS->psPNGInfo );

    poDS->nBands = png_get_channels( poDS->hPNG, poDS->psPNGInfo );

    poDS->nBitDepth = png_get_bit_depth( poDS->hPNG, poDS->psPNGInfo );

    poDS->bInterlaced = png_get_interlace_type( poDS->hPNG, poDS->psPNGInfo ) 

        				!= PNG_INTERLACE_NONE;

    poDS->nColorType = png_get_color_type( poDS->hPNG, poDS->psPNGInfo );

    if( poDS->nColorType == PNG_COLOR_TYPE_PALETTE 

        && poDS->nBands > 1 )

    {

        CPLDebug( "GDAL", "PNG Driver got %d from png_get_channels(),\n"

                  "but this kind of image (paletted) can only have one band.\n"

                  "Correcting and continuing, but this may indicate a bug!",

                  poDS->nBands );

        poDS->nBands = 1;

    }

/* -------------------------------------------------------------------- */

/*      We want to treat 1,2,4 bit images as eight bit.  This call      */

/*      causes libpng to unpack the image.                              */

/* -------------------------------------------------------------------- */

    if( poDS->nBitDepth < 8 )

        png_set_packing( poDS->hPNG );

/* -------------------------------------------------------------------- */

/*      Create band information objects.                                */

/* -------------------------------------------------------------------- */

    for( int iBand = 0; iBand < poDS->nBands; iBand++ )

        poDS->SetBand( iBand+1, new PNGRasterBand( poDS, iBand+1 ) );

/* -------------------------------------------------------------------- */

/*      Adopt the file pointer.                                         */

/* -------------------------------------------------------------------- */

    poDS->fpImage = poOpenInfo->fp;

    poOpenInfo->fp = NULL;

/* -------------------------------------------------------------------- */

/*      Is there a palette?  Note: we should also read back and         */

/*      apply transparency values if available.                         */

/* -------------------------------------------------------------------- */

    if( poDS->nColorType == PNG_COLOR_TYPE_PALETTE )

    {

        png_color *pasPNGPalette;

        int	nColorCount;

        GDALColorEntry oEntry;

        unsigned char *trans = NULL;

        png_color_16 *trans_values = NULL;

        int	num_trans = 0;

        int	nNoDataIndex = -1;

        if( png_get_PLTE( poDS->hPNG, poDS->psPNGInfo, 

                          &pasPNGPalette, &nColorCount ) == 0 )

            nColorCount = 0;

        png_get_tRNS( poDS->hPNG, poDS->psPNGInfo, 

                      &trans, &num_trans, &trans_values );

        poDS->poColorTable = new GDALColorTable();

        for( int iColor = nColorCount - 1; iColor >= 0; iColor-- )

        {

            oEntry.c1 = pasPNGPalette[iColor].red;

            oEntry.c2 = pasPNGPalette[iColor].green;

            oEntry.c3 = pasPNGPalette[iColor].blue;

            if( iColor < num_trans )

            {

                oEntry.c4 = trans[iColor];

                if( oEntry.c4 == 0 )

                {

                    if( nNoDataIndex == -1 )

                        nNoDataIndex = iColor;

                    else

                        nNoDataIndex = -2;

                }

            }

            else

                oEntry.c4 = 255;

            poDS->poColorTable->SetColorEntry( iColor, &oEntry );

        }

        /*

        ** Special hack to an index as the no data value, as long as it

        ** is the _only_ transparent color in the palette.

        */

        if( nNoDataIndex > -1 )

        {

            poDS->bHaveNoData = TRUE;

            poDS->dfNoDataValue = nNoDataIndex;

        }

    }

/* -------------------------------------------------------------------- */

/*      Check for transparency values in greyscale images.              */

/* -------------------------------------------------------------------- */

    if( poDS->nColorType == PNG_COLOR_TYPE_GRAY 

        || poDS->nColorType == PNG_COLOR_TYPE_GRAY_ALPHA )

    {

        png_color_16 *trans_values = NULL;

        unsigned char *trans;

        int num_trans;

        if( png_get_tRNS( poDS->hPNG, poDS->psPNGInfo, 

                          &trans, &num_trans, &trans_values ) != 0 

            && trans_values != NULL )

        {

            poDS->bHaveNoData = TRUE;

            poDS->dfNoDataValue = trans_values->gray;

        }

    }

/* -------------------------------------------------------------------- */

/*      Extract any text chunks as "metadata".                          */

/* -------------------------------------------------------------------- */

    poDS->CollectMetadata();

/* -------------------------------------------------------------------- */

/*      Open overviews.                                                 */

/* -------------------------------------------------------------------- */

    poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );

/* -------------------------------------------------------------------- */

/*      Initialize any PAM information.                                 */

/* -------------------------------------------------------------------- */

    poDS->SetDescription( poOpenInfo->pszFilename );

    poDS->TryLoadXML();

/* -------------------------------------------------------------------- */

/*      Check for world file.                                           */

/* -------------------------------------------------------------------- */

    poDS->bGeoTransformValid = 

        GDALReadWorldFile( poOpenInfo->pszFilename, NULL, 

                           poDS->adfGeoTransform );

    if( !poDS->bGeoTransformValid )

        poDS->bGeoTransformValid = 

            GDALReadWorldFile( poOpenInfo->pszFilename, ".wld", 

                               poDS->adfGeoTransform );

    if( !poDS->bGeoTransformValid )

        poDS->bGeoTransformValid = 

            GDALReadWorldFile( poOpenInfo->pszFilename, ".tfw", 

                               poDS->adfGeoTransform );

    if( !poDS->bGeoTransformValid )

        poDS->bGeoTransformValid = 

            GDALReadWorldFile( poOpenInfo->pszFilename, ".tifw", 

                               poDS->adfGeoTransform );

    return poDS;

}

/************************************************************************/

/*                           PNGCreateCopy()                            */

/************************************************************************/

static GDALDataset *

PNGCreateCopy( const char * pszFilename, GDALDataset *poSrcDS, 

               int bStrict, char ** papszOptions, 

               GDALProgressFunc pfnProgress, void * pProgressData )

{

    int  nBands = poSrcDS->GetRasterCount();

    int  nXSize = poSrcDS->GetRasterXSize();

    int  nYSize = poSrcDS->GetRasterYSize();

/* -------------------------------------------------------------------- */

/*      Some some rudimentary checks                                    */

/* -------------------------------------------------------------------- */

    if( nBands != 1 && nBands != 2 && nBands != 3 && nBands != 4 )

    {

        CPLError( CE_Failure, CPLE_NotSupported, 

                  "PNG driver doesn't support %d bands.  Must be 1 (grey),\n"

                  "2 (grey+alpha), 3 (rgb) or 4 (rgba) bands.\n", 

                  nBands );

        return NULL;

    }