Macintosh-SW/supermario
1
0
Fork 0
mirror of https://github.com/elliotnunn/supermario.git synced 2024-11-27 22:51:28 +00:00
Code Issues Projects Releases Wiki Activity
master
supermario/base/SuperMarioProj.1994-02-09/QuickDraw/Classic/Stretch.m.a
Elliot Nunn 2e16381318 Bring in sources, and document
2019-06-29 23:17:50 +08:00

1206 lines
36 KiB
Plaintext
Raw Permalink Blame History

;
; File: Stretch.m.a
;
; Contains: xxx put contents here (or delete the whole line) xxx
;
; Written by: xxx put name of writer here (or delete the whole line) xxx
;
; Copyright: © 1988-1990 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <4> 11/8/90 KON Stretch chokes when horizonally scaling bitmaps with rowbytes >=
; $100. The problem is that ratiocase assumes reg. D0 is cleared
; (except the low byte) which it ain't.
; <3> 10/10/90 JL Change FixRatio to MFixRatio to avoid conflict with Traps.a
; <2> 7/20/90 gbm Fix some conflicting symbols
; <1.1> 11/11/88 CCH Fixed Header.
; <1.0> 11/9/88 CCH Adding to EASE.
; <1.2> 10/12/88 CCH Changed “m.GrafType.a” to “GrafType.m.a”.
; <1.1> 5/18/88 MSH Changed inclides to use m.GRAPHTYPES to work under EASE.
; <1.0> 2/11/88 BBM Adding file for the first time into EASE…
;
; To Do:
;
;EASE$$$ READ ONLY COPY of file “STRETCH.m.a”
; 1.1 CCH 11/11/1988 Fixed Header.
; 1.0 CCH 11/ 9/1988 Adding to EASE.
; OLD REVISIONS BELOW
; 1.2 CCH 10/12/1988 Changed “m.GrafType.a” to “GrafType.m.a”.
; 1.1 MSH 5/18/88 Changed inclides to use m.GRAPHTYPES to work under EASE.
; 1.0 BBM 2/11/88 Adding file for the first time into EASE…
; END EASE MODIFICATION HISTORY
BLANKS ON
STRING ASIS
INCLUDE 'GRAFTYPES.m.a'
;------------------------------------------------------------------
;
; --> STRETCH.TEXT
;
StretchBits PROC EXPORT
IMPORT RgnBlt,RSect,ShieldCursor,ShowCursor
IMPORT InitRgn,SeekRgn,SetupStretch,ColorMap,XorSlab
;--------------------------------------------------------------
;
; PROCEDURE StretchBits(srcBits,dstBits: BitMap;
; srcRect,dstRect: Rect;
; mode: INTEGER
; rgnA,rgnB,rgnC: RgnHandle);
;
; Transfer a rectangle of bits from srcBits to dstBits,
; stretching or compressing according to srcRect and dstRect.
; The transfer is clipped to the intersection of rgnA, rgnB, and rgnC.
;
;
; Restrictions:
;
; transfer mode 0..7 only.
; if numer <> denom, then src and dst bitmaps do not overlap.
;
;
; COPYRIGHT APPLE COMPUTER INC.
; DESIGNED AND WRITTEN BY BILL ATKINSON
;
;----------------------------------------------------
;
; A6 OFFSETS OF PARAMETERS AFTER LINK:
;
PARAMSIZE EQU 30 ;TOTAL BYTES OF PARAMETERS
SRCBITS EQU PARAMSIZE+8-4 ;LONG, ADDR OF BITMAP
DSTBITS EQU SRCBITS-4 ;LONG, ADDR OF BITMAP
SRCRECT EQU DSTBITS-4 ;LONG, ADDR OF RECT
DSTRECT EQU SRCRECT-4 ;LONG, ADDR OF RECT
MODE EQU DSTRECT-2 ;WORD
RGNA EQU MODE-4 ;RGNHANDLE
RGNB EQU RGNA-4 ;RGNHANDLE
RGNC EQU RGNB-4 ;RGNHANDLE
;-------------------------------------------------
;
; A6 OFFSETS OF LOCAL VARIABLES AFTER LINK:
;
NUMER EQU -4 ;POINT
DENOM EQU NUMER-4 ;POINT
VERROR EQU DENOM-4 ;INTEGER
MINRECT EQU VERROR-8 ;RECT
SRCBUF EQU MINRECT-4 ;LONG
DSTBUF EQU SRCBUF-4 ;LONG
SRCLONGS EQU DSTBUF-2 ;WORD
DSTLONGS EQU SRCLONGS-2 ;WORD
STATEA EQU DSTLONGS-RGNREC ;RGN STATE RECORD
STATEB EQU STATEA-RGNREC ;RGN STATE RECORD
STATEC EQU STATEB-RGNREC ;RGN STATE RECORD
SAVESTK EQU STATEC-4 ;LONG
RECTFLAG EQU SAVESTK-2 ;WORD
MASKBUF EQU RECTFLAG-4 ;LONG
BUFLEFT EQU MASKBUF-2 ;WORD
BUFSIZE EQU BUFLEFT-2 ;WORD
SRCADDR EQU BUFSIZE-4 ;LONG
DSTADDR EQU SRCADDR-4 ;LONG
SRCROW EQU DSTADDR-4 ;LONG
DSTROW EQU SRCROW-4 ;LONG
SRCLIMIT EQU DSTROW-4 ;LONG
VERT EQU SRCLIMIT-2 ;WORD
MODECASE EQU VERT-4 ;LONG
PAT EQU MODECASE-4 ;LONG, ADDR OF PAT
RATIOCASE EQU PAT-4 ;LONG
HORIZFRACTION EQU RATIOCASE-2 ;WORD
VARSIZE EQU HORIZFRACTION ;SIZE OF LOCAL VARIABLES
LINK A6,#VARSIZE ;ALLOCATE LOCAL VARIABLES
MOVEM.L D0-D7/A1-A4,-(SP) ;SAVE REGS
MOVE.L SP,SAVESTK(A6) ;REMEMBER STACK FOR LATER
;----------------------------------------------------------------
;
; CALC NUMER AND DENOM BASED ON DSTRECT AND SRCRECT.
; IF NUMER = DENOM THEN JUST CALL RGNBLT.
;
MOVE.L DSTRECT(A6),A0 ;POINT TO DSTRECT
MOVE BOTTOM(A0),D0
SUB TOP(A0),D0 ;CALC DST HEIGHT
SWAP D0 ;PUT IN HI WORD
MOVE RIGHT(A0),D0
SUB LEFT(A0),D0 ;CALC DST WIDTH
MOVE.L SRCRECT(A6),A0 ;POINT TO SRCRECT
MOVE BOTTOM(A0),D1
SUB TOP(A0),D1 ;CALC SRC HEIGHT
SWAP D1 ;PUT IN HI WORD
MOVE RIGHT(A0),D1
SUB LEFT(A0),D1 ;CALC SRC WIDTH
CMP.L D0,D1 ;ARE BOTH RECTS SAME SIZE
BNE.S STRETCH ;NO, CAN'T USE RGNBLT
XRGNBLT MOVE.L SRCBITS(A6),-(SP) ;PUSH SRCBITS
MOVE.L DSTBITS(A6),-(SP) ;PUSH DSTBITS
MOVE.L SRCRECT(A6),-(SP) ;PUSH SRCRECT
MOVE.L DSTRECT(A6),-(SP) ;PUSH DSTRECT
MOVE MODE(A6),-(SP) ;PUSH MODE
MOVE.L PAT(A6),-(SP) ;PAT ONLY USED FROM BELOW
MOVE.L RGNA(A6),-(SP) ;PUSH RGNA
MOVE.L RGNB(A6),-(SP) ;PUSH RGNB
MOVE.L RGNC(A6),-(SP) ;PUSH RGNC
JSR RGNBLT ;CALL RGNBLT
BRA GOHOME ;AND QUIT
STRETCH MOVE.L D0,NUMER(A6) ;NUMER := DST SIZE
MOVE.L D1,DENOM(A6) ;DENOM := SRC SIZE
JSR SetupStretch ;CALC CASEJUMP AND HORIZ FRACT
MOVE.L A0,RATIOCASE(A6) ;SAVE CASE JUMP FOR LATER
MOVE D0,HORIZFRACTION(A6) ;SAVE FRACTION FOR LATER
;----------------------------------------------------------------
;
; ADJUST MODE AND PATTERN FOR COLOR SEPARATION.
;
MOVE MODE(A6),-(SP) ;PUSH INPUT MODE
MOVE.L PAT(A6),-(SP) ;PUSH ADDR OF DUMMY PATTERN
JSR COLORMAP ;ALTER FOR COLOR SEPARATION
MOVE.L (SP)+,PAT(A6) ;GET (ALTERED) PATTERN
MOVE (SP)+,D2 ;GET (ALTERED) MODE
MOVE D2,D3 ;COPY MODE
ROR #4,D3 ;IS PATTERN BIT SET ?
BCS.S XRGNBLT ;YES, USE RGNBLT TO DO PAT
MOVE D2,MODE(A6) ;NO, UPDATE (ALTERED) MODE
;-------------------------------------------------------------------
;
; CALC MINRECT = INTERSECTION OF DSTRECT, DSTBITS.BOUNDS, AND THREE
; REGION BOUNDING BOXES. QUIT IF THE INTERSECTION IS EMPTY.
;
MOVE.L DSTBITS(A6),A3 ;POINT TO DST BITMAP
MOVE.L DSTRECT(A6),-(SP) ;PUSH ADDR OF DSTRECT
PEA BOUNDS(A3) ;PUSH ADDR OF DSTBITS.BOUNDS
MOVE.L RGNA(A6),A0 ;GET RGNHANDLE
MOVE.L (A0),A0 ;DE-REFERENCE IT
PEA RGNBBOX(A0) ;PUSH RGN BBOX
MOVE.L RGNB(A6),A0 ;GET RGNHANDLE
MOVE.L (A0),A0 ;DE-REFERENCE IT
PEA RGNBBOX(A0) ;PUSH RGN BBOX
MOVE.L RGNC(A6),A0 ;GET RGNHANDLE
MOVE.L (A0),A0 ;DE-REFERENCE IT
PEA RGNBBOX(A0) ;PUSH RGN BBOX
MOVE #5,-(SP) ;PUSH NRECTS
PEA MINRECT(A6) ;PUSH WHERE TO PUT RESULT
JSR RSECT ;INTERSECT ALL RECTS
BEQ GOHOME ;QUIT IF RESULT IS EMPTY
;----------------------------------------------------
;
; HIDE THE CURSOR IF IT INTERSECTS MINRECT
;
PEA MINRECT(A6) ;PUSH SHIELD RECT
MOVE.L BOUNDS+TOPLEFT(A3),-(SP) ;PUSH DELTA TO CONVERT TO GLOBAL
JSR SHIELDCURSOR ;REMOVE CURSOR IF INTERSECT
;-----------------------------------------------------------------------
;
; ALLOCATE AND CLEAR SRCBUF TO HOLD SRCWIDTH.
;
MOVE DENOM+H(A6),D0 ;GET SRC WIDTH
SUB #1,D0 ;SUBTRACT 1 PIXEL
LSR #5,D0 ;AND DIV BY 32 FOR LONGS
MOVE D0,SRCLONGS(A6) ;SAVE FOR LATER
CLR.L -(SP) ;CLEAR A LONG OF SLOP AT RIGHT
CLRSRC CLR.L -(SP) ;ALLOCATE AND CLEAR A LONG
DBRA D0,CLRSRC ;LOOP ENTIRE BUFFER
MOVE.L SP,SRCBUF(A6); ;REMEMBER WHERE SRCBUF IS
;-----------------------------------------------------------------------
;
; ALLOCATE AND CLEAR DSTBUF TO HOLD DSTWIDTH.
;
MOVE NUMER+H(A6),D0 ;GET DST WIDTH
SUB #1,D0 ;SUBTRACT 1 PIXEL
LSR #5,D0 ;AND DIV BY 32 FOR LONGS
MOVE D0,DSTLONGS(A6) ;SAVE FOR LATER
CLR.L -(SP) ;CLEAR A LONG OF SLOP AT RIGHT
CLR.L -(SP) ;CLEAR ANOTHER LONG OF SLOP
CLRDST CLR.L -(SP) ;ALLOCATE AND CLEAR A LONG
DBRA D0,CLRDST ;LOOP ENTIRE BUFFER
MOVE.L SP,DSTBUF(A6); ;REMEMBER WHERE DSTBUF IS
;--------------------------------------------------------
;
; CALC BUFLEFT AND BUFSIZE FOR RGN SCANLINE BUFFERS
;
MOVE.L DSTRECT(A6),A0 ;POINT TO DSTRECT
MOVE LEFT(A0),D1 ;GET DSTRECT LEFT
SUB BOUNDS+LEFT(A3),D1 ;CONVERT TO GLOBAL COORDS
AND #$FFF0,D1 ;TRUNC TO MULT OF 16
ADD BOUNDS+LEFT(A3),D1 ;CONVERT BACK TO LOCAL
MOVE D1,BUFLEFT(A6) ;SAVE AS BUFLEFT
MOVE MINRECT+RIGHT(A6),D0 ;GET MINRECT RIGHT
SUB D1,D0 ;CALC WIDTH IN DOTS
LSR #5,D0 ;DIV BY 32 FOR LONGS
MOVE D0,BUFSIZE(A6) ;BUFSIZE = # LONGS -1
;-----------------------------------------------------------------------
;
; ALLOCATE AND CLEAR A SCANLINE BUFFER FOR THE COMPOSITE MASK.
;
CLRMASK CLR.L -(SP) ;ALLOCATE AND CLEAR
DBRA D0,CLRMASK ;LOOP TILL DONE
MOVE.L SP,MASKBUF(A6); ;REMEMBER WHERE MASKBUF IS
;-------------------------------------------------------------------
;
; INIT STATE RECORDS VERT0 AND VERT1 IN CASE RECTANGULAR
;
MOVE #32767,D0
MOVE D0,STATEA+NEXTV(A6)
MOVE D0,STATEB+NEXTV(A6)
MOVE D0,STATEC+NEXTV(A6)
NEG D0
MOVE D0,STATEA+THISV(A6)
MOVE D0,STATEB+THISV(A6)
MOVE D0,STATEC+THISV(A6)
;----------------------------------------------------------------------
;
; ALLOCATE BUFFERS AND INIT STATE RECORDS FOR EACH NON-RECT REGION
;
MOVEQ #10,D7
CLR D5 ;INIT ALL RGNS RECT
MOVE.L RGNA(A6),A0 ;GET RGNHANDLE
MOVE.L (A0),A0 ;DE-REFERENCE IT
CMP RGNSIZE(A0),D7 ;IS RGNA RECTANGULAR ?
BEQ.S ARECT ;YES, SKIP IT
ADD #2,D5 ;NO, SET UP FLAG
LEA STATEA(A6),A1 ;POINT TO STATE RECORD A
BSR.S INITONE ;INIT STATE, ALLOC BUFFER
ARECT
MOVE.L RGNB(A6),A0 ;GET RGNHANDLE
MOVE.L (A0),A0 ;DE-REFERENCE IT
CMP RGNSIZE(A0),D7 ;IS RGNB RECTANGULAR ?
BEQ.S BRECT ;YES, SKIP IT
ADD #4,D5 ;NO, BUMP FLAG
LEA STATEB(A6),A1 ;POINT TO STATE RECORD B
BSR.S INITONE ;INIT STATE, ALLOC BUFFER
BRECT
MOVE.L RGNC(A6),A0 ;GET RGNHANDLE
MOVE.L (A0),A0 ;DE-REFERENCE IT
CMP RGNSIZE(A0),D7 ;IS RGNC RECTANGULAR ?
BEQ.S CRECT ;YES, SKIP IT
ADD #8,D5 ;NO, BUMP FLAG
LEA STATEC(A6),A1 ;POINT TO STATE RECORD C
PEA CRECT ;PUSH FAKE RETURN ADDR
INITONE MOVE MINRECT+LEFT(A6),D0 ;GET MINH
MOVE MINRECT+RIGHT(A6),D1 ;GET MAXH
MOVE BUFLEFT(A6),D2 ;GET BUFLEFT
JMP INITRGN ;INIT STATE, ALLOC BUFFER
CRECT
;--------------------------------------------------------------------
;
; IF ALL REGIONS ARE RECTANGULAR, THEN DRAW MINRECT INTO MASK BUFFER
;
MOVE.W D5,RECTFLAG(A6) ;ARE ALL RGNS RECT ?
BNE.S NOTRECT ;NO, CONTNUE
MOVE.L MASKBUF(A6),A0 ;YES, POINT TO MASK BUFFER
MOVE MINRECT+LEFT(A6),D3 ;SET UP LEFT
SUB BUFLEFT(A6),D3 ;MAKE IT BUFFER RELATIVE
MOVE MINRECT+RIGHT(A6),D4 ;SET UP RIGHT
SUB BUFLEFT(A6),D4 ;MAKE IT BUFFER RELATIVE
JSR XorSlab ;AND XOR BETWEEN THEM
NOTRECT
;------------------------------------------------------
;
; SET UP INVERT FLAG IN D7 TO REFLECT MODE BIT 2
;
CLR.L D7 ;SAY NOT INVERTED
MOVE MODE(A6),D2 ;GET TRANSFER MODE
BMI DONE ;QUIT IF MODE NEGATIVE
BCLR #2,D2 ;TEST AND CLR INVERT BIT
BEQ.S SETMODE ;SKIP IF NOT INVERTED
NOT.L D7 ;INVERTED; D7 GETS ALL 1'S
;--------------------------------------------------
;
; CALCULATE CASE JUMP FOR DIFFERENT TRANSFER MODES
;
SETMODE CMP #7,D2 ;IS MODE > 7 ?
BGT DONE ;YES, QUIT
LEA MODETAB,A0 ;POINT TO MODE TABLE
MOVE.B 0(A0,D2),D2 ;GET OFFSET
SUB D2,A0 ;COMPUTE ADDRESS
MOVE.L A0,MODECASE(A6) ;SAVE FOR LATER
;------------------------------------------------
;
; SET UP SRCROW, SRCLIMIT, SRCSHIFT, AND SRCADDR
;
MOVE.L SRCBITS(A6),A2 ;POINT TO SRCBITS
MOVE ROWBYTES(A2),D0 ;GET SRC ROWBYTES
EXT.L D0 ;AND EXTEND TO LONG
MOVE.L D0,SRCROW(A6) ;SRCROW := SRC ROWBYTES
MOVE BOUNDS+BOTTOM(A2),D1 ;GET SRCBITS.BOUNDS.BOTTOM
SUB BOUNDS+TOP(A2),D1 ;MAKE IT GLOBAL
MULU D0,D1 ;MULT BY SRC ROWBYTES
ADD.L BASEADDR(A2),D1 ;ADD BASEADDR
ADD.L #2,D1 ;ADJUST FOR -2(A0) SRC PICKUP
MOVE.L D1,SRCLIMIT(A6) ;SAVE RESULT AS SRCLIMIT
MOVE.L SRCRECT(A6),A0 ;POINT TO SRCRECT
MOVE LEFT(A0),D1 ;GET SRCRECT LEFT
SUB BOUNDS+LEFT(A2),D1 ;CONVERT TO SRC GLOBAL
MOVE D1,D5 ;MAKE A COPY
NEG D5 ;NEGATE IT AND
AND #$F,D5 ;TREAT MOD 16 FOR SRCSHIFT
MOVE TOP(A0),D0 ;GET SRCRECT TOP
SUB BOUNDS+TOP(A2),D0 ;CONVERT TO SRC GLOBAL
MULU ROWBYTES(A2),D0 ;MULT BY SRC ROWBYTES
MOVE.L BASEADDR(A2),A0 ;GET START OF SRC BITMAP
ADD.L D0,A0 ;ADD VERTICAL OFFSET
ADD D5,D1 ;ADJUST SRCLEFT FOR SRCSHIFT
ASR #4,D1 ;CONVERT DOTS TO WORDS
ADD D1,A0 ;ADD HORIZONTAL OFFSET
ADD D1,A0 ;TWICE FOR BYTES
MOVE.L A0,SRCADDR(A6) ;SAVE AS SRCADDR
;----------------------------------------------------
;
; CALC STARTING DSTROW, DSTSHIFT, AND DSTADDR
;
MOVE ROWBYTES(A3),D0 ;GET DST ROWBYTES
EXT.L D0 ;EXTEND TO LONG
MOVE.L D0,DSTROW(A6) ;DSTROW := DST ROWBYTES
MOVE.L DSTRECT(A6),A0
MOVE TOP(A0),VERT(A6) ;INIT CURRENT VERTICAL
MOVE LEFT(A0),D1 ;GET DSTRECT LEFT
SUB BOUNDS+LEFT(A3),D1 ;CONVERT TO GLOBAL COORDS
MOVEQ #$F,D6
AND D1,D6 ;TREAT MOD 16 FOR SHIFTCNT
MOVE MINRECT+TOP(A6),D0 ;GET MINRECT TOP
SUB BOUNDS+TOP(A3),D0 ;CONVERT TO GLOBAL COORDS
MULU ROWBYTES(A3),D0 ;MULT BY DST ROWBYTES
MOVE.L BASEADDR(A3),A0 ;GET START OF DST BITMAP
ADD.L D0,A0 ;ADD VERTICAL OFFSET
ASR #4,D1 ;CONVERT DOTS TO WORDS
ADD D1,A0 ;ADD HORIZ OFFSET
ADD D1,A0 ;TWICE FOR BYTES
MOVE.L A0,DSTADDR(A6) ;SAVE AS DSTADDR
;-----------------------------------------------------
;
; INIT ERROR TERM FOR DDA
;
MOVE DENOM+V(A6),D0
LSR #1,D0
NEG D0
MOVE D0,VERROR(A6) ;VERROR := -DENOM.V/2
;-----------------------------------------------------
;
; GET FIRST SCANLINE OF SRC INTO SRCBUF
;
NEXTSRC MOVE.L SRCADDR(A6),A0 ;POINT TO SRC BITMAP
CMP.L SRCLIMIT(A6),A0 ;IS IT EXHAUSTED ?
BHS DONE ;YES, QUIT
MOVE.L SRCBUF(A6),A1 ;POINT TO SRCBUF
MOVE SRCLONGS(A6),D1 ;GET COUNT OF LONGS
NXTSRC2 MOVE.L -2(A0),D0 ;GET A LONG OF SRC
LSR.L D5,D0 ;ALIGN TO SRCBUF
MOVE D0,(A1)+ ;PUT A WORD TO SRCBUF
MOVE.L (A0)+,D0 ;GET A SECOND LONG
LSR.L D5,D0 ;ALIGN TO SRCBUF
MOVE D0,(A1)+ ;PUT A WORD TO SRCBUF
DBRA D1,NXTSRC2 ;LOOP FOR ALL LONGS
MOVE.L SRCROW(A6),D2 ;GET SRC ROWBYTES
ADD.L D2,SRCADDR(A6) ;BUMP SRC TO NEXT ROW
MOVE NUMER+V(A6),D0 ;GET NUMER.V
ADD D0,VERROR(A6) ;VERROR := VERROR + NUMER.V
BGT.S SRCOK ;SKIP IF VERROR > 0
;-----------------------------------------------------
;
; WHILE (VERROR < 0) DO MERGE OTHER SCANLINES INTO SRCBUF.
;
SRCLOOP MOVE.L SRCADDR(A6),A0 ;POINT TO SRC BITMAP
CMP.L SRCLIMIT(A6),A0 ;IS IT EXHAUSTED ?
BHS.S SRCOK ;YES, DONT GET ANY MORE
MOVE.L SRCBUF(A6),A1 ;POINT TO SRCBUF
MOVE SRCLONGS(A6),D1 ;GET COUNT OF LONGS
NXTSRC3 MOVE.L -2(A0),D0 ;GET A LONG OF SRC
LSR.L D5,D0 ;ALIGN TO SRCBUF
OR D0,(A1)+ ;OR A WORD TO SRCBUF
MOVE.L (A0)+,D0 ;GET A SECOND LONG
LSR.L D5,D0 ;ALIGN TO SRCBUF
OR D0,(A1)+ ;OR A WORD TO SRCBUF
DBRA D1,NXTSRC3 ;LOOP FOR ALL LONGS
ADD.L D2,SRCADDR(A6) ;BUMP SRC TO NEXT ROW
MOVE NUMER+V(A6),D0 ;GET NUMER.V
ADD D0,VERROR(A6) ;VERROR := VERROR + NUMER.V
MORESRC BLE.S SRCLOOP ;LOOP WHILE VERROR <= 0
SRCOK
;----------------------------------------------------------
;
; HORIZONTALLY STRETCH SRCBUF INTO DSTBUF
;
MOVE.L SRCBUF(A6),A0 ;POINT TO SRCBUF
MOVE.L DSTBUF(A6),A1 ;POINT TO DSTBUF
MOVE DSTLONGS(A6),D0 ;GET DSTLONGS
LSL #2,D0 ;QUAD FOR BYTE OFFSET
LEA 4(A1,D0),A2 ;SET UP DSTLIMIT
MOVE HORIZFRACTION(A6),D4 ;GET HORIZONTAL FRACTION
MOVE.L RATIOCASE(A6),A3 ;GET CASE JUMP
moveq #0,d0 ;RatioCase assumes D0 is clear <KON 8NOV90>
JSR (A3) ;AND CALL STRETCHROW
;-------------------------------------------------------
;
; TRANSFER ONE OR MORE COPIES OF DSTBUF INTO DSTBITS
;
NXTMASK MOVE VERT(A6),D0 ;GET CURRENT VERT COORD
CMP MINRECT+TOP(A6),D0 ;IS VERT < MINV ?
BLT.S NODRAW ;YES, DON'T DRAW
BSR SEEKMASK ;MAKE MASK BUFFER CURRENT
MOVE.L DSTBUF(A6),A3 ;INIT SRCPTR
MOVE.L DSTADDR(A6),A4 ;INIT DSTPTR FOR ROW
MOVE.L MASKBUF(A6),A2 ;INIT MASKPTR FOR ROW
MOVE BUFSIZE(A6),D2 ;INIT COUNT OF LONGS
MOVE.L MODECASE(A6),A0 ;GET MODE CASE JUMP
JMP (A0) ;TAKE MODE JUMP
NEXTDST MOVE.L DSTROW(A6),D0 ;GET DST ROWBYTES
ADD.L D0,DSTADDR(A6) ;BUMP DST TO NEXT ROW
NODRAW ADD #1,VERT(A6) ;BUMP TO NEXT VERT
MOVE VERT(A6),D0 ;GET VERT
CMP MINRECT+BOTTOM(A6),D0 ;ARE WE AT THE LAST SCAN LINE ?
BEQ.S DONE ;YES, QUIT
MOVE DENOM+V(A6),D0
SUB D0,VERROR(A6) ;VERROR := VERROR - DENOM.V
BGE NXTMASK ;IF VERROR >= 0 THEN DRAW MORE
BRA NEXTSRC ;ELSE GET NEXT SRC
;-----------------------------------------------------------------
;
; ENTIRE STRETCHBITS COMPLETE. RESTORE REGS AND STACK AND GO HOME.
;
DONE JSR SHOWCURSOR ;RESTORE CURSOR
GOHOME MOVE.L SAVESTK(A6),SP ;STRIP VARIABLE SIZED BUFFER
MOVEM.L (SP)+,D0-D7/A1-A4 ;RESTORE REGISTERS
UNLINK PARAMSIZE,'STRETCHB'
;-----------------------------------------------------------------
;
; LOCAL ROUTINE TO UPDATE MASK BUFFER TO CURRENT VERTICAL COORD.
;
SEEKMASK MOVE VERT(A6),D0 ;GET CURRENT VERT COORD
MOVE RECTFLAG(A6),D1 ;GET RECTFLAG = 0,2,4
MOVE RECTJMP(D1),D1 ;GET OFFSET FROM TABLE
JMP RECTJMP(D1) ;TAKE CASE JUMP
RECTJMP DC.W SEEKOK-RECTJMP
DC.W A-RECTJMP
DC.W B-RECTJMP
DC.W AB-RECTJMP
DC.W C-RECTJMP
DC.W AC-RECTJMP
DC.W BC-RECTJMP
DC.W ABC-RECTJMP
;--------------------------------------------------------------------
;
; ONLY REGION A IS NON RECTANGULAR. UPDATE IT AND USE IT AS THE MASK
;
A LEA STATEA(A6),A1
BRA.S JMPSEEK
;--------------------------------------------------------------------
;
; ONLY REGION B IS NON RECTANGULAR. UPDATE IT AND USE IT AS THE MASK
;
B LEA STATEB(A6),A1
BRA.S JMPSEEK
;--------------------------------------------------------------------
;
; ONLY REGION C IS NON RECTANGULAR. UPDATE IT AND USE IT AS THE MASK
;
C LEA STATEC(A6),A1
JMPSEEK MOVE.L MASKBUF(A6),SCANBUF(A1) ;PLAY DIRECTLY INTO MASKBUF
JMP SEEKRGN
;-------------------------------------------------------------------
;
; REGIONS A AND B ARE NON-RECTANGULAR. UPDATE EACH,
; THEN FORM INTERSECTION IN THE MASK BUFFER.
;
AB LEA STATEA(A6),A1
JSR SEEKRGN
MOVE D1,-(SP) ;REMEMBER IF RGN CHANGED
LEA STATEB(A6),A1
JSR SEEKRGN
OR (SP)+,D1 ;HAS EITHER RGN CHANGED ?
BEQ.S SEEKOK ;NO, WE'RE DONE
MOVE.L STATEA+SCANBUF(A6),A0
MOVE.L STATEB+SCANBUF(A6),A1
BRA.S CPY2BUF
;-------------------------------------------------------------------
;
; REGIONS A AND C ARE NON-RECTANGULAR. UPDATE EACH,
; THEN FORM INTERSECTION IN THE MASK BUFFER.
;
AC LEA STATEA(A6),A1
JSR SEEKRGN
MOVE D1,-(SP) ;REMEMBER IF RGN CHANGED
LEA STATEC(A6),A1
JSR SEEKRGN
OR (SP)+,D1 ;HAS EITHER RGN CHANGED ?
BEQ.S SEEKOK ;NO, WE'RE DONE
MOVE.L STATEA+SCANBUF(A6),A0
MOVE.L STATEC+SCANBUF(A6),A1
BRA.S CPY2BUF
;-------------------------------------------------------------------
;
; REGIONS B AND C ARE NON-RECTANGULAR. UPDATE EACH,
; THEN FORM INTERSECTION IN THE MASK BUFFER.
;
BC LEA STATEB(A6),A1
JSR SEEKRGN
MOVE D1,-(SP) ;REMEMBER IF RGN CHANGED
LEA STATEC(A6),A1
JSR SEEKRGN
OR (SP)+,D1 ;HAS EITHER RGN CHANGED ?
BEQ.S SEEKOK ;NO, WE'RE DONE
MOVE.L STATEB+SCANBUF(A6),A0
MOVE.L STATEC+SCANBUF(A6),A1
CPY2BUF MOVE.L MASKBUF(A6),A2
MOVE BUFSIZE(A6),D1
BCLOOP MOVE.L (A0)+,D0
AND.L (A1)+,D0
MOVE.L D0,(A2)+
DBRA D1,BCLOOP
SEEKOK RTS ;ALL 3 ARE RECT, DO NOTHING
;-------------------------------------------------------------------
;
; REGIONS A, B AND C ARE ALL NON-RECTANGULAR. UPDATE EACH,
; THEN FORM INTERSECTION IN THE MASK BUFFER.
;
ABC LEA STATEA(A6),A1
JSR SEEKRGN
MOVE D1,-(SP) ;REMEMBER IF RGN CHANGED
LEA STATEB(A6),A1
JSR SEEKRGN
OR D1,(SP) ;REMEMBER IF RGN CHANGED
LEA STATEC(A6),A1
JSR SEEKRGN
OR (SP)+,D1 ;HAS EITHER RGN CHANGED ?
BEQ.S ABCDONE ;NO, WE'RE DONE
MOVE.L STATEA+SCANBUF(A6),A0
MOVE.L STATEB+SCANBUF(A6),A1
MOVE.L STATEC+SCANBUF(A6),A2
MOVE.L MASKBUF(A6),A3
MOVE BUFSIZE(A6),D1
ABCLOOP MOVE.L (A0)+,D0
AND.L (A1)+,D0
AND.L (A2)+,D0
MOVE.L D0,(A3)+
DBRA D1,ABCLOOP
ABCDONE RTS
;---------------------------------------------------------------;
; ;
; INTERFACE TO EACH OF THE STRETCHBITS SCANLINE LOOPS: ;
; ;
; REGISTERS: A0: D0: ;
; A1: D1: ;
; A2: MASKPTR D2: LONGCNT ;
; A3: SRCPTR D3: ;
; A2: DSTPTR D4: ;
; A4: D5: SRCSHIFT ;
; A6: D6: DSTSHIFT ;
; A7: D7: INVERT ;
; ;
;---------------------------------------------------------------;
;-------------------------------------------------------
;
; MODE 0 OR 4: SRC --> DST
;
MASK0 MOVE.L -2(A3),D0 ;GET SRC FROM BITMAP
LSR.L D6,D0 ;ALIGN TO DST
SWAP D0 ;PUT INTO HI HALF OF D0
MOVE.L (A3)+,D1 ;GET SRC FROM BITMAP AND BUMP RIGHT
LSR.L D6,D1 ;ALIGN TO DST
MOVE D1,D0 ;ASSEMBLE ONE LONG
EOR.L D7,D0 ;INVERT SRC IF MODE BIT 2 SET
MOVE.L (A2)+,D1 ;GET MASK
AND.L D1,D0 ;MASK SRC
NOT.L D1 ;FORM NOTMASK
AND.L (A4),D1 ;GET DST DATA
OR.L D1,D0 ;MERGE WITH SRC DATA
MOVE.L D0,(A4)+ ;PUT RESULT IN DST
DBRA D2,MASK0 ;LOOP ALL LONGS THIS ROW
BRA NEXTDST ;GO FOR NEXT ROW
;-------------------------------------------------------
;
; MODE 1 OR 5: SRC OR DST --> DST
;
MASK1 MOVE.L -2(A3),D0 ;GET SRC FROM BITMAP
LSR.L D6,D0 ;ALIGN TO DST
SWAP D0 ;PUT INTO HI HALF OF D0
MOVE.L (A3)+,D1 ;GET SRC FROM BITMAP
LSR.L D6,D1 ;ALIGN TO DST
MOVE D1,D0 ;ASSEMBLE ONE LONG
EOR.L D7,D0 ;INVERT SRC IF MODE BIT 2 SET
AND.L (A2)+,D0 ;AND WITH MASK
OR.L D0,(A4)+ ;OR RESULT INTO DST
DBRA D2,MASK1 ;LOOP ALL LONGS THIS ROW
BRA NEXTDST ;LOOP FOR NEXT ROW
;-------------------------------------------------------
;
; MODE 2 OR 6: SRC XOR DST --> DST
;
MASK2 MOVE.L -2(A3),D0 ;GET SRC FROM BITMAP
LSR.L D6,D0 ;ALIGN TO DST
SWAP D0 ;PUT INTO HI HALF OF D0
MOVE.L (A3)+,D1 ;GET SRC FROM BITMAP
LSR.L D6,D1 ;ALIGN TO DST
MOVE D1,D0 ;ASSEMBLE ONE LONG
EOR.L D7,D0 ;INVERT SRC IF MODE BIT 2 SET
AND.L (A2)+,D0 ;AND WITH MASK
EOR.L D0,(A4)+ ;XOR RESULT INTO DST
DBRA D2,MASK2 ;LOOP ALL LONGS THIS ROW
BRA NEXTDST ;LOOP FOR NEXT ROW
;-------------------------------------------------------
;
; MODE 3 OR 7: SRC BIC DST --> DST
;
MASK3 MOVE.L -2(A3),D0 ;GET SRC FROM BITMAP
LSR.L D6,D0 ;ALIGN TO DST
SWAP D0 ;PUT INTO HI HALF OF D0
MOVE.L (A3)+,D1 ;GET SRC FROM BITMAP
LSR.L D6,D1 ;ALIGN TO DST
MOVE D1,D0 ;ASSEMBLE ONE LONG
EOR.L D7,D0 ;INVERT SRC IF MODE BIT 2 SET
AND.L (A2)+,D0 ;AND WITH MASK
NOT.L D0 ;INVERT FOR BIC
AND.L D0,(A4)+ ;BIC RESULT INTO DST
DBRA D2,MASK3 ;LOOP ALL LONGS THIS ROW
BRA NEXTDST ;LOOP FOR NEXT ROW
MODETAB DC.B MODETAB-MASK0
DC.B MODETAB-MASK1
DC.B MODETAB-MASK2
DC.B MODETAB-MASK3
SetupStretch PROC EXPORT
;--------------------------------------------------------------
;
; Routine to setup case jump for StretchRow,
; based on horiz numer and denom.
;
; Call SetupStretch with numer in D0, denom in D1.
; Returns case jump in A0, fraction in D0.
;
; Call resulting case jump with:
;
; A0: srcPtr
; A1: dstPtr
; A2: dstLimit
; D4: fraction
;
; clobbers D0-D3,A0-A1
;
LEA DONE,A0 ;POINT TO ABORT
TST D0 ;IS NUMER <= 0 ?
BLE FOUND ;YES, POINT TO ABORT
TST D1 ;IS DENOM <= 0 ?
BLE FOUND ;YES, POINT TO ABORT
LEA ONE,A0 ;POINT TO FAST COPY
CMP D1,D0 ;IS NUMER = DENOM ?
BEQ FOUND ;YES, USE FAST COPY
BLT.S SHRNKING ;NO, BRANCH IF SHRINKING
;
; We will be stretching. Calc fract = denom/numer and check for fast.
;
STRCHING MOVE D0,D3 ;MAKE A COPY OF NUMER
MOVE D1,D4 ;MAKE A COPY OF DENOM
CLR.L -(SP) ;ROOM FOR FCN RESULT
MOVE D1,-(SP) ;PUSH DENOM
MOVE D0,-(SP) ;PUSH NUMER
_MFixRatio ;CALL FIXRATIO, < 1.0
MOVE.L (SP)+,D0 ;POP RESULT
LEA DOUBLE,A0 ;CHECK FOR FAST RATIOS
CMP #$8000,D0
BEQ.S FOUND
LEA QUAD,A0
CMP #$4000,D0
BEQ.S FOUND
LEA EIGHT,A0
CMP #$2000,D0
BEQ.S FOUND
LEA SIXTEEN,A0
CMP #$1000,D0
BEQ.S FOUND
LEA ONE_5,A0
CMP #$AAAA,D0
BEQ.S FOUND
LEA TRIPLE,A0
CMP #$5555,D0
BEQ.S FOUND
LEA SIX,A0
CMP #$2AAA,D0
BEQ.S FOUND
;
; check for any multiple of 8:
;
EXT.L D3 ;CLEAR HI WORD OF NUMER
DIVU D4,D3 ;CALC NUMER DIV DENOM
MOVE D3,D1 ;SAVE QUOTIENT
AND.L #$FFFF0007,D3 ;IS SCALE AN EVEN MULT OF 8 ?
BNE.S NOMATCH ;NO, USE GENERAL STRETCH
MOVE D1,D0 ;YES RETURN QUOTIENT IN D0
LEA EIGHTS,A0 ;POINT TO FAST ROUTINE
RTS ;AND RETURN
NOMATCH LEA STRETCH,A0 ;POINT TO SLOW GENERAL CODE
FOUND RTS ;RETURN WITH CASE JUMP IN A0
;
; We will be shrinking. Calc fract = numer/denom and check for fast.
;
SHRNKING CLR.L -(SP) ;ROOM FOR FCN RESULT
MOVE D0,-(SP) ;PUSH NUMER
MOVE D1,-(SP) ;PUSH DENOM
_MFixRatio ;CALL FIXRATIO, < 1.0
MOVE.L (SP)+,D0 ;POP RESULT
LEA HALF,A0 ;CHECK FOR FAST RATIOS
CMP #$8000,D0
BEQ.S FOUND
LEA QRTR,A0
CMP #$4000,D0
BEQ.S FOUND
LEA THREE4,A0
CMP #$C000,D0
BEQ.S FOUND
LEA SHRINK,A0
BRA FOUND
;-----------------------------------------------
;
; NUMERATOR = DENOMINATOR, JUST COPY LONGS
;
ONE MOVE.L (A0)+,(A1)+ ;COPY ONE LONG
MOVE.L (A0)+,(A1)+ ;COPY ANOTHER LONG
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO ONE ;NO, LOOP FOR MORE
RTS ;ALL DONE
;---------------------------------------------------
;
; SHRINK TO THREE QUARTERS.
;
THREE4 MOVEQ #3,D3 ;MASK FOR HI 2 BITS
ROR.L #2,D3 ;IE. $C0000000
CLR.L -(SP) ;ALLOCATE A LONG OF TEMP
THREE4A MOVE.L (A0)+,D0 ;GET A LONG OF SRC
MOVEQ #7,D2 ;INIT COUNT OF 24 DST BITS
THREE4B ADD.L D0,D0 ;GET 1 BIT OF SRC
ADDX.L D1,D1 ;PUT 1 BIT TO DST
ADD.L D3,D0 ;PUT HI 2 BITS INTO CARRY
ADDX.L D1,D1 ;SHIFT INTO DST
LSL.L #3,D0 ;SHIFT LEFT 3 BITS
ADDX.L D1,D1 ;PUT CARRY BIT INTO DST
DBRA D2,THREE4B ;LOOP 8 TIMES
MOVE.L D1,(SP) ;STASH 3 DST BYTES IN TEMP
MOVE.B 1(SP),(A1)+ ;PUT FIRST BYTE TO DST
MOVE.B 2(SP),(A1)+ ;PUT SECOND BYTE TO DST
MOVE.B 3(SP),(A1)+ ;PUT THIRD BYTE TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO THREE4A ;NO, CONTINUE
ADD #4,SP ;YES, STRIP TEMP
RTS ;AND QUIT
;---------------------------------------------------
;
; SHRINK TO ONE HALF.
;
HALF MOVEQ #3,D3 ;MASK FOR HI 2 BITS
ROR.L #2,D3 ;IE. $C0000000
HALF1 MOVE.L (A0)+,D0 ;GET A LONG OF SRC
MOVEQ #7,D2 ;INIT COUNT OF 16 DST BITS
HALF2 ADD.L D3,D0 ;PUT OR OF HI BITS INTO CARRY
ADDX D1,D1 ;SHIFT BIT INTO DST
LSL.L #2,D0 ;SHIFT LEFT 2 BITS
ADD.L D3,D0 ;PUT OR OF HI BITS INTO CARRY
ADDX.L D1,D1 ;SHIFT BIT INTO DST
LSL.L #2,D0 ;SHIFT LEFT 2 BITS
DBRA D2,HALF2 ;LOOP 8 TIMES
MOVE D1,(A1)+ ;THEN PUT A WORD TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO HALF1 ;NO, CONTINUE
RTS ;YES, QUIT
;---------------------------------------------------
;
; SHRINK TO ONE QUARTER.
;
QRTR MOVE.L #$F0000000,D3 ;MASK FOR HI 4 BITS
QRTR1 MOVE.L (A0)+,D0 ;GET A LONG OF SRC
MOVEQ #7,D2 ;INIT COUNT OF 8 DST BITS
QRTR2 ADD.L D3,D0 ;PUT OR OF HI BITS INTO CARRY
ADDX.L D1,D1 ;SHIFT BIT INTO DST
LSL.L #4,D0 ;SHIFT LEFT 4 BITS
DBRA D2,QRTR2 ;LOOP 8 TIMES
MOVE.B D1,(A1)+ ;THEN PUT A BYTE TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO QRTR1 ;NO, CONTINUE
RTS ;YES, QUIT
;-----------------------------------------------
;
; STRETCH TO 1.5 TIMES AS WIDE
;
ONE_5 MOVE.B (A0)+,D0 ;GET FIRST BYTE FROM SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
LSR.B #4,D1 ;GET HI NIBBLE
MOVE.B TABLE15(D1),D2 ;EXPAND TO 6 BITS
LSL.L #6,D2 ;SHIFT OVER 6
AND #$F,D0 ;GET LO NIBBLE
MOVE.B TABLE15(D0),D2 ;EXPAND TO 6 BITS
LSL.L #6,D2 ;SHIFT OVER 6
MOVE.B (A0)+,D0 ;GET SECOND BYTE FROM SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
LSR.B #4,D1 ;GET HI NIBBLE
MOVE.B TABLE15(D1),D2 ;EXPAND TO 6 BITS
LSL.L #6,D2 ;SHIFT OVER 6
AND #$F,D0 ;GET LO NIBBLE
MOVE.B TABLE15(D0),D2 ;EXPAND TO 6 BITS
LSR.L #2,D2 ;RIGHT JUSTIFY
SWAP D2 ;FLIP WORDS
MOVE.B D2,(A1)+ ;PUT FIRST BYTE TO DST
SWAP D2 ;FLIP BACK AGAIN
MOVE D2,D1
ROR #8,D1
MOVE.B D1,(A1)+ ;PUT SECOND BYTE TO DST
MOVE.B D2,(A1)+ ;PUT THIRD BYTE TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO ONE_5 ;NO, LOOP FOR MORE
RTS ;ALL DONE
TABLE15 DC.B $00,$0C,$10,$1C ;1.5 TIMES TABLE
DC.B $60,$6C,$70,$7C
DC.B $80,$8C,$90,$9C
DC.B $E0,$EC,$F0,$FC
;-----------------------------------------------
;
; DOUBLE USING TABLE LOOKUP
;
DOUBLE MOVE.B (A0)+,D0 ;GET A BYTE FROM SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
LSR.B #4,D1 ;GET HI NIBBLE
MOVE.B TABLE2(D1),(A1)+ ;DOUBLE FOR A BYTE
AND #$F,D0 ;GET LO NIBBLE
MOVE.B TABLE2(D0),(A1)+ ;DOUBLE FOR A BYTE
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO DOUBLE ;NO, LOOP FOR MORE
RTS ;ALL DONE
TABLE2 DC.B $00,$03,$0C,$0F ;DOUBLING TABLE
DC.B $30,$33,$3C,$3F
DC.B $C0,$C3,$CC,$CF
DC.B $F0,$F3,$FC,$FF
;-----------------------------------------------
;
; TRIPLE USING TABLE LOOKUP
;
TRIPLE MOVE.B (A0)+,D0 ;GET A BYTE FROM SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
MOVE D0,D2 ;MAKE A THIRD COPY
LSR.B #5,D2 ;GET 3 HI BITS
MOVE.B TABLE3A(D2),(A1)+ ;PUT FIRST BYTE TO DST
LSR.B #2,D1
AND #$F,D1 ;GET MIDDLE 4 BITS
MOVE.B TABLE3B(D1),(A1)+ ;PUT SECOND BYTE TO DST
AND #$7,D0 ;GET 3 LO BITS
MOVE.B TABLE3C(D0),(A1)+ ;PUT THIRD BYTE TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO TRIPLE ;NO, LOOP FOR MORE
RTS ;ALL DONE
TABLE3A DC.B $00,$03,$1C,$1F ;TRIPLING TABLE
DC.B $E0,$E3,$FC,$FF
TABLE3B DC.B $00,$01,$0E,$0F
DC.B $70,$71,$7E,$7F
DC.B $80,$81,$8E,$8F
DC.B $F0,$F1,$FE,$FF
TABLE3C DC.B $00,$07,$38,$3F
DC.B $C0,$C7,$F8,$FF
;-----------------------------------------------
;
; QUADRUPLE USING TABLE LOOKUP
;
QUAD MOVE.B (A0)+,D0 ;GET A BYTE FROM SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
AND #$F0,D1 ;MASK FOR HI NIBBLE
LSR #3,D1 ;SHIFT FOR TABLE INDEX
MOVE.W TABLE4(D1),(A1)+ ;PUT FIRST WORD TO DST
AND #$F,D0 ;MASK FOR LO NIBBLE
ADD D0,D0 ;DOUBLE FOR TABLE INDEX
MOVE.W TABLE4(D0),(A1)+ ;PUT SECOND WORD TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO QUAD ;NO, LOOP FOR MORE
RTS ;ALL DONE
TABLE4 DC.W $0000,$000F,$00F0,$00FF ;QUADRUPLING TABLE
DC.W $0F00,$0F0F,$0FF0,$0FFF
DC.W $F000,$F00F,$F0F0,$F0FF
DC.W $FF00,$FF0F,$FFF0,$FFFF
;-----------------------------------------------
;
; STRETCH BY SIX USING TABLE LOOKUP
;
SIX MOVE.B (A0)+,D0 ;GET A BYTE FROM SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
AND #$E0,D1 ;MASK FOR HI 3 BITS
LSR.B #4,D1 ;SHIFT FOR TABLE INDEX
MOVE.W TABLE6A(D1),(A1)+ ;PUT A WORD TO DST
MOVE D0,D1 ;GET SRC BYTE AGAIN
AND #$3C,D1 ;MASK FOR MIDDLE 4 BITS
LSR.B #1,D1 ;SHIFT FOR TABLE INDEX
MOVE.W TABLE6B(D1),(A1)+ ;PUT A WORD TO DST
MOVE D0,D1 ;GET SRC BYTE AGAIN
AND #7,D1 ;MASK FOR LO 3 BITS
ADD D1,D1 ;DOUBLE FOR TABLE INDEX
MOVE.W TABLE6C(D1),(A1)+ ;PUT A WORD TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO SIX ;NO, LOOP FOR MORE
RTS ;ALL DONE
TABLE6A DC.W $0000,$000F,$03F0,$03FF ;SIX TIMES TABLE
DC.W $FC00,$FC0F,$FFF0,$FFFF
TABLE6B DC.W $0000,$0003,$00FC,$00FF
DC.W $3F00,$3F03,$3FFC,$3FFF
DC.W $C000,$C003,$C0FC,$C0FF
DC.W $FF00,$FF03,$FFFC,$FFFF
TABLE6C DC.W $0000,$003F,$0FC0,$0FFF
DC.W $F000,$F03F,$FFC0,$FFFF
;-----------------------------------------------
;
; SCALE UP BY EIGHT USING TABLE LOOKUP
;
EIGHT MOVE.B (A0)+,D0 ;GET A BYTE OF SRC
MOVE D0,D1 ;MAKE AN EXTRA COPY
AND #$F0,D1 ;MASK FOR HI NIBBLE
LSR #2,D1 ;SHIFT FOR TABLE INDEX
MOVE.L TABLE8(D1),(A1)+ ;PUT FIRST LONG TO DST
AND #$0F,D0 ;MASK FOR LO NIBBLE
LSL #2,D0 ;SHIFT FOR TABLE INDEX
MOVE.L TABLE8(D0),(A1)+ ;PUT SECOND LONG TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO EIGHT ;NO, GO FOR MORE
RTS ;ALL DONE
TABLE8 DC.L $00000000,$000000FF,$0000FF00,$0000FFFF
DC.L $00FF0000,$00FF00FF,$00FFFF00,$00FFFFFF
DC.L $FF000000,$FF0000FF,$FF00FF00,$FF00FFFF
DC.L $FFFF0000,$FFFF00FF,$FFFFFF00,$FFFFFFFF
;-------------------------------------------------
;
; SCALE UP BY 16
;
SIXTEEN MOVEQ #-1,D1 ;GET SOME BLACK
MOVE #$8000,D0 ;INIT SRC DATA
SIXTENA ADD D0,D0 ;GET ONE BIT OF SRC
BCC.S WHITE16 ;BR IF WHITE
BNE.S BLACK16 ;BR IF BLACK
MOVE (A0)+,D0 ;ELSE GET NEXT SRC WORD
ADDX D0,D0 ;SHIFT SRC BIT OUT, 1 BIT IN
BCS.S BLACK16 ;BR IF BLACK
WHITE16 CLR.W (A1)+ ;PUT A WORD OF WHITE TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO SIXTENA ;NO, GO FOR MORE
RTS ;ALL DONE
BLACK16 MOVE D1,(A1)+ ;PUT A WORD OF BLACK TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
BLO SIXTENA ;NO, GO FOR MORE
RTS ;ALL DONE
;-----------------------------------------------
;
; SCALE UP BY ANY MULTIPLE OF 8 GREATER THAN 2
;
EIGHTS LSR #3,D4 ;DIVIDE SCALE FACTOR BY 8
SUB #1,D4 ;SUB 1 FOR LOOP COUNT
MOVE #$8000,D0 ;INIT SRC DATA
EIGHTS1 ADD D0,D0 ;GET ONE SRC BIT IN CARRY
BNE.S EIGHTS2 ;TIME FOR NEW SRC ?
MOVE (A0)+,D0 ;YES, GET NEXT SRC LONG
ADDX D0,D0 ;SHIFT SRC BIT OUT, 1 BIT IN
EIGHTS2 SCS D1 ;SET OR CLR A BYTE
MOVE D4,D2 ;INIT LOOP COUNT
EIGHTS3 MOVE.B D1,(A1)+ ;PUT ONE BYTE TO DST
CMP.L A2,A1 ;IS DSTPTR >= DSTLIMIT ?
DBHI D2,EIGHTS3 ;LOOP TILL SCALE OR DST FULL
BLS EIGHTS1 ;MORE SRC IF DST NOT FULL
BRA.S DONE ;THEN QUIT
;------------------------------------------------------------------
;
; DO FULL RATIO SCALING, SHRINKING ONE BIT AT A TIME
;
SHRINK CLR D1 ;INIT DST WORD
MOVE #$8000,D0 ;INIT SRC WORD
MOVE D0,D2 ;INIT MASK
MOVE D4,D3 ;COPY RATIO
LSR #1,D3 ;INIT ERR TO RATIO/2
NXTSRC1 ADD D0,D0 ;GET SRC BIT
BCC.S WHITE1 ;BRANCH IF WHITE
BNE.S BLACK1 ;BRANCH IF BLACK
MOVE (A0)+,D0 ;ELSE GET NEW SRC WORD
ADDX D0,D0 ;GET SRC BIT
BCC.S WHITE1 ;AND CONTINUE
BLACK1 OR D2,D1 ;SET A BIT IN DST
WHITE1 ADD D4,D3 ;TIME FOR NEXT DSTBIT ?
BCC NXTSRC1 ;NO, LOOP MORE SRC
ROR #1,D2 ;YES, ROTATE MASK
BCC NXTSRC1 ;LOOP IF DST WORD OK
MOVE D1,(A1)+ ;ELSE WRITE WORD TO DST
CLR D1 ;RESET DST WORD
CMP.L A2,A1 ;DSTPTR >= DSTLIMIT ?
BLO NXTSRC1 ;NO, LOOP
RTS ;YES, QUIT
;------------------------------------------------------------------
;
; DO FULL RATIO SCALING, STRETCHING ONE BIT AT A TIME
;
STRETCH CLR D1 ;INIT DST WORD
MOVE #$8000,D0 ;INIT SRC WORD
MOVE D0,D2 ;INIT MASK
MOVE D4,D3 ;COPY RATIO
LSR #1,D3 ;INIT ERR TO RATIO/2
NXTSRC2 ADD D0,D0 ;GET SRC BIT
BCC.S WHITE2 ;BRANCH IF WHITE
BNE.S BLACK2 ;BRANCH IF BLACK
MOVE (A0)+,D0 ;ELSE GET NEW SRC WORD
ADDX D0,D0 ;GET SRC BIT
BCC.S WHITE2 ;CONTINUE WITH WHITE
BRA.S BLACK2 ;CONTINUE WITH BLACK
BLACKOK ADD D4,D3 ;TIME FOR NEXT SRC BIT ?
BCS NXTSRC2 ;YES, LOOP FOR SRC
BLACK2 OR D2,D1 ;SET A BIT OF DST
ROR #1,D2 ;ROTATE MASK
BCC BLACKOK ;LOOP IF DST WORD OK
MOVE D1,(A1)+ ;ELSE WRITE WORD TO DST
CLR D1 ;RESET DST WORD
CMP.L A2,A1 ;DSTPTR >= DSTLIMIT ?
BLO BLACKOK ;NO, LOOP
RTS ;YES, QUIT
WHITEOK ADD D4,D3 ;TIME FOR NEXT SRC BIT ?
BCS NXTSRC2 ;YES, LOOP FOR SRC
WHITE2 ROR #1,D2 ;ROTATE MASK
BCC WHITEOK ;LOOP IF DST WORD OK
MOVE D1,(A1)+ ;ELSE WRITE WORD TO DST
CLR D1 ;RESET DST WORD
CMP.L A2,A1 ;DSTPTR >= DSTLIMIT ?
BLO WHITEOK ;NO, LOOP
DONE RTS
END
Reference in New Issue View Git Blame Copy Permalink