"

 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' }"

ImageReader subclass:#PNGReader

	instanceVariableNames:'colorType bitsPerChannel depth compressionMethod filterMethod

		interlaceMode bytesPerScanline globalDataChunk thisScanline

		prevScanline'

	classVariableNames:'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 will provide methods for loading and saving PNG pictures.

    It is currenty unfinished (interlaced image support is missing).

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

    [caveats:]

        writer ignores any mask (for now).

        writer only generates unfiltered rows or interlace data

    [See also:]

        Image Form Icon

        BlitImageReader FaceReader GIFReader JPEGReader 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.

! !

!PNGReader class methodsFor:'queries'!

canRepresent:anImage

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

     Any image is supported."

    ^ true

! !

!PNGReader class methodsFor:'testing'!

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:'private-chunks'!

doPass: pass

    "Certain interlace passes are skipped with certain small image dimensions"

    pass = 1 ifTrue: [ ^ true ].

    ((width = 1) and: [height = 1]) ifTrue: [ ^ false ].

    pass = 2 ifTrue: [ ^ width >= 5 ].

    pass = 3 ifTrue: [ ^ height >= 5 ].

    pass = 4 ifTrue: [ ^ (width >=3 ) or: [height >= 5] ].

    pass = 5 ifTrue: [ ^ height >=3 ].

    pass = 6 ifTrue: [ ^ width >=2 ].

    pass = 7 ifTrue: [ ^ height >=2 ].

    self error:'invalid argument'.

    ^ true

!

processBKGDChunkLen:len

    inStream skip:len.

    ^ true

    "Created: 21.6.1996 / 21:15:49 / cg"

!

processCHRMChunkLen:len

    "cHRM Primary chromaticities chunk - currently unhandled"

    |whitePointX whitePointY redX redY greenX greenY blueX blueY|

    whitePointX := (inStream nextLongMSB:true) / 100000.0.

    whitePointY := (inStream nextLongMSB:true) / 100000.0.

    redX := (inStream nextLongMSB:true) / 100000.0.

    redY := (inStream nextLongMSB:true) / 100000.0.

    greenX := (inStream nextLongMSB:true) / 100000.0.

    greenY := (inStream nextLongMSB:true) / 100000.0.

    blueX := (inStream nextLongMSB:true) / 100000.0.

    blueY := (inStream nextLongMSB:true) / 100000.0.

    Verbose == true ifTrue:[

        'PNGReader: CHRM chunk ignored:' infoPrintCR.

        'PNGReader:   whitePointX:' infoPrint. whitePointX infoPrintCR.

        'PNGReader:   whitePointY:' infoPrint. whitePointX infoPrintCR.

        'PNGReader:   redX:' infoPrint. redX infoPrintCR.

        'PNGReader:   redY:' infoPrint. redY infoPrintCR.

        'PNGReader:   greenX:' infoPrint. greenX infoPrintCR.

        'PNGReader:   greenY:' infoPrint. greenY infoPrintCR.

        'PNGReader:   blueX:' infoPrint. blueX infoPrintCR.

        'PNGReader:   blueY:' infoPrint. blueY infoPrintCR.

    ].

    ^ true

!

processChunk:type len:len

    |chunk|

    type = 'IDAT' ifTrue:[

        "---since the compressed data can span multiple

        chunks, stitch them all together first. later,

        if memory is an issue, we need to figure out how

        to do this on the fly---"

        chunk := inStream next:len.

        globalDataChunk := globalDataChunk isNil 

                                ifTrue: [chunk] 

                                ifFalse:[globalDataChunk,chunk].

        ^ true

"/        ^ self processIDATChunkLen:len

    ].

    type = 'gAMA' ifTrue:[^ self processGAMAChunkLen:len].

    type = 'sBIT' ifTrue:[^ self processSBITChunkLen:len].

    type = 'tEXt' ifTrue:[^ self processTEXTChunkLen:len].

    type = 'tIME' ifTrue:[^ self processTIMEChunkLen:len].

    type = 'bKGD' ifTrue:[^ self processBKGDChunkLen:len].

    type = 'zTXt' ifTrue:[^ self processZTXTChunkLen:len].

    type = 'PLTE' ifTrue:[^ self processPLTEChunkLen:len].

    type = 'pHYs' ifTrue:[^ self processPHYSChunkLen:len].

    type = 'cHRM' ifTrue:[^ self processCHRMChunkLen:len].

    type = 'tRNS' ifTrue:[^ self processTRNSChunkLen:len].

    type = 'IHDR' ifTrue:[^ self processIHDRChunkLen:len].

    ('PNGReader: unrecognized chunk: ' , type , ' ignored.') infoPrintCR.

    inStream skip:len.

    ^ true.

    "Created: 21.6.1996 / 21:10:37 / cg"

    "Modified: 21.6.1996 / 21:22:37 / cg"

!

processGAMAChunkLen:len

    inStream skip:len.

    ^ true

    "Created: 21.6.1996 / 21:10:52 / cg"

!

processGlobalIDATChunk

    interlaceMode == 0 ifTrue: [

        ^ self processNonInterlacedGlobalDATA

    ]. 

    ^ self processInterlacedGlobalDATA

!

processIDATChunkLen:len

    interlaceMode == 0 ifTrue: [

        ^ self processNonInterlacedDATA:len

    ]. 

    ^ self processInterlacedDATA:len

!

processInterlacedDATA:len

    inStream skip:len.

    ^ true

!

processInterlacedGlobalDATA

    | zlibReader filter bytesPerPass startingCol colIncrement rowIncrement 

      startingRow cx sc temp "filtersSeen" bitsPerPixel copyMethod|

    self error:'interlaced pictures not yet supported'.

    "/ filtersSeen := Set new.

    startingCol := #(0 4 0 2 0 1 0 ).

    colIncrement := #(8 8 4 4 2 2 1 ).

    rowIncrement := #(8 8 8 4 4 2 2 ).

    startingRow := #(0 0 4 0 2 0 1 ).

    zlibReader := ZipStream readOpenAsZipStreamOn:(globalDataChunk readStream) suppressHeaderAndChecksum:false.

    zlibReader binary.

    bytesPerScanline := self bytesPerRow.

    bitsPerPixel := self bitsPerPixel.

    copyMethod := #(copyPixelsGray: nil copyPixelsRGB: copyPixelsIndexed:

                    copyPixelsGrayAlpha: nil copyPixelsRGBA:) at:colorType+1.     

    1 to: 7 do: [:pass |

        (self doPass: pass) ifTrue:[

            cx := colIncrement at: pass.

            sc := startingCol at: pass.

            bytesPerPass := width - sc + cx - 1 // cx * bitsPerPixel + 7 // 8.

            prevScanline := ByteArray new: bytesPerPass.

            thisScanline := ByteArray new: bytesPerScanline.

            (startingRow at: pass) to: height - 1 by: (rowIncrement at: pass) do: [:y |

                filter := zlibReader next.

                "/ filtersSeen add: filter.

                (filter isNil or: [(filter between: 0 and: 4) not])

                    ifTrue: [^ self].

                zlibReader next: bytesPerPass into: thisScanline startingAt: 1.

                filter ~~ 0 ifTrue:[ self filterScanline: filter count: bytesPerPass ].

                self copyPixels:y at:sc by:cx.

                temp := prevScanline.

                prevScanline := thisScanline.

                thisScanline := temp.

            ]

        ]

    ].

    zlibReader atEnd ifFalse:[self error:'Unexpected data'].

!

processNonInterlacedDATA:len

    self halt:'not used'

"/

"/    | zlibReader filter temp prevScanline thisScanline bytesPerScanline filtersSeen|

"/

"/    zlibReader := ZipStream readOpenAsZipStreamOn:inStream suppressHeaderAndChecksum:false. 

"/    "/ zlibReader := ZLibReadStream on:inStream from: 1 to:len.

"/

"/    prevScanline := ByteArray new: self bytesPerRow.

"/    thisScanline := ByteArray new: self bytesPerRow.

"/    0 to: height - 1 do:[:index | 

"/            filter := (zlibReader next: 1) first.

"/            filtersSeen add: filter.

"/            (filter isNil or: [(filter between: 0 and: 4) not]) ifTrue: [^self].

"/            thisScanline := zlibReader next: bytesPerScanline into: thisScanline startingAt: 1.

"/            self filterScanline: filter count: bytesPerScanline.

"/            self copyPixels: index.

"/            temp := prevScanline.

"/            prevScanline := thisScanline.

"/            thisScanline := temp

"/    ]

!

processNonInterlacedGlobalDATA

    | "data n" zlibReader filter temp bytesPerScanline "filtersSeen" i|

    "/ filtersSeen := Set new.

"/    data := ByteArray new:(self bytesPerRow * height)+1000.

"/    n := ZipStream uncompress: globalDataChunk into: data.

"/    self halt.

    zlibReader := ZipStream readOpenAsZipStreamOn:(globalDataChunk readStream) suppressHeaderAndChecksum:false.

    zlibReader binary.

    bytesPerScanline := self bytesPerRow.

    prevScanline := ByteArray new: bytesPerScanline.

    thisScanline := ByteArray new: bytesPerScanline.

    0 to: height - 1 do:[:y | 

        filter := (zlibReader next: 1) first.

        "/ filtersSeen add: filter.

        (filter notNil and: [filter between: 0 and: 4]) ifFalse: [

            'PNGReader: unsupported filter' infoPrintCR.

            ^ self

        ].

        zlibReader next: bytesPerScanline into: thisScanline startingAt: 1.

        filter ~~ 0 ifTrue:[ self filterScanline: filter count: bytesPerScanline ].

        i := y * bytesPerScanline.

        data replaceFrom:i+1 to:(i+bytesPerScanline) with:thisScanline startingAt:1.

        temp := prevScanline.

        prevScanline := thisScanline.

        thisScanline := temp

    ]

!

processPHYSChunkLen:len

    "physical pixel chunk - currently unhandled"

    |pixelPerUnitX pixelPerUnitY unit|

    pixelPerUnitX := inStream nextLongMSB:true.  

    pixelPerUnitY := inStream nextLongMSB:true.

    unit := inStream nextByte.

    Verbose == true ifTrue:[

        'PNGReader: PHYS chunk ignored:' infoPrintCR.

        'PNGReader:   ppuX:' infoPrint. pixelPerUnitX infoPrintCR.

        'PNGReader:   ppuY:' infoPrint. pixelPerUnitY infoPrintCR.

        'PNGReader:   unit:' infoPrint. unit infoPrintCR.

    ].

    ^ true

!

processPLTEChunkLen:len

    "read a color palette"

    |n "{ Class: SmallInteger }"

     redBytes greenBytes blueBytes|

    (len \\ 3) ~~ 0 ifTrue:[

        'PNGReader: invalid size of PLTE chunk' infoPrintCR.

        ^ false

    ].

    n := len // 3.

    redBytes := ByteArray new:n.

    greenBytes := ByteArray new:n.

    blueBytes := ByteArray new:n.

    1 to:n do:[:i |

        redBytes at:i put:(inStream nextByte).

        greenBytes at:i put:(inStream nextByte).

        blueBytes at:i put:(inStream nextByte)

    ].

    colorMap := MappedPalette 

                    redVector:redBytes 

                    greenVector:greenBytes 

                    blueVector:blueBytes.

    ^ true

    "Created: 21.6.1996 / 21:22:28 / cg"

    "Modified: 21.6.1996 / 21:43:01 / cg"

!

processSBITChunkLen:len

    inStream skip:len.

    ^ true

    "Created: 21.6.1996 / 21:13:09 / cg"

!

processTEXTChunkLen:len

    inStream skip:len.

    ^ true

    "Modified: 21.6.1996 / 21:15:27 / cg"

!

processTIMEChunkLen:len

    inStream skip:len.

    ^ true

    "Created: 21.6.1996 / 21:15:43 / cg"

    "Modified: 21.6.1996 / 21:20:42 / cg"

!

processTRNSChunkLen:len

    inStream skip:len.

    ^ true

!

processZTXTChunkLen:len

    inStream skip:len.

    ^ true

    "Created: 21.6.1996 / 21:15:58 / cg"

! !

!PNGReader methodsFor:'private-filtering'!

filterAverage: count

    "Use the average of the pixel to the left and the pixel above as a predictor"

    | delta |

    delta := self bitsPerPixel // 8 max: 1.

    1 to: delta do: [:i |

        thisScanline at: i put: ((thisScanline at: i) + ((prevScanline at: i) // 2) bitAnd: 255)].

    delta + 1 to: count do: [:i |

        thisScanline at: i put:

            ((thisScanline at: i)

            + ((prevScanline at: i)

            + (thisScanline at: i - delta) // 2) bitAnd: 255)]

!

filterHorizontal:count

    "use the pixel to the left as a predictor"

    |delta|

    delta := self bitsPerPixel // 8 max:1.

    delta+1 to:count do:[:i|

        thisScanline at:i put:(((thisScanline at:i)+ (thisScanline at:i-delta)) bitAnd:255) 

    ]

!

filterNone: count

!

filterPaeth: count

    "Select one of (the pixel to the left, the pixel above and the pixel to above left) to

    predict the value of this pixel"

    | delta |

    delta _ self bitsPerPixel // 8 max: 1.

    1 to: delta do: [ :i |

        thisScanline at: i put:

            (((thisScanline at: i) + (prevScanline at: i)) bitAnd: 255)].

    delta+1 to: count do: [ :i |

        thisScanline

            at: i

            put: (((thisScanline at: i) + (self

                paethPredictLeft: (thisScanline at: i-delta)

                above: (prevScanline at: i)

                aboveLeft: (prevScanline at: i-delta)))

                    bitAnd: 255)]

!

filterScanline:filterType count:count

    self 

        perform:(#(filterNone: filterHorizontal: filterVertical: filterAverage: filterPaeth:)

                    at:filterType+1)

        with:count

!

filterVertical: count

    "Use the pixel above as a predictor"

    1 to: count do: [ :i |

        thisScanline at: i put: (((thisScanline at: i) +

                                 (prevScanline at: i)) bitAnd: 255) 

    ]