"

 COPYRIGHT (c) 1995 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:libview' }"

"{ NameSpace: Smalltalk }"

Image subclass:#Depth32Image

	instanceVariableNames:''

	classVariableNames:'RGBA_R_OFFSET_NET RGBA_G_OFFSET_NET RGBA_B_OFFSET_NET

		RGBA_A_OFFSET_NET'

	poolDictionaries:''

	category:'Graphics-Images'

!

!Depth32Image class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1995 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 represents 32 bit images.

    Only the minimum protocol is implemented here; much more is

    needed for higher performance operations on depth32 images.

    (however, 32bit images are very seldom used, so falling back into the

    slow general methods from Image should not hurt too much ..)

    [author:]

	Claus Gittinger

    [see also:]

	Depth1Image Depth2Image Depth4Image Depth8Image Depth16Image Depth24Image

	ImageReader

"

! !

!Depth32Image class methodsFor:'initialization'!

initialize

    RGBA_A_OFFSET_NET := 4.

    RGBA_B_OFFSET_NET := 3.

    RGBA_G_OFFSET_NET := 2.

    RGBA_R_OFFSET_NET := 1.

    "Created: / 28-02-2016 / 11:29:08 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 28-02-2016 / 14:36:04 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!Depth32Image class methodsFor:'queries'!

defaultPhotometric

    "return the default photometric pixel interpretation"

    ^ #rgb

    "Created: / 27-05-2007 / 14:03:59 / cg"

    "Modified: / 06-06-2007 / 11:12:13 / cg"

!

imageDepth

    "return the depth of images represented by instances of

     this class - here we return 32"

    ^ 32

    "Modified: 20.4.1996 / 23:40:01 / cg"

    "Created: 24.4.1997 / 19:00:28 / cg"

! !

!Depth32Image methodsFor:'accessing'!

bitsARGB32Into: buffer startingAt: first stride: stride

    "Store each pixel is a 32-bit quantity, with alpha in the upper 

     8 bits, then red, then green, then blue. The 32-bit quantities are 

     stored native-endian. Pre-multiplied alpha is used. (That is, 50% 

     transparent red is 0x80800000, not 0x80ff0000.)

     IMPORTANT: The following code assumes that the data (`bytes` instvar)

     are stored in network byte order with NON-premultiplied alpha. This is

     true for PNG data.

     NOTE: This is a good candidate for C-level optimization.

    "

    | base pixelIndex bufferIndex  a r g b |

    pixelFunction isNil ifTrue:[ 

        photometric == #rgba ifTrue:[

            bitsPerSample = #(8 8 8 8) ifTrue:[ 

                1 to: height do:[:y |  

                    base := ((y - 1) * stride) + first - 1.

                    1 to: width do:[:x |  

                        pixelIndex := ((((y - 1) * width) + (x - 1)) * 4).

                        "/ Extract components...

                        a := bytes at: pixelIndex + RGBA_A_OFFSET_NET.

                        r := bytes at: pixelIndex + RGBA_R_OFFSET_NET.

                        g := bytes at: pixelIndex + RGBA_G_OFFSET_NET.

                        b := bytes at: pixelIndex + RGBA_B_OFFSET_NET.

                        "/ Pre-multiply

                        r := (r * a) // 255.

                        g := (g * a) // 255.

                        b := (b * a) // 255.

                        "/ Assemble pixel

                        bufferIndex := base + ((x - 1) * 4).

                        buffer at: bufferIndex + ARGB_A_OFFSET_MACHINE put: a.

                        buffer at: bufferIndex + ARGB_R_OFFSET_MACHINE put: r.

                        buffer at: bufferIndex + ARGB_G_OFFSET_MACHINE put: g.

                        buffer at: bufferIndex + ARGB_B_OFFSET_MACHINE put: b.

                    ]

                ].

                ^ self.

            ].

        ].

        photometric == #argb ifTrue:[ 

            self notYetImplemented.

            ^ self.

        ].

    ].

    ^ super bitsARGB32Into: buffer startingAt: first stride: stride

    "Created: / 28-02-2016 / 06:54:40 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified (comment): / 28-02-2016 / 14:44:21 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!Depth32Image methodsFor:'accessing-pixels'!

colorAtX:x y:y

    "retrieve a pixel at x/y; return a color.

     Pixels start at x=0 , y=0 for upper left pixel, 

     end at x = width-1, y=height-1 for lower right pixel"

    |index "{ Class: SmallInteger }"

     rVal gVal bVal aVal|

    index := 1 + (((width * y) + x) * 4).

    photometric == #rgb ifTrue:[

        rVal := bytes at:(index).

        gVal := bytes at:(index + 1).

        bVal := bytes at:(index + 2).

        ^ Color redByte:rVal greenByte:gVal blueByte:bVal

    ].

    photometric == #rgba ifTrue:[

        rVal := bytes at:(index).

        gVal := bytes at:(index + 1).

        bVal := bytes at:(index + 2).

        aVal := bytes at:(index + 3).

        ^ Color redByte:rVal greenByte:gVal blueByte:bVal alphaByte:aVal

    ].

    photometric == #argb ifTrue:[

        aVal := bytes at:(index).

        rVal := bytes at:(index + 1).

        gVal := bytes at:(index + 2).

        bVal := bytes at:(index + 3).

        ^ Color redByte:rVal greenByte:gVal blueByte:bVal alphaByte:aVal

    ].

    "/ the inherited method should handle all cases.

    ^ super colorAtX:x y:y. 

!

colorAtX:x y:y put:aColor

    "set the pixel at x/y to aColor.

     Pixels start at x=0 , y=0 for upper left pixel, end at

     x = width-1, y=height-1 for lower right pixel."

    |index "{ Class: SmallInteger }"|

    ((photometric == #rgba) or:[photometric == #rgb]) ifTrue:[

        index := 1 + (((width * y) + x) * 4).

        bytes at:(index) put:(aColor redByte).

        bytes at:(index + 1) put:(aColor greenByte).

        bytes at:(index + 2) put:(aColor blueByte).

        bytes at:(index + 3) put:255.               "alpha channel"

        ^ self

    ].

    (photometric == #argb) ifTrue:[

        index := 1 + (((width * y) + x) * 4).

        bytes at:(index) put:255.                   "alpha channel"

        bytes at:(index + 1) put:(aColor redByte).

        bytes at:(index + 2) put:(aColor greenByte).

        bytes at:(index + 3) put:(aColor blueByte).             

        ^ self

    ].

    super colorAtX:x y:y put:aColor. 

!

pixelAtX:x y:y

    "retrieve a pixel at x/y; return a pixelValue.

     The interpretation of the returned value depends on the photometric

     and the colormap. See also Image>>atX:y:)

     Pixels start at x=0 , y=0 for upper left pixel, end at

     x = width-1, y=height-1 for lower right pixel.

     The pixel value contains r/g/b/a in msb order (i.e. r at high, a at low bits)"

    |pixelIndex "{ Class: SmallInteger }"|

%{  /* NOCONTEXT */

    OBJ b = __INST(bytes);

    OBJ w = __INST(width);

    if (__isByteArrayLike(b)

     && __bothSmallInteger(x, y)

     && __isSmallInteger(w)

     && (__INST(pixelFunction)==nil) ) {

        int _idx;

        _idx = ((__intVal(w) * __intVal(y)) + __intVal(x))*4;

        if (((unsigned)(_idx+3)) < __byteArraySize(b)) {

            unsigned char *pPix = &(__ByteArrayInstPtr(b)->ba_element[_idx]);

            unsigned int _pix;

            _pix = (((((pPix[0]<<8)+pPix[1])<<8)+pPix[2])<<8)+pPix[3];

#if __POINTER_SIZE__ == 8

            RETURN( __MKSMALLINT(_pix) );

#else

            RETURN( __MKUINT(_pix) );

#endif

        }

    }

%}.

    pixelFunction notNil ifTrue:[^ pixelFunction value:x value:y].

    pixelIndex := 1 + (((width * y) + x) * 4).

    "left pixel in high bits"

    ^ bytes unsignedInt32At:pixelIndex MSB:true.

    "Created: 24.4.1997 / 19:00:28 / cg"

    "Modified: 24.4.1997 / 23:11:05 / cg"

!

pixelAtX:x y:y put:aPixelValue

    "set the pixel at x/y to aPixelValue.

     The interpretation of the pixelValue depends on the photometric

     and the colormap. (see also: Image>>atX:y:put:)

     Pixels start at x=0 , y=0 for upper left pixel, end at

     x = width-1, y=height-1 for lower right pixel"

    |pixelIndex "{ Class: SmallInteger }"|

    pixelIndex := 1 + (((width * y) + x) * 4).

    bytes isNil ifTrue:[

        self createPixelStore

    ].

    bytes unsignedInt32At:pixelIndex put:aPixelValue MSB:true

    "Created: / 24-04-1997 / 19:00:28 / cg"

    "Modified: / 06-06-2007 / 12:20:57 / cg"

!

rowAt:y putAll:pixelArray startingAt:startIndex

    "store a single rows bits from bits in the pixelArray argument;

     Return the pixelArray.

     Notice: row coordinate starts at 0."

    |bytes dstIdx pixel 

     w "{ Class: SmallInteger }"|

    bytes := self bits.

    dstIdx := (y * self bytesPerRow) + 1.

    w := width - 1.

    0 to:w do:[:col |

        pixel := pixelArray at:(startIndex + col).

        bytes unsignedInt32At:dstIdx put:pixel MSB:true.

        dstIdx := dstIdx + 4.

    ].

    ^ pixelArray

! !

!Depth32Image methodsFor:'converting rgb images'!

computeAlphaValuesFromMask:aMaskImage

    "convert a mask into alpha values;

     masked pixels get an alpha value of 0,

     unmasked of 255"

    |alphaMask|

    alphaMask := self alphaMaskForPixelValue.

    self valuesFromX:0 y:0

                 toX:width-1 y:height-1

                  do:[:x :y :pixelValue |

        (aMaskImage pixelAtX:x y:y) ~~ 0 ifTrue:[

            self pixelAtX:x y:y put:(pixelValue bitOr:alphaMask).

        ] ifFalse:[

            self pixelAtX:x y:y put:(pixelValue bitClear:alphaMask).

        ].

    ].

    photometric := #rgba

!

rgbImageAsTrueColorFormOn:aDevice

    "return a truecolor form from the rgba or argb-picture."

    |bytes bestFormat usedDeviceDepth usedDeviceBitsPerPixel usedDevicePadding

     myDepth form imageBits padd

     rightShiftR rightShiftG rightShiftB shiftRed shiftGreen shiftBlue|

    bytes := self bits.

    bestFormat := self bestSupportedImageFormatFor:aDevice.

    usedDeviceDepth := bestFormat at:#depth.

    usedDeviceBitsPerPixel := bestFormat at:#bitsPerPixel.

    usedDevicePadding := bestFormat at:#padding.

    rightShiftR := (8 - aDevice bitsRed).

    rightShiftG := (8 - aDevice bitsGreen).

    rightShiftB := (8 - aDevice bitsBlue).

    shiftRed := aDevice shiftRed.

    shiftGreen := aDevice shiftGreen.

    shiftBlue := aDevice shiftBlue.

    "/

    "/ for now, only a few formats are supported

    "/

    myDepth := self bitsPerPixel.

    usedDeviceBitsPerPixel == 24 ifTrue:[

        "/

        "/ 24 bit/pixel

        "/

        imageBits := ByteArray uninitializedNew:(width * height * 3).

        usedDevicePadding := 8.

        "/ now, walk over the image and compose 24bit values from the r/g/b/a triples

%{

        unsigned char *srcPtr = 0;

        unsigned char *dstPtr = 0;

        int redOffs = 0;

        int greenOffs = 1;  

        int blueOffs = 2;

        int alphaOffs = 3;

        if (__INST(photometric) == @symbol(argb)) {

            redOffs = 1; greenOffs = 2; blueOffs = 3; alphaOffs = 0;

        }

        if (__isByteArrayLike(bytes)) {

            srcPtr = __ByteArrayInstPtr(bytes)->ba_element;

        } else {

            if (__isExternalBytesLike(bytes)) {

                srcPtr = __externalBytesAddress(bytes);

            }

        }

        if (__isByteArray(imageBits)) {

            dstPtr = __ByteArrayInstPtr(imageBits)->ba_element;

        } else {

            if (__isExternalBytesLike(imageBits)) {

                dstPtr = __externalBytesAddress(imageBits);

            }

        }

        if (__bothSmallInteger(__INST(height), __INST(width))

         && __bothSmallInteger(rightShiftR, shiftRed)

         && __bothSmallInteger(rightShiftG, shiftGreen)

         && __bothSmallInteger(rightShiftB, shiftBlue)

         && srcPtr

         && dstPtr) {

            int rShRed = __intVal(rightShiftR),

                rShGreen = __intVal(rightShiftG),

                rShBlue = __intVal(rightShiftB),

                lShRed = __intVal(shiftRed),

                lShGreen = __intVal(shiftGreen),

                lShBlue = __intVal(shiftBlue);

            int x, y, w;

            w = __intVal(__INST(width));

            if ((rShRed == 0) && (rShGreen == 0) && (rShBlue == 0)) {

                if ((lShRed == 0) && (lShGreen == 8) && (lShBlue == 16)) {

                    for (y=__intVal(__INST(height)); y > 0; y--) {

                        for (x=w; x > 0; x--) {                        

# ifdef __MSBFIRST

                            dstPtr[0] = srcPtr[redOffs];

                            dstPtr[1] = srcPtr[greenOffs];

                            dstPtr[2] = srcPtr[blueOffs];

# else /* not MSB */

                            dstPtr[0] = srcPtr[blueOffs];

                            dstPtr[1] = srcPtr[greenOffs];

                            dstPtr[2] = srcPtr[redOffs];

# endif /* not MSB */

                            dstPtr += 3;

                            srcPtr += 4;

                        }

                    }

                } else {

                    for (y=__intVal(__INST(height)); y > 0; y--) {

                        for (x=w; x > 0; x--) {

                            unsigned v;

                            v = srcPtr[redOffs] << lShRed;

                            v |= (srcPtr[greenOffs] << lShGreen);

                            v |= (srcPtr[blueOffs] << lShBlue);

# ifdef __MSBFIRST

                            dstPtr[0] = (v) & 0xFF;

                            dstPtr[1] = (v>>8) & 0xFF;

                            dstPtr[2] = (v>>16) & 0xFF;

# else /* not MSB */

                            dstPtr[0] = (v>>16) & 0xFF;

                            dstPtr[1] = (v>>8) & 0xFF;

                            dstPtr[2] = (v) & 0xFF;

# endif /* not MSB */

                            dstPtr += 3;

                            srcPtr += 4;

                        }

                    }

                }

            } else {

                for (y=__intVal(__INST(height)); y > 0; y--) {

                    for (x=w; x > 0; x--) {

                        unsigned r, g, b, v;

                        r = srcPtr[redOffs] >> rShRed;

                        g = srcPtr[greenOffs] >> rShGreen;

                        b = srcPtr[blueOffs] >> rShBlue;

                        v = r << lShRed;

                        v |= (g << lShGreen);

                        v |= (b << lShBlue);

# ifdef __MSBFIRST

                        dstPtr[0] = (v) & 0xFF;

                        dstPtr[1] = (v>>8) & 0xFF;

                        dstPtr[2] = (v>>16) & 0xFF;

# else /* not MSB */

                        dstPtr[0] = (v>>16) & 0xFF;

                        dstPtr[1] = (v>>8) & 0xFF;

                        dstPtr[2] = (v) & 0xFF;

# endif /* not MSB */

                        dstPtr += 3;

                        srcPtr += 4;

                    }

                }

            }

        }

%}.

    ] ifFalse:[

        "/

        "/ 8, 16 or 32 bit/pixel ...

        "/

        (usedDeviceBitsPerPixel == 16) ifTrue:[

            padd := width \\ (usedDevicePadding // 16).

            imageBits := ByteArray uninitializedNew:((width + padd) * height * 2).

            "/ now, walk over the image and compose 16bit values from the r/g/b triples

%{

            unsigned char *srcPtr = 0;

            unsigned char *dstPtr = 0;

            int redOffs = 0;

            int greenOffs = 1;  

            int blueOffs = 2;

            int alphaOffs = 3;

            if (__INST(photometric) == @symbol(argb)) {

                redOffs = 1; greenOffs = 2; blueOffs = 3; alphaOffs = 0;

            }

            if (__isByteArrayLike(bytes)) {

                srcPtr = __ByteArrayInstPtr(bytes)->ba_element;

            } else {

                if (__isExternalBytesLike(bytes)) {

                    srcPtr = __externalBytesAddress(bytes);

                }

            }

            if (__isByteArray(imageBits)) {

                dstPtr = __ByteArrayInstPtr(imageBits)->ba_element;

            } else {

                if (__isExternalBytesLike(imageBits)) {

                    dstPtr = __externalBytesAddress(imageBits);

                }

            }