;**
;** ReadIFF Version 1.0
;** geschrieben von Michael Maier 1989
;**

;**
;** Macros
;**
CALL MACRO
	XREF 	_LVO\1
	move.l \2,a6
	jsr _LVO\1(a6)
     ENDM

;**
;** Wer die Strukturen schon hat, kann sich die Zeilen sparen und
;** gibt dafür >> include "exec/types.i" << ein!
;**
STRUCTURE   MACRO
\1          EQU     0
SOFFSET     SET     \2
     ENDM
UBYTE       MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+1
     ENDM
WORD        MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+2
     ENDM
UWORD       MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+2
     ENDM
SHORT        MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+2
     ENDM
USHORT      MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+2
     ENDM
LONG        MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+4
     ENDM
ULONG       MACRO
\1          EQU     SOFFSET
SOFFSET     SET     SOFFSET+4
     ENDM
LABEL       MACRO
\1          EQU     SOFFSET
     ENDM

;** 
;** bis hier hin!
;**

	extern	_DOSBase
	extern	_IntuitionBase
	extern	_SysBase
	extern	_GfxBase
	entry	ReadIFF,NoFile2
	entry	ScreenPtr,BitMapLen,BitMapAdr
	extern	MyWindow,InfoFlag,XKoor,YKoor,Width,Height,Depth
	extern	KonvertFlag,MyBitMap
	extern	XImage,YImage,WidthImage,HeightImage,DepthImage

;**
;** Strukturen
;** Man sollte darauf achten, daß mindestens ein Leerzeichen vor dem Macro
;** steht, sonst denkt der Computer, es wäre ein Label und gibt eine
;** Fehlermeldung aus, weil das Wort schon als Macro benutzt wird.
;**

;**
;** BitMapHeaDer - Struktur
;**
 STRUCTURE  BMHD,0
  UWORD    BMHD_w
  UWORD    BMHD_h
  WORD     BMHD_x
  WORD     BMHD_y
  UBYTE    BMHD_nPlanes
  UBYTE    BMHD_masking
  UBYTE    BMHD_compression
  UBYTE    BMHD_pad1
  UWORD    BMHD_transparentColor
  UBYTE    BMHD_xAspect
  UBYTE    BMHD_yAspect
  WORD     BMHD_pageWidth
  LABEL    BMHD_pageHeight

;**
;** Commodore Amiga - Struktur
;**
 STRUCTURE  CAMG,0
  UWORD    CAMG_PadWord
  LABEL    CAMG_ViewModes

;**
;** NewScreen - Struktur
;**
 STRUCTURE  SCR,0
  SHORT     SCR_LeftEdge
  SHORT     SCR_TopEdge
  SHORT     SCR_Width
  SHORT     SCR_Height
  SHORT     SCR_Depth
  UBYTE     SCR_DetailPen
  UBYTE     SCR_BlockPen
  USHORT    SCR_ViewModes
  USHORT    SCR_Type
  LONG      SCR_Font
  LONG      SCR_Title
  LONG      SCR_Gadget
  LONG      SCR_Bitmap

;**
;** Verschiedene Labels
;**
mode_old equ 1005			;Flag für Open
CLEAR    equ $10000			;Flag für AllocMem

;**
;** Zeigt einen Requester an
;** => a1 = Zeiger auf BodyText
;** <= -
;**
ShowRequester:
	move.l	MyWindow,a0
	lea	CancelText,a2
	movea.l	a2,a3
	clr.l	d0
	clr.l	d1
	move.l	#250,d2
	move.l	#60,d3
	CALL	AutoRequest,_IntuitionBase
	clr.w	InfoFlag		;Error
	clr.w	KonvertFlag		;Error
	rts
;**
;** Gibt alle Chunks aus
;** => a0 Zeiger auf Filename
;** <= - ( Zeiger auf Screen steht in "ScreenPtr" )
;**
ReadIFF:
	move.l	sp,Stack		;Stack sichern
	clr.l	FoundBMHD		;
	clr.l	FilePtr			;
	clr.w	SysFlag			;SysFlag löschen
	move.l	a0,a5			;Kopie nach a5 
	move.l	a0,d1			;Name
	move.l	#-2,d2			;Zugriffsmodus
	CALL	Lock,_DOSBase		;

	move.l	d0,Lock			;Lock speichern
	beq	NoFile			;
	move.l	d0,d1			;Lock
	move.l	#InfoBlock,d2		;InfoBlock
	CALL	Examine,_DOSBase	;untersuchen

	move.l	Lock,d1			;Lock freigeben
	CALL	UnLock,_DOSBase		;

	lea	InfoBlock,a0		;
	move.l	124(a0),d0		;Länge
	move.l	d0,FileLength		;speichern
	move.l	d0,Length
	move.l	#CLEAR,d1		;PUBLIC
	CALL	AllocMem,_SysBase	;
	move.l	d0,FilePtr		;Pointer speichern
	beq	NoRam			;

	move.l	a5,d1			;File öffnen
	move.l	#mode_old,d2		;
	CALL	Open,_DOSBase		;
	move.l	d0,FileHandle		;Filehandle speichern
	beq	NoFile			;Fehler ->Abbruch
	move.l	d0,d1			;Filehandle
	move.l	FilePtr,d2		;Zeiger
	move.l	FileLength,d3		;Länge
	CALL	Read,_DOSBase		;lesen
	move.l	FileHandle,d1		;
	CALL	Close,_DOSBase		;
	move.l	FilePtr,d7		;
	add.l	d7,FileLength		;
	move.l	FilePtr,a5		;
;**
;** FORM & ILBM Test
;**
	move.l	(a5)+,d7	;4 Bytes lesen
	cmp.l	#'FORM',d7	;IFF-File?
	bne	NotIFF		;nein, Abbruch
	adda.l	#4,a5		;nächsten 8 Bytes lesen
	move.l	(a5)+,d7	;Bytes nach D7
	cmp.l	#'ILBM',d7	;Grafik?
	bne	NotIFF		;nein, Abbruch

;**
;** einzelne Chunks lesen und Ausgeben
;**
Loop1:
	move.l	(a5),d7		;Bytes lesen
;**
;** nicht unterstützte Chunks werden überlesen
;**
	cmpi.l	#'BMHD',d7		;BMHD ?
	bne.s	TstCMAP			;nein, auf CMAP testen
	tst.b	FoundBMHD		;sonst: 1.BMHD ?
	bne	ChunkErr		;nein, Abbruch
	move.l	4(a5),d7		;Länge lesen
	adda.l	#8,a5			;Zeiger auf BMHD
	move.l	a5,BitMapHeader		;
	add.l	d7,a5			;nächster Chunk
	jsr	CreateScreen		;Screen öffnen
	moveq.b	#1,d0			;
	move.b	d0,FoundBMHD		;
	bra	Loop1			;
TstCMAP:
	cmpi.l	#'CMAP',d7		;CMAP ?
	bne.s	TstCAMG			;nein, auf CAMG testen
	tst.b	FoundCMAP		;sonst: 1.CMAP ?
	bne	ChunkErr		;nein, Abbruch
	move.l	4(a5),d7		;Länge lesen
	adda.l	#8,a5			;Zeiger auf Colors
	move.l	a5,Colors		;
	add.l	d7,a5			;nächster Chunk
	moveq.b	#1,d0			;
	move.b	d0,FoundCMAP		;
	tst.b	FoundBMHD		;BMHD gefunden ?
	beq	Loop1			;
	jsr	SetColors		;Farben setzen
	bra	Loop1			;
TstCAMG:
	cmpi.l	#'CAMG',d7		;CAMG ?
	bne.s	TstBODY			;nein, auf BODY testen
	tst.b	FoundCAMG		;sonts: 1.CAMG ?
	bne	ChunkErr		;nein, Abbruch
	move.l	4(a5),d7		;Länge lesen
	adda.l	#8,a5			;Zeiger auf CAMG
	move.l	a5,ComAmg		;
	add.l	d7,a5			;nächster Chunk
	tst.l	ScreenPtr		;
	beq	NoScreenForRemake	;nein weiter lesen
	move.l	ScreenPtr,a0		;Screen-Pointer nach A0
	add.l	#76,a0			;ViewPort.Modes
	move.l	ComAmg,a1		;Zeiger auf CAMG
	move.w	CAMG_ViewModes(a1),(a0)	;ViewModes kopieren
	CALL	RemakeDisplay,_IntuitionBase
NoScreenForRemake:
	moveq.b	#1,d0			;Found-Flag setzen
	move.b	d0,FoundCAMG		;
	bra	Loop1			;Hauptschleife
TstBODY:
	cmpi.l	#'BODY',d7		;BODY ?
	bne.s	Chunk			;nein, weiter lesen
	tst.b	FoundBODY		;sonts: 1.BODY ?
	bne	ChunkErr		;nein, Abbruch
	tst.w	KonvertFlag		;KonvertFlag?
	bne.s	1$			;ja
	tst.b	FoundBMHD		;BMHD?
	beq	ChunkErr		;nein, Abbruch
1$:
	add.l	#8,a5			;Zeiger auf BODY
	move.l	a5,BitmapPtr		;
	move.l	BitMapHeader,a0		;
	cmpi.b	#1,BMHD_masking(a0)	;Masking?
	bne.s	NoMaskingOpt		;nein, normal lesen
	move.l	#CLEAR,d1		;
	clr.l	d0			;
	move.w	BytesPerRow,d0		;
	CALL	AllocMem,_SysBase	;Speicher anforden
	move.l	d0,MaskingLine		;Fehler ?
	beq	NoRam			;ja, Abbruch
NoMaskingOpt:
	jsr	ReadBody_Ram		;entpacken
	tst.l	MaskingLine		;MaskingLine ?
	beq.s	TstBODY2		;
	move.l	MaskingLine,a1		;
	clr.l	d0			;
	move.w	BytesPerRow,d0		;
	CALL	FreeMem,_SysBase	;
TstBODY2:
	jmp	Quit
Chunk:
	addq.l	#2,a5			;Zeiger +2
	cmp.l	FileLength,a5		;
	blt	Loop1			;
	jmp	Quit
;**
;** Verschiedene Fehler, die während des Laden aufgetreten sind:
;** ( Es wird ein Requester geöffnet, der die genaue Beschreibung des
;** Fehlers enthält. Für eigene Programme können andere Fehlermeldung
;** verwendet werden. Man muß lediglich bei "jsr >>ShowRequester<<" den
;** Namen der eigene Routine, die die Fehler behandelt, einsetzen. )
;**

;**
;** keinen File gefunden
;**
NoFile:
	lea	NoFileMsg,a1		;Fehlermeldung ausgeben
	jsr	ShowRequester		;
	bra	Quit			;und Programm verlasen
;**
;** kein IFF-File (Grafik)
;**
NotIFF:
	lea	IFFErrMsg,a1		;Fehlermeldung ausgeben
	jsr	ShowRequester		;
	bra	Quit
;**
;** kein Screen
;**
NoScreen:
	lea	NoScreenMsg,a1
	jsr	ShowRequester
	bra	Quit

NoFile2:
	lea	NoFile2Msg,a1
	jsr	ShowRequester
	rts

;**
;** Fehler in der Reihenfolge der Chunks
;**
ChunkErr:
	lea	ChuErrMsg,a1
	jsr	ShowRequester
	bra	Quit
;**
;** Keinen Speicher für Masking
;**
NoRam:
	lea	NoRamMsg,a1
	jsr	ShowRequester
	bra	Quit
;**
;** Fehler beim Lesen aufgetreten o. File-Ende
;**
IOError:
	tst.l	d0			;File - Ende?
	beq	CloseFile		;ja, Fileschließen
	lea	ReadErrMsg,a1		;sonst Fehlermeldung ausgeben
	jsr	ShowRequester		;
CloseFile:
	move.l	FileHandle,d1		;File-Handle nach D1
	CALL	Close,_DOSBase		;File schließen

;**
;** Rückkehr zum Hauptprogramm
;**
Quit:
	
	tst.l	FilePtr			;
	beq.s	1$			;
	move.l	FilePtr,a1		;
	move.l	Length,d0		;
	CALL	FreeMem,_SysBase	;
1$:
	move.l	Stack,sp		;Stack restaurieren
	rts				;und zurück

;**
;** SetColors: die Farbtöne werden gesetzt
;** => -
;** <= -
;**
SetColors:
	move.l	a5,-(sp)		;File-Pointer
	lea	ColorMaskTab,a0		;Zeiger auf ColorMaskTabelle
	move.l	BitMapHeader,a1		;BMHD-Struktur
	clr.l	d0			;d0 löschen
	clr.l	d7			;d7 löschen
	move.b	BMHD_nPlanes(a1),d0	;Anzahl der Bitplanes
	move.b	0(a0,d0),d7		;Anzahl der Farben
	subq.w	#1,d7			;minus 1
	move.l	Colors,a5		;Zeiger auf Daten
	moveq.l	#-1,d6			;Zähler = -1
SCLoop1:
	addq.l	#1,d6			;Zähler erhöhen
	move.l	d6,d0			;nach D0 kopeiren
	clr.l	d1			;d1,d2 und d3
	clr.l	d2			;
	clr.l	d3			;löschen
	move.l	ScreenPtr,a0		;ViewPort-Zeiger
	add.l	#44,a0			;holen
	move.b	(a5)+,d1		;Rotwert
	move.b	(a5)+,d2		;Grünwert
	move.b	(a5)+,d3		;Blauwert
	asr.b	#4,d1			;Farbwerte / 16
	asr.b	#4,d2			;
	asr.b	#4,d3			;
	CALL	SetRGB4,_GfxBase	;Farben setzen
	dbf	d7,SCLoop1		;
	move.l	(sp)+,a5		;
	rts				;zurück

;**
;** CreateScreen: öffnet unter Intuition einen Screen
;** => -
;** <= -
;**
CreateScreen:
	move.l	a5,-(sp)			;Zeiger sichern
	tst.w	InfoFlag			;InfoFlag ?
	bne	GetInfo				;ja, Informationen holen
	clr.l	d0				;D0 löschen
	move.l	BitMapHeader,a1
	lea	NewScreen,a0			;Screen-Struktur
	move.l	ComAmg,a2			;CAMG-Struktur
	move.w	BMHD_w(a1),SCR_Width(a0)	;Größe
	move.w	BMHD_h(a1),SCR_Height(a0)	;
	clr.w	d0				;D0 löschen
	move.b	BMHD_nPlanes(a1),d0		;Bit-Planes
	move.w	d0,SCR_Depth(a0)		;
	clr.l	d0				;d0 löschen
	move.w	BMHD_w(a1),d0			;Width in d0
	divu	#8,d0				;/8
	move.l	d0,d1				;
	swap	d1				;Rest
	tst.w	d1				;untersuchen
	beq	NoModulo			;=0?
	addq.w	#1,d0				;+1
NoModulo:
	move.w	d0,BytesPerRow				;Bytes / Zeile
	clr.l	d0					;
	move.w	BytesPerRow,d0				;
	divu	#2,d0					;/2
	swap	d0					;
	tst.w	d0					;PadWord?
	beq	NoPadWord				;nein, weiter
	addq.w	#1,BytesPerRow				;
	add.w	#8,SCR_Width(a0)			;
NoPadWord:
	move.w	CAMG_ViewModes(a2),SCR_ViewModes(a0)	;ViewModes von CAMG
	tst.b	FoundCAMG				;wurde CAMG gefunden?
	bne	OpenScr					;ja, OpenScr
	clr.w	SCR_ViewModes(a0)			;
	cmp.w	#321,BMHD_pageWidth(a1)			;sonst feststellen, ob
	blt	TstLace					;Hires?
	ori.w	#$8000,SCR_ViewModes(a0)		;
TstLace:						;oder
	cmp.w	#257,BMHD_pageHeight(a1)			;Interlace?
	blt	OpenScr					;
	ori.w	#$4,SCR_ViewModes(a0)			;
OpenScr:
	move.w	BytesPerRow,d0				;
	move.w	d0,BytesPerRow2
	tst.w	KonvertFlag				;KonvertFlag ?
	bne	GetKonvertInfos				;
	cmpi.w	#48,BMHD_w(a1)				;Breite ?
	bgt.s	1$					;größer als 48!
	move.w	#48,SCR_Width(a0)			;
	move.w	#6,BytesPerRow				;
1$:
	CALL	OpenScreen,_IntuitionBase		;Screen öffnen
	move.l	d0,ScreenPtr				;Screen-Pointer
	beq	NoScreen				;Fehler, Abbruch
	move.l	(sp)+,a5				;
	rts						;zurück

GetInfo:
	move.l	BitMapHeader,a0				;
	clr.l	d0					;
	move.w	BMHD_h(a0),Height			;Höhe
	move.w	BMHD_w(a0),Width			;Breite
	move.b	BMHD_nPlanes(a0),d0			;Planes
	move.w	d0,Depth				;
	move.w	BMHD_x(a0),XKoor			;
	move.w	BMHD_y(a0),YKoor			;
	jmp	Quit
GetKonvertInfos:
	move.l	BitMapHeader,a0				;
	move.w	BMHD_x(a0),XImage			;
	move.w	BMHD_y(a0),YImage				;
	move.w	BMHD_w(a0),WidthImage			;
	move.w	BMHD_h(a0),HeightImage			;
	move.w	NewScreen+8,DepthImage			;
	move.l	(sp)+,d0				;Stack
	move.l	BitMapHeader,a1				;
	lea	MyBitMap,a0				;
	clr.w	d0					;
	clr.l	d1
	clr.l	d2
	move.b	BMHD_nPlanes(a1),d0			;
	move.w	BMHD_w(a1),d1				;
	move.w	BMHD_h(a1),d2				;
	CALL	InitBitMap,_GfxBase			;BitMap initialisieren
	clr.l	d0					;d0 löschen
	move.w	BytesPerRow,d0				;BytesPerRow
	move.w	d0,MyBitMap
	mulu	MyBitMap+2,d0				;*Rows
	move.l	d0,PlaneLen				;
	clr.l	d1					;d1 löschen
	move.b	MyBitMap+5,d1				;
	mulu	d1,d0					;*Depth
	move.l	#1,d1					;
	move.l	d0,BitMapLen				;
	CALL	AllocMem,_SysBase			;Speicher anfordern
	move.l	d0,BitMapAdr				;Zeiger speichern
	beq	NoRam					;Fehler!
	lea	MyBitMap,a0				;Zeiger auf MyBitMap
	adda.l	#8,a0					;Zeiger auf Planes
	move.l	d0,a1					;Zeiger d. Planes
	move.l	PlaneLen,d0				;Länge einer Plane
	clr.l	d1					;d1 löschen
	move.b	MyBitMap+5,d1				;Tiefe holen
	subq.l	#1,d1					;-1
1$:
	move.l	a1,(a0)+				;Adresse eintragen
	add.l	d0,a1					;nächste Plane
	dbf	d1,1$					;
	bra	Loop1
;**
;** ReadBody: liest die Grafikdaten aus dem Speicher in den Screen
;** => -
;** <= -
;**
ReadBody_Ram:
	move.l	a5,-(sp)
	move.l	BitmapPtr,a4
	move.l	BitMapHeader,a0		;Zeiger auf BitmapHeader-Struktur
	clr.l	d7			;d7 = 0
	clr.l	d4			;d4 löschen
	sub.w	BytesPerRow,d4		;minus Bytes / Zeile
RBLoop1_Ram:
	cmp.w	BMHD_h(a0),d7		;alle Zeilen ?
	beq	EndBody_Ram		;ja, Ende
	addq.w	#1,d7			;Zeile + 1
	add.w	BytesPerRow,d4		;
	move.l	ScreenPtr,a1		;Screenpointer holen
	add.l	#192,a1			;und Adresse v. Zeiger auf 1.Bitplane
	tst.w	KonvertFlag		;
	beq.s	1$
	lea	MyBitMap,a1		;
	adda.l	#8,a1			;
1$:
	moveq.b	#-1,d6			;Planecounter
RBLoop2_Ram:
	addq.b	#1,d6			;
	cmp.b	BMHD_nPlanes(a0),d6	;alle Bitplanes ?
	beq	TestMasking		;ja, testen ob Masking
	move.l	(a1)+,a2		;
	clr.l	d5			;Bytecounter löschen
	tst.b	BMHD_compression(a0)	;komprimiert ?
	beq.s	NoCompression_Ram	;nein, NoCompression
	jsr	Compression		;
	bra.s	RBLoop2_Ram		;nächste Plane
NoCompression_Ram:
	clr.l	d3			;d3 löschen
	move.w	BytesPerRow2,d3		;Länge
	move.l	a2,a5			;Adresse
	add.l	d4,a5			;Zeile
	jsr	ReadBytesRam		;
	bra.s	RBLoop2_Ram		;und nächste Plane
EndBody_Ram:
	move.l	(sp)+,a5		;
	rts				;und zurück

ReadBytesRam:
	subq.l	#1,d3			;Zähler minus 1
RBRLoop1:
	move.b	(a4)+,(a5)+		;Bytes aus Speicher
	dbf	d3,RBRLoop1		;kopieren
	rts				;

TestMasking:
	cmpi.b	#1,BMHD_masking(a0)		;Masking?
	bne	RBLoop1_Ram			;nein, Weiter
	cmp.b	BMHD_h(a0),d7			;letzte Zeile
	beq	RBLoop1_Ram			;ja, Ende
	movem.l	a0-a3/a5/a6/d0-d7,-(sp)		;a2 retten
	move.l	MaskingLine,a2			;Adresse von MaskingLine
	clr.l	d5				;Bytecounter löschen
	clr.l	d4				;d4 löschen
	jsr	Compression			;entpacken
	movem.l	(sp)+,a0-a3/a5/a6/d0-d7		;a2 vom Stack
	bra	RBLoop1_Ram			;
;**
;** entpackt eine Linie
;** => a2 Zeiger auf Zieldaten
;**    a4 Zeiger auf Quelldaten
;**    ( d0,d1,d2,d3,d4,d5,a2,a3,a4 zerstört )
;** <= -
;**

Compression:
	cmp.w	BytesPerRow2,d5		;eine Zeile ?
	bge	EndCompression		;ja, fertig
	clr.l	d0			;
	move.b	(a4)+,d0		;ein Zeichen lesen
	cmpi.b	#128,d0			;größer als 128
	bcc.s	NoRead_Ram		;ja, nicht lesen
	clr.l	d3			;
	move.b	d0,d3			;
	addq.b	#1,d3			;+1
	move.l	a2,a5			;Adresse
	add.l	d4,a5			;Zeile
	add.l	d5,a5			;
	add.w	d3,d5			;Offset
	jsr	ReadBytesRam		;Bytes lesen
	bra.s	Compression		;weiter
NoRead_Ram:
	move.b	(a4)+,d1		;
	clr.l	d2			;
	move.w	#257,d2			;-257
	sub.w	d0,d2			;
	move.l	a2,a3			;
	add.l	d5,a3			;
	add.l	d4,a3			;
	add.l	d2,d5			;
	subq.w	#1,d2			;
RBLoop3_Ram:
	move.b	d1,(a3)+		;Farbwert kopieren
	dbf	d2,RBLoop3_Ram		;
	bra	Compression		;weiter
EndCompression:
	rts				;


;**
;** Variabeln und Textdaten
;**

;**
;** IntuiText - Strukturen für AutoRequester (Fehlermeldungen)
;** 

Msg1:
	dc.b	'Cannot open File!',0
	cnop	2
Msg2:
	dc.b	'Chunk Error!',0
	cnop	2
Msg3:
	dc.b	'Not a IFF-File',0
	cnop	2
Msg4:
	dc.b	'Read Error!',0
	cnop	2
Msg5:
	dc.b	'Cannot open Screen!',0
	cnop	2
Msg6:
	dc.b	'No CNIP-RAM!',0
	cnop	2
Msg7:
	dc.b	'Cannot create File!',0
	cnop	2
Cancel:
	dc.b	'CANCEL',0
	cnop	2

NoFileMsg:
	dc.b	0,1,0,0
	dc.w	49,10
	dc.l	0,Msg1,0
ChuErrMsg:
	dc.b	0,1,0,0
	dc.w	69,10
	dc.l	0,Msg2,0
IFFErrMsg:
	dc.b	0,1,0,0
	dc.w	61,10
	dc.l	0,Msg3,0
ReadErrMsg:
	dc.b	0,1,0,0
	dc.w	72,10
	dc.l	0,Msg4,0
NoScreenMsg:
	dc.b	0,1,0,0
	dc.w	41,10
	dc.l	0,Msg5,0
NoFile2Msg:
	dc.b	0,1,0,0
	dc.w	41,10
	dc.l	0,Msg7,0
NoRamMsg:
	dc.b	0,1,0,0
	dc.w	41,10
	dc.l	0,Msg6,0
CancelText:
	dc.b	0,1,0,0
	dc.w	5,3
	dc.l	0,Cancel,0

ColorMaskTab:
	dc.b	0,2,4,8,16,32,32
	cnop	2
BytesPerRow:	dc.w	0
BytesPerRow2:	dc.w	0
ScreenPtr:	dc.l	0
BitmapPtr:	dc.l	0
MaskingLine:	dc.l	0
BitmapLength:	dc.l	0
Stack:		dc.l	0
FileHandle:	dc.l	0
FilePtr:	dc.l	0
Lock:		dc.l	0
FileLength:	dc.l	0
Length:		dc.l	0
BitMapLen:	dc.l	0
PlaneLen:	dc.l	0
BitMapAdr:	dc.l	0
FoundBMHD:	dc.b	0
FoundCMAP:	dc.b	0
FoundCAMG:	dc.b	0
FoundBODY:	dc.b	0

;**
;** Variabeln
;**
BitMapHeader:
	dc.l	0
Colors:
	dc.l	0
ComAmg:
	dc.l	0
NewScreen:
	dc.w	0,0,0,0,0
	dc.b	0,0
	dc.w	0,$f
	dc.l	0,0,0,0
UndoBytesPR:
	dc.w	0
SysFlag:
	dc.w	0
	cnop	4
InfoBlock:
	ds.b	260
;**
;** Ende von ReadIFF.a
;**