"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1996 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libview2' }"

"{ NameSpace: Smalltalk }"

ImageReader subclass:#PNGReader

	instanceVariableNames:'colorType bitsPerChannel compressionMethod filterMethod

		interlaceMode bytesPerScanline globalDataChunk thisScanline

		prevScanline processTextChunks specialChunkHandlers

		paletteAlphaEntries paletteIndexForMaskedPixels image forceRGB

		depthImage specialChunks extractSpecialChunksOnly'

	classVariableNames:'ColorTypeGray ColorTypeGrayAlpha ColorTypePalette ColorTypeRGB

		ColorTypeRGBAlpha Verbose'

	poolDictionaries:''

	category:'Graphics-Images-Readers'

!

!PNGReader class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1996 by Claus Gittinger

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    This class provides methods for loading and saving PNG pictures.

    It is currenty unfinished (some interlaced image formats are unsupported, for example: grayscale+alpha)

    In the meantime, use a pngtoXXX converter for interlaced images, and read XXX.

    [caveats:]

        writer can only store mask with depth24 images (for now).

        writer only generates unfiltered non-interlaced data.

    [Special:]

        the EnforcedImageTypeQuery is asked for;

        if #rgb is returned AND the image is rgba, then the alpha channel is ignored

        and an rgb (Depth24Image) is returned instead.

        Proprietary chunks can be extracted by defining a specialChunkHandler,

        which is invoked (indexed by chunkType) with the chunk data when such a

        chunk is encountered. This allows for private data to be extracted.

        (labview does this, and expecco can do this)

        Proprietary chunks can be written by setting the specialChunks collection

        before writing.

    [See also:]

        Image Form Icon

        BlitImageReader FaceReader GIFReader JPEGReader MacOSXIconReader

        PBMReader PCXReader 

        ST80FormReader SunRasterReader TargaReader TIFFReader WindowsIconReader 

        XBMReader XPMReader XWDReader 

    [author:]

        Claus Gittinger

"

!

examples

"

    PNGReader fromFile:'/home/cg/AudioExplorer_51_files/use_small.png'

    PNGReader fromFile:'\\Exeptn\tmp\images\expeccoScreenshot4020_5526507.png'

    PNGReader fromFile:'C:\Users\cg\Desktop\croquet\cobalt-base-current-build-20090210\cobalt-base-current-build-20090210\content\models\textures\checkerboard.png'

    PNGReader fromFile:'C:\Dokumente und Einstellungen\cg\Desktop\misc\PNGs\Delete.png'

    PNGReader fromFile:'\\exeptn\unsaved\pd_stuff\PNGs\Delete.png'

    PNGReader fromFile:'\\exeptn\unsaved\pd_stuff\PNGs\Down.png'

    |img img2 outStream png|

    img := ToolbarIconLibrary error32x32Icon.

    outStream := WriteStream on:(ByteArray new:100).

    PNGReader save:img onStream:outStream.

    png := outStream contents.

    img2 := PNGReader fromStream:(png readStream).

    self assert:(img bits = img2 bits).

    img inspect.

    img2 inspect.

"

! !

!PNGReader class methodsFor:'initialization'!

initialize

    "install myself in the Image classes fileFormat table for the `.png' extension."

    MIMETypes defineImageType:'image/png'  suffix:'png' reader:self.

    "/ backward compatibility from times when png was not yet so common...

    MIMETypes defineImageType:'image/x-png' suffix:nil reader:self.

    ColorTypeGray := 0.

    ColorTypeRGB := 2.

    ColorTypePalette := 3.

    ColorTypeGrayAlpha := 4.

    ColorTypeRGBAlpha := 6.

    "Modified: / 16-02-2017 / 19:41:40 / cg"

! !

!PNGReader class methodsFor:'accessing'!

pngHeader

    ^ #[137 80 78 71 13 10 26 10]

! !

!PNGReader class methodsFor:'queries'!

canRepresent:anImage

    "return true, if anImage can be represented in my file format.

     Any image without mask is supported;

     only depth24 images with mask are (currently)."

    anImage mask notNil ifTrue:[

        "/ for now, can only write depth24 images with mask

        ^ anImage depth == 24

    ].    

    ^ true

    "Modified (comment): / 16-02-2017 / 16:28:53 / cg"

! !

!PNGReader class methodsFor:'testing'!

file:filename hasSpecialChunk:chunkTag

    "true if there is a special chunk with chunkTag in filename"

    |pngReader hasChunk|

    hasChunk := false.    

    pngReader := self new.

    pngReader extractSpecialChunksOnly:true.

    pngReader 

        specialChunkHandlerAt:chunkTag 

        put:[:data | hasChunk := true].

    filename asFilename readingFileDo:[:inStream |        

        pngReader fromStream:inStream.

    ].        

    ^ hasChunk

    "Created: / 19-05-2019 / 20:15:13 / Claus Gittinger"

!

isValidImageFile:aFileName

    "return true, if aFileName contains a PNG image"

    |inStream magic|

    inStream := self streamReadingFile:aFileName.

    inStream isNil ifTrue:[^ false].

    inStream binary.

    magic := ByteArray new:8.

    inStream nextBytes:8 into:magic.

    inStream close.

    ^ (magic = #[137 80 78 71 13 10 26 10])

    "

     self isValidImageFile:'/home/cg/AudioExplorer_51_files/use_small.png'

     self isValidImageFile:'C:\Users\cg\Desktop\croquet\cobalt-base-current-build-20090210\cobalt-base-current-build-20090210\content\models\textures\checkerboard.png'

     self isValidImageFile:'C:\Dokumente und Einstellungen\cg\Desktop\misc\PNGs\Delete.png'

    "

    "Modified: 21.6.1996 / 20:38:46 / cg"

! !

!PNGReader methodsFor:'accessing'!

extractSpecialChunksOnly:aBoolean

    "if set to true, only special chunks will be processed via

     corresponding specialChunkHandlers.

     No image will be extracted.

     The default is (of course) false."

    extractSpecialChunksOnly := aBoolean.

    "Modified (comment): / 27-10-2018 / 17:39:50 / Claus Gittinger"

!

makeImage

    image isNil ifTrue:[

        image := super makeImage.

    ].

    ^ image

    "Created: / 17-02-2017 / 11:14:45 / cg"

!

pngHeader

    <resource: #obsolete>

    ^ self class pngHeader

    "Modified: / 22-02-2017 / 11:00:44 / cg"

!

specialChunks:aDictionaryOfChunkTypesAndBlobs

    specialChunks := aDictionaryOfChunkTypesAndBlobs.

    "Modified (format): / 27-10-2018 / 16:09:56 / Claus Gittinger"

! !

!PNGReader methodsFor:'hooks'!

specialChunkHandlerAt:chunkType put:aHandlerBlock

    "define a handler action, which processes unknown chunks.

     The handler block will be called with one or two arguments:

     the binary data of the chunk, and optionally the reader itself"

    specialChunkHandlers isNil ifTrue:[ 

        specialChunkHandlers := Dictionary new

    ].

    specialChunkHandlers at:chunkType put:aHandlerBlock

    "Created: / 14-02-2017 / 11:43:33 / cg"

! !

!PNGReader methodsFor:'reading'!

fromStream:aStream

    "read a stream containing a PNG image.

     Leave the image description in instance variables

     (i.e. to get the image, ask with image)."

    |header bitsPerSampleOut bytesPerScanlineOut|

    inStream := aStream.

    aStream binary.

    "PNG-files are always msb (network-world)"

    byteOrder := #msb.

    header := ByteArray new:8.

    aStream nextBytes:8 into:header.

    header = (self class pngHeader) ifFalse:[

        Logger warning:'PNGReader: not a png file (%1)' with:aStream.

        Image badImageFormatQuerySignal raiseRequestErrorString:'PNGReader: not a png file'.

        ^ nil

    ].

    (self getIHDRChunk) ifFalse:[

        Logger warning:'PNGReader: required IHDR chunk missing (%1)' with:aStream.

        Image badImageFormatQuerySignal raiseRequestErrorString:'PNGReader: required IHDR chunk missing'.

        ^ nil

    ].

    compressionMethod ~~ 0 ifTrue:[

        ('PNGReader: compressionMethod %s not supported.' printfWith:compressionMethod printString) infoPrintCR.

        Image badImageFormatQuerySignal raiseRequestErrorString:'PNGReader: unsupported compression method'.

        ^ nil

    ].

    filterMethod > 0 ifTrue:[

        'PNGReader: invalid filterMethod' infoPrintCR.

        Image badImageFormatQuerySignal raiseRequestErrorString:'PNGReader: invalid/unsupported filterMethod'.

        ^ nil.

    ].

    interlaceMode > 1 ifTrue:[

        Image badImageFormatQuerySignal raiseRequestErrorString:'PNGReader: invalid/unsupported interlaceMode'.

        'PNGReader: invalid interlaceMode' infoPrintCR.

        ^ nil.

    ].

    (self setColorType:colorType) ifFalse:[

        ^ nil

    ].

    [self getChunk] whileTrue.

    extractSpecialChunksOnly == true ifTrue:[^nil].

    "/ kludge: if we get a grey image with alpha,

    "/ load as rgb+alpha

    forceRGB := false. 

    depthImage := depth.

    "/ bytesPerScanline is always the in-bytesPerScanline

    bytesPerScanline := self bytesPerRow.

    bytesPerScanlineOut := bytesPerScanline.

    samplesPerPixel == 2 ifTrue:[

        photometric == #blackIs0 ifTrue:[

            depth == 16 ifTrue:[

                "/ force grey8+a8 into red8+green8+blue8+a8

                forceRGB := true. 

                depthImage := 32.

                bytesPerScanlineOut := width * 4.

                bitsPerSampleOut := #[8 8 8 8].

            ] ifFalse:[

                depth == 32 ifTrue:[

                    "/ force grey16+a16 into red8+green8+blue8+a8

                    forceRGB := true. 

                    depthImage := 32.

                    bytesPerScanlineOut := width * 4.

                    bitsPerSampleOut := #[8 8 8 8].

                ] ifFalse:[

                    self error:'unsupported grayscale image depth'.

                ].    

            ].    

        ].    

    ].

    data := ByteArray new:(bytesPerScanlineOut * height).

    globalDataChunk notNil ifTrue:[

        self processGlobalIDATChunk.

        globalDataChunk := nil.

    ].

    photometric == #palette ifTrue:[

        colorMap isNil ifTrue:[

            Image badImageFormatQuerySignal raiseRequestErrorString:'PNGReader: palette chunk missing'.

            'PNGReader: palette chunk missing.' infoPrintCR.

            "/ ^ nil

        ].

    ].

    paletteAlphaEntries notNil ifTrue:[

        "/ this vector now provides alpha values.

        "/ for now, we can only deal with 0/255 alpha values...

        self generateMaskFromPaletteAlphaEntries

    ].

    forceRGB ifTrue:[ 

        depth := depthImage.

        photometric := #rgba.

        bitsPerSample := bitsPerSampleOut.

        samplesPerPixel := 4.

    ].    

    "

     PNGReader fromFile:'/home/cg/libpng-0.89c/pngtest.png'

     Verbose := true.

     PNGReader fromFile:(RegressionTests::ImageReaderTest packageDirectory construct:'testData/pngImages/tbbn3p08.png')

    "

    "Modified: / 17-09-2017 / 15:30:45 / cg"

    "Modified: / 27-10-2018 / 17:29:21 / Claus Gittinger"

! !

!PNGReader methodsFor:'reading-private'!

generateMaskFromPaletteAlphaEntries

    image isNil ifTrue:[

        self makeImage

    ].

    colorType == ColorTypePalette ifTrue:[        

        image depth == 8 ifTrue:[

            "/ if there is only one entry to care for...

            (paletteAlphaEntries occurrencesOf:0) == 1 ifTrue:[

                (paletteAlphaEntries conform:[:alpha | (alpha == 0) or:[alpha == 255]]) ifTrue:[

                    image mask:(self class 

                                    buildMaskFromColor:(paletteAlphaEntries indexOf:0)-1 

                                    for:data depth:(image depth)

                                    width:width height:height).

                    ^ self

                ].    

            ].    

        ].

        "/ multiple masked pixels...

        paletteAlphaEntries keysAndValuesDo:[:pixelIndex :alpha |

            alpha == 255 ifTrue:[

                image createMaskForPixelValue:pixelIndex

            ] ifFalse:[

                alpha == 0 ifTrue:[

                    "/ ok; already

                ] ifFalse:[

                    image createMaskForPixelValue:pixelIndex

                ]    

            ].

        ].

        "/ image mask:nil.

        ^ self.

    ].

    colorType == ColorTypeGray ifTrue:[

        |maskPixel|

        maskPixel := paletteAlphaEntries unsignedInt16At:1 MSB:true.

        image createMaskForPixelValue:maskPixel.

        ^ self 

    ].    

    colorType == ColorTypeRGB ifTrue:[

        |mr mg mb maskPixel|

        mr := paletteAlphaEntries unsignedInt16At:1 MSB:true.

        mg := paletteAlphaEntries unsignedInt16At:3 MSB:true.

        mb := paletteAlphaEntries unsignedInt16At:5 MSB:true.

        depth <= 32 ifTrue:[

            "/ only use the low bits...

            mr > 255 ifTrue:[ self error:'only 8bit RGB supported'].

            mg > 255 ifTrue:[ self error:'only 8bit RGB supported'].

            mb > 255 ifTrue:[ self error:'only 8bit RGB supported'].

            maskPixel := ((mr bitShift:16) bitOr:(mg bitShift:8)) bitOr:mb.

        ] ifFalse:[

            maskPixel := ((mr bitShift:32) bitOr:(mg bitShift:16)) bitOr:mb.

        ].   

        image createMaskForPixelValue:maskPixel.

        ^ self 

    ].

    "Created: / 17-02-2017 / 08:07:04 / cg"

    "Modified: / 23-08-2017 / 17:24:30 / cg"

!

getChunk

    |len type crc|

    inStream atEnd ifTrue:[^ false].

    len := inStream nextInt32MSB:true.

    type := String new:4.

    (inStream nextBytes:4 into:type) ~~ 4 ifTrue:[^ false].

    Verbose == true ifTrue:[

        'PNGReader: chunk: ' infoPrint. type infoPrint.

        ' len: ' infoPrint. len infoPrintCR.

    ].

    type = 'IEND' ifTrue:[^ false].

    (self processChunk:type len:len) ifFalse:[^ false].

    crc := inStream nextInt32MSB:true.  "/ ignored - for now

    ^ true

    "Created: / 21-06-1996 / 21:09:36 / cg"

    "Modified: / 02-06-2018 / 06:42:58 / Claus Gittinger"

!

getIHDRChunk

    |len type crc|

    len := inStream nextInt32MSB:true.

    type := String new:4.

    inStream nextBytes:4 into:type.

    type = 'IHDR' ifFalse:[

        Logger warning:'PNGReader: expected IHDR magic (%1)' with:inStream.

        ^ false

    ].

    len == 13 ifFalse:[

        Logger warning:'PNGReader: bad IHDR size (%1)' with:inStream.

        ^ false

    ].

    width := inStream nextInt32MSB:true.        

    height := inStream nextInt32MSB:true.        

    (width <= 0 or:[height <= 0]) ifTrue:[

        Logger warning:'PNGReader: invalid dimension(s) (%1)' with:inStream.

        ^ false.

    ].

    self reportDimension.

    bitsPerChannel := inStream nextByte.

    depth := bitsPerChannel. "/ for now - might be changed by setColorType.

    colorType := inStream nextByte.

    compressionMethod := inStream nextByte.

    filterMethod := inStream nextByte.

    interlaceMode := inStream nextByte.

    Verbose == true ifTrue:[