; 1). Set your editor's TAB width to 3 in order to correctly view this file.
; 2). Delete the following 2 directives if not using MANX. If using LATTICE,
;		make sure that you assemble this module with large CODE and DATA
;     model.

  far code  ;for Manx only, it means large code, large data (int = 32 bits)
  far data  ;this module must be assembled expecting passed ints as 32 bits

; 3). Copy the file "IFF.i" to the current directory.
; 4). Assemble this module and link it with your C application modules.
;
;As an additional savings in size, you may wish to clip out the interface code
;for any routines that you do not wish to use. For example, if you don't plan
;on using "GetIFFPMsg", delete the 7 lines starting at XDEF _GetIFFPMsg.

	SECTION	ilbmcode,CODE

	INCLUDE	"IFF.i"	;supplies the LVO offsets

	XREF	_ILBMBase	;ilbm.library opened from C code, and base stored there

	XDEF	_GetIFFPMsg
	XDEF	__GetIFFPMsg
_GetIFFPMsg:
	movea.l	_ILBMBase,a6
__GetIFFPMsg:
	move.l	4(sp),d0
	jmp		_LVOGetIFFPMsg(a6)

	XDEF	_BlankPointer
	XDEF	__BlankPointer
_BlankPointer:
	movea.l	_ILBMBase,a6
__BlankPointer:
	movea.l	4(sp),a0
	jmp		_LVOBlankPointer(a6)


;######################## IFF READER ROUTINES ##########################

;***********************************************************************
;BOOL = LoadIFFToWindow(fileName, ILBMFrame)
; d0								d1				a1

	XDEF	_LoadIFFToWindow,__LoadIFFToWindow
_LoadIFFToWindow:
	movea.l	_ILBMBase,a6
__LoadIFFToWindow:
	move.l	4(sp),d1
	movea.l	8(sp),a1
	jmp		_LVOLoadIFFToWindow(a6)


;**************************** LoadIFF() *********************************
; IFFP = LoadIFF(fileHandle, Vectors, masterFrame)
;  d0						d1			a0				a1

	XDEF	_LoadIFF,__LoadIFF
_LoadIFF:
	movea.l	_ILBMBase,a6
__LoadIFF:
	movem.l	4(sp),d1/a0/a1
	bsr.s		SetVectors
	jmp		_LVOLoadIFF(a6)


;**************************** ScaleImage() *********************************
;BOOL ScaleImage(dest_rectangle,source_rectangle,dest_rport,source_bitmap)
;							a0					a1						a2				a4


	XDEF	_ScaleImage,__ScaleImage
_ScaleImage:
	movea.l	_ILBMBase,a6
__ScaleImage:
	movem.l	a2/a4,-(sp)
	movem.l	12(sp),a0/a1/a2/a4
	jsr		_LVOScaleImage(a6)
	movem.l	(sp)+,a2/a4
	rts

;**************************** SetupBitmap() *********************************
; SetupBitmap(raster, Bitmap, BMHD)
;					d0			a0		a1


	XDEF	_SetupBitmap,__SetupBitmap
_SetupBitmap:
	movea.l	_ILBMBase,a6
__SetupBitmap:
	movem.l	4(sp),d0/a0/a1
	jmp		_LVOSetupBitmap(a6)


;**************************** DecompBODY() *********************************
; DecompBODY(BODY, BMHD, Bitmap)
;					a0		a1		a2
; Decompresses the BODY chunk into the passed BitMap's planes based on the
; passed BMHD's w, h, numPlanes, and pageWidth. This is used for the first
; frame of the ANIM (ANHD's opmode = 0). BODY is the address of the loaded
; BODY chunk of the first frame of the ANIM file (minus the 8 byte header).


	XDEF	_DecompBODY,__DecompBODY
_DecompBODY:
	movea.l	_ILBMBase,a6
__DecompBODY:
	move.l	a2,-(sp)
	movem.l	8(sp),a0/a1/a2
	jsr		_LVODecompBODY(a6)
	movea.l	(sp)+,a2
	rts

;**************************** LoadILBM() *********************************
; IFFP = LoadILBM(fileHandle, Vectors, ILBMFrame)
;  d0						d1			a0				a1


	XDEF	_LoadILBM,__LoadILBM
_LoadILBM:
	movea.l	_ILBMBase,a6
__LoadILBM:
	movem.l	4(sp),d1/a0/a1
	bsr.s		SetVectors
	jmp		_LVOLoadILBM(a6)


SetVectors:
	movem.l	a0/a2/a3,-(sp)
	;---Setup CInterface to PROP handler
	lea		PROPVector,a3
	move.l	(a0)+,(a3)+
	beq.s		noPROP
	lea		PropHandler,a2
	move.l	a2,-4(a0)
noPROP:
	;---Setup CInterface to FORM handler
	move.l	(a0)+,(a3)+
	beq.s		noFORM
	lea		FormHandler,a2
	move.l	a2,-4(a0)
noFORM:
	;---Setup CInterface to Chunk handler
	move.l	(a0)+,(a3)+
	beq.s		noChunk
	lea		ChunkHandler,a2
	move.l	a2,-4(a0)
noChunk:
	;---Setup CInterface to Non-ILBM FORM handler
	move.l	(a0),(a3)
	beq.s		noNon
	lea		NONILBM,a2
	move.l	a2,(a0)
noNon:
	movem.l	(sp)+,a0/a2/a3
	rts

; Calls C PROP routine as follows:
; IFFP = PropRoutine(chunkID,PropID,Context,Vectors,Frame,PROPList)
PropHandler:
	movem.l	d0/d2/a0/a2/a3/a4,-(sp)
	movea.l	PROPVector,a1
	jsr		(a1)
	movem.l	(sp)+,d1/d2/a0/a2/a3/a4
	rts

; Calls C FORM routine as follows:
; IFFP = FormRoutine(chunkID,Context,Vectors,Frame,PROPList)
FormHandler:
	movea.l	FORMVector,a1
do_hand:
	movem.l	d0/a0/a2/a3/a4,-(sp)
	jsr		(a1)
	movem.l	(sp)+,d1/a0/a2/a3/a4
	rts

 ; An Unknown chunk in an ILBM (i.e. DLTA, ANHD, DEST, GRAB...)
ChunkHandler:
	movea.l	ChunkVector,a1
	bra.s		do_hand

 ; A Non-ILBM FORM
NONILBM:
	movea.l	NonILBMVector,a1
	bra.s		do_hand

;*************************** GetPROPStruct() *****************************
; PropStruct = GetPROPStruct(size, PropID, PROPList)
;		d0								d0		d1			a1


	XDEF _GetPROPStruct,__GetPROPStruct
_GetPROPStruct:
	movea.l	_ILBMBase,a6
__GetPROPStruct:
	movem.l	4(sp),d0/d1/a1
	jmp		_LVOGetPROPStruct(a6)


;*************************** SearchPROP() *****************************
; PropStruct = SearchPROP(PropID, PROPList)
;		d0							d0			a1


	XDEF _SearchPROP,__SearchPROP
_SearchPROP:
	movea.l	_ILBMBase,a6
__SearchPROP:
	movem.l	4(sp),d0/a1
	jmp		_LVOSearchPROP(a6)


;*************************** CopyILBMProp() *****************************
; CopyILBMProp(FromFrame, ToFrame)
;						d0			a1


	XDEF _CopyILBMProp,__CopyILBMProp
_CopyILBMProp:
	movea.l	_ILBMBase,a6
__CopyILBMProp:
	movem.l	4(sp),d0/a1
	jmp		_LVOCopyILBMProp(a6)

;*************************** FreePROPStruct() *****************************
; FreePROPStruct(PROPList)
;						a1


	XDEF _FreePROPStruct,__FreePROPStruct
_FreePROPStruct:
	movea.l	_ILBMBase,a6
__FreePROPStruct:
	movea.l	4(sp),a1
	jmp		_LVOFreePROPStruct(a6)


;*************************** HandleCAMG() *******************************
; HandleCAMG(Context,ILBMFrame)
;					a0			a1


	XDEF _HandleCAMG,__HandleCAMG
_HandleCAMG:
		movea.l	_ILBMBase,a6
__HandleCAMG:
		movem.l	4(sp),a0/a1
		jmp		_LVOHandleCAMG(a6)


;*************************** HandleCRNG() *******************************
; HandleCRNG(Context,ILBMFrame)
;					a0			a1

	XDEF _HandleCRNG,__HandleCRNG
_HandleCRNG:
		movea.l	_ILBMBase,a6
__HandleCRNG:
		movem.l	4(sp),a0/a1
		jmp		_LVOHandleCRNG(a6)


;*************************** HandleCCRT() *******************************
; HandleCCRT(Context,ILBMFrame)
;					a0			a1

	XDEF _HandleCCRT,__HandleCCRT
_HandleCCRT:
		movea.l	_ILBMBase,a6
__HandleCCRT:
		movem.l	4(sp),a0/a1
		jmp		_LVOHandleCCRT(a6)


;**************************** OpenRIFF() *******************************
; IFFP = OpenRIFF(fileHandle, newContext, Frame)
;  d0						d1				a0			a1

	XDEF	_OpenRIFF,__OpenRIFF
_OpenRIFF:
	movea.l	_ILBMBase,a6
__OpenRIFF:
	movem.l	4(sp),d1/a0/a1
	jmp		_LVOOpenRIFF(a6)


;**************************** FileLength() *****************************
;FileSize = FileLength(fileHandle)
;	d0								d1

	XDEF	_FileLength,__FileLength
_FileLength:
	movea.l	_ILBMBase,a6
__FileLength:
	move.l	4(sp),d1
	move.l	a6,-(sp)
	jsr		_LVOFileLength(a6)
	movea.l	(sp)+,a6
	rts


;********************** OpenRGroup() *****************************
; IFFP = OpenRGroup(parent, new)   passed 2 Context structures
;  d0						a0		 a1


	XDEF	_OpenRGroup,__OpenRGroup
_OpenRGroup:
	movea.l	_ILBMBase,a6
__OpenRGroup:
	movea.l	4(sp),a0
	movea.l	8(sp),a1
	jmp		_LVOOpenRGroup(a6)


;***************************** CloseRGroup ******************************
; IFFP = CloseRGroup(context)
;  d0							a0

	XDEF	_CloseRGroup,__CloseRGroup
_CloseRGroup:
	movea.l	_ILBMBase,a6
__CloseRGroup:
	movea.l	4(sp),a0
	jmp		_LVOCloseRGroup(a6)


;*************************** SkipFwd() **********************************
; IFFP = SkipFwd(context, bytes)
;  d0              a0       d1


	XDEF	_SkipFwd,__SkipFwd
_SkipFwd:
	movea.l	_ILBMBase,a6
__SkipFwd:
	movea.l	4(sp),a0
	move.l	8(sp),d1
	jmp		_LVOSkipFwd(a6)


;*************************** GetChunkHdr *******************************
; ID = GetChunkHdr(context)
; d0						a0


	XDEF	_GetChunkHdr,__GetChunkHdr
_GetChunkHdr:
	movea.l	_ILBMBase,a6
__GetChunkHdr:
	movea.l	4(sp),a0
	jmp		_LVOGetChunkHdr(a6)


;************************** IFFReadBytes ********************************
; IFFP = IFFReadBytes(nBytes, context, buffer)
;  d0							d0			a0			a1


	XDEF	_IFFReadBytes,__IFFReadBytes
_IFFReadBytes:
	movea.l	_ILBMBase,a6
__IFFReadBytes:
	movem.l	4(sp),d0/a0/a1
	jmp		_LVOIFFReadBytes(a6)


;************************* GetFChunkHdr() ******************************
; ID = GetFChunkHdr(context)
; d0						a0

	XDEF	_GetFChunkHdr,__GetFChunkHdr
_GetFChunkHdr:
	movea.l _ILBMBase,a6
__GetFChunkHdr:
	movea.l	4(sp),a0
	jmp		_LVOGetFChunkHdr(a6)


;************************* GetF1ChunkHdr() ******************************
; ID = GetF1ChunkHdr(context)
; d0							a0


	XDEF	_GetF1ChunkHdr,__GetF1ChunkHdr
_GetF1ChunkHdr:
	movea.l	_ILBMBase,a6
__GetF1ChunkHdr:
	movea.l	4(sp),a0
	jmp		_LVOGetF1ChunkHdr(a6)


;**************************** GetPChunkHdr ****************************
; ID = GetPChunkHdr(context)
; d0                  a0


	XDEF	_GetPChunkHdr,__GetPChunkHdr
_GetPChunkHdr:
	movea.l	_ILBMBase,a6
__GetPChunkHdr:
	movea.l	4(sp),a0
	jmp		_LVOGetPChunkHdr(a6)


;**************************** GetCMAP() *******************************
; IFFP = GetCMAP(Context, colorMap, pNColorRegs)
;  d0						d0			a0			a1

	XDEF	_GetCMAP,__GetCMAP
_GetCMAP:
	movea.l	_ILBMBase,a6
__GetCMAP:
	movem.l	4(sp),d0/a0/a1
	jmp		_LVOGetCMAP(a6)


;****************************** GetBODY() *******************************
; IFFP = GetBODY(bitmap, mask, context, BMHD)
;  d0					d0			d1		a0			a1

	XDEF	_GetBODY,__GetBODY
_GetBODY:
	movea.l	_ILBMBase,a6
__GetBODY:
	movem.l	4(sp),d0/d1/a0/a1
	jmp		_LVOGetBODY(a6)

;*********************************************************************
;BOOL = UnPackRow(dstBytes0, srcBytes0, Source, Dest)
; d0						d1				d3			a2		a3

	XDEF	_UnPackRow,__UnPackRow
_UnPackRow:
	movea.l	_ILBMBase,a6
__UnPackRow:
	movem.l	d3/a2/a3,-(sp)
	movem.l	16(sp),d1/d3/a2/a3
	jsr		_LVOUnPackRow(a6)
	movem.l	(sp)+,d3/a2/a3
	rts

;****************************** DecompDLTA() *******************************
; DecompDLTA(DLTA,bitmap)
;				  a0		a2

	XDEF	_DecompDLTA,__DecompDLTA
_DecompDLTA:
	movea.l	_ILBMBase,a6
__DecompDLTA:
	move.l	a2,-(sp)
	movem.l	8(sp),a0/a2
	jsr		_LVODecompDLTA(a6)
	movea.l	(sp)+,a2
	rts

;****************************** DecodeVKPlane() *******************************
; DecodeVKPlane(linebytes, ytable, in, out)
; 						d0				d1		a0	 a1

	XDEF	_DecodeVKPlane,__DecodeVKPlane
_DecodeVKPlane:
	movea.l	_ILBMBase,a6
__DecodeVKPlane:
	movem.l	4(sp),d0/d1/a0/a1
	jmp		_LVODecodeVKPlane(a6)

;****************************** MakeYTable() *******************************
; MakeYTable(width, height, table)
;  				d0		d1			a0

	XDEF	_MakeYTable,__MakeYTable
_MakeYTable:
	movea.l	_ILBMBase,a6
__MakeYTable:
	movem.l	4(sp),d0/d1/a0
	jmp		_LVOMakeYTable(a6)


;######################## IFF WRITER ROUTINES #########################

;*************************************************************************
; IFFP = SaveWindowToIFF(fileName, window)
;  d0                       d1       a0

   XDEF   _SaveWindowToIFF,__SaveWindowToIFF
_SaveWindowToIFF:
    movea.l _ILBMBase,a6
__SaveWindowToIFF:
    movem.l 4(sp),d1/a0
    jmp     _LVOSaveWindowToIFF(a6)

;******************************* SaveILBM() ******************************
;IFFP = SaveILBM(ViewModes,Compress,fhandle,Mask,CTable,BitMap,xyPnt,Handler)
; d0                 d0       d1       d2    d3    a0      a1    a2     a3

   XDEF _SaveILBM,__SaveILBM
_SaveILBM:
    movea.l _ILBMBase,a6
__SaveILBM:
    movem.l d2/d3/a2/a3,-(sp)
    movem.l 20(sp),d0/d1/d2/d3/a2/a3
    move.l  a3,C_Vector1
    beq.s   noCHand
    lea     C_Handler1,a3
noCHand:
    jsr     _LVOSaveILBM(a6)
    movem.l (sp)+,d2/d3/a2/a3
    rts

C_Handler1:
	move.l	a0,-(sp)		;pass Context to C routine
	movea.l	C_Vector1,a1
	jsr		(a1)
	movea.l	(sp)+,a0
	rts


;******************************* SaveANIM() ******************************
;IFFP = SaveANIM(Modes,Compress,fhandle,Mask,CTable,BitMap,xyPnt,Handler,ANHD)
; d0              d0      d1       d2    d3    a0      a1    a2     a3    a4

   XDEF _SaveANIM,__SaveANIM
_SaveANIM:
    movea.l _ILBMBase,a6
__SaveANIM:
    movem.l d2/d3/a2/a3/a4,-(sp)
    movem.l 24(sp),d0/d1/d2/d3/a2/a3/a4
    move.l  a3,C_Vector2
    beq.s   noCHand2
    lea     C_Handler2,a3
noCHand2:
    jsr     _LVOSaveANIM(a6)
    movem.l (sp)+,d2/d3/a2/a3/a4
    rts

C_Handler2:
	movem.l	a0/a1,-(sp)		;pass Context and Parent to C routine
	movea.l	C_Vector2,a1
	jsr		(a1)
	movem.l	(sp)+,a0/a1
	rts


;**************************** OpenWIFF() *****************************
;IFFP = OpenWIFF(limit, fileHandle, newContext)
; d0					d0			d1				a0

	XDEF	_OpenWIFF,__OpenWIFF
_OpenWIFF:
	movea.l	_ILBMBase,a6
__OpenWIFF:
	movem.l	4(sp),d0/d1/a0
	jmp		_LVOOpenWIFF(a6)


;*************************** StartWGroup() ********************************
;IFFP = StartWGroup(groupType, groupSize, subtype, parent, new)
; d0							d0				d1			d2			a0		a1

	XDEF	_StartWGroup,__StartWGroup
_StartWGroup:
	movea.l _ILBMBase,a6
__StartWGroup:
	move.l   d2,-(sp)
	movem.l  8(sp),d0/d1/d2/a0/a1
	jsr     _LVOStartWGroup(a6)
	move.l  (sp)+,d2
	rts


;*************************** OpenWGroup() *******************************
;IFFP = OpenWGroup(parent, new)
; d0                 a0    a1

   XDEF _OpenWGroup,__OpenWGroup
_OpenWGroup:
    movea.l _ILBMBase,a6
__OpenWGroup:
    movea.l 4(sp),a0
    movea.l 8(sp),a1
    jmp     _LVOOpenWGroup(a6)


;***************************** EndWGroup() ********************************
;IFFP = EndWGroup(old)
; d0               a0

   XDEF _EndWGroup,__EndWGroup
_EndWGroup:
    movea.l _ILBMBase,a6
__EndWGroup:
    movea.l 4(sp),a0
    jmp     _LVOEndWGroup(a6)


;************************ CloseWGroup *********************************
;IFFP = CloseWGroup(old)
; d0                a0

   XDEF _CloseWGroup,__CloseWGroup
_CloseWGroup:
    movea.l _ILBMBase,a6
__CloseWGroup:
    movea.l 4(sp),a0
    jmp     _LVOCloseWGroup(a6)


;******************************* PutCk **********************************
;IFFP = PutCk(ckID, ckSize, context, data)
; d0           d0     d1      a0      a1

   XDEF   _PutCk,__PutCk
_PutCk:
    movea.l _ILBMBase,a6
__PutCk:
    movem.l  4(sp),d0/d1/a0/a1
    jmp     _LVOPutCk(a6)


;******************************* PutCkHdr() ****************************
;IFFPreturn = PutCkHdr(chunkID, chunkSize, context)
;                        d0        d1        a0

   XDEF   _PutCkHdr,__PutCkHdr
_PutCkHdr:
    movea.l _ILBMBase,a6
__PutCkHdr:
    movem.l  4(sp),d0/d1/a0
    jmp     _LVOPutCkHdr(a6)


;*************************** IFFWriteBytes() ***************************
;IFFP IFFWriteBytes(nBytes, context, data)
;                     d0       a0     a1

   XDEF   _IFFWriteBytes,__IFFWriteBytes
_IFFWriteBytes:
    movea.l _ILBMBase,a6
__IFFWriteBytes:
    movem.l  4(sp),d0/a0/a1
    jmp     _LVOIFFWriteBytes(a6)


;****************************** PutCkEnd() ******************************
;IFFP = PutCkEnd(context)
; d0               a0

   XDEF   _PutCkEnd,__PutCkEnd
_PutCkEnd:
    movea.l _ILBMBase,a6
__PutCkEnd:
    move.l  4(sp),a0
    jmp     _LVOPutCkEnd(a6)


;*************************** InitBMHdr() ********************************
;IFFP InitBMHdr(masking, compression, transparentColor,
;                 d0          d1              d2
;               pageWidth, pageHeight, BMHD, bitmap)
;                   d3         d4       a0     a1

   XDEF   _InitBMHdr,__InitBMHdr
_InitBMHdr:
    movea.l _ILBMBase,a6
__InitBMHdr:
    movem.l  d2/d3/d4,-(sp)
    movem.l  16(sp),d0/d1/d2/d3/d4/a0/a1
    jsr      _LVOInitBMHdr(a6)
    movem.l  (sp)+,d2/d3/d4
    rts

;**************************** PutCMAP() *********************************
;IFFP PutCMAP(depth, context, colorTable)
;               d0     a0        a1

   XDEF _PutCMAP,__PutCMAP
_PutCMAP:
    movea.l _ILBMBase,a6
__PutCMAP:
    movem.l  4(sp),d0/a0/a1
    jmp     _LVOPutCMAP(a6)


;******************************** PutBODY() ******************************
;IFFP = PutBODY(mask, context, bmHdr, bitmap)
; d0             d0     d1       a0     a1

   XDEF _PutBODY,__PutBODY
_PutBODY:
    movea.l _ILBMBase,a6
__PutBODY:
    movem.l  4(sp),d0/d1/a0/a1
    jmp     _LVOPutBODY(a6)

;============================ PackRow ===========================
;bytes = PackRow(rowSize, pSource, pDest)
; d0               d0       a0      a1

   XDEF _PackRow,__PackRow
_PackRow:
    movea.l _ILBMBase,a6
__PackRow:
    movem.l  4(sp),d0/a0/a1
    jsr     _LVOPackRow(a6)
    move.l  a6,d1
    lea     _sourceptr,a6
    move.l  a0,(a6)+
    move.l  a1,(a6)
    movea.l d1,a6
    rts

  SECTION  ilbmdata,DATA

C_Vector2	dc.l 0

C_Vector1	dc.l 0

  XDEF _sourceptr,_destptr
_sourceptr: dc.l 0
_destptr    dc.l 0

PROPVector		dc.l 0
FORMVector		dc.l 0
ChunkVector		dc.l 0
NonILBMVector	dc.l 0

	END