Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-06-06 06:29:27 +00:00
Code Issues Projects Releases Wiki Activity
master
sys7.1-doc-wip/QuickDraw/Patches/DrawPicture32Patch.a
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

1928 lines
60 KiB
Plaintext
Raw Permalink Blame History

;
; File: DrawPicture32Patch.a
;
; Contains: This patch gets loaded on Classic QD machines
;
; Written by: Konstantin Othmer
;
; Copyright: © 1987-1990 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <12> 3/23/91 KON csd, WRKSHT#SAH-QD-58: ReduceD3D4 would hang because MapRatio
; would return a zero result. I removed calls to MapRatio (since
; ReduceD3D4 does the same work) and changed ReduceD3D4 so it
; won't hang.
; <11> 1/14/91 KON Reduce Numer and Denom by GCD when drawing a picture. These
; overflow on higher DPI devices. [CEL]
; <10> 11/7/90 KON Fix display of 16-bit pixmaps (were drawn as all black). [smc]
; <9> 9/21/90 KON Added check for PICT2 header so we use the resolution adjusted
; rectangle for the header if the picture was created by
; openCPicture.
; <8> 9/17/90 dba Fix loop case for unpacking bits when the rectangle has a 0
; height. This was crashing while printing in Claris applications.
; <7> 9/11/90 KON Remove benign redefinition of pixmapTooDeepErr.
; <6> 8/2/90 gbm fix more warnings
; <5> 7/20/90 gbm get rid of excess equates
; <4> 4/4/90 KON Make into a linked patch
; <3> 3/29/90 KON Broke traps which load on all B&W machines to a new file
; AllB&WQDPatch.a. This makes the disk footprint much smaller.
; <2> 3/16/90 KON Add gWorld calls to PLUS, SE, and portable.
; <1.5> 12/4/89 KON Uses GrafTypes.m.a for include rather than ColorEqu.a.
; <1.4> 11/15/89 KON Now includes common file GetPMData.a and installs GetPMData as
; Trap $ABC4.
; <1.3> 11/9/89 KON Patch BitMapRgn only on Plus and SE
; <1.2> 11/7/89 KON Fixed font name/ID binding, added ptch for open picture and
; close picture
; <1.1> 11/7/89 BAL Added Font Name/ID binding, draw picture now works in low memory
; situations
; <1.0> 10/16/89 CCH Adding to EASE.
; 8/25/89 KON Added support for 16 & 32 bit picts for plus and SE
; PMAB270> 9/13/87 FJL Patch DrawPicture to first check for valid picture handle and
; pointer, then do GetState, make it non-purgeable, and SetState
; on return. At the request of Sheila, Phil and Scott.
; <PMA207> 7/16/87 EHB If device color table found, fill in pixel values
; <PMA157> 3/30/87 DBG Fixed bug where color table was freed even if there wasn't one.
; <S072> 2/27/87 DBG Added support for interpolated colors
; <S051> 2/19/87 DBG Fixed bug in interpretation of color table
;
;INITFILE EQU 0 ;set to 1 for standalone install, 0 for ptchInstall
;withFonts EQU 1 ;set to 1 to build with font name/ID binding
;wholeErrors EQU 1
;; INCLUDE 'SysErr.a'
; INCLUDE 'Traps.a'
; INCLUDE 'QuickEqu.a'
; INCLUDE 'SysEqu.a'
; INCLUDE 'GrafTypes.m.a'
; INCLUDE 'LinkedPatchMacros.a'
; RomBinds were here
PStdBits_SE_Portable EQU $0E00+(4*$EB)
PStdBits_Plus EQU $0C00+(4*$EB)
PStdGetPic_SE_Portable EQU $0E00+(4*$EE)
PStdGetPic_Plus EQU $0C00+(4*$EE)
IF (&TYPE('onMac') = 'UNDEFINED') THEN
onMac EQU 0
ENDIF
IF (&TYPE('onMacPP') = 'UNDEFINED') THEN
onMacPP EQU 0
ENDIF
noROM EQU 0
StdOpcodeProc PROC EXPORT
IMPORT GETWORD, GetLong,GetPicdata
;------------------------------------------------------------------
;
; PROCEDURE StdOpcode(fromRect,toRect: Rect; opcode,version: INTEGER);
;
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (StdOpcode) (StdOpcode)
;
; GETS CALLED FOR OPCODE VALUES $0100-$FFFF
;
; OPCODE: $0100-$01FF 2 BYTES DATA
; $0200-$02FF 4 BYTES DATA
; ...
; $7F00-$7FFF 254 BYTES DATA
; $8000-$80FF 0 BYTES DATA
; $8100-$FFFF 4 BYTES SIZE + SIZE BYTES DATA
;
; THIS PROCEDURE READS THE OPCODE'S DATA AND IGNORES IT unless it's the header
; from a PICT 2 created by OpenCPicture. <20Sept90 KON>
;
;--------------------------------------------
;
; OFFSETS WITHIN A PICTURE PLAY STATE RECORD:
;
THERECT EQU 0 ;RECT
PENLOC EQU THERECT+8 ;POINT
TEXTLOC EQU PENLOC+4 ;POINT
OVALSIZES EQU TEXTLOC+4 ;POINT
FROMRECT EQU OVALSIZES+4 ;RECT
TORECT EQU FROMRECT+8 ;RECT
NUMER EQU TORECT+8 ;POINT
DENOM EQU NUMER+4 ;POINT
THECLIP EQU DENOM+4 ;RGNHANDLE
USERCLIP EQU THECLIP+4 ;RGNHANDLE
PLAYVERSION EQU USERCLIP+4 ;PICTURE VERSION
TXHFRAC EQU PLAYVERSION+2 ;FRACTIONAL TEXT POSITION
NEWHFRAC EQU TXHFRAC+2 ;UPDATED FRACTION RECIEVED
TEMPPIXPAT EQU NEWHFRAC+2 ;PIXPAT FOR PLAYING NEW PICS IN OLD PORTS
FontMappingTbl EQU TEMPPIXPAT+4 ;Handle to array of old,new font id pairs
PSreserve1 EQU FontMappingTbl+4 ;reserved
PSreserve2 EQU PSreserve1+4 ;reserved
PLAYREC EQU PSreserve2+4 ;TOTAL SIZE
;------------------------------------------------------
;
; New offsets in a PICT2 header record:
;
hdrVersion EQU 0 ;Word (=-2)
hdrReserved EQU hdrVersion+2 ;Word
hdrHRes EQU hdrReserved+2 ;Fixed
hdrVRes EQU hdrHRes+4 ;Fixed
hdrSrcRect EQU hdrVRes+4 ;Rect
hdrReserved2 EQU hdrSrcRect+8 ;Long
picHdrSize EQU hdrReserved2+4 ;size of a PICT2 header record
;------------------------------------------------------------------
;
; PROCEDURE StdOpcode(fromRect,toRect: Rect; opcode,version: INTEGER);
;
; GETS CALLED FOR OPCODE VALUES $0100-$FFFF
;
; OPCODE: $0100-$01FF 2 BYTES DATA
; $0200-$02FF 4 BYTES DATA
; ...
; $7F00-$7FFF 254 BYTES DATA
; $8000-$80FF 0 BYTES DATA
; $8100-$FFFF 4 BYTES SIZE + SIZE BYTES DATA
;
; THIS PROCEDURE READS THE OPCODE'S DATA AND IGNORES IT
;
; A6 OFFSETS OF PARAMS AFTER LINK:
;
PARAMSIZE EQU 12
pFROMRECT EQU PARAMSIZE+8-4 ;LONG
pTORECT EQU pFROMRECT-4 ;LONG
OPCODE EQU pTORECT-2 ;WORD
VERSION EQU OPCODE-2 ;WORD
LINK A6,#0 ;NO LOCAL VARS
MOVEM.L D6/D7,-(SP) ;SAVE WORK REGISTERS
MOVE.L #256,D6 ;GET USEFUL NUMBER
SUB.L D6,SP ;ALLOCATE STACK BUFFER
MOVE OPCODE(A6),D0 ;GET THE OPCODE
BMI.S GETSIZE ;=>OP CONTAINS SIZE
LSR #8,D0 ;GET SIZE/2 IN LOW NIBBLE
ADD D0,D0 ;CALC SIZE
EXT.L D0 ;MAKE IT LONG
BRA.S SHARE ;=>USE COMMON CODE
GETSIZE AND #$7F00,D0 ;MASK THE OPCODE
BEQ.S DONE ;=>NO DATA BYTES
JSR GETLONG ;READ IN SIZE
SHARE MOVE.L D0,D7 ;SAVE WHOLE SIZE
NXTCHNK MOVE D6,D0 ;ASSUME SIZE >= 256
CMP.L D6,D7 ;IS SIZE >= 256?
BGE.S SIZEOK ;=>YES, SKIP 256 BYTES
MOVE D7,D0 ;ELSE SKIP REMAINING BYTES
SIZEOK MOVE.L SP,-(SP) ;PUSH BUFFER POINTER
MOVE D0,-(SP) ;PUSH BYTECOUNT
JSR GETPICDATA ;READ DATA INTO BUFFER
SUB.L D6,D7 ;SUBTRACT BUFSIZE FROM COUNT
BGT.S NXTCHNK ;=>GO SKIP NEXT CHUNK
;
; This stuff is taken from Pictures.a <20Sept90 KON>
;
cmp.w #ngHeaderOp,OPCODE(a6) ;pict2 header opcode? <18Jan90 KON>
bne.s done ;not a pict2 header opcode <18Jan90 KON>
cmp.w #$fffe,(sp) ;is it version -2 header? <18Jan90 KON>
bne.s done ;<27nov89 KON> <18Jan90 KON>
move.l pFromRect(a6),a1 ;point to playstate's FromRect
lea hdrSrcRect(sp),a0 ;point to sourceRect stored in header record
MOVE RIGHT(A0),D0
SUB LEFT(A0),D0 ;CALC SRC WIDTH
MOVE D0,DENOM+H-FromRect(A1) ;DENOM.H := SRC WIDTH
MOVE BOTTOM(A0),D0
SUB TOP(A0),D0 ;CALC SRC HEIGHT
MOVE D0,DENOM+V-FromRect(A1) ;DENOM.V := SRC HEIGHT
MOVE.L (A0)+,(A1)+
MOVE.L (A0)+,(A1)+ ;FROMRECT := PICFRAME
;
; end <20Sept90 KON>
;
DONE ADD.L D6,SP ;STRIP BUFFER
MOVEM.L (SP)+,D6/D7 ;RESTORE WORK REGISTERS
UNLINK PARAMSIZE,'STDPICPR' ;destroys condition codes
ENDPROC
;=========================================================================================
;=========================================================================================
;
; Add routines to calculate to reduce numer and denom by GCD
;
; These are called by DrawPicture and PicItem1
;
;=========================================================================================
;=========================================================================================
CalcGCD PROC EXPORT
; Routine returns GCD( d0, d1 ) using Euclidean method
; On Entry: D0 and D1 contain word size values to reduce
; On Exit: D0 and D1 both contain GCD
;
cmp.l d0,d1 ;while d0 != d1 (unsigned word compare)
beq.s @FoundGCD
bgt.s @D1isBigger ; if( d1 < d0 )
exg d0,d1 ; swap( d1, d0 )
@D1isBigger
sub d0,d1 ; d1 = d1 - d0
bra.s CalcGCD ;end while
@FoundGCD
rts ;d0 and d1 contain GCD
ENDPROC
ReduceD3D4 PROC EXPORT
IMPORT CalcGCD
; Routine returns ReduceD3D4( d3, d4 ) reduces d3.w and d4.w by GCD for
; both the low and high words
;
; On Entry: D3 and D4 contain two word size values to reduce
; On Exit: D3 and D4 contain reduced values
;
;
; Divide Numer and Denom for width and height by GCD to prevent overflow.
;
moveq #0,d0 ;make sure high word is zero for next 2 divides
move.l d0,d1 ;CalcGCD exchanges regs, so both need to be cleared
move.w d3,d0 ;D0 has denom.v, d1 has numer.v
beq.s @Done ;abort if zero.
move.w d4,d1 ;D0 has denom.v, d1 has numer.v
beq.s @Done ;abort if zero.
jsr CalcGCD ;returns GCD in d0
move.w d3,d1 ;D0 has denom.v, d1 has numer.v
divu.w d0,d1 ;dividing by GCD should never leave remainder
move.w d1,d3 ;save reduced numer.v
move.w d4,d1 ;D0 has denom.v, d1 has numer.v
divu.w d0,d1
move.w d1,d4 ;save reduced denom.v
;
; Now do width: Could have different scale factor than height did
;
swap d3 ;operate on high word
swap d4
move.w d3,d0 ;D0 has denom.h, d1 has numer.h
beq.s @DoneSwap ;abort if zero.
move.w d4,d1 ;D0 has denom.h, d1 has numer.h
beq.s @DoneSwap ;abort if zero.
jsr CalcGCD ;returns GCD in d0
move.w d3,d1 ;D0 has denom.h, d1 has numer.h
divu.w d0,d1 ;dividing by GCD should never leave remainder
move.w d1,d3 ;save reduced numer.h
move.w d4,d1 ;D0 has denom.h, d1 has numer.h
divu.w d0,d1
move.w d1,d4 ;save reduced denom.h
@DoneSwap
swap d3 ;put things back
swap d4
@Done
rts ;all done
;
; End <KON 7/1/91>
;
ENDPROC
INCLUDE 'DrawPicturePlusSE.a'
INCLUDE 'DrawPicturePortable.a'
;---------- broke out local procs from picItem1 for code sharing ------------
GETSBYTE FUNC EXPORT
IMPORT GetPicData
;------------------------------------------------------
;
; LOCAL PROCEDURE TO GET A SIGNED BYTE INTO D0 FROM PICTURE
;
CLR.B -(SP) ;ALLOCATE TEMP
MOVE.L SP,-(SP) ;PUSH ADDR OF TEMP
MOVE #1,-(SP) ;PUSH BYTECOUNT
JSR GetPicData ;GET DATA FROM THEPIC
MOVE.B (SP)+,D0 ;POP RESULT
EXT.W D0 ;SIGN EXTEND TO WORD
RTS
;-----------------End of breaking out local procs-----------------------------
GETLONG FUNC EXPORT
IMPORT GetPicData
;----------------------------------------------------------
;
; LOCAL PROCEDURE TO GET A LONG FROM PICTURE INTO D0
;
CLR.L -(SP) ;ALLOCATE TEMP
MOVE.L SP,-(SP) ;PUSH ADDR OF TEMP
MOVE #4,-(SP) ;PUSH BYTECOUNT
JSR GetPicData ;GET DATA FROM THEPIC
MOVE.L (SP)+,D0 ;RETURN ANSWER IN D0
RTS
MAPMODE FUNC EXPORT
;----------------------------------------------------------
;
; LOCAL PROCEDURE TO MAP COLOR QUICKDRAW MODES TO OLD MODES
;
CMP.W #$1F,D0 ;OLD MODE, OR UNKNOWN?
BLS.S DONEMODE ;SKIP OUT
CMP.W #$2F,D0 ;WITHIN CORRECT RANGE?
BLS.S @MAPIT ;SKIP IF SO
CMP.W #$32,D0 ;HILITE?
BEQ.S @MAPIT ;SKIP IF SO
CMP.W #$3A,D0 ;HILITE?
BNE.S DONEMODE ;NO, PASS THROUGH
@MAPIT
AND.W #7,D0 ;EXTRACT LOW 3 BITS
MOVE.B arithMode(D0.W),D0 ;GET EQUIVALENT MODE
DONEMODE
RTS ;QUIT
; [This table extracted from utils.a]
arithMode
; hilite
;avg addPin addOver subPin trans max subOver min
DC.B srcCopy, srcBic, srcXor, srcOr, srcOr, srcBic, srcXor, srcOr
SkipPicData PROC EXPORT
IMPORT GETPICDATA
;----------------------------------------------------------
;
; LOCAL PROCEDURE TO SKIP D0.L BYTES IN THE PICTURE
;
MOVEM.L D6/D7,-(SP) ;SAVE WORK REGISTERS
MOVE.L #256,D6 ;GET USEFUL NUMBER
SUB.L D6,SP ;ALLOCATE STACK BUFFER
MOVE.L D0,D7 ;SAVE WHOLE SIZE
BEQ.S IGDONE ;=>NO DATA, JUST RETURN
NXTCHNK MOVE D6,D0 ;ASSUME SIZE >= 256
CMP.L D6,D7 ;IS SIZE >= 256?
BGE.S IGSIZEOK ;=>YES, SKIP 256 BYTES
MOVE D7,D0 ;ELSE SKIP REMAINING BYTES
IGSIZEOK MOVE.L SP,-(SP) ;PUSH BUFFER POINTER
MOVE D0,-(SP) ;PUSH BYTECOUNT
JSR GETPICDATA ;READ DATA INTO BUFFER
SUB.L D6,D7 ;SUBTRACT BUFSIZE FROM COUNT
BGT.S NXTCHNK ;=>GO SKIP NEXT CHUNK
IGDONE ADD.L D6,SP ;STRIP BUFFER
MOVEM.L (SP)+,D6/D7 ;RESTORE WORK REGISTERS
RTS
GetPicTable PROC EXPORT
IMPORT GetPicData,GETLONG
;------------------------------------------------------
;
; PROCEDURE GetPicTable(CTabHandle);
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (GetPicTable) (GetPicTable)
;
;
JSR GETLONG ;GET SEED INTO D0
MOVE.L D0,-(SP) ;SAVE SEED
JSR GETLONG ;GET TRANSINDEX, SIZE INTO D0
MOVE.L D0,-(SP) ;SAVE TRANSINDEX,SIZE
MOVE D0,D2 ;GET SIZE INTO D2
ADDQ #1,D2 ;MAKE IT ONE BASED
MULU #CTENTRYSIZE,D2 ;GET SIZE OF TABLE
MOVE.L D2,D0 ;SAVE SIZE OF TABLE
ADD #CTREC,D0 ;ADD SIZE OF HEADER
MOVE.L 12(SP),A0 ;GET HANDLE
_SETHANDLESIZE ;RESIZE IT
BEQ.S @1 ;Skip if OK
MOVEQ #25, D0 ;Sayonara, sweetheart
_SysError
; ??? Should really be able to do better than this. Maybe if this fails,
; we should do an _EmptyHandle as a signal to the caller that we flopped???
@1
_HLock ;LOCK IT
MOVE.L (A0),A0 ;POINT TO CTAB
MOVE.L (SP)+,D0 ;GET TRANSINDEX,SIZE
MOVE.L (SP)+,(A0)+ ;COPY SEED TO CTAB
MOVE.L D0,(A0)+ ;COPY TRANSINDEX,SIZE
MOVE.L A0,-(SP) ;PUSH DST POINTER
MOVE D2,-(SP) ;PUSH BYTECOUNT
JSR GETPICDATA ;READ DATA FROM PICTURE
MOVE.L 4(SP),A0 ;GET HANDLE
_HUnlock ;UNLOCK IT
MOVE.L (A0),A0 ;point to table <PMA207>
TST transIndex(A0) ;device color table? <PMA207>
BPL.S @done ;=>no, just return <PMA207>
MOVE ctSize(A0),D0 ;get size of table <PMA207>
MOVEQ #0,D1 ;get first pixel value <PMA207>
ADDQ #ctRec,A0 ;point to first entry <PMA207>
@2 MOVE D1,(A0) ;stuff a pixel <PMA207>
ADDQ #ctEntrySize,A0 ;bump to next entry <PMA207>
ADDQ #1,D1 ;bump to next pixel value <PMA207>
DBRA D0,@2 ;repeat for all entries <PMA207>
@done MOVE.L (SP)+,(SP) ;STRIP PARAM
RTS ;AND RETURN
;
; GetPicData, getubyte, getword also appear in DrawPicture32Patch.a. They should
; only appear in one place xxxxx
;
GetPicData PROC EXPORT
;------------------------------------------------------------------
;
; PROCEDURE GetPicData(dataPtr: QDPtr; byteCount: INTEGER);
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (GetPicData) (GetPicData)
;
;
MOVE.L 6(SP),-(SP) ;COPY DATAPTR
MOVE.W 8(SP),-(SP) ;COPY BYTECOUNT
MOVE.L GRAFGLOBALS(A5),A0 ;POINT TO QUICKDRAW GLOBALS
MOVE.L THEPORT(A0),A0 ;GET CURRENT GRAFPORT
MOVE.L GRAFPROCS(A0),D0 ;IS GRAFPROCS NIL ?
MOVE.L PStdGetPic_SE_Portable,A0 ;get piece of trap table (SE or Portable)
ENTRY GetPicDataStdGetPic
GetPicDataStdGetPic equ * - 2 ;fix the word in the above instruction on Plus
BEQ.S USESTD ;yes, use std proc
MOVE.L D0,A0
MOVE.L GETPICPROC(A0),A0 ;NO, GET GET PROC PTR
USESTD JSR (A0) ;AND CALL IT
MOVEQ #0,D0 ;CLEAR HIGH WORD
MOVE.W 4(SP),D0 ;GET BYTECOUNT
MOVE.L GRAFGLOBALS(A5),A0 ;POINT TO QUICKDRAW GLOBALS
ADD.L D0,PLAYINDEX(A0) ;BUMP PLAYINDEX
MOVE.L (SP)+,A0 ;RETURN ADDRESS
ADDQ #6,SP ;STRIP PARAMS
JMP (A0) ;RETURN
ENDPROC
FixStdGetPicInGetPicData INSTALLPROC (Plus)
IMPORT GetPicDataStdGetPic
lea GetPicDataStdGetPic,a0 ;point at above code
move.w #PStdGetPic_Plus,(a0) ;jam in the correct vector for the Mac. Plus
rts
ENDPROC
GETUBYTE FUNC EXPORT
IMPORT GetPicData
;------------------------------------------------------
;
; LOCAL PROCEDURE TO GET AN UNSIGNED BYTE INTO D0 FROM PICTURE
;
CLR.B -(SP) ;ALLOCATE TEMP
MOVE.L SP,-(SP) ;PUSH ADDR OF TEMP
MOVE #1,-(SP) ;PUSH BYTECOUNT
JSR GetPicData ;GET DATA FROM THEPIC
CLR D0 ;GET READY FOR BYTE
MOVE.B (SP)+,D0 ;POP RESULT INTO LO BYTE
RTS
GETWORD FUNC EXPORT
IMPORT GetPicData
;------------------------------------------------------
;
; LOCAL PROCEDURE TO GET A WORD FROM PICTURE INTO D0
;
CLR.W -(SP) ;ALLOCATE TEMP
MOVE.L SP,-(SP) ;PUSH ADDR OF TEMP
MOVE #2,-(SP) ;PUSH BYTECOUNT
JSR GetPicData ;GET DATA FROM THEPIC
MOVE (SP)+,D0 ;RETURN ANSWER IN D0
RTS
GetPicPixPat PROC EXPORT
IMPORT GetWord,GETPICDATA
IMPORT RGB2Pat,GETLONG,GetUByte
;------------------------------------------------------
;
; PROCEDURE GetPicPixPat(PatPtr);
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (GetPicPixPat) (GetPicPixPat)
;
;
; GET TYPE AND ONE BIT PATTERN FROM THE PICTURE
MOVEQ #10,D0 ;GET NUMBER OF BYTES
SUB D0,SP ;MAKE ROOM FOR TYPE, PATTERN
MOVE.L SP,-(SP) ;PUSH POINTER
MOVE D0,-(SP) ;PUSH BYTE COUNT
JSR GETPICDATA ;READ IN 10 BYTES
MOVE.L 14(SP),A0 ;GET PTR TO PATTERN
MOVE (SP)+,D1 ;GET TYPE
MOVE.L (SP)+,(A0)+ ;SAVE 1ST HALF PATTERN
MOVE.L (SP)+,(A0) ;SAVE 2ND HALF PATTERN
CMP.W #ditherPat,D1 ;IS IT A DITHER PATTERN?
BNE.S @1 ;No, just use pattern data
MOVEQ #6,D0 ;Size of RGB buffer
SUB.L D0,SP ;MAKE ROOM FOR RGB ON STACK
MOVE.L SP,-(SP) ;BUFFER ADDRESS
MOVE D0,-(SP) ;LENGTH
jsr GetPicData ;GET R, G, B
MOVE.L SP,A1 ;Point at RGB
JSR RGB2Pat ;Get pattern
ADDQ #6,SP ;Blow off RGB
MOVE.L 4(SP),A1 ;GET PAT PTR
MOVE.L D0,(A1)+ ;Copy gray pattern
MOVE.L D0,(A1)
BRA.S PATDONE ;No pixmap to skip
@1
; GET PIXMAP FROM THE PICTURE
MOVEQ #PMREC-4,D0 ;Size of record
SUB.W D0,SP ;Make handy buffer
MOVE.L SP,-(SP) ;Push PIXMAP pointer
MOVE.W D0,-(SP) ;Push length
JSR GetPicData ;Get the information
; SKIP THE COLOR TABLE.
JSR GETLONG ;Skip the seed
JSR GETLONG ;Get TRANSINDEX, SIZE
ADDQ #1,D0 ;Make size 1-based
MULU #CTENTRYSIZE,D0 ;Get size of table
JSR SkipPicData ;Skip the rest of the table
; SKIP PIXMAP DATA FROM PICTURE
LEA -4(SP),A1 ;GET PIXMAP POINTER
MOVE BOUNDS+BOTTOM(A1),D1 ;GET TOP OF PIXMAP
SUB BOUNDS+TOP(A1),D1 ;CALC HEIGHT OF PIXMAP
MOVE ROWBYTES(A1),D0 ;GET WIDTH OF PIXMAP
AND #RBMASK,D0 ;MASK OFF FLAG BITS
CMP #8,D0 ;IS ROWBYTES < 8
BLT.S @NOPACK ;=>YES, DON'T UNPACK
MOVEM.L D3-D4,-(SP) ;SAVE WORK REGS
MOVE D0,D3 ;SAVE ROWBYTES
MOVE D1,D4 ;SAVE HEIGHT
BRA.S @START1 ;GO TO LOOP START
@MORE1
CMP #250,D3 ;IS ROWBYTES > 250
BGT.S @3 ;=>YES, GET WORD
JSR GetUByte ;ELSE GET A BYTE INTO D0
BRA.S @2 ;=>AND GO GET DATA
@3 JSR GETWORD ;GET A WORD INTO D0
@2
SWAP D0 ;HIGH WORD
CLR.W D0 ;MAKE SURE IT'S 0
SWAP D0 ;GET BACK IN RIGHT ORDER
JSR SkipPicData ;Skip that much
@START1
DBRA D4,@MORE1 ;LOOP HEIGHT ROWS
MOVEM.L (SP)+,D3-D4 ;RESTORE WORK REGS
BRA.S @PIXDONE ;CONTINUE
;
; ROWBYTES < 8, DON'T USE PACKING
;
@NOPACK
MULU D1,D0 ;GET DATA SIZE
JSR SkipPicData ;Skip that much
@PIXDONE
ADD #PMREC-4,SP ;POP PIXMAP
PATDONE
MOVE.L (SP)+,(SP) ;STRIP PARAM
RTS ;AND RETURN
GetPM1Deep PROC EXPORT
IMPORT GetUByte,GetWord,GetPicData, patTBL
;------------------------------------------------------
;
; PROCEDURE GetPM1Deep(myDst: Ptr; xTab: Ptr; myData: Handle; targetRB: SHORT; mode SHORT); <19Feb87 DBG>
;
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (GetPM1Deep) (GetPM1Deep)
;
; HANDLE SIZE IS SET TO ROWBYTES*(BOUNDS.BOTTOM-BOUNDS.TOP) EXTERNALLY
;
PARAMSIZE EQU 16
MYDST EQU PARAMSIZE+8-4 ;DST PIXMAP POINTER
XTAB EQU MYDST-4 ;TRANSLATE TABLE POINTER <19Feb87 DBG>
MYDATA EQU XTAB-4 ;DST DATA HANDLE <19Feb87 DBG>
TARGETRB EQU MYDATA-2 ;TARGET ROWBYTES
MODE EQU TARGETRB-2 ;copybits copy mode (64 means dither)
SrcHndl EQU -4 ;VAR POINTER TO SOURCE
DSTPTR EQU SrcHndl-4 ;VAR POINTER TO DST
PACKBUF EQU DSTPTR-4 ;POINTER TO PACKING BUFFER
SAVEDSP EQU PACKBUF-4 ;PRESERVE STACK POINTER
BITSDST EQU SAVEDSP-4 ;CURRENT OUTPUT POINTER
MUSTMAP EQU BITSDST-2 ;NEED TO MAP?
LastError EQU MustMap-2 ;luminance error value
Direction EQU LastError-2 ;alternate directions for dither
VARSIZE EQU Direction
LINK A6,#VARSIZE ;MAKE A STACK FRAME
MOVEM.L D3-D7/A2-A4,-(SP) ;SAVE WORK REGISTERS
MOVE.L SP,SAVEDSP(A6) ;PRESERVE STACK POINTER
MOVE.L MYDST(A6),A2 ;POINT TO PIXMAP
MOVE.L MYDATA(A6),A0 ;GET DATA HANDLE
; _HLOCK ;LOCK IT DOWN
MOVE.L (A0),BITSDST(A6) ;GET DATA POINTER IN BITSDST
MOVE BOUNDS+BOTTOM(A2),D7
SUB BOUNDS+TOP(A2),D7 ;HEIGHT := BOUNDS BOT - TOP
MOVE ROWBYTES(A2),D5 ;GET ROWBYTES
SMI MUSTMAP(A6) ;SET FLAG IFF PIXMAP
AND #RBMASK,D5 ;CLEAR OFF FLAG BITS
;
; Here we calculate ROWBYTES + ROWBYTES/64, rounded up to an even number.
; The worst-case expansion from _PackBits is one extra byte for every
; 127 bytes of data. Rather than divide by 127, we divide by 64, the next
; lowest power of 2.
;
MOVE D5,D6 ;COPY ROWBYTES
ADD #63,D6 ;MAKE SURE TO ROUND UP!
LSR.W #6,D6 ;GET CEIL(ROWBYTES/64)
ADDQ.W #1,D6 ;ROUND UP...
BCLR #0,D6 ;...TO EVEN NUMBER
ADD D5,D6 ;SIZE OF PACKED BUFFER
CMP #8,D5 ;ROWBYTES < 8?
BGE.S @DOUNPACK ;=>NO, GO DO UNPACK
TST ROWBYTES(A2) ;BITMAP, NOT PIXMAP?
BPL NOPACK ;GO READ IT STRAIGHT IN
@DOUNPACK
TST.B MUSTMAP(A6) ;PIXMAP?
BEQ.S @GetRow ;=>NO, BITMAP
MOVE PIXELSIZE(A2),D4 ;=>YES, PIXMAP: GET BITS/PIXEL
cmp #32,d4 ;32 bit/pixel?
beq @getrow ;if so, skip get mask stuff
MOVE D4,D0 ;COPY IT
LSL.W #1,D0 ;DOUBLE IT
NEG.W D0 ;NEGATE IT
; ??? 64K ROM problem. Need to do LEA on 64K ROM. ???
_GetMaskTable ;GET MASK TABLE ADDRESS
MOVE (16*2*2)(A0,D0.W),D3 ;GET MASK FOR PIXEL
MOVE.L XTAB(A6),A4 ;XLATE TABLE POINTER <19Feb87 DBG>
CMP.W #1,D4 ;TEST BITS/PIXEL
BNE.S @GetRow ;IF <>1, MUST MAP
CMP.W #$0001,(A4) ;MAPPING NEEDED? <19Feb87 DBG>
SNE MUSTMAP(A6) ;IF NOT $0001, MUST MAP
;----------------------------------------------------------------
;
; Get unpacked data one row at a time
;
@GetRow
;
; Allocate handle for one row of source information
; and initialize various dither parameters
;
move.w #-127, LastError(a6) ;init luminance error (8-bit)
cmp.w #16,d4
bne @1
move.w #-15, LastError(a6) ;5-bit luminance error init
@1
move.w #0, direction(a6)
move RowBytes(A2),d0
and #RBMASK,d0
_NewHandle ;allocate handle for row of source info
bne.s ExitGetPM1Deep ;Exit with not equal set <Halloween89 KON>
move.l a0, SrcHndl(a6)
_HLock
;
; Do one row at a time
;
move Bounds+bottom(a2), d5 ;Save old bounds.bottom
move Bounds+top(a2), Bounds+bottom(a2) ;make bit/pix map ...
addq #1, Bounds+bottom(a2) ;...one row high
bra.s START1 ;start off the loop <8 dba>
GetRow1
move.l a2,-(sp) ;push source pixmap data
MOVE.L SrcHndl(A6),-(SP) ;put row of data here
IF INITFILE THEN
dc.w $A8F3 ;Test with open picture trap num
ELSE
dc.w $ABC4 ;_GetPMData
ENDIF
; JSR GETPMDATA ;AND READ IN PIXMAP DATA
move.l SrcHndl(a6),a0
move.l (a0),a0
JSR MapRow ;Map the row and place 1 bit/pixel in dst
START1 DBRA D7,GetRow1 ;LOOP HEIGHT ROWS
;----------------------------------------------------------------
;
; Dispose row handle and set bounds back
;
move d5, Bounds+bottom(a2) ;bounds.top was unchanged
move.l SrcHndl(a6),a0
_DisposHandle
BRA.S DONE ;CONTINUE
;----------------------------------------------------------------
; ROWBYTES < 8 and it's a bitmap, DON'T USE PACKING
; OR it's already 1 bit/pixel
;
NOPACK MULU D7,D5 ;BYTECOUNT := HEIGHT * WIDTH
MOVE.L BITSDST(A6),-(SP) ;PUSH DATA POINTER
MOVE D5,-(SP) ;PUSH BYTECOUNT
JSR GetPicData ;READ BITMAP DATA BITS
Done
move #0, d0 ;successfully created 1-bit bitmap <Halloween89 KON>
bra.s PMDone
ExitGetPM1Deep ;Error exit branches here <Halloween89 KON>
move #1, d0 ;d0 != 0 indicates error
PMDone MOVE.L SAVEDSP(A6),SP ;RESTORE STACK POINTER
MOVEM.L (SP)+,D3-D7/A2-A4 ;RESTORE WORK REGISTERS
UNLINK PARAMSIZE,'GETPMDAT' ;destroys condition codes
;-----------------------------------------------
;
; MapRow - internal utility to map a row to a one-bit-deep row
; and copy it into the target bitmap.
; Uses up-level stack frame. Source ptr passed in a0, destination in bitsdst
; d4.w has bits/pixel
MapRow
;
; Now it's time to actually shrink the bits.
; We build up a word of output at a time (since rowbytes is even, it doesn't
; matter if we convert a slop byte), then write it out. We have two loops:
; An outer one over words of output, and an inner one over words of input.
; In the interests of patch compactness, the only special case we make is
; if the number of colors is <= 32, in which case we keep the color mapping
; bitmap in D6 for speed.
;
MOVEM.W D4-D7/a3,-(SP) ;SAVE REGISTERS
MOVE BOUNDS+RIGHT(A2),D7 ;GET BOUNDS.RIGHT
SUB BOUNDS+LEFT(A2),D7 ;CALC WIDTH
MOVE.L BITSDST(A6),A1 ;Destination pointer
tst.b MustMap(a6)
bne.s MapRow1 ;need to map the row
;
; No mapping needed: copy bits to destination buffer
;
move.w rowbytes(a2),d7
and #RBMask, d7
sub #1, d7 ;zero base loop
@LOOP
move.b (a0)+,(a1)+
dbra d7,@loop
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES (HIWRD CLR)
and.l #$FFFF,d0
ADD.l D0,BITSDST(A6) ;NEXT SCAN LINE
bra Shrunk
MapRow1
CMP.W #8,D4 ;8 BITS/PIXEL?
BEQ.S EIGHTLOOP ;=>YES, USE CUSTOM LOOP
cmp.w #32,d4
beq ThirtyTwoLOOP ;Use custom loop for 32bits/pixel <28AUG89 KON>
cmp.w #16,d4
beq SixteenBitLOOP ;Use custom loop for 16bits/pixel <28AUG89 KON>
;
; Start of the shrinking loop. A0 is source, A1 is destination, a4 points to translation table.
; We assume an even number of pixels per 16-bit word. They are isolated,
; one by one, and a one or zero or'd in to the output word we're building up.
;
@NEXTOUTWORD
MOVEQ #16,D6 ;BITS/OUTPUT WORD
MOVEQ #0,D2 ;OUTPUT WORD
@NEXTINWORD
MOVEQ #16,D1 ;BITS IN INPUT WORD
MOVE (A0)+,D5 ;GET NEXT INPUT WORD
@NEXTPIX
ROL.W D4,D5 ;ISOLATE NEXT PIXEL
MOVE D5,D0 ;GET COPY
AND D3,D0 ;GET PIXEL
LSL.W #1,D2 ;MAKE ROOM FOR NEW PIXEL
OR.B (A4,D0.W),D2 ;GET NEW PIXEL <19Feb87 DBG>
SUBQ #1,D7 ;ONE LESS PIXEL
SUBQ #1,D6 ;ONE LESS OUTPUT PIXEL
SUB D4,D1 ;BITS LEFT IN INPUT WORD
BGT.S @NEXTPIX ;IF SOME LEFT, GET NEXT PIX
TST D7 ;ANY INPUT LEFT?
BLE.S @1 ;NO, DONE WITH LINE
TST D6 ;ANY OUTPUT ROOM LEFT?
BGT.S @NEXTINWORD ;YES, GET NEXT INPUT WORD
MOVE D2,(A1)+ ;WRITE AN OUTPUT WORD
BRA.S @NEXTOUTWORD
@1
LSL.W D6,D2 ;LEFT JUSTIFY LAST WORD
MOVE D2,(A1)+ ;WRITE AN OUTPUT WORD
MOVEQ #0,D0 ;CLEAR OUT LONG
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES
and.l #$ffff,d0 ;clear hi word
ADD.L D0,BITSDST(A6) ;NEXT SCAN LINE
BRA SHRUNK ;EXIT
;
; Here is the custom loop for eight bit pixels. Principle is
; the same as the previous loop.
;
EIGHTLOOP
MOVEQ #0,D0 ;CLEAR PIXEL BUFFER/ROWBYTES
@NEXTOUTWORD
MOVEQ #15,D6 ;BITS/OUTPUT WORD (-1)
MOVEQ #0,D2 ;OUTPUT WORD
@NEXTPIX
MOVE.B (A0)+,D0 ;GET NEXT INPUT BYTE
LSL.W #1,D2 ;MAKE ROOM FOR NEW PIXEL
OR.B (A4,D0.W),D2 ;GET IT <19Feb87 DBG>
SUBQ #1,D7 ;ONE LESS PIXEL
BLE.S @1 ;IF NONE LEFT, DONE WITH ROW
DBRA D6,@NEXTPIX ;LOOP FOR NEXT PIXEL
MOVE D2,(A1)+ ;WRITE AN OUTPUT WORD
BRA.S @NEXTOUTWORD
@1
LSL.W D6,D2 ;LEFT JUSTIFY LAST WORD
MOVE D2,(A1)+ ;WRITE LAST OUTPUT WORD
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES
and.l #$ffff,d0 ;clear hi word
ADD.L D0,BITSDST(A6) ;NEXT SCAN LINE
bra SHRUNK ;exit <28AUG89 KON>
;------------------------------------------------------------------
;
; SCALES A SCANLINE OF PIXELS FROM 32 BIT DIRECT TO A B/W BitMap
; ASSUMES SRC IS COMPOSED OF FOUR BYTES OF THE FORM 'XRGB'
;
; D7: Number of pixels to convert
; A0: SRC BUFFER
; A1: DST BUFFER
ThirtyTwoLOOP
move.l #$80000000,d5 ;init offset into dst
moveq #0,d0 ; d0-d2 hold r,g,b values...
moveq #0,d1 ;...when calculating luminance...
moveq #0,d2 ;...and only low byte is used.
move.w LastError(a6),d3 ;get luminance error from last line
btst #6, mode+1(a6) ;do dithering?
beq.s NewOutputLong ;no
eori.w #1, direction(a6) ;if we dither, we scan ...
beq.s DoReverseThirtyTwoLoop ;... backwards every other time
NewOutputLong
moveq #0, d6 ;assume output value will be white
move.l #$80000000,d5 ; rotating mask
NextInputLong
move.l (a0)+,d4 ;get next long of src
move.b d4,d2 ; get the blue component
lsr.l #8,d4 ; get red,green in low word
move.b d4,d1 ; get the green component
lsr.w #8,d4 ; get red in low byte
move.b d4,d0 ; get the red component
; Compute Luminance = ((((((r+g)/2)+b)/2+r)/2)+g)/2
add.w d1,d4
add.w d2,d4
add.w d2,d4
lsr.w #2,d4
add.w d0,d4
add.w d1,d4
add.w d1,d4
lsr.w #2,d4
btst #6, mode+1(a6)
beq.s NoDither
;
; add luminance to current error and compare to threshold
; if lum + err <= 0 then pixel is set.
;
add.w d4,d3 ;add luminance to error (slop)
ble.s SetBit
sub.w #255,d3
bra.s SetBitDone
;
; No Dithering: Use 50% theshold
NoDither
tst.b d4 ; check high bit of luminance
bmi.s SetBitDone ; if set, pixel is white (0), so skip
SetBit
or.l d5,D6 ; set pixel value
SetBitDone
sub #1, d7 ;done enough pixels?
beq.s @rowdone ;
lsr.l #1,d5 ;BUMP TO NEXT DST PIXEL
bne.s NextInputLong
move.l d6,(a1)+ ;save destination pixel values
bra.s NewOutputLong
@rowdone
MOVE.L D6,(A1)+ ;done: save current output value
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES
and.l #$ffff,d0 ;clear hi word
ADD.L D0,BITSDST(A6) ;NEXT SCAN LINE
move.w d3, LastError(a6) ;save luminance error for next line
bra shrunk
;
; Scan line in reverse direction
;
DoReverseThirtyTwoLoop
moveq #0,d4 ;clear high word of temp pixel count
move.w d7, d4 ;pixel count to temp register
lsl.l #2, d4 ;convert to long
add.l d4, a0 ;move to end of source
add.l #31<<2,d4 ;31<<2
lsr.l #5, d4 ;/4 to convert XRGB to pixels...
;... and /32 because 32 pixels/long...
;... and *4 because we 4 bytes/long
and.w #$fffc,d4 ;must end on word boundry
add.l d4, a1 ;move to end of destination
move d7, d4 ;find starting pixel position
sub.w #1, d4
and.w #$1f, d4 ;get pixel count mod 32
move.l #$80000000,d5
lsr.l d4, d5 ;move to starting pixel position
moveq #0, d6
bra.s ReverseNextInputLong
ReverseNewOutputLong
moveq #0,d6 ;assume output value will be white
moveq #$00000001,d5 ; rotating mask: start on right...
;...and move left
ReverseNextInputLong
move.l -(a0),d4 ;get long of src
move.b d4,d2 ; get the blue component
lsr.l #8,d4 ; get red,green in low word
move.b d4,d1 ; get the green component
lsr.w #8,d4 ; get red in low byte
move.b d4,d0 ; get the red component
; Compute Luminance = ((((((r+g)/2)+b)/2+r)/2)+g)/2
add.w d1,d4
add.w d2,d4
add.w d2,d4
lsr.w #2,d4
add.w d0,d4
add.w d1,d4
add.w d1,d4
lsr.w #2,d4
add.w d4,d3 ;add luminance to error (slop)
bpl.s ReverseDitherSetBitDone
or.l d5,D6 ; set pixel value
bra.s ReverseSetBitDone
ReverseDitherSetBitDone
sub.w #255,d3
ReverseSetBitDone
sub #1, d7 ;done enough pixels?
beq.s @rowdone ;
lsl.l #1, d5 ;BUMP TO NEXT DST PIXEL
bne.s ReverseNextInputLong
move.l d6,-(a1) ;save destination pixel values
bra.s ReverseNewOutputLong
@rowdone
MOVE.L D6,-(A1) ;done: save current output value
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES
and.l #$ffff,d0 ;clear hi word
ADD.L D0,BITSDST(A6) ;NEXT SCAN LINE
move.w d3, LastError(a6) ;save luminance error for next line
bra shrunk
;------------------------------------------------------------------
;
; SCALES A SCANLINE OF PIXELS FROM 16 BIT DIRECT TO A B/W BitMap
; ASSUMES SRC IS COMPOSED OF one word OF THE FORM 'XRRRRRGGGGGBBBBB'
;
; D7: Number of pixels to convert
; A0: SRC BUFFER
; A1: DST BUFFER
SixteenBitLOOP
move.l #$80000000,d5 ;init offset into dst
moveq #0,d0 ; zero luninance rgb values
moveq #0,d1 ;
moveq #0,d2 ;
move.w LastError(a6),d3 ;get luminance error from last line
btst #6, mode+1(a6) ;do dithering?
beq.s NewOutputLong16 ;no
eori.w #1, direction(a6) ;if we dither, we scan ...
beq.s DoReverse16Loop ;... backwards every other time
NewOutputLong16
move.l #0, d6 ;assume output value will be white
move.l #$80000000,d5 ; rotating mask
NextInputWord16
move.w (a0)+,d4 ;get first word of src
move.b d4,d2 ; get the blue component
and.b #$1F,d2 ;save only bottom 5 bits
lsr.l #5,d4 ; get red,green in low word
move.b d4,d1 ; get the green component
and.b #$1F,d1 ;save only bottom 5 bits
lsr.w #5,d4 ; get red in low byte
move.b d4,d0 ; get the red component
and.b #$1F,d0 ;save only bottom 5 bits
; Compute Luminance = ((((((r+g)/2)+b)/2+r)/2)+g)/2
add.w d1,d4
add.w d2,d4
add.w d2,d4
lsr.w #2,d4
add.w d0,d4
add.w d1,d4
add.w d1,d4
lsr.w #2,d4
btst #6, mode+1(a6)
beq.s NoDither16
;
; Do dithering
;
add.w d4,d3 ;add luminance to error (slop)
ble.s SetBit16
sub.w #$1F,d3 ;reset error (max luminance for five bits)
bra.s SetBitDone16
;
; No Dithering: Use 50% theshold
;
NoDither16
btst #4,d4 ; check bit 4 (high bit of luminance for 16 bit) <KON 2NOV90>
bne.s SetBitDone16 ; if set, pixel is white (0), so skip
SetBit16
or.l d5,D6 ; set pixel value
SetBitDone16
sub #1, d7 ;done enough pixels?
beq.s @rowdone ;
lsr.l #1,d5 ;BUMP TO NEXT DST PIXEL
bne.s NextInputWord16
move.l d6,(a1)+ ;save destination pixel values
bra.s NewOutputLong16
@rowdone
MOVE.L D6,(A1)+ ;done: save current output value
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES
and.l #$ffff,d0 ;clear hi word
ADD.L D0,BITSDST(A6) ;NEXT SCAN LINE
move.w d3, LastError(a6) ;save luminance error for next line
bra shrunk
;
; Scan line in reverse direction
;
DoReverse16Loop
moveq #0,d4 ;clear high word of temp pixel count
move.w d7, d4 ;pixel count to temp register
lsl.l #1, d4 ;convert to number of words
add.l d4, a0 ;move to end of source
add.l #15<<2,d4 ;adjust to round up
lsr.l #4, d4 ;/2 to convert 16 bit to number of pixels...
;... and /32 because 32 pixels/long...
;... and *2 because 2 bytes/word
and.w #$fffc,d4 ;must end on word boundry
add.l d4, a1 ;move to end of destination
move d7, d4 ;find starting pixel position
sub.w #1, d4
and.w #$1f, d4 ;get pixel count mod 32
move.l #$80000000,d5
lsr.l d4, d5 ;move to starting pixel position
moveq #0, d6
bra.s ReverseNextInputLong16
ReverseNewOutputLong16
moveq #0, d6 ;assume output value will be white
moveq #$00000001,d5 ; rotating mask: start on right...
;...and move left
ReverseNextInputLong16
move.w -(a0),d4 ;get word of src
move.b d4,d2 ; get the blue component
and.b #$1F,d2 ;save only bottom 5 bits
lsr.l #5,d4 ; get red,green in low word
move.b d4,d1 ; get the green component
and.b #$1F,d1 ;save only bottom 5 bits
lsr.w #5,d4 ; get red in low byte
move.b d4,d0 ; get the red component
and.b #$1F,d0 ;save only bottom 5 bits
; Compute Luminance = ((((((r+g)/2)+b)/2+r)/2)+g)/2
add.w d1,d4
add.w d2,d4
add.w d2,d4
lsr.w #2,d4
add.w d0,d4
add.w d1,d4
add.w d1,d4
lsr.w #2,d4
add.w d4,d3 ;add luminance to error (slop)
bpl.s ReverseDitherSetBitDone16
or.l d5,D6 ; set pixel value
bra.s ReverseSetBitDone16
ReverseDitherSetBitDone16
sub.w #$1F,d3
ReverseSetBitDone16
sub #1, d7 ;done enough pixels?
beq.s @rowdone ;
lsl.l #1, d5 ;BUMP TO NEXT DST PIXEL
bne ReverseNextInputLong16
move.l d6,-(a1) ;save destination pixel values
bra.s ReverseNewOutputLong16
@rowdone
MOVE.L D6,-(A1) ;done: save current output value
MOVE TARGETRB(A6),D0 ;GET TARGET ROWBYTES
and.l #$ffff,d0 ;clear hi word
ADD.L D0,BITSDST(A6) ;NEXT SCAN LINE
move.w d3, LastError(a6) ;save luminance error for next line
SHRUNK
MOVEM.W (SP)+,D4-D7/a3 ;Restore registers
RTS ;EXIT
ENDPROC
RGB2OLD PROC EXPORT
;-----------------------------------------------
;
; UTILITY TO CONVERT AN RGB (POINTED TO BY A1) VALUE
; TO AN OLD STYLE COLOR VALUE. RETURNS VALUE IN D0. CLOBBERS D0,D1
;
; USES HIGH BIT OF EACH COMPONENT TO SELECT RGB OFF (0) OR ON (1)
MOVEQ #0,D1 ; clear out D1
MOVE (A1)+,D1 ; get red
LSL.L #1,D1 ; get high bit
MOVE (A1)+,D1 ; get green
LSL.L #1,D1 ; get high bit
MOVE (A1)+,D1 ; get blue
LSL.L #1,D1 ; get high bit
SWAP D1 ; get RGB index
LSL.W #1,D1 ; Make a word index
MOVEQ #0,D0 ; clear out target
MOVE.W MapTBL(D1.W),D0 ; convert to planar value
RTS ; => all done
; TABLE TO MAP FROM 3 BIT RGB TO OLD-STYLE COLOR INDICES
MapTBL DC.W blackColor ; RBG = 0,0,0 -> black
DC.W blueColor ; RBG = 0,0,1 -> blue
DC.W greenColor ; RBG = 0,1,0 -> green
DC.W cyanColor ; RBG = 0,1,1 -> cyan
DC.W redColor ; RBG = 1,0,0 -> red
DC.W magentaColor ; RBG = 1,0,1 -> magenta
DC.W yellowColor ; RBG = 1,1,0 -> yellow
DC.W whiteColor ; RBG = 1,1,1 -> white
RGB2Pat PROC EXPORT
ENTRY RGB2Pixel
EXPORT PatTBL
;-----------------------------------------------
;
; UTILITY TO CONVERT AN RGB (POINTED TO BY A1) VALUE
; TO AN OLD STYLE GRAY PATTERN. RETURNS HALF-PATTERN IN D0. CLOBBERS D1.
;
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (RGB2Pat) (RGB2Pat)
;
; USES COMPUTED GRAY LEVEL TO SELECT A PATTERN
MOVE (A1)+,D1 ; Get Red
MULU #$4CCC,D1 ; Weight for Red
MOVE (A1)+,D0 ; Get Green
MULU #$970A,D0 ; Weight for Green
ADD.L D0,D1 ; Add in
MOVE (A1)+,D0 ; Get Blue
MULU #$1C28,D0 ; Weight for Blue
ADD.L D0,D1 ; Get sum: luminance of RGB
CLR D1 ; Clear low word
ROL.L #3,D1 ; Get high three bits (0-7)
LSL.W #2,D1 ; Get long offset
MOVE.L PatTBL(D1.W),D0 ; Get half-pattern
RTS
PatTBL
DC.L $FFFFFFFF ; Gray = 0 -> black
DC.L $DDFF77FF ; Gray = 1 -> 7/8 gray
DC.L $FF55FF55 ; Gray = 2 -> 3/4 gray
DC.L $EE55BB55 ; Gray = 3 -> 5/8 gray
DC.L $AA55AA55 ; Gray = 4 -> 1/2 gray
DC.L $88552255 ; Gray = 5 -> 3/8 gray
DC.L $88002200 ; Gray = 6 -> 1/8 gray
DC.L $00000000 ; Gray = 7 -> white
;-----------------------------------------------
;
; UTILITY TO CONVERT AN RGB (POINTED TO BY A0) VALUE <19Feb87 DBG>
; TO A SINGLE PIXEL. RETURNS VALUE IN D0.B. CLOBBERS D1.
;
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (RGB2Pixel) (RGB2Pixel)
;
; USES COMPUTED GRAY LEVEL TO SELECT A PATTERN
RGB2Pixel
MOVEQ #0,D1 ; Clear out
MOVE (A0)+,D1 ; Get Red <19Feb87 DBG>
MOVEQ #0,D0 ; Clear out
MOVE (A0)+,D0 ; Get Green <19Feb87 DBG>
ADD.L D0,D1 ; Add in
MOVE (A0)+,D0 ; Get Blue <19Feb87 DBG>
ADD.L D0,D1 ; Get sum
DIVU #3,D1 ; Compute unweighted Gray value
SGE D0 ; Should be 1 (black) if <$8000
NEG.B D0 ; Make single bit
RTS
MapRatio PROC EXPORT
;-------------------------------------------------------------
;
; PROCEDURE MapRatio(VAR numer, denom: Point; fromRect: Rect);
;
; Fix File Date Patch# Fix Routine(s) Routine(s) Fixed
;AppleSystemPatch DrawPicturePatch.a 01Jan1904 #??? (MapRatio) (MapRatio)
;
; Map ratio so that denom.h/.v = height/width of fromRect.
; This is so that later scaling of the numerator will have some
; range to work within.
;
; NOTE: Only necessary because fractional numer, denom not used
;
; numer.h := numer.h * fromWidth / denom.h
; denom.h := fromWidth
; numer.v := numer.v * fromHeight / denom.v
; denom.v := fromHeight
PARAMSIZE EQU 12 ; TOTAL BYTES OF PARAMS
NUMER EQU PARAMSIZE+8-4 ; LONG, ADDR OF POINT
DENOM EQU NUMER-4 ; LONG, ADDR OF POINT
FROMRECT EQU DENOM-4 ; LONG, ADDR OF RECT
LINK A6,#0 ; NO LOCALS
MOVEM.L D0-D1/A0-A2,-(SP) ; SAVE REGS
MOVE.L NUMER(A6),A0 ; point to numer
MOVE.L DENOM(A6),A1 ; point to denom
MOVE.L FROMRECT(A6),A2 ; point to fromRect
MOVE.W right(A2),D0 ; get fromRect right
SUB.W left(A2),D0 ; get fromWidth
MOVE.W h(A0),D1 ; get numer.h
MULU D0,D1 ; multiply by fromWidth
DIVU h(A1),D1 ; divide by denom.h
MOVE.W D1,h(A0) ; update numer.h
MOVE.W D0,h(A1) ; update denom.h
MOVE.W bottom(A2),D0 ; get fromRect bottom
SUB.W top(A2),D0 ; get fromHeight
MOVE.W v(A0),D1 ; get numer.v
MULU D0,D1 ; multiply by fromHeight
DIVU v(A1),D1 ; divide by denom.v
MOVE.W D1,v(A0) ; update numer.v
MOVE.W D0,v(A1) ; update denom.v
DONE MOVEM.L (SP)+,D0-D1/A0-A2 ; RESTORE REGS
UNLINK PARAMSIZE,'MAPRATIO' ;destroys condition codes
ENDPROC
;--------- BitMap to Region Added by KON 11/6/89 for Plus and SE only -----------
;________________________________________________________________________________
;
; FUNCTION BitMapRgn(region:RgnHandle; bMap:BitMap): OSErr; INLINE $A8D7;
; (BHogToRegion is debugging memory hog version)
;
; Given a region and bitmap, BitMapRgn makes the region a bounding
; region for the 'map. If it can't get memory it will return a
; Memory Manager-type error and an empty region gibbley. Note that
; the region might also be empty with no error (if the bounds is an
; empty rectangle or there are no 1 bits in the bitmap). Lastly,
; if the region would have to exceed 32K it returns a result of
; -500 (rgnTooBigErr).
;
; The bMap parameter may be a pointer to a bitmap, a pointer to a
; pixmap, or a pointer to a portBits field in a color grafport.
; In the latter two cases, if the pixmap is not 1-bit deep, an error
; result of -148 (pixmapTooDeepErr) is returned.
;
; (the nibble state machine idea is from the Finder MaskToRgn routine)
;
; History
; 2/19/88 RBB changed to take in washing and handle rect. & empties properly
; also now finds minimum rectangle to enclose region
; *** version of 2/22/88 ***
; 2/23/88 RBB putting in numerous optimizations recommended by Darin
; 4/4/88 RBB trying to re-do lost work from March
; DBA
; 3/28/89 CSD adjusted setup to know about pixmaps and portBits
; 5/18/89 BAL made classic QD friendly
;
;________________________________________________________________________________
;
;Theory
; We scan each line of the bitmap and pump inversion points (ip's) into the region
; to put the areas with ones in the bitmap into the region and the areas
; with zeroes outside the region.
;
; In order to keep track of where we are in "inversion land" we use two
; techniques:
; The first is a scanline buffer which records the changes
; (zeroes to ones and vice versa) as we go. Wherever a change occurs (a
; 1 next to a 0 in the buffer) we need to put out an inversion point.
; The second is a togglin' flag which tells us whether we are "inverted" or not.
; Since we use a state machine in the innermost (nibble) loop to churn out
; ip's, the input to the state machine must be complemented if the flag is set.
; The loop stuff looks like this:
; outer line loop (grows handle in anticipation of worst case for next line)
; longword loop for current line (puts out inter-long ip's as needed)
; loop for 4 nibbles in current long (calls state maching for each nibble)
;
;________________________________________________________________________________
BitMapRgnptch PROC EXPORT
BMFrame RECORD {A6Link},DECR
result DS.W 1
paramTop EQU *
regionH DS.L 1
bMapPtr DS.L 1
paramSize EQU paramTop-*
return DS.L 1
A6Link DS.L 1
rowLongs DS.L 1 ;number of longwords per line
rightMask DS.L 1 ;mask for rightmost long of each line
slHandle DS.L 1 ;handle to scanline buffer
numLines DS.W 1 ;number of lines in bitmap
rowNumBytes DS.W 1 ;rowbytes from the bitmap
startSize DS.W 1 ;size of region at start of line
lastLineH DS.L 1 ;last line (zeroes) handle
handSize DS.L 1 ;size of handle (avoid calls to GetHandleSize)
max2Add DS.L 1 ;worst case for bytes we could add for next line
localSize EQU *
ENDR
WITH BMFrame
LINK A6,#localSize
MOVEM.L A2-A5/D3-D7,-(SP) ;save work registers
CLR.L slHandle(A6) ;no scanline handle, yet
CLR.W result(A6) ;function result presumed zero at start
MOVE.L regionH(A6),A0
MOVE.L (A0),A2
MOVEQ #0,D0
MOVE.W (A2),D0 ;get size of region
MOVE.L D0,handSize(A6) ;save it long
;get boundary rectangle so we can tell how to process the bitmap
MOVE.L bMapPtr(A6),A1 ;get bitmap pointer
MOVE.W rowBytes(A1), D0 ;rowbytes
if hasCQD then
BPL.S @1 ;it's a bitmap so go ahead
BTST #isCPort, D0 ;is this a ptr to portBits?
BEQ.S @2 ;nope; it's a ptr to a pixmap
MOVE.L baseAddr(A1), A0 ;get the PixMapHandle
MOVE.L (A0), A1 ;and get the real ptr to pixmap
@2
CMP.W #1, pmPixelSize(A1) ;is it 1 bit per pixel deep?
BEQ.S @1 ;if yes, we're fine
MOVE.W #pixmapTooDeepErr, D0 ;return an error otherwise
BRA BMRBadEmpty ;clean up and bail out
@1
MOVE.W rowBytes(A1), rowNumBytes(A6) ;get the rowbytes from the bit/pixmap
ANDI.W #$7FFF, rowNumBytes(A6) ;mask off pixmap flag
else
MOVE.W rowBytes(A1), rowNumBytes(A6) ;get the rowbytes from the bit/pixmap
endif ;hasCQD
MOVE.L bounds+topLeft(A1),D2 ;get topLeft
MOVE.W bounds+right(A1),D0 ;get right
;figure the number of longs per row (according to width, not rowbytes)
;so we can get a scanline buffer
SUB.W D2,D0 ;right - left
BLE BMREmptyOut ;if empty rect. then empty region
EXT.L D0
MOVE.L D0,D4
ADD.L D4,D4 ;double width for 2 bytes/ip
ADDQ.L #4+2,D4 ;add 4 bytes for y value and $7FFF word
;add 2 more for the $7FFF if the last line
ADD.L D4,D4 ;double, just 'cause I feel like it!
MOVE.L D4,max2Add(A6) ;save max. bytes for a given line
MOVEQ #32,D7 ;(side effect: clear high word of D7)
DIVU D7,D0 ;number of longs = width/32
;get a mask for the rightmost long into rightMask
MOVE.L D0,D3 ;save remainder(hi word)
SWAP D3 ;get remainder from width/32
MOVEQ #-1,D1 ;default rightmost long mask
TST.W D3 ;zero remainder?
BEQ.S @0 ;yes, $FFFF is a good mask
ADDQ.W #1,D0 ;we need one more long
SUB.W D3,D7 ;32 - remainder = zero bits to shift in
ASL.L D7,D1 ;get proper mask
@0 MOVE.L D1,rightMask(A6)
EXT.L D0
MOVE.L D0,rowLongs(A6) ;save # of longs
ASL.L #2,D0 ;longs => bytes
;get the scanline buffer (D0 = number of bytes per line)
_NewHandle clear ;get a scanline buffer (of zeroes)
BNE BMRBadEmpty ;if we failed then return a NIL handle
MOVE.L A0,slHandle(A6) ;save buffer handle
;figure the number of lines
MOVE.L D2,D3
SWAP D3 ;get top
MOVE.W bounds+bottom(A1),D0 ;get bottom
SUB.W D3,D0 ;bottom - top
BLE BMREmptyOut ;if empty rect. then empty region
MOVE.W D0,numLines(A6) ;number of lines
MOVE.L baseAddr(A1),A4 ;point to start of map
MOVE.W #rgnData,D7 ;initial region size
;OK, now we start the loops.
; A1 will point to the bitmap long,
; A2 to the region.
; A3 points to the current scanline buffer long.
; A4 will point to the row in the map.
; A5 points to the current word (= size + A2)
; D1 holds the current long (modified).
; D2 holds the leftmost coordinate of bitmap.bounds.
; D3 has the y coordinate, and
; D4 the x coordinate (high word stays clear!).
; D5 has number of longs remaining for current line.
; D6 holds the (on or off) value of the "beam" (for the line).
; D7 holds the size outside the longword loop (used as scratch while nibbling).
; (we assume at the very end that D7's high word has remained clear)
BMRHScramLine
MOVE.L regionH(A6),A2
MOVE.L (A2),A2 ;point to start of region
BMRLineLoop
LEA (A2,D7.W),A5 ;point to new region start + size
MOVE.L handSize(A6),D1 ;get handle size
SUB.W D7,D1 ;handle size - region size
CMP.L max2Add(A6),D1 ;is there enough for worst case on next line?
BGE.S @1 ;skippy if so
MOVE.L handSize(A6),D0 ;get handle size
ADD.L max2Add(A6),D0 ;add more than enough for worst case on next line
MOVE.L D0,handSize(A6) ;save new size
MOVE.L regionH(A6),A0 ;region handle
_SetHandleSize
BNE BMRBadEmpty ;if we failed then return a NIL handle
BRA.S BMRHScramLine ;rederef. handle and recompute current pointer
@1
MOVE.W D2,D4 ;get current x coordinate from left
MOVEQ #0,D6 ;beam initially off
MOVE.L A4,A1 ;start of current line into map pointer
MOVE.L rowLongs(A6),D5 ;longs remaining for current line
MOVE.L slHandle(A6),A3 ;A3 points to the current "differences" long
MOVE.L (A3),A3
; Note: within this loop we assume that nothing will be done to move the heap
MOVE.W D3,D0 ;get y position
BSR OutputRgnWord ;output y pos to region
MOVE.W D7,startSize(A6) ;save size at line start (a la Derwood)
BRA NextBMRLong ;enter the long loop
BMRLongLoop
MOVE.L (A1)+,D0 ;fetch the next long for this line
BMRLastLEntry
MOVE.L (A3),D1 ;get differences long
EOR.L D0,D1 ;compute the differences
BNE BMRDiff ;if not the same, skip ahead
BMRSame
;since we want to skip this long (it matches the previous line) we need to
;put out an ip if the beam is on
TST.B D6 ;beam on?
BEQ.S @1 ;skip if not
MOVE.W D4,(A5)+ ;pump it out
MOVEQ #0,D6 ;beam off
@1
ADD.W #32,D4 ;slip to next long's x coordinate
@2 ADDQ.W #4,A3 ;to next changes buffer long
BRA NextBMRLong
;----------------------------------------------------------------------------------------
; Start of State Machine
; Handle state 0001
BMRState1
ADDQ.W #3,D4 ;bump x by 3
State1Common
MOVE.W D4,(A5)+ ;generate one
;Tog1StateDone
ADDQ.W #1,D4 ;bump x by one more
TogStateDone
NOT.B D6 ;toggle state
RTS
; Handle state 0010
BMRState2
ADDQ.W #2,D4 ;bump x by 2
MOVE.W D4,(A5)+ ;generate one
Gen1BumpBy1
BSR.S Gen1InvPoint ;and another one
BumpBy1
ADDQ.W #1,D4 ;bump once more
RTS ;state doesn't change
; Handle state 0011
BMRState3
ADDQ.W #2,D4 ;bump x by 2
MOVE.W D4,(A5)+ ;generate one
ADDQ.W #2,D4 ;bump
BRA.S TogStateDone ;toggle the state
; Handle state 0100
BMRState4
BSR.S Gen1InvPoint
BSR.S Gen1InvPoint
BumpBy2
ADDQ.W #2,D4
RTS
; Handle state 0101
BMRState5
BSR.S BMRState4 ;start out as state 4
SUBQ #1,D4
BRA.S State1Common ;use common code
; Handle state 0110
BMRState6
BSR.S Gen1InvPoint
ADDQ.W #1,D4
BRA.S Gen1BumpBy1
; Handle state 0111
BMRState7
BSR.S Gen1InvPoint
ADDQ.W #3,D4
BRA.S TogStateDone
; Gen1InvPoint bumps x by one and then generates a horizontal inversion point
Gen1InvPoint
ADDQ.W #1,D4 ;bump by 1, first
MOVE.W D4,(A5)+ ;add x value (ip) to region
RTS
; Handle State 1000
BMRState8
MOVE.W D4,(A5)+
BSR.S Gen1InvPoint
ADDQ.W #3,D4
RTS
; Handle State 1001
BMRState9
MOVE.W D4,(A5)+
BSR.S Gen1InvPoint
ADDQ.W #2,D4
BRA.S State1Common
; Handle State 1010 (most complicated case)
BMRState10
MOVE.W D4,(A5)+
BSR.S Gen1InvPoint
BSR.S Gen1InvPoint
BRA.S Gen1BumpBy1
; Handle State 1011
BMRState11
MOVE.W D4,(A5)+
BSR.S Gen1InvPoint
BSR.S Gen1InvPoint
ADDQ.W #2,D4
BRA.S TogStateDone
; Handle State 1100
BMRState12
MOVE.W D4,(A5)+
ADDQ.W #2,D4
MOVE.W D4,(A5)+
BRA.S BumpBy2
; Handle State 1101
BMRState13
BSR.S BMRState12
SUBQ #1,D4
BRA.S State1Common
; Handle State 1110
BMRState14
MOVE.W D4,(A5)+
ADDQ.W #3,D4
MOVE.W D4,(A5)+
BRA.S BumpBy1
; State table
BMRHandler
BRA.S BMRState0
BRA.S BMRState1
BRA.S BMRState2
BRA.S BMRState3
BRA.S BMRState4
BRA.S BMRState5
BRA.S BMRState6
BRA.S BMRState7
BRA.S BMRState8
BRA.S BMRState9
BRA.S BMRState10
BRA.S BMRState11
BRA.S BMRState12
BRA.S BMRState13
BRA.S BMRState14
; Handle State 15 or 1111
BMRState15
MOVE.W D4,(A5)+ ;generate one now
NOT.B D6 ;toggle the state
; Handle State 0 or 0000
BMRState0
ADDQ.W #4,D4
RTS
; End of the State Guys
;----------------------------------------------------------------------------------------
BMRDiff
MOVE.L D0,(A3)+ ;fix up scanline buffer for next time
; this long is different from the last one, so output a bunch
; of inversion points by pumping it through the state machine, a nibble
; at a time.
MOVEQ #3,D7 ;4 bytes to process (D7 high word clear)
MOVEQ #0,D0 ;prevent need to mask for first nibble
; here is the loop where we feed it through a nibble at a time.
; it's worth it to special case a whole byte of 0
BMRByteLoop
ROL.L #8,D1 ;get next (topmost) byte
TST.B D1 ;is it zero?
BNE.S BMRNibble ;if not, 4 bits at a time
TST.B D6
BNE.S BMRNibble ;if beam on, must pass through
;the top 8 are zero, so we can save some time
ADDQ.W #8,D4 ;bump x
BRA.S BMRNextByte
;take care of the rightmost long for a line
BMRLastLong
MOVE.L (A1),D0 ;fetch the long from the bitmap
AND.L rightMask(A6),D0 ;mask off right bits that aren't in map
BRA BMRLastLEntry ;go process this long
; handle the first nibble
BMRNibble
MOVE.B D1,D0 ;get byte
EOR.B D6,D0 ;invert nibble when beam is on
LSR.B #4,D0 ;get 1st nibble
ADD.W D0,D0 ;double for word index
JSR BMRHandler(D0.W) ;invoke the handler
; handle the second nibble
MOVE.B D1,D0 ;get byte again
EOR.B D6,D0 ;invert nibble when beam is on
AND.W #%1111,D0 ;mask to it
ADD.W D0,D0 ;double for word index
JSR BMRHandler(D0.W) ;invoke the handler
BMRNextByte
DBRA D7,BMRByteLoop ;loop for all 8 nibbles
; bump to the next long
NextBMRLong
SUBQ.W #1,D5 ;decrement longword index
BGT BMRLongLoop ;not at end, loop for whole line
BEQ.S BMRLastLong ;process last long for this line
; we've reached the end of the (this) line
BMREOL
MOVE.W A5,D7 ;current region pointer
SUB.W A2,D7 ;figga region size
CMP.W startSize(A6),D7 ;did we add inv. pts to this line?
BEQ.S BMRNoLine ;br = no, so back up
BLT BMR32KErr ;if the size decreased, we overflowed
; if the state is on, generate one last inversion point
TST.B D6
BEQ.S @1
MOVE.W D4,(A5)+ ;generate a last one
ADDQ.W #2,D7 ;keep sizable advantage
@1
; end the scan line with the traditional $7FFF
BSR.S OutputLastRgnWord
BMREOL2
ADDQ.W #1,D3 ;bump y position
MOVE.W D2,D4 ;start x at left again
ADD.W rowNumBytes(A6),A4 ;bump to next row in map
SUBQ.W #1,numLines(A6)
BGT BMRLineLoop ;if we're not done then do next line
BLT.S BMRFinis ;br if really done
; as the last line process an imaginary line of zeroes to end the region…
MOVE.L rowLongs(A6),D0
ASL.L #2,D0 ;longs => bytes
_NewHandle clear ;get a full line of zero bits
BNE.S BMRBadEmpty ;if we failed then return a NIL handle
MOVE.L A0,lastLineH(A6) ;save handle
MOVE.L (A0),A4 ;start of current line
BRA BMRHScramLine ;do this last one (and rederef handle)
BMRNoLine
SUBQ.L #2,A5 ;back up pointer
SUBQ.W #2,D7 ;back down size
BRA.S BMREOL2 ;go for next line
; Append the "end of line" token to the region
OutputLastRgnWord
MOVE.W #$7FFF,D0
; OutputRgnWord takes the word in D0, appends it to the region,
; and leaves the condition codes set for ADDQ.W D7 (which contains the length)
OutputRgnWord
MOVE.W D0,(A5)+ ;put a word to the region
ADDQ.W #2,D7 ;ink the size
RTS
; all done so clean up, output the final $7FFF
BMRFinis
MOVE.L lastLineH(A6),A0
_DisposHandle ;get rid of that last line of zeroes
CMP.W #10,D7 ;is region empty of inversion points?
BEQ.S BMREmptyOut ;skip if so (it's an empty region)
BSR.S OutputLastRgnWord ;put End-O-Region ($7FFF) word
BMI.S BMR32KErr ;if we went negative, we overflowed!
; find the smallest rectangle that encompasses all the inversion points
; A0 will point to the current region word, A1 to the start of the line
; D1 will have the smallest x, D2 the largest x, D4 will contain $7FFF
; D3 gets the smallest y value (which we know at the start)
LEA rgnData(A2),A0 ;point A0 past the rgnBBox
MOVE.W #$7FFF,D4
MOVE.W D4,D1 ;smallest x so far = $7FFF
MOVE.W #$8000,D2 ;largest x so far = -32768
MOVE.W (A0),D3 ;smallest y there is
BRA.S BMRPackStart ;enter loop
BMRPackY
MOVE.L A0,A1 ;remember where the y value is (sort of)
CMP.W (A0)+,D1 ;less than smallest x so far?
BLE.S @1 ;skip if not
MOVE.W -2(A0),D1 ;new smallest x
@1 CMP.W (A0)+,D4 ;end of line?
BNE.S @1 ;if not then keep looking
CMP.W -4(A0),D2 ;last x greater than largest x so far?
BGE.S BMRPackStart ;skip if not
MOVE.W -4(A0),D2 ;new largest x
BMRPackStart
MOVE.W (A0)+,D0 ;get next word (y value or $7FFF)
CMP.W D4,D0 ;if $7FFF then we're done
BNE.S BMRPackY ;otherwise loop
SWAP D3 ;top into top word
MOVE.W D1,D3 ;left into bottom word
MOVE.W -2(A1),D4 ;bottom (from last y at start of line)
SWAP D4 ;move bottom to high word
MOVE.W D2,D4 ;get right
CMP.W #28,D7 ;size = 28? (do we have a rect. region?)
BEQ.S BMRRect ;skip if so
BRA.S BMROut ;return complex region
;the region would exceed 32K, so we have to error out, man
BMR32KErr
MOVE.W #rgnTooBigErr,D0 ;if >32K needed return error
;we come here after failing a SetHandleSize (or NewHandle)
BMRBadEmpty
MOVE.W D0,result(A6) ;OSErr function result
; emptify the region on errors (or when it should be empty with no error)
BMREmptyOut
MOVE.L regionH(A6),A0 ;handle to region
MOVE.L (A0),A2 ;point to it
CLR.L D3 ;(0, 0) to topLeft
CLR.L D4 ;(0, 0) to botRight
BMRRect
MOVEQ #10,D7 ;the size of the region = 10
;output the region with size (longword, high word clear) in D7
;D3 comes in with topLeft, D4 with botRight
BMROut
MOVE.W D7,(A2)+ ;the size of the region
MOVE.L D3,(A2)+ ;topLeft to rgnBBox
MOVE.L D4,(A2) ;botRight to rgnBBox
MOVE.L D7,D0 ;size
MOVE.L regionH(A6),A0 ;handle to region
_SetHandleSize
BMRDspSL
MOVE.L slHandle(A6),A0
_DisposHandle ;get rid of the scanline buffer (even if NIL)
BMRDone
MOVEM.L (SP)+,A2-A5/D3-D7 ;restore work registers
UNLK A6
MOVE.L (SP)+,A0 ;pop return address
ADD #paramSize,SP ;pop params
JMP (A0)
ENDWITH
;-------------End of BitMap to Region Code Addition 11/6/89 --------------
Reference in New Issue View Git Blame Copy Permalink