examples/Multimedia/ICL/ICLCodec/PNGCodec.h

/*
Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 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 Nokia Corporation nor the names of its 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 HOLDER 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.

Description:  
*/


#ifndef __PNGCODEC_H__
#define __PNGCODEC_H__

#include <bitdev.h>
#include <ezcompressor.h>
#include <ezdecompressor.h>
#include <icl/imageprocessor.h>
#include <icl/imagecodec.h>

#include "PNGConvert.h"

//.
// Constants.relating to PNG standard 
//
const TInt KPngFileSignatureLength = 8;
const TUint8 KPngSignature[KPngFileSignatureLength] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };

const TInt KPngChunkIdSize = 4;
const TInt KPngMaxPLTESize = 256;
const TInt KPngNumInterlacedPasses = 8; // 7 passes plus a safety entry

const TInt KPngChunkLengthSize = 4;
const TInt KPngChunkCRCSize = 4;

const TInt KPngIHDRChunkSize = 13;
const TInt KPngIENDChunkSize = 0;
const TInt KPngcHRMChunkSize = 32;
const TInt KPnggAMAChunkSize = 4;
const TInt KPngpHYsChunkSize = 9;
const TInt KPngtIMEChunkSize = 7;

// KPngMaxImageSize is the maximum size for width and height, as defined in the PNG Specification v1.0 page 14
const TUint KPngMaxImageSize = ((TUint)2 << 30) - 1;
const TInt KPngCrcTableLength = 256;
const TUint KPngCrcMask = 0xffffffff;

_LIT8(KPngIHDRChunkId,"IHDR");
_LIT8(KPngPLTEChunkId,"PLTE");
_LIT8(KPngIDATChunkId,"IDAT");
_LIT8(KPngIENDChunkId,"IEND");
_LIT8(KPngbKGDChunkId,"bKGD");
_LIT8(KPngpHYsChunkId,"pHYs");
_LIT8(KPngtRNSChunkId,"tRNS");


// .
// Encapsulates information about a PNG image
// See PNG standard for details.
// 
class TPngImageInformation : public TFrameInfo
        {
public:
        TPngImageInformation();
public:
        enum TColorElements
                {
                EMonochrome = 0x0,
                EPaletteUsed = 0x1,
                EColorUsed = 0x2,
                EAlphaChannelUsed = 0x4
                };
        enum TColorType
                {
                EGrayscale = EMonochrome, // 0
                EDirectColor = EColorUsed, // 2
                EIndexedColor = EColorUsed | EPaletteUsed, // 3
                EAlphaGrayscale = EMonochrome | EAlphaChannelUsed, // 4
                EAlphaDirectColor = EColorUsed | EAlphaChannelUsed // 6
                };
        enum TCompressionMethod
                {
                EDeflateInflate32K = 0
                };
        enum TFilterMethod
                {
                EAdaptiveFiltering = 0
                };
        enum TInterlaceMethod
                {
                ENoInterlace = 0,
                EAdam7Interlace = 1
                };
        enum TPhysicalUnits
                {
                EUnknownUnits = 0,
                EMeters = 1
                };
public:
        // IHDR chunk
        TSize iSize; // iWidth/iHeight = 1 ... (2^31)-1
        TInt iBitDepth; // 1,2,4,8,16 subject to color type restrictions
        TColorType iColorType; // 0,2,3,4,6
        TCompressionMethod iCompressionMethod; // 0
        TFilterMethod iFilterMethod; // 0
        TInterlaceMethod iInterlaceMethod; // 0 or 1

        // PLTE chunk
        TBool iPalettePresent;
        TRgb iPalette[KPngMaxPLTESize];

        // bKGD chunk
        TBool iBackgroundPresent;

        // pHYs chunk
        TBool iPhysicalPresent;
        TPhysicalUnits iPhysicalUnits;
        TSize iPhysicalSize;

        // tRNS chunk
        TBool iTransparencyPresent;
        TUint16 iTransparentGray;
        TUint16 iTransparentRed;
        TUint16 iTransparentGreen;
        TUint16 iTransparentBlue;
        TUint8 iTransparencyValue[KPngMaxPLTESize];
        };

//
// Handles reading raw PNG scanlines and preparing the data
// to be decompressed. A helper to CPngReadCodec.
// It is abstract, and subclassed to implement readers for 
// scanlines of different bitmap depths
//
class CPngReadSubCodec : public CBase
        {
public:
        static CPngReadSubCodec* NewL(CImageProcessor* aImageProc,CImageProcessor* aMaskProc,const TPngImageInformation& aInfo);
        virtual ~CPngReadSubCodec();
        TDes8& FirstBuffer();
        TDes8& DecodeL();
protected:
        CPngReadSubCodec();
        void WritePixel(TRgb aPixelColor);
        void WritePixel(TRgb aPixelColor,TUint8 aAlphaValue);
private:
        void ConstructL(CImageProcessor* aImageProc,CImageProcessor* aMaskProc,const TPngImageInformation& aInfo);
        void FilterScanlineDataL(TUint8* aDataPtr,const TUint8* aDataPtrLimit);
        TInt PaethPredictor(TInt aLeft,TInt aAbove,TInt aAboveLeft);
        virtual void DoConstructL() = 0;
        virtual TInt ScanlineBufferSize(TInt aPixelLength) = 0;
        virtual void DoDecode(TUint8* aDataPtr,const TUint8* aDataPtrLimit) = 0;
        void UpdatePos();
protected:
        CImageProcessor* iImageProc;
        CImageProcessor* iMaskProc;
        TPngImageInformation iInfo;
        TInt iScanlineBufferSize;
        TInt iBytesPerPixel;
        HBufC8* iScanlineBuffer1;
        HBufC8* iScanlineBuffer2;
        TPtr8 iScanlineDes1;
        TPtr8 iScanlineDes2;
        TInt iCurrentScanlineBuffer;
        TInt iInterlacedScanlineBufferSize[KPngNumInterlacedPasses];
        TInt iPass;
        TPoint iPos;
        };

class CPngDecoder;

//
// Codec class that does the real work of reading a PNG image.
// Inherits base classes that provide image mask processing
// and interface to unzip functionality
//
class CPngReadCodec : public CImageMaskProcessorReadCodec, public MEZBufferManager
        {
public:
        // Construction
        ~CPngReadCodec();
        void ConstructL () { CImageMaskProcessorReadCodec::ConstructL(); } // make public, since we don't have NewL

private:
        // From CImageReadCodec
        // Initialise frame to read
        void InitFrameL(TFrameInfo& aFrameInfo, CFrameImageData& aFrameImageData, 
                TBool aDisableErrorDiffusion, CFbsBitmap& aDestination, CFbsBitmap* aDestinationMask);
        // Initialise from header
        void InitFrameHeader(TFrameInfo& aFrameSettings, CFrameImageData& /* aFrameImageData */);
        // Process header
        TFrameState ProcessFrameHeaderL(TBufPtr8& aData);
        // Process frame
        TFrameState ProcessFrameL(TBufPtr8& aSrc);

private:
        // Helper functions to process PNG chunk types
        void DoNewFrameL(CPngDecoder* aPngDecoder);
        void DoProcessInfoL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit);
        void DoProcessIHDRL(const TUint8* aDataPtr,TInt aChunkLength);
        void DoProcessPLTEL(const TUint8* aDataPtr,TInt aChunkLength);
        void DoProcessbKGDL(const TUint8* aDataPtr,TInt aChunkLength);
        void DoProcesspHYsL(const TUint8* aDataPtr,TInt aChunkLength);
        void DoProcesstRNSL(const TUint8* aDataPtr,TInt aChunkLength);
        void DoProcessDataL(const TUint8*& aDataPtr,const TUint8* aDataPtrLimit);

        // From MEZBufferManager: feed data to unzip
        void InitializeL(CEZZStream &aZStream);
        void NeedInputL(CEZZStream &aZStream);
        void NeedOutputL(CEZZStream &aZStream);
        void FinalizeL(CEZZStream &aZStream);

private:
        TFrameInfo* iFrameInfo;
        TPngImageInformation iImageInfo;
        TBuf8<KPngChunkIdSize> iChunkId;
        TInt iChunkBytesRemaining;
        CPngReadSubCodec* iDecoder;
        CEZDecompressor* iDecompressor;
        TPtrC8 iDataDes;
        };

//
// Handles preparing image data
// for compression and writing raw scanlines 
// A helper to CPngWriteCodec
// 
class CPngWriteSubCodec : public CBase
        {
public:
        static CPngWriteSubCodec* NewL(const TPngImageInformation& aInfo, const CFbsBitmap* aSource);
        virtual ~CPngWriteSubCodec();
protected:
        CPngWriteSubCodec();
private:
        void ConstructL(const TPngImageInformation& aInfo, const CFbsBitmap* aSource);
public:
        TDes8& Buffer();
        inline TInt BufferSize() const;
        TDes8& EncodeL(const TInt aScanline);
        inline CPalette* Palette() const;
protected:
        TUint8 ReverseBits(const TUint8 aValue) const;
        void EncodePalettedScanline(TUint8* aDataPtr, const CFbsBitmap* aSource, const TInt aScanline,
                                                                const TInt aPixelsPerByte, const TInt aShiftValue);
private:
        virtual void DoConstructL();
        virtual TInt ScanlineBufferSize(TInt aPixelLength) = 0;
        virtual void DoEncode(const CFbsBitmap* aSource, const TInt aScanline,
                                        TUint8* aDataPtr, const TUint8* aDataPtrLimit) = 0;
protected:
        TPngImageInformation iInfo;
        const CFbsBitmap* iSource;
        TInt iScanlineBufferSize;
        HBufC8* iScanlineBuffer;
        TPtr8 iScanlineDes;
        CPalette* iPalette;
        };

//
// Codec class that does the real work of writing a PNG image.
// Inherits base classes to interface to zip functionality
//
class CPngWriteCodec : public CImageWriteCodec, public MEZBufferManager
        {
public:
        // Construction
        CPngWriteCodec(TInt aBpp, TBool aColor, TBool aPaletted, TInt aCompressionLevel);
        void ConstructL () { CImageWriteCodec::ConstructL(); } // make public, since we don't have NewL
        ~CPngWriteCodec();

private:
        // from CImageWriteCodec
        void InitFrameL(TBufPtr8& aDst, const CFbsBitmap& aSource);
        TFrameState ProcessFrameL(TBufPtr8& aDst);

private:
        // Helper functions to write PNG chunks
        void WritePngChunk(TUint8*& aDestPtr, const TDesC8& aChunkId, const TDesC8& aData, TInt& aLength);
        void DeflateEncodedDataL(TBufPtr8& aDst, TFrameState& aState);
        void FlushCompressedDataL(TBufPtr8& aDst, TFrameState& aState);
        void WritePLTEChunk(TBufPtr8& aDst);
        void WriteIDATChunk(TBufPtr8& aDst);
        void WriteEndChunk(TBufPtr8& aDst);
        TInt WriteHeaderChunk(TBufPtr8& aDst);
        void GetImageDataL(TInt& aBytesToProcess);
        void GetPngScanLine(TDes8& aBuf, const TPoint& aPixel, TInt& aLength);
        void CalcCrcTable();
        void GetCrc(TUint32& aCrc, const TUint8* aPtr, const TInt aLength);

private:
        // from MEZBufferManager
        // feeds data to zip
        void InitializeL(CEZZStream &aZStream);
        void NeedInputL(CEZZStream &aZStream);
        void NeedOutputL(CEZZStream &aZStream);
        void FinalizeL(CEZZStream &aZStream);

private:
        enum TPngEncoderState
                {
                EPngDeflate,    // Deflate encoded image data
                EPngFlush,              // Flush encoded image data
                EPngWritePLTE,  // Write PLTE chunk
                EPngWriteIDAT,  // Write IDAT chunk
                EPngEndChunk    // Write end chunk
                };
        
private:
        TUint32 iCrcTable[KPngCrcTableLength];
        TBool iCrcTableCalculated;
        CPngWriteSubCodec* iEncoder;
        TPngEncoderState iEncoderState;
        TInt iCompressionLevel;
        CEZCompressor* iCompressor;
        TInt iScanline;
        TUint8* iDestStartPtr;
        TUint8* iDestPtr;
        TUint8* iDestPtrLimit;
        TPngImageInformation iImageInfo;
        TPtr8 iCompressorPtr;   // data area for compressor to write to
        TBool iCallAgain;
        };


// Global panic function
void Panic(TInt aError);

//
// inline definitions
//
inline TInt CPngWriteSubCodec::BufferSize() const
        { return iScanlineBufferSize; }

inline CPalette* CPngWriteSubCodec::Palette() const
        { return iPalette; }


#endif // __PNGCODEC_H__

---