<<>>
    <<RasterOpGreenbayImpl.mesa>>
        <<Copyright Ó 1988, 1990, 1991 by Xerox Corporation.  All rights reserved.>>
        <<Michael Plass, October 1, 1991 11:34 am PDT>>
        <<>>
    DIRECTORY
        Basics,
        RasterOp USING [BitAddress, BitsPerSample];

RasterOpGreenbayImpl: PROGRAM
    IMPORTS Basics
    EXPORTS RasterOp
    ~ BEGIN OPEN RasterOp, Basics;

        bpw: CARDINAL ~ BITS[WORD];

        Pack: PUBLIC PROC [dst: BitAddress, src: LONG POINTER TO RawWords, bitsPerSample: BitsPerSample, nSamples: CARDINAL] ~ UNCHECKED {
            p: LONG POINTER TO ARRAY [0..0] OF WORD Ź LOOPHOLE[dst.word];
            h: WORD Ź BITSHIFT[p[0], dst.bit-bpw];
            g: [0..bpw] Ź dst.bit; -- number of good bits at least-sig end of h
            j: CARDINAL Ź 0;
            count: CARDINAL Ź nSamples;
            bps: [0..bpw) ~ bitsPerSample;
            m: WORD ~ BITLSHIFT[1, bps]-1;
            bitsPerSample2: CARDINAL ~ bitsPerSample+bitsPerSample;
            bitsPerSample4: CARDINAL ~ bitsPerSample2+bitsPerSample2;
            bitsPerSample8: CARDINAL ~ bitsPerSample4+bitsPerSample4;
            Combine: PROC [w: WORD, s: WORD] RETURNS [WORD] ~ INLINE {
                RETURN [BITOR[BITLSHIFT[w, bps], BITAND[s, m]]]
                };
            WHILE count >= 8 DO
                SELECT CARDINAL[bpw-g] FROM
                    >= bitsPerSample8 => {
                        h Ź Combine[h, src[j]];
                        h Ź Combine[h, src[j+1]];
                        h Ź Combine[h, src[j+2]];
                        h Ź Combine[h, src[j+3]];
                        h Ź Combine[h, src[j+4]];
                        h Ź Combine[h, src[j+5]];
                        h Ź Combine[h, src[j+6]];
                        h Ź Combine[h, src[j+7]];
                        count Ź count - 8;
                        j Ź j + 8;
                        g Ź g + bitsPerSample8;
                        };
                    >= bitsPerSample4 => {
                        h Ź Combine[h, src[j]];
                        h Ź Combine[h, src[j+1]];
                        h Ź Combine[h, src[j+2]];
                        h Ź Combine[h, src[j+3]];
                        count Ź count - 4;
                        j Ź j + 4;
                        g Ź g + bitsPerSample4;
                        };
                    >= bitsPerSample2 => {
                        h Ź Combine[h, src[j]];
                        h Ź Combine[h, src[j+1]];
                        count Ź count - 2;
                        j Ź j + 2;
                        g Ź g + bitsPerSample2;
                        };
                    >= bps => {
                        h Ź Combine[h, src[j]];
                        count Ź count - 1;
                        j Ź j + 1;
                        g Ź g + bps;
                        };
                    ENDCASE => EXIT; -- Need to span a word, so drop through to the slower case below
                IF g = bpw THEN {
                    p[0] Ź h;
                    p Ź p + SIZE[WORD];
                    g Ź 0;
                    };
                ENDLOOP;
            UNTIL j = nSamples DO
                SELECT bpw-g FROM
                    >= bps => {
                        <<There is room for another whole sample in this output word>>
                        h Ź Combine[h, src[j]];
                        g Ź g + bps;
                        };
                    = 0 => {
                        <<The output word is full; store it and get the next sample>>
                        p[0] Ź h;
                        p Ź p + SIZE[WORD];
                        h Ź src[j];
                        g Ź bps;
                        };
                    ENDCASE => {
                        <<The sample goes partially in this word and partially in the next>>
                        k: WORD ~ BITAND[src[j], m];
                        p[0] Ź BITLSHIFT[h, bpw-g] + BITRSHIFT[k, bps+g-bpw];
                        p Ź p + SIZE[WORD];
                        h Ź k;
                        g Ź g + bps - bpw;
                        };
                j Ź j + 1;
                ENDLOOP;
            IF g # 0 THEN {
                p[0] Ź BITLSHIFT[h, bpw-g]+BITAND[p[0], BITLSHIFT[1, bpw-g]-1];
                };
            };

        Unpack: PUBLIC PROC [dst: LONG POINTER TO RawWords, src: BitAddress, bitsPerSample: BitsPerSample, nSamples: CARDINAL] ~ UNCHECKED {
            SELECT TRUE FROM
                (nSamples = 0) => NULL;
                (bitsPerSample = 1) => {
                    wordPointer: LONG POINTER TO WORD Ź @(dst[0]);
                    srcp: LONG POINTER TO WORD Ź src.word;
                    bit: CARDINAL Ź src.bit;
                    word: WORD Ź 0;
                    count: CARDINAL Ź nSamples;
                    IF bit#0 THEN {
                        word Ź BITLSHIFT[srcp­, bit];
                        srcp Ź srcp + SIZE[WORD];
                        WHILE count#0 AND bit#bpw DO
                        <<Assert[word = BITSHIFT[(srcp-SIZE[WORD])^, bit]];>>
                            wordPointer­ Ź BITRSHIFT[word, bpw-1];
                            count Ź count-1;
                            bit Ź bit+1;
                            word Ź 2*word;
                            wordPointer Ź wordPointer + SIZE[WORD];
                            ENDLOOP;
                        };
                    bit Ź bpw;
                    WHILE count>=32 DO
                        a: LONG POINTER TO ARRAY [0..32) OF WORD ~ LOOPHOLE[wordPointer];
                        lp: LONG POINTER TO PACKED ARRAY [0..32) OF [0..1] ~ LOOPHOLE[srcp];
                        b: PACKED ARRAY [0..32) OF [0..1] ~ lp­;
                        a[0]  Ź  b[0];      a[1]  Ź  b[1];      a[2]  Ź  b[2];      a[3] Ź b[3];  
                        a[4]  Ź  b[4];      a[5]  Ź  b[5];      a[6]  Ź  b[6];      a[7] Ź b[7];  
                        a[8]  Ź  b[8];      a[9]  Ź  b[9];      a[10] Ź b[10];    a[11] Ź b[11];
                        a[12] Ź b[12];    a[13] Ź b[13];    a[14] Ź b[14];    a[15] Ź b[15];
                        a[16] Ź b[16];    a[17] Ź b[17];    a[18] Ź b[18];    a[19] Ź b[19];
                        a[20] Ź b[20];    a[21] Ź b[21];    a[22] Ź b[22];    a[23] Ź b[23];
                        a[24] Ź b[24];    a[25] Ź b[25];    a[26] Ź b[26];    a[27] Ź b[27];
                        a[28] Ź b[28];    a[29] Ź b[29];    a[30] Ź b[30];    a[31] Ź b[31];
                        wordPointer Ź wordPointer + SIZE[ARRAY [0..32) OF WORD];
                        count Ź count - 32;
                        srcp Ź srcp + SIZE[PACKED ARRAY [0..32) OF [0..1]];
                        ENDLOOP;
                    WHILE count#0 DO
                    <<Assert[word = BITSHIFT[(srcp-SIZE[WORD])^, bit]];>>
                        IF bit = bpw THEN {bit Ź 0; word Ź srcp­; srcp Ź srcp + SIZE[WORD]};
                    <<Assert[word = BITSHIFT[(srcp-SIZE[WORD])^, bit]];>>
                        wordPointer­ Ź BITRSHIFT[word, bpw-1];
                        count Ź count-1;
                        word Ź 2*word;
                        wordPointer Ź wordPointer + SIZE[WORD];
                        bit Ź bit+1;
                        ENDLOOP;
                    };
                ((bitsPerSample = 8) AND ((src.bit MOD 8) = 0)) => {
                    wordPointer: LONG POINTER TO WORD Ź @(dst[0]);
                    chunksize: CARDINAL ~ 8; -- to change this, also change assignments in the unrolled loop below.  Must be a multiple of BYTES[WORD].
                    srcp: LONG POINTER TO PACKED ARRAY [0..chunksize) OF BYTE Ź LOOPHOLE[src.word];
                    byte: CARDINAL Ź src.bit/8;
                    count: CARDINAL Ź nSamples;
                    IF byte#0 THEN {
                        WHILE count#0 AND byte#chunksize DO
                            wordPointer­ Ź srcp[byte];
                            wordPointer Ź wordPointer + SIZE[WORD];
                            byte Ź byte + 1;
                            count Ź count-1;
                            ENDLOOP;
                        srcp Ź srcp + SIZE[PACKED ARRAY [0..chunksize) OF BYTE];
                        byte Ź 0;
                        };
                    WHILE count>=chunksize DO
                        a: LONG POINTER TO ARRAY [0..chunksize) OF WORD ~ LOOPHOLE[wordPointer];
                        b: PACKED ARRAY [0..chunksize) OF BYTE ~ srcp­;
                        a[0]  Ź  b[0];      a[1]  Ź  b[1];      a[2]  Ź  b[2];      a[3] Ź b[3];  
                        a[4]  Ź  b[4];      a[5]  Ź  b[5];      a[6]  Ź  b[6];      a[7] Ź b[7];  
                        wordPointer Ź wordPointer + SIZE[ARRAY [0..chunksize) OF WORD];
                        count Ź count - chunksize;
                        srcp Ź srcp + SIZE[PACKED ARRAY [0..chunksize) OF BYTE];
                        ENDLOOP;
                    WHILE count#0 DO
                        wordPointer­ Ź srcp[byte];
                        wordPointer Ź wordPointer + SIZE[WORD];
                        byte Ź byte + 1;
                        count Ź count-1;
                        ENDLOOP;
                    };
                ENDCASE => {
                    m: WORD ~ BITLSHIFT[1, bitsPerSample]-1;
                    p: LONG POINTER TO ARRAY [0..1] OF WORD Ź LOOPHOLE[src.word];
                    h: WORD Ź p[0];
                    g: INTEGER Ź bpw-src.bit; -- number of good bits at least-sig end of h
                    FOR j: CARDINAL IN [0..nSamples) DO
                        SELECT g FROM
                            >= bitsPerSample => {
                                <<The whole sample is in this word>>
                                dst[j] Ź BITAND[m, BITRSHIFT[h, g-bitsPerSample]];
                                g Ź g - bitsPerSample;
                                };
                            0 => {
                                <<The word is totally exhausted; pull the next one>>
                                p Ź p + SIZE[WORD];
                                h Ź p[0];
                                dst[j] Ź BITAND[m, BITRSHIFT[h, bpw-bitsPerSample]];
                                g Ź bpw - bitsPerSample;
                                };
                            ENDCASE => {
                                <<The sample is partially in this word and partially in the next>>
                                k: WORD ~ p[1];
                                dst[j] Ź BITAND[m, BITOR[BITLSHIFT[h, bitsPerSample-g], BITRSHIFT[k, g+bpw-bitsPerSample]]];
                                h Ź k;
                                p Ź p + SIZE[WORD];
                                g Ź g + bpw - bitsPerSample;
                                };
                        ENDLOOP;
                    };
            };

    END.