-- PDInterpBitmapImpl.mesa
-- Copyright (C) 1984, 1886 Xerox Corporation.  All rights reserved.
-- Michael Plass,  November 2, 1984 9:13:09 am PST
-- Tim Diebert, 5-Sep-86 13:10:03 
-- 
DIRECTORY BitBlt, Environment, Inline, PDInterpBitmap;
   
PDInterpBitmapImpl: PROGRAM
   IMPORTS BitBlt, Inline
   EXPORTS PDInterpBitmap
   = BEGIN
BitmapDesc: TYPE = PDInterpBitmap.BitmapDesc;
Tile: TYPE = PDInterpBitmap.Tile;
Rectangle: TYPE = PDInterpBitmap.Rectangle;
Function: TYPE = PDInterpBitmap.Function;
bitsPerWord: NAT = Environment.bitsPerWord;
lgBitsPerWord: NAT = Environment.logBitsPerWord;
wordsPerPage: NAT = Environment.wordsPerPage;
lgBitsPerPixel: NAT = 0;
pixelsPerWord: NAT = bitsPerWord;
-- Some inlines for basic bit-hacking operations.
   BITAND: PROC [a, b: CARDINAL] RETURNS[CARDINAL]
      = INLINE {RETURN[Inline.BITAND[a, b]]};
   Shift: PROC [a: CARDINAL, b: INTEGER] RETURNS [CARDINAL]
      = INLINE {RETURN[Inline.BITSHIFT[a, b]]};
      
BITBLT: PROC [ptr: BitBlt.BBptr] = {
   -- In a separate procedure so the spy can figure out how much time goes here.
   -- Could make this an inline for production.
   BitBlt.BITBLT[ptr];
   };
   
Intersect: PUBLIC PROC [a, b: Rectangle] RETURNS [Rectangle] = {
   sMin: INTEGER    ¬ MAX[a.sMin, b.sMin];
   fMin: INTEGER    ¬ MAX[a.fMin, b.fMin];
   sMax: INTEGER    ¬ MIN[INT[a.sMin]+a.sSize, INT[b.sMin]+b.sSize];
   fMax: INTEGER    ¬ MIN[INT[a.fMin]+a.fSize, INT[b.fMin]+b.fSize];
   IF sMax <= sMin OR fMax <= fMin THEN RETURN [[0, 0, 0, 0]]
   ELSE RETURN [[sMin, fMin, sMax-sMin, fMax-fMin]]
   };
   
LongZero: PROC [address: LONG POINTER TO CARDINAL, count: CARDINAL] = {
   IF count > 0 THEN {
      address­    ¬ 0;
      Inline.LongCOPY[from: address, nwords: count-1, to: address+1];
      };
   };
   
Clear: PUBLIC PROC [bitmapDesc: BitmapDesc] = {
   pointer: LONG POINTER    ¬ bitmapDesc.pointer;
   words: LONG CARDINAL    ¬ Inline.LongMult[bitmapDesc.rast, bitmapDesc.lines];
   WHILE words > 32768 DO
      LongZero[pointer, 32768];
      pointer    ¬ pointer + 32768;
      words    ¬ words - 32768;
      ENDLOOP;
   LongZero[pointer, words];
   };
   
InsufficientSpace: PUBLIC ERROR = CODE;
Reshape: PUBLIC PROC [pointer: LONG POINTER, words: INT, bounds: Rectangle] RETURNS [bitmapDesc: BitmapDesc] = {
   bitsPerPixel: CARDINAL = Shift[1, lgBitsPerPixel];
   bitsPerLine: NAT = Inline.LongMult[bounds.fSize, bitsPerPixel];
      -- Will raise a bounds fault if too many bits per line.
   wordsPerLine: CARDINAL = (bitsPerLine+(bitsPerWord-1)) / bitsPerWord;
   wordsNeeded: INT = Inline.LongMult[wordsPerLine, bounds.sSize];
   IF wordsNeeded > words THEN ERROR InsufficientSpace;
   RETURN [[bounds.sMin, bounds.fMin, 0, 0, bounds.sSize, bounds.fSize, pointer, wordsPerLine, bounds.sSize]];
   };
   
ShiftMap: PUBLIC PROC [p: BitmapDesc, s, f: INTEGER] RETURNS [BitmapDesc] = {
   p.sOrigin    ¬ p.sOrigin + s;
   p.fOrigin    ¬ p.fOrigin + f;
   RETURN [p]
   };
   
ShiftWindow: PUBLIC PROC [p: BitmapDesc, s, f: INTEGER] RETURNS [BitmapDesc] = {
   p.sMin    ¬ p.sMin + s;
   p.fMin    ¬ p.fMin + f;
   RETURN [p]
   };
   
Clip: PUBLIC PROC [p: BitmapDesc, bounds: Rectangle] RETURNS [BitmapDesc] = {
   bounds    ¬ Intersect[Window[p], bounds]; 
   p.sMin    ¬ bounds.sMin-p.sOrigin;
   p.fMin    ¬ bounds.fMin-p.fOrigin;
   p.sSize    ¬ bounds.sSize;
   p.fSize    ¬ bounds.fSize;
   RETURN [p]
   };
   
SetWindow: PUBLIC PROC [p: BitmapDesc, bounds: Rectangle] RETURNS [BitmapDesc] = {
   RETURN [p]
   };
   
Window: PUBLIC PROC [p: BitmapDesc] RETURNS [Rectangle] = {
   RETURN [[p.sOrigin + p.sMin, p.fOrigin + p.fMin, p.sSize, p.fSize]]
   };
   
BufferBounds: PUBLIC PROC [p: BitmapDesc] RETURNS [Rectangle] = {
   RETURN [[p.sOrigin, p.fOrigin, p.lines, Shift[p.rast, lgBitsPerWord-lgBitsPerPixel]]]
   };
   
BoundedWindow: PUBLIC PROC [p: BitmapDesc] RETURNS [Rectangle] = {
   sMin: INTEGER    ¬ MAX[p.sOrigin + p.sMin, p.sOrigin];
   fMin: INTEGER    ¬ MAX[p.fOrigin + p.fMin, p.fOrigin];
   sMax: INTEGER    ¬ MIN[p.sOrigin + p.sMin + p.sSize, p.sOrigin + p.lines];
   fMax: INTEGER    ¬ MIN[p.fOrigin + p.fMin + p.fSize, p.fOrigin + Shift[p.rast, lgBitsPerWord-lgBitsPerPixel]];
   RETURN [[sMin, fMin, MAX[sMax-sMin, 0], MAX[fMax-fMin, 0]]]
   };
   
replicator: ARRAY [0..4] OF CARDINAL = [0FFFFH, 05555H, 01111H, 00101H, 00001H];
Fill: PUBLIC PROC [dest: BitmapDesc, area: Rectangle, value: CARDINAL, function: Function] = {
   lgPixelsPerWord: INTEGER = lgBitsPerWord-lgBitsPerPixel;
   -- The following bounding box is calculated in terms of the destination buffer.
      sMin: INTEGER = MAX[dest.sMin, 0, area.sMin-dest.sOrigin];
      sMax: INTEGER = MIN[dest.sMin+dest.sSize, dest.lines, area.sMin+area.sSize-dest.sOrigin];
      fMin: INTEGER = MAX[dest.fMin, 0, area.fMin-dest.fOrigin];
      fMax: INTEGER = MIN[dest.fMin+dest.fSize, Shift[dest.rast, lgBitsPerWord-lgBitsPerPixel], area.fMin+area.fSize-dest.fOrigin];
   replicatedPixel: CARDINAL    ¬ Inline.BITAND[value, Shift[1, Shift[1, lgBitsPerPixel]]-1] * replicator[lgBitsPerPixel];
   bbTableSpace: BitBlt.BBTableSpace;
   bb: BitBlt.BBptr    ¬ BitBlt.AlignedBBTable[@bbTableSpace];
   IF sMin<sMax AND fMin<fMax THEN {
      bb­    ¬ [
         dst: [word: dest.pointer + Inline.LongMult[sMin, dest.rast] + Shift[fMin, -lgPixelsPerWord], bit: Inline.BITAND[fMin, Shift[1, lgPixelsPerWord]-1]],
         dstBpl: dest.rast*bitsPerWord,
         src: [word: @replicatedPixel, bit: 0],
         srcDesc: [gray[[yOffset: 0, widthMinusOne: 0, heightMinusOne: 0]]],
         height: sMax-sMin,
         width: Shift[fMax-fMin, lgBitsPerPixel],
         flags: [direction: forward, disjoint: TRUE, disjointItems: TRUE, gray: TRUE, srcFunc: function.srcFunc, dstFunc: function.dstFunc]
         ];
      BITBLT[bb];
      };
   };
   
Transfer: PUBLIC PROC [dest, source: BitmapDesc, function: Function] = {
   lgPixelsPerWord: INTEGER = lgBitsPerWord-lgBitsPerPixel;
   sMin: INTEGER = MAX[dest.sOrigin+MAX[dest.sMin, 0], source.sOrigin+MAX[source.sMin, 0]];
   sMax: INTEGER = MIN[dest.sOrigin+MIN[dest.sMin+dest.sSize, dest.lines], source.sOrigin+MIN[source.sMin+source.sSize, source.lines]];
   fMin: INTEGER = MAX[dest.fOrigin+MAX[dest.fMin, 0], source.fOrigin+MAX[source.fMin, 0]];
   fMax: INTEGER = MIN[dest.fOrigin+MIN[dest.fMin+dest.fSize, Shift[dest.rast, lgBitsPerWord-lgBitsPerPixel]], source.fOrigin+MIN[source.fMin+source.fSize, Shift[source.rast, lgBitsPerWord-lgBitsPerPixel]]];
   bbTableSpace: BitBlt.BBTableSpace;
   bb: BitBlt.BBptr = BitBlt.AlignedBBTable[@bbTableSpace];
   fMinDest: NAT = fMin - dest.fOrigin;
   fMinSource: NAT = fMin - source.fOrigin;
   sStartDest: NAT    ¬ sMin-dest.sOrigin;
   sStartSource: NAT    ¬ sMin-source.sOrigin;
   IF sMin<sMax AND fMin<fMax THEN {
      bb­    ¬ [
         dstBpl: dest.rast*bitsPerWord,
         srcDesc: [srcBpl[source.rast*bitsPerWord]],
         height: sMax-sMin,
         width: Shift[fMax-fMin, lgBitsPerPixel],
         flags: [direction: forward, disjoint: TRUE, disjointItems: TRUE, gray: FALSE, srcFunc: function.srcFunc, dstFunc: function.dstFunc]
         ];
      IF source.pointer = dest.pointer THEN {
         sSize: NAT = sMax-sMin;
         fSize: NAT = fMax-fMin;
         IF (fMinSource+fSize)>fMinDest AND (fMinDest+fSize)>fMinSource AND (sStartSource+sSize)>sStartDest AND (sStartDest+sSize)>sStartSource THEN {
            bb.flags.disjoint    ¬ FALSE; -- the rectangles overlap
            IF sStartDest=sStartSource THEN bb.flags.disjointItems    ¬ FALSE; -- so do the items
            IF sStartDest>sStartSource OR (sStartDest=sStartSource AND fMinDest>fMinSource) THEN { -- reverse direction
               bb.flags.direction    ¬ backward; bb.srcDesc.srcBpl    ¬ bb.dstBpl    ¬ -bb.dstBpl;
               sStartSource    ¬ sStartSource + (sSize-1); sStartDest    ¬ sStartDest + (sSize-1);
               };
            };
         };
      bb.dst    ¬ [word: dest.pointer + Inline.LongMult[sStartDest, dest.rast] + Shift[fMinDest, -lgPixelsPerWord], bit: Inline.BITAND[fMinDest, Shift[1, lgPixelsPerWord]-1]];
      bb.src    ¬ [word: source.pointer + Inline.LongMult[sStartSource, source.rast] + Shift[fMinSource, -lgPixelsPerWord], bit: Inline.BITAND[fMinSource, Shift[1, lgPixelsPerWord]-1]];
      BITBLT[bb];
      };
   };
   
IsPowerOfTwo: PROC [c: CARDINAL] RETURNS [BOOLEAN] = INLINE {
   RETURN [BITAND[c, c-1] = 0]
   };
   
largeBitSize: INT    ¬ 5000;
fSizeHint: NAT    ¬ 100;
CreateTile: PUBLIC PROC [rectangle: Rectangle, phase: INTEGER    ¬ 0, rasterPointer: LONG POINTER, scratchPointer: LONG POINTER    ¬ NIL, scratchWords: INT    ¬ 0] RETURNS [tile: Tile] = {
   ENABLE InsufficientSpace => GO TO InsufficientScratch;
   bitWidth: CARDINAL = Shift[rectangle.fSize, lgBitsPerPixel];
   bitmapDesc: BitmapDesc = [rectangle.sMin, rectangle.fMin, 0, 0, rectangle.sSize, rectangle.fSize, rasterPointer, (rectangle.fSize+(pixelsPerWord-1))/pixelsPerWord, rectangle.sSize];
   IF bitWidth <= 16 AND IsPowerOfTwo[bitWidth] AND bitmapDesc.sSize < 16 AND phase = 0 THEN {
      small: BitmapDesc    ¬ Reshape[scratchPointer, scratchWords, [rectangle.sMin, rectangle.fMin, rectangle.sSize, Shift[16, -lgBitsPerPixel]]];
      FOR fShift: NAT    ¬ 0, fShift+bitmapDesc.fSize UNTIL fShift>=small.fSize DO
         Transfer[small, ShiftMap[bitmapDesc, 0, fShift], [null, null]];
         ENDLOOP;
      tile    ¬ [small.sOrigin, small.fOrigin, small.sSize, small.fSize, 0, small.pointer, small.rast, small.lines];
      }
   ELSE {
      fSize: NAT    ¬ (fSizeHint+bitmapDesc.fSize-1)/bitmapDesc.fSize*bitmapDesc.fSize;
      bitsPerLine: NAT    ¬ Shift[fSize, lgBitsPerPixel];
      sSize: NAT    ¬ MAX[(((largeBitSize+bitsPerLine-1)/bitsPerLine)/bitmapDesc.sSize)*bitmapDesc.sSize, bitmapDesc.sSize];
      large: BitmapDesc    ¬ Reshape[scratchPointer, scratchWords, [bitmapDesc.sOrigin+bitmapDesc.sMin, bitmapDesc.fOrigin+bitmapDesc.fMin, sSize, fSize]];
      finalPhase: CARDINAL;
      WHILE phase<0 DO phase    ¬ phase + bitmapDesc.fSize ENDLOOP;
      phase    ¬ phase MOD bitmapDesc.fSize;
      finalPhase    ¬ (phase * (sSize/bitmapDesc.sSize)) MOD bitmapDesc.fSize;
      large.sSize    ¬ bitmapDesc.sSize;
      large.fSize    ¬ bitmapDesc.fSize;
      Transfer[large, bitmapDesc, [null, null]];
      WHILE large.fSize<fSize DO
         fSizePrev: NAT = large.fSize;
         large.fSize    ¬ MIN[fSize, 2*fSizePrev];
         Transfer[large, ShiftMap[large, 0, fSizePrev], [null, null]];
         ENDLOOP;
      WHILE large.sSize<sSize DO
         sSizePrev: NAT = large.sSize;
         large.sSize    ¬ MIN[sSize, 2*sSizePrev];
         Transfer[large, ShiftMap[large, sSizePrev, phase], [null, null]];
         {firstPart: BitmapDesc    ¬ ShiftMap[large, sSizePrev, phase-bitmapDesc.fSize];
            firstPart.fSize    ¬ bitmapDesc.fSize;
            Transfer[large, firstPart, [null, null]];
            };
         phase    ¬ 2*phase;
         WHILE phase > bitmapDesc.fSize DO phase    ¬ phase - bitmapDesc.fSize ENDLOOP;
         ENDLOOP;
      tile    ¬ [large.sOrigin, large.fOrigin, sSize, fSize, finalPhase, large.pointer, large.rast, large.lines];
      };
   EXITS InsufficientScratch => {
      tile    ¬ [rectangle.sMin, rectangle.fMin, rectangle.sSize, rectangle.fSize, phase, rasterPointer, (rectangle.fSize+(pixelsPerWord-1))/pixelsPerWord, rectangle.sSize];
      };
   };
   
TransferTile: PUBLIC PROC [dest: BitmapDesc, tile: Tile, function: Function    ¬ [null, null]] = {
   bitWidth: CARDINAL = Shift[tile.fSize, lgBitsPerPixel];
   IF bitWidth = bitsPerWord AND tile.rast = 1 AND tile.sSize <= 16 AND tile.phase = 0 THEN {
      startLine: NAT    ¬ MAX[dest.sMin, 0];
      endLine: INTEGER    ¬ MIN[dest.sMin+dest.sSize, dest.lines];
      startPixel: NAT    ¬ MAX[dest.fMin, 0];
      endPixel: INTEGER    ¬ MIN[dest.fMin+dest.fSize, Shift[dest.rast, lgBitsPerWord-lgBitsPerPixel]];
      IF endLine>startLine AND endPixel>startPixel THEN {
         startBit: NAT    ¬ Shift[startPixel, lgBitsPerPixel];
         bbTableSpace: BitBlt.BBTableSpace;
         bb: BitBlt.BBptr = BitBlt.AlignedBBTable[@bbTableSpace];
         sOffset: INTEGER    ¬ (dest.sOrigin+dest.sMin-tile.sOrigin) MOD tile.sSize;
         fOffset: INTEGER    ¬ (dest.fOrigin+dest.fMin-tile.fOrigin) MOD tile.fSize;
         WHILE sOffset < 0 DO sOffset    ¬ sOffset + tile.sSize ENDLOOP;
         WHILE fOffset < 0 DO fOffset    ¬ fOffset + tile.fSize ENDLOOP;
         bb­    ¬ [
            dst: [word: dest.pointer + Inline.LongMult[startLine, dest.rast] + startBit/bitsPerWord, bit: startBit MOD bitsPerWord],
            dstBpl: dest.rast*bitsPerWord,
            src: [word: tile.pointer+sOffset, bit: Shift[fOffset, lgBitsPerPixel]],
            srcDesc: [gray[[yOffset: sOffset, widthMinusOne: 0, heightMinusOne: tile.sSize-1]]],
            height: endLine-startLine,
            width: Shift[endPixel-startPixel, lgBitsPerPixel],
            flags: [direction: forward, disjoint: TRUE, disjointItems: TRUE, gray: TRUE, srcFunc: function.srcFunc, dstFunc: function.dstFunc]
            ];
         BITBLT[bb];
         };
      }
   ELSE {
      sMin: INT    ¬ dest.sOrigin+dest.sMin;
      fMin: INT    ¬ dest.fOrigin+dest.fMin;
      source: BitmapDesc;
      sOrigin: INT    ¬ tile.sOrigin;
      fOrigin: INT    ¬ tile.fOrigin;
      WHILE sOrigin < sMin DO
         sOrigin    ¬ sOrigin + tile.sSize;
         fOrigin    ¬ fOrigin + tile.phase;
         ENDLOOP;
      WHILE sOrigin > sMin DO
         sOrigin    ¬ sOrigin - tile.sSize;
         fOrigin    ¬ fOrigin - tile.phase;
         ENDLOOP;
      WHILE fOrigin < fMin DO fOrigin    ¬ fOrigin + tile.fSize ENDLOOP;
      WHILE fOrigin > fMin DO fOrigin    ¬ fOrigin - tile.fSize ENDLOOP;
      source    ¬ [sOrigin, fOrigin, 0, 0, tile.sSize, tile.fSize, tile.pointer, tile.rast, tile.lines];
      WHILE source.sOrigin < sMin+dest.sSize DO
         source.fOrigin    ¬ fOrigin;
         WHILE source.fOrigin < fMin+dest.fSize DO
            Transfer[dest, source, function];
            source.fOrigin    ¬ source.fOrigin + source.fSize;
            ENDLOOP;
         source.sOrigin    ¬ source.sOrigin + source.sSize;
         fOrigin    ¬ fOrigin + tile.phase;
         WHILE fOrigin > fMin DO fOrigin    ¬ fOrigin - source.fSize ENDLOOP;
         ENDLOOP;
      };
   };
   
END.