"

 COPYRIGHT (c) 1993 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:#WindowsIconReader

	instanceVariableNames:'compression inDepth topDown'

	classVariableNames:''

	poolDictionaries:''

	category:'Graphics-Images-Readers'

!

!WindowsIconReader class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 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

"

    Image writing is only supported for BMP format with depth 1,4,8 and 24 bit images.

    The reader tries to figure out which version of BMP/ICO is used.

    It seems to be able to load most formats, but who knows ...

    The class name *IconReader is a bad, historic choice - it ws originally

    written to read icons only, but evolved over time and is now also

    capable of reading/writing bmp and cursor files.

    [See also:]

        Image Form Icon

        BlitImageReader FaceReader GIFReader JPEGReader PBMReader PCXReader

        ST80FormReader SunRasterReader TargaReader TIFFReader

        XBMReader XPMReader XWDReader

"

!

fileFormatDescription

"

    Information from http://www.daubnet.com/formats/BMP.html - no Warranty.

          Name           Size                Description

      Header            14 bytes            Windows Structure: BITMAPFILEHEADER

          Signature      2 bytes             'BM'

          FileSize       4 bytes             File size in bytes

          reserved       4 bytes             unused (=0)

          DataOffset     4 bytes             File offset to Raster Data

      InfoHeader        40 bytes            Windows Structure: BITMAPINFOHEADER

          Size           4 bytes             Size of InfoHeader =40

          Width          4 bytes             Bitmap Width

          Height         4 bytes             Bitmap Height

          Planes         2 bytes             Number of Planes (=1)

          BitCount       2 bytes             Bits per Pixel

                                             1 = monochrome palette. NumColors = 1

                                             4 = 4bit palletized. NumColors = 16

                                             8 = 8bit palletized. NumColors = 256

                                             16 = 16bit RGB. NumColors = 65536 (?)

                                             24 = 24bit RGB. NumColors = 16M

          Compression    4 bytes             Type of Compression

                                             0 = RGB            no compression

                                             1 = RLE8           8bit RLE encoding

                                             2 = RLE4           4bit RLE encoding

                                             3 = BITFIELDS      Windows V3+ only

                                             4 = JPEG           Windows V3+ only

                                             5 = PNG            Windows V3+ only

                                             3 = HUFFMAN1D      OS/2 2.x-only

                                             4 = RLE24          OS/2 2.x-only

          ImageSize      4 bytes             (compressed) Size of Image

                                             It is valid to set this =0 if Compression = 0

          XpixelsPerM    4 bytes             horizontal resolution: Pixels/meter

          YpixelsPerM    4 bytes             vertical resolution: Pixels/meter

          ColorsUsed     4 bytes             Number of actually used colors

          ColorsImportant

                         4 bytes             Number of important colors

                                             0 = all

       ColorTable        4 * NumColors bytes

                                             present only if Info.BitsPerPixel <= 8

                                             colors should be ordered by importance

            Red           1 byte              Red intensity

            Green         1 byte              Green intensity

            Blue          1 byte              Blue intensity

            reserved      1 byte             unused (=0)

          repeated NumColors times

       Raster Data      Info.ImageSize bytes     The pixel data

Raster Data encoding:

       Depending on the image's BitCount and on the Compression flag there are 6 different encoding schemes.

       All of them share the following:

       Pixels are stored bottom-up, left-to-right. Pixel lines are padded with zeros to end on a 32bit (4byte) boundary. For

       uncompressed formats every line will have the same number of bytes. Color indices are zero based, meaning a pixel

       color of 0 represents the first color table entry, a pixel color of 255 (if there are that many) represents the 256th entry.

       For images with more than 256 colors there is no color table.

Raster Data encoding for 1bit / black & white images:

       BitCount = 1 Compression = 0

       Every byte holds 8 pixels, its highest order bit representing the leftmost pixel of those. There are 2 color table entries.

       Some readers will ignore them though, and assume that 0 is black and 1 is white. If you are storing black and white

       pictures you should stick to this, with any other 2 colors this is not an issue. Remember padding with zeros up to a

       32bit boundary (This can be up to 31 zeros/pixels!!)

Raster Data encoding for 4bit / 16 color images:

       BitCount = 4 Compression = 0

       Every byte holds 2 pixels, its high order 4 bits representing the left of those. There are 16 color table entries. These

       colors do not have to be the 16 MS-Windows standard colors. Padding each line with zeros up to a 32bit boundary

       will result in up to 28 zeros = 7 'wasted pixels'.

Raster Data encoding for 8bit / 256 color images:

       BitCount = 8 Compression = 0

       Every byte holds 1 pixel. There are 256 color table entries. Padding each line with zeros up to a 32bit boundary will

       result in up to 3 bytes of zeros = 3 'wasted pixels'.

Raster Data encoding for 16bit / hicolor images:

       BitCount = 16 Compression = 0

       Every 2bytes / 16bit holds 1 pixel.

       <information missing: the 16 bit was introduced together with Video For Windows? Is it a memory-only-format?>

       The pixels are no color table pointers. There are no color table entries. Padding each line with zeros up to a 16bit

       boundary will result in up to 2 zero bytes.

Raster Data encoding for 24bit / truecolor images:

       BitCount = 24 Compression = 0

       Every 4bytes / 32bit holds 1 pixel. The first holds its red, the second its green, and the third its blue intensity. The

       fourth byte is reserved and should be zero. There are no color table entries. The pixels are no color table pointers. No

       zero padding necessary.

Raster Data compression for 4bit / 16 color images:

       BitCount = 4 Compression = 2

       The pixel data is stored in 2bytes / 16bit chunks.  The first of these specifies the number of consecutive pixels with the

       same pair of color. The second byte defines two color indices. The resulting pixel pattern will be interleaved

       high-order 4bits and low order 4 bits (ABABA...). If the first byte is zero, the second defines an escape code. The

       End-of-Bitmap is zero padded to end on a 32bit boundary. Due to the 16bit-ness of this structure this will always be

       either two zero bytes or none.

        n (byte 1) c (Byte 2)                                       Description

        >0        any      n pixels are to be drawn. The 1st, 3rd, 5th, ... pixels' color is in c's high-order 4 bits, the even

                            pixels' color is in c's low-order 4 bits. If both color indices are the same, it results in just n

                            pixels of color c

        0         0        End-of-line

        0         1        End-of-Bitmap

        0         2        Delta. The following 2 bytes define an unsigned offset in x and y direction (y being up) The

                            skipped pixels should get a color zero.

        0         >=3      The following c bytes will be read as single pixel colors just as in uncompressed files. up to 12

                            bits of zeros follow, to put the file/memory pointer on a 16bit boundary again.

                                      Example for 4bit RLE

        Compressed Data                           Expanded data

        03 04              0 4 0

        05 06              0 6 0 6 0

        00 06 45 56 67 00  4 5 5 6 6 7

        04 78              7 8 7 8

        00 02 05 01        Move 5 right and 1 up. (Windows docs say down, which is wrong)

        00 00              End-of-line

        09 1E              1 E 1 E 1 E 1 E 1

        00 01              EndofBitmap

        00 00              Zero padding for 32bit boundary

Raster Data compression for 8bit / 256 color images:

       BitCount = 8 Compression = 1

       The pixel data is stored in 2bytes / 16bit chunks.  The first of these specifies the number of consecutive pixels with the

       same color. The second byte defines their color index. If the first byte is zero, the second defines an escape code. The

       End-of-Bitmap is zero padded to end on a 32bit boundary. Due to the 16bit-ness of this structure this will always be

       either two zero bytes or none.

        n (byte 1)   c (Byte 2)                                    Description

        >0       any        n pixels of color number c

        0        0          End-of-line

        0        1          End Of Bitmap

        0        2          Delta. The following 2 bytes define an unsigned offset in x and y direction (y being up) The

                            skipped pixels should get a color zero.

        0        >=3        The following c bytes will be read as single pixel colors just as in uncompressed files. A zero

                            follows, if c is odd, putting the file/memory pointer on a 16bit boundary again.

                                      Example for 8bit RLE

        Compressed Data                           Expanded data

        03 04              04 04 04

        05 06              06 06 06 06 06

        00 03 45 56 67 00  45 56 67

        02 78              78 78

        00 02 05 01        Move 5 right and 1 up. (Windows docs say down, which is wrong)

        00 00              End-of-line

        09 1E              1E 1E 1E 1E 1E 1E 1E 1E 1E

        00 01              End-of-bitmap

        00 00              Zero padding for 32bit boundary

Portability:

       Although BMPs were invented by Microsoft for its Windows platform, a lot of programs on other platforms are capable

       of reading and writing them. Notice the Intel order in 2byte and 4-byte integer values (Least significant byte first). The

       16bit BMPs have been introduced to Windows after the others, still puzzling many applications.

Trademarks, Patents and Royalties

       To my knowledge: None.

"

! !

!WindowsIconReader class methodsFor:'initialization'!

initialize

    "tell Image-class, that a new fileReader is present

     for the '.bmp' and '.ico' extensions."

    MIMETypes defineImageType:'image/x-MS-bitmap' suffix:'bmp' reader:self.

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

    MIMETypes defineImageType:nil                 suffix:'ico' reader:self.

    "Modified: 1.2.1997 / 15:03:59 / cg"

! !

!WindowsIconReader class methodsFor:'testing'!

canRepresent:anImage

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

     BMP supports depth 1,4,8 and 24."

    (#(1 4 8 24) includes:anImage depth) ifTrue:[^true].

    ('WindwsIconReader [info]: image depth is not 1,4,8 or 24.') infoPrintCR.

    ^ false

    "Created: 17.10.1997 / 20:18:23 / cg"

!

isValidImageFile:aFileName

    "return true, if aFileName contains a valid windows bitmap-file image"

    |inStream header ok|

    inStream := self streamReadingFile:aFileName.

    inStream isNil ifTrue:[^ false].

    inStream binary.

    ok := false.

    inStream fileSize > 16 ifTrue:[

	header := ByteArray uninitializedNew:4.

	inStream nextBytes:4 into:header.

	(header startsWith:#(66 77)) ifTrue:[     "BM"

	    ok := true.

"/            'WINREADER: Win3.x or OS/2 vsn 2 BM format' infoPrintNL.

	].

	(header startsWith:#(66 65)) ifTrue:[     "BA"

	    ok := true.

"/            'WINREADER: OS/2 vsn 2 BA format' infoPrintNL.

	].

	(header startsWith:#(73 67)) ifTrue:[     "IC"

	    ok := true.

"/            'WINREADER: OS/2 IC format' infoPrintNL.

	].

	(header startsWith:#(80 84)) ifTrue:[     "PT"

	    ok := true.

"/            'WINREADER: OS/2 PT format' infoPrintNL.

	].

	(header startsWith:#(0 0 1 0)) ifTrue:[

	    ok := true.

"/            'WINREADER: Win3.x ICO format' infoPrintNL.

	].

    ].

    inStream close.

    ^ ok

    "

     WindowsIconReader isValidImageFile:'/phys/clam2/LocalLibrary/Images/OS2_icons/dos.ico'

    "

    "Created: 17.9.1995 / 17:14:20 / claus"

! !

!WindowsIconReader methodsFor:'private'!

swapBytesFromRGB_to_BGR

    |idx bytesPerRow|

    "/ Depth24Image keeps its data r/g/b; BMP has it b/g/r (sigh)

    idx := 1.

    bytesPerRow := self bytesPerRow.

    1 to:height do:[:y |

    ].

! !

!WindowsIconReader methodsFor:'private-reading'!

loadBMP1From:aStream into:aByteArray

    "load bmp-1 bit per pixel imagedata."

    compression == 0 ifFalse:[

	^ false

    ].

    ^ self loadUncompressedFrom:aStream into:aByteArray

!

loadBMP2From:aStream into:aByteArray

    "load bmp-2 bit per pixel imagedata."

    compression == 0 ifFalse:[

	^ false

    ].

    ^ self loadUncompressedFrom:aStream into:aByteArray

!

loadBMP4From:aStream into:aByteArray

    "load bmp-4 bit per pixel imagedata."

    compression == 0 ifTrue:[

	^ self loadUncompressedFrom:aStream into:aByteArray

    ].

    compression == 2 ifTrue:[

	^ self loadRLECompressedBMP4From:aStream into:aByteArray

    ].

    ^ false

!

loadBMPWidth:w height:h bytesPerPixel:bpp from:aStream into:data

    "load bmp-16/24/32 bit per pixel imagedata."

    |buff dstIdx fileBytesPerRow imgBytesPerRow align lineDelta|

    align := 4.

    ((compression == 0) or:[compression == 3]) ifTrue:[

        imgBytesPerRow := w * bpp.

        fileBytesPerRow := imgBytesPerRow.

        (fileBytesPerRow bitAnd:(align-1)) ~~ 0 ifTrue:[

            fileBytesPerRow := (fileBytesPerRow bitAnd:((align-1) bitInvert)) + align.

        ].

        "/

        "/ stupid - last row comes first

        "/

        buff := ByteArray uninitializedNew:fileBytesPerRow.

        topDown ifTrue:[

            dstIdx := 1.

            lineDelta := imgBytesPerRow

        ] ifFalse:[

            dstIdx := imgBytesPerRow * (h - 1) + 1.

            lineDelta := imgBytesPerRow negated

        ].

        1 to:h do:[:row |

            (aStream nextBytes:fileBytesPerRow into:buff) == fileBytesPerRow ifFalse:[

                ^ false

            ].

            data replaceFrom:dstIdx to:(dstIdx+imgBytesPerRow-1) with:buff.

            dstIdx := dstIdx + lineDelta.

        ].

        ^ true

    ].

    "/ 'BMPReader: unsupported compression: ' infoPrint. compression infoPrintCR. 

    self fileFormatError:('unsupported compression:', compression printString).

    ^ false.

!

loadBMPWidth:w height:h depth:d from:aStream into:data

    "helper: load a BMP image"

    d == 8 ifTrue:[

        compression == 0 ifTrue:[

            ^ self loadUncompressedFrom:aStream into:data.

        ].

        compression == 1 ifTrue:[

            ^ self loadRLECompressedBMP8From:aStream into:data.

        ].

        "/ self breakPoint:#cg info:'unhandled compression'.

        self fileFormatError:('unsupported compression:', compression printString).

        ^ false

    ].

    d == 4 ifTrue:[

        ^ self loadBMP4From:aStream into:data

    ].

    d == 2 ifTrue:[

        ^ self loadBMP2From:aStream into:data

    ].

    d == 1 ifTrue:[

        ^ self loadBMP1From:aStream into:data

    ].

    ((d == 16)

    or:[ (d == 24)

    or:[ (d == 32) ]]) ifTrue:[

        (self loadBMPWidth:w height:h bytesPerPixel:(d // 8) from:aStream into:data) ifFalse:[

            ^ false

        ].

        inDepth == 16 ifTrue:[

            "/ Depth16Image keeps its data MSB (sigh); here they come LSB.

            data swapBytes.

        ].

        inDepth == 24 ifTrue:[

            "/ Depth24Image keeps its data r/g/b; BMP has it b/g/r (sigh)

            self swapBytesFromRGB_to_BGR.

        ].

        ^ true

    ].

    self fileFormatError:('unsupported depth:', d printString).

    ^ false

    "Created: / 17.9.1995 / 18:48:11 / claus"

    "Modified: / 3.2.1998 / 20:21:16 / cg"

!

loadRLECompressedBMP4From:aStream into:aByteArray

    "load bmp-rle-4 pixel imagedata"

    |bytesPerRowInData x y dstIndex lineStartIndex cnt pair clr1 clr2 code nbyte byte bytes byteIdx|

    bytesPerRowInData := self bytesPerRow.

    x := 0.

    topDown ifTrue:[

        y := 0.

        lineStartIndex := 1.

    ] ifFalse:[

        y := height - 1.

        lineStartIndex := (y * bytesPerRowInData) + 1.

    ].

    dstIndex := lineStartIndex.

    [ y between:0 and:height-1 ] whileTrue:[

        cnt := aStream nextByte.

        pair := aStream nextByte.

        cnt ~~ 0 ifTrue:[

            ((x between:0 and:width-1) and:[y between:0 and:height-1]) ifFalse:[

                self breakPoint:#cg.

                self fileFormatError:('invalid delta').

            ].    

Transcript printf:'RUN y: %d x: %d cnt: %d pair: %02x\n' with:y with:x with:cnt with:pair.

            clr1 := pair bitShift:-4.

            clr2 := pair bitAnd:16rF.

            x even ifTrue:[

                byte := ((clr2 << 4) bitOr:clr1).

                (cnt >= 2) ifTrue:[