;Codé par Denis Duplan pour Stash of Code (http://www.stashofcode.fr, stashofcode@gmail.com) en 2018.

;Ce(tte) oeuvre est mise à disposition selon les termes de la Licence (http://creativecommons.org/licenses/by-nc/4.0/) Creative Commons Attribution - Pas d’Utilisation Commerciale 4.0 International.

;Chargement et affichage d'un fichier IFF en 5 bitplanes de n'importe quelles dimensions pourvu qu'elles ne dépassent pas DISPLAY_DX x DISPLAY_DY (DISPLAY_DEPTH doit correspondre au nombre de bitplanes du fichier IFF : attention, car certains logiciels sauvegardent des images en plus de bitplanes qu'on ne le croit, comme Pro Motion NG qui sauvegarde systématiquement en 8 bitplanes). 

;A FAIRE : Tester des overflows dans la décompression (dépassement de la longueur du fichier en entrée, dépassement de la taille des bitplanes en sortie)

;********** Directives **********

	SECTION yragael,CODE_C

;********** Constantes **********

;Programme

DISPLAY_X=$81
DISPLAY_Y=$2C
DISPLAY_DX=320
DISPLAY_DY=256
DISPLAY_DEPTH=5
COPPERLIST=10*4+DISPLAY_DEPTH*2*4+(1<<DISPLAY_DEPTH)*4+4
	;10*4						Configuration de l'affichage
	;DISPLAY_DEPTH*2*4			Adresses des bitplanes
	;(1<<DISPLAY_DEPTH)*4		Palette
	;4							$FFFFFFFE

;********** Initialisations **********

	;Empiler les registres

	movem.l d0-d7/a0-a6,-(sp)
	lea $DFF000,a5

	;Récupérer le chemin d'accès à l'image

	lea readArgsData,a0
	move.l #argsTemplate,OFFSET_READARGS_TEMPLATE(a0)
	move.l #argsValues,OFFSET_READARGS_VALUES(a0)
	move.l #argsHelp,OFFSET_READARGS_HELP(a0)
	bsr _readArgs
	tst.w d0
	bne _readArgsSucceeded
	bsr _freeArgs
	movem.l (sp)+,d0-d7/a0-a6
	rts
_readArgsSucceeded:

	;Charger l'image

	lea argsValues,a0
	movea.l (a0),a0
	bsr _loadFile
	move.l d0,pictureSize
	move.l a0,pictureData
	bne _pictureLoaded
	bsr _freeArgs
	movem.l (sp)+,d0-d7/a0-a6
	rts
_pictureLoaded:
	bsr _freeArgs

	;Allouer de la mémoire en CHIP mise à 0 pour la Copper list

	movea.l $4,a6
	move.l #COPPERLIST,d0
	move.l #$10002,d1
	jsr -198(a6)
	move.l d0,copperList

	;Allouer de la mémoire en CHIP mise à 0 pour les bitplanes d'affichage

	move.l #DISPLAY_DEPTH*DISPLAY_DY*(DISPLAY_DX>>3),d0
	move.l #$10002,d1
	jsr -198(a6)
	move.l d0,bitplanes

	;StingRay's stuff
	
	lea graphicsLibrary,a1
	movea.l $4,a6
	jsr -408(a6)		;OpenLibrary ()
	move.l d0,graphicsBase
	move.l graphicsBase,a6
	move.l $22(a6),view
	movea.l #0,a1
	jsr -222(a6)		;LoadView ()
	jsr -270(a6)		;WaitTOF ()
	jsr -270(a6)		;WaitTOF ()
	jsr -228(a6)		;WaitBlit ()
	jsr -456(a6)		;OwnBlitter ()
	move.l graphicsBase,a1
	movea.l $4,a6
	jsr -414(a6)		;CloseLibrary ()

	;Couper le système

	jsr -132(a6)

	;Attendre un VERTB (pour éviter que les sprites ne bavent) et couper les interruptions hardware et les DMA

	lea $DFF000,a5
	bsr _waitVERTB
	move.w INTENAR(a5),intena
	move.w #$7FFF,INTENA(a5)
	move.w INTREQR(a5),intreq
	move.w #$7FFF,INTREQ(a5)
	move.w DMACONR(a5),dmacon
	move.w #$07FF,DMACON(a5)

;---------- Copper list ----------

	movea.l copperList,a0

	;Configuration de l'écran

	move.w #DIWSTRT,(a0)+
	move.w #(DISPLAY_Y<<8)!DISPLAY_X,(a0)+
	move.w #DIWSTOP,(a0)+
	move.w #((DISPLAY_Y+DISPLAY_DY-256)<<8)!(DISPLAY_X+DISPLAY_DX-256),(a0)+
	move.w #BPLCON0,(a0)+
	move.w #(DISPLAY_DEPTH<<12)!$0200,(a0)+
	move.w #BPLCON1,(a0)+
	move.w #$0000,(a0)+
	move.w #BPLCON2,(a0)+
	move.w #$0000,(a0)+
	move.w #DDFSTRT,(a0)+
	move.w #((DISPLAY_X-17)>>1)&$00FC,(a0)+
	move.w #DDFSTOP,(a0)+
	move.w #((DISPLAY_X-17+(((DISPLAY_DX>>4)-1)<<4))>>1)&$00FC,(a0)+
	move.w #BPL1MOD,(a0)+
	move.w #0,(a0)+
	move.w #BPL2MOD,(a0)+
	move.w #0,(a0)+

	;Comptabilité OCS avec AGA

	move.w #FMODE,(a0)+
	move.w #$0000,(a0)+

	;Adresses des bitplanes

	move.w #BPL1PTH,d0
	move.l bitplanes,d1
	moveq #DISPLAY_DEPTH-1,d2
_copperListBitplanes:
	move.w d0,(a0)+
	swap d1
	move.w d1,(a0)+
	addq.w #2,d0
	move.w d0,(a0)+
	swap d1
	move.w d1,(a0)+
	addq.w #2,d0
	addi.l #DISPLAY_DY*(DISPLAY_DX>>3),d1
	dbf d2,_copperListBitplanes

	;Palette

	move.w #COLOR00,d1
	moveq #(1<<DISPLAY_DEPTH)-1,d0
_copperListColors:
	move.w d1,(a0)+
	addq.w #2,d1
	move.w #$0000,(a0)+
	dbf d0,_copperListColors

	;Fin

	move.l #$FFFFFFFE,(a0)

	;Activer les DMA

	bsr _waitVERTB
	move.w #$83C0,DMACON(a5)	;DMAEN=1, BPLEN=1, COPEN=1, BLTEN=1

	;Démarrer la Copper list

	move.l copperList,COP1LCH(a5)
	clr.w COPJMP1(a5)

;********** Programme principal **********

	;Afficher l'image

	lea IFFLoaderData,a0
	move.l pictureData,OFFSET_IFFLOADER_DATA(a0)
	move.l bitplanes,OFFSET_IFFLOADER_BITPLANES(a0)
	move.l #palette,OFFSET_IFFLOADER_PALETTE(a0)
	move.l pictureSize,OFFSET_IFFLOADER_FILESIZE(a0)
	move.l #DISPLAY_DX>>3,OFFSET_IFFLOADER_LINESMODULO(a0)
	move.l #DISPLAY_DY*(DISPLAY_DX>>3),OFFSET_IFFLOADER_BITPLANESMODULO(a0)
	bsr _IFFLoader

	movea.l copperList,a0
	lea 10*4+DISPLAY_DEPTH*2*4+2(a0),a0
	lea palette,a1
	moveq #(1<<DISPLAY_DEPTH)-1,d0
_setPalette:
	move.w (a1)+,(a0)
	lea 4(a0),a0
	dbf d0,_setPalette

	;Libérer la mémoire utilisée pour le fichier

	movea.l pictureData,a1
	move.l pictureSize,d0
	movea.l $4,a6
	jsr -210(a6)

	;Attendre la pression du bouton gauche de la souris

_loop:
	btst #6,$BFE001
	bne _loop
_loopEnd:

;********** Finalisations **********

	;Couper les interruptions hardware et les DMA

	move.w #$7FFF,INTENA(a5)
	move.w #$7FFF,INTREQ(a5)
	move.w #$07FF,DMACON(a5)

	;Rétablir les interruptions hardware et les DMA

	move.w dmacon,d0
	bset #15,d0
	move.w d0,DMACON(a5)
	move.w intreq,d0
	bset #15,d0
	move.w d0,INTREQ(a5)
	move.w intena,d0
	bset #15,d0
	move.w d0,INTENA(a5)

	;Rétablir la Copper list

	lea graphicsLibrary,a1
	movea.l $4,a6
	jsr -408(a6)		;OpenLibrary ()
	move.l d0,graphicsBase

	movea.l d0,a0
	move.l 38(a0),COP1LCH(a5)
	clr.w COPJMP1(a5)

	;StingRay's stuff

	movea.l view,a1
	move.l graphicsBase,a6
	jsr -222(a6)		;LoadView ()
	jsr -462(a6)		;DisownBlitter ()
	move.l graphicsBase,a1
	movea.l $4,a6
	jsr -414(a6)		;CloseLibrary ()

	;Rétablir le système

	jsr -138(a6)

	;Libérer la mémoire

	movea.l copperList,a1
	move.l #COPPERLIST,d0
	jsr -210(a6)

	movea.l bitplanes,a1
	move.l #DISPLAY_DEPTH*DISPLAY_DY*(DISPLAY_DX>>3),d0
	jsr -210(a6)

	;Dépiler les registres

	movem.l (sp)+,d0-d7/a0-a6
	rts

;********** Routines **********

	INCLUDE "SOURCES:common/registers.s"

PUTSTR:		MACRO
	move.l \1,d1
	movea.l dosBase,a6
	jsr -948(a6)			;PutStr ()
	ENDM

IFERROR:	MACRO
	cmp.l \2,\1
	bne _ifErrorDone\@
	PUTSTR \3
	move.w \4,\5
	bra \6
_ifErrorDone\@
	ENDM

;---------- Attente du blanc vertical (ne fonctionne que si l'interruption VERTB est activée !) ----------

_waitVERTB:
	movem.w d0,-(sp)
_waitVERTBLoop:
	move.w INTREQR(a5),d0
	btst #5,d0
	beq _waitVERTBLoop
	movem.w (sp)+,d0
	rts

;---------- Lecture d'arguments de ligne de commandes ----------

;Entrée(s) :
;	(la structure readArgsData)
;Sortie(s) :
;	D0 = 1 si succès, sinon 0
;Notice :
;	A appeler avant de couper l'OS et bidouiller le hardware !
;	Ne pas oublier d'appeler _freeArgs après avoir utilisé le résultat.

_readArgs:
	movem.l a0-a6/d1-d7,-(sp)
	move.w #0,readArgsResult

	;Ouvrir la bibliothèque DOS

	lea dosLibrary,a1
	moveq #0,d0
	movea.l $4,a6
	jsr -408(a6)			;OpenLibrary ()
	move.l d0,dosBase
	beq _readArgsOpenLibraryError

	;Lire les arguments

	lea readArgsData,a0
	move.l OFFSET_READARGS_TEMPLATE(a0),d1
	move.l OFFSET_READARGS_VALUES(a0),d2
	moveq #0,d3
	movea.l dosBase,a6
	jsr -798(a6)			;ReadArgs ()
	move.l d0,readArgsStructure
	IFERROR d0,#0,readArgsData+OFFSET_READARGS_HELP,#0,readArgsResult,_readArgsError
	move.w #1,readArgsResult

	;Fermer la bibliothèque DOS

_readArgsError:
	movea.l dosBase,a1
	movea.l $4,a6
	jsr -414(a6)			:;CloseLibrary ()

_readArgsOpenLibraryError:
	move.w readArgsResult,d0
	movem.l (sp)+,a0-a6/d1-d7
	rts

readArgsResult:		DC.W 0
readArgsStructure:	DC.L 0
readArgsData:
OFFSET_READARGS_TEMPLATE=0
OFFSET_READARGS_VALUES=4
OFFSET_READARGS_HELP=8
DATASIZE_READARGS=3*4
					BLK.B DATASIZE_READARGS,0

;Entrée(s) :
;	(rien)
;Sortie(s) :
;	(rien)
;Notice :
;	A appeler systématiquement après _readArgs une fois les arguments utilisés. N'est pas gênée si jamais elle est appelée alors que _readArgs a planté pour une raison quelconque, car FreeArgs () ne fait rien quand D1 vaut 0.

_freeArgs:
	movem.l a0-a6/d0-d7,-(sp)

	;Ouvrir la bibliothèque DOS

	lea dosLibrary,a1
	moveq #0,d0
	movea.l $4,a6
	jsr -408(a6)			;OpenLibrary ()
	move.l d0,dosBase

	;Libérer les ressources allouées pour lire les arguments
	
	move.l readArgsStructure,d1
	movea.l dosBase,a6
	jsr -858(a6)			;FreeArgs ()

	;Fermer la bibliothèque DOS

	movea.l dosBase,a1
	movea.l $4,a6
	jsr -414(a6)			:;CloseLibrary ()

	movem.l (sp)+,a0-a6/d0-d7
	rts

;---------- Chargement d'un fichier ----------

;Entrée(s) :
;	A0 = Adresse du chemin d'accès au fichier se terminant par $00
;Sortie(s) :
;	A0 = Adresse à laquelle le contenu du fichier a été chargé, ou 0 si échec
;	D0 = Taille du contenu du fichier en octets, ou 0 si échec
;Notice :
;	A appeler avant de couper l'OS et bidouiller le hardware !

_loadFile:
	movem.l a1-a6/d1-d7,-(sp)
	move.l a0,loadFileName
	move.l #0,loadFileNbBytesLoaded
	move.l #0,loadFileData

	;Ouvrir la bibliothèque DOS

	lea dosLibrary,a1
	moveq #0,d0
	movea.l $4,a6
	jsr -408(a6)			;OpenLibrary ()
	move.l d0,dosBase
	IFERROR d0,#0,#loadFileMsgOpenLibrary,#0,loadFileResult,_loadFileOpenLibraryError

	;Verrouiller le fichier

	move.l loadFileName,d1
	moveq #-2,d2
	movea.l dosBase,a6
	jsr -84(a6)				;Lock ()
	move.l d0,loadFileLock
	IFERROR d0,#0,#loadFileMsgLock,#0,loadFileResult,_loadFileLockFailed

	;Examiner le fichier
	
	move.l loadFileLock,d1
	move.l #loadFileInfoBlock,d2
	movea.l dosBase,a6
	jsr -102(a6)			;Examine ()
	IFERROR d0,#0,#loadFileMsgExamine,#0,loadFileResult,_loadFileExamineError
	move.l loadFileInfoBlock+124,d0
	move.l d0,loadFileSize

	;Ouvrir le fichier

	move.l loadFileName,d1
	move.l #1005,d2
	movea.l dosBase,a6
	jsr -30(a6)				;Open ()
	move.l d0,loadFileHandle
	IFERROR d0,#0,#loadFileMsgOpen,#0,loadFileResult,_loadFileOpenError

	;Allouer de la mémoire quelconque pour le contenu du fichier

	move.l loadFileSize,d0
	moveq #0,d1
	movea.l $4,a6
	movea.l $4,a6
	jsr -198(a6)			;AllocMem ()
	move.l d0,loadFileData
	IFERROR d0,#0,#loadFileMsgAllocMem,#0,loadFileResult,_loadFileAllocMemError

	;Charger le contenu du fichier

	move.l loadFileHandle,d1
	move.l loadFileData,d2
	move.l loadFileSize,d3
	movea.l dosBase,a6
	jsr -42(a6)				;Read ()
	move.l d0,loadFileNbBytesLoaded
	IFERROR d0,#0,#loadFileMsgRead,#0,loadFileResult,_loadFileReadError

	;Fermer le fichier

_loadFileAllocMemError:
_loadFileReadError:
	move.l loadFileHandle,d1
	movea.l dosBase,a6
	jsr -36(a6)				;Close ()

	;Déverrouiller le fichier

_loadFileOpenError:
_loadFileExamineError:
	move.l loadFileLock,d1
	movea.l dosBase,a6
	jsr -90(a6)				;Unlock ()

	;Fermer la bibliothèque DOS

_loadFileLockFailed:
	movea.l dosBase,a1
	movea.l $4,a6
	jsr -414(a6)			:;CloseLibrary ()
	
_loadFileOpenLibraryError:
	move.l loadFileNbBytesLoaded,d0
	move.l loadFileData,a0
	movem.l (sp)+,a1-a6/d1-d7
	rts

dosLibrary:				DC.B "dos.library",0
						EVEN
dosBase:				DC.L 0
loadFileName:			DC.L 0
loadFileSize:			DC.L 0
loadFileHandle:			DC.L 0
loadFileData:			DC.L 0
loadFileLock:			DC.L 0
						CNOP 0,4			;Aligner sur 32 bits, sans quoi loadFileInfoBlock est en désordre au retour de Examine ()
loadFileInfoBlock:		BLK.B 260,0
loadFileNbBytesLoaded:	DC.L 0
loadFileResult:			DC.W 0
loadFileMsgOpenLibrary:	DC.B "Could not open DOS library",$0A,0
						EVEN
loadFileMsgLock:		DC.B "Could not lock file",$0A,0
						EVEN
loadFileMsgExamine:		DC.B "Could not examine file",$0A,0
						EVEN
loadFileMsgOpen:		DC.B "Could not open file",$0A,0
						EVEN
loadFileMsgAllocMem:	DC.B "Could not allocate memory for file",$0A,0
						EVEN
loadFileMsgRead:		DC.B "Could not read file",$0A,0
						EVEN

;---------- Chargement d'une image au format IFF ILBM ----------

;Contenu du chunk FORM :

IFF_FORM_ID=0			;"FORM" = $464F524D
IFF_FORM_lENGTH=4		;Taille du chunk sans compter l'ID et la taille (ie : taille du fichier - 8)
IFF_FORM_ILBM=0			;"ILBM" = $494C424D

;Contenu du chunk CMAP :

IFF_CMAP_ID=0			;"CMAP" = $434D4150
IFF_CMAP_LENGTH=4		;Taille du chunk sans compter l'ID et la taille (ie : # d'octets du chunk à suivre)
;(suite de triplets d'octets R, G, B)

;Contenu du chunk BMHD :

IFF_BMHD_ID=0			;"BMHD" = $424D4844
IFF_BMHD_LENGTH=4		;Taille du chunk sans compter l'ID et la taille (ie : # d'octets du chunk à suivre)
IFF_BMHD_WIDTH=0
IFF_BMHD_HEIGHT=2
IFF_BMHD_X=4
IFF_BMHD_Y=6
IFF_BMHD_NBPLANES=8
IFF_BMHD_MASKING=9
IFF_BMHD_COMPRESSION=10	;1 si compression en RLE
IFF_BMHD_PADDING=11
IFF_BMHD_TRANSPARENTCOLOR=12
IFF_BMHD_XASPECT=14
IFF_BMHD_YASPECT=15
IFF_BMHD_PAGEWIDTH=16
IFF_BMHD_PAGEHEIGHT=18

;Contenu du chunk BODY :

IFF_BODY_ID=0			;"BODY" = $424F4459
IFF_BODY_LENGTH=4		;Taille du chunk sans compter l'ID et la taille (ie : # d'octets du chunk à suivre)
;(données des lignes successives, compressées ou non en RLE)

;Recherche d'un chunk IFF ILBM à partir de son identifiant
;
;Entrée(s) :
;	A0 = Adresse de départ
;	D0 = # d'octets à tester au maximum (WORD)
;	D1 = ID du chunk à trouver, renversé (DWORD)
;Sortie(s) :
;	A0 = Adresse de l'octet suivant l'ID
;	D0 = # d'octets initial diminué du # d'octets parcourus jusqu'à la fin de l'ID, ou 0
;	D1 = 1 si le chunk a été trouvé, sinon 0

_IFFSeekChunk:
	movem.l d2-d3,-(sp)

	move.l d1,d2
	moveq #4,d3
_IFFSeekChunkLoop:

	subq.l #1,d0
	bge _IFFSeekChunkNext
	moveq #0,d1
	bra _IFFSeekChunkDone
_IFFSeekChunkNext:

	cmp.b (a0)+,d2
	beq _IFFSeekChunkCharFound

	moveq #4,d3
	move.l d1,d2
	bra _IFFSeekChunkLoop

_IFFSeekChunkCharFound:
	subq.b #1,d3
	bne _IFFSeekChunkNextChar
	moveq #1,d1
	bra _IFFSeekChunkDone

_IFFSeekChunkNextChar:
	lsr.l #8,d2
	bra _IFFSeekChunkLoop
	
_IFFSeekChunkDone:
	movem.l (sp)+,d2-d3
	rts

;Entrée(s) :
;	(la structure IFFLoaderData)
;Sortie(s) :
;	D0 = 1 si OK, sinon 0

_IFFLoader:
	movem.l d1-d6/a2-a5,-(sp)

	;Lire le chunk FORM

	lea IFFLoaderData,a1
	movea.l OFFSET_IFFLOADER_DATA(a1),a0
	move.l OFFSET_IFFLOADER_FILESIZE(a1),d0
	move.l #$4D524F46,d1	;"MROF"
	bsr _IFFSeekChunk
	tst.w d1
	bne _IFFFORMFound
	moveq #0,d0
	bra _IFFLoaderDone
_IFFFORMFound:

	lea 8(a0),a0
	subq.l #8,d0

	;Lire le chunk BMHD

	move.l #$44484D42,d1	;"DHMB"
	bsr _IFFSeekChunk
	tst.w d1
	bne _IFFBMHDFound
	moveq #0,d0
	bra _IFFLoaderDone
_IFFBMHDFound:

	move.l (a0)+,d1
	move.l a0,a2
	add.l d1,a0
	sub.l d1,d0

	;Lire le chunk CMAP

	move.l #$50414D43,d1	;"PAMC"
	bsr _IFFSeekChunk
	tst.w d1
	bne _IFFCMAPFound
	moveq #0,d0
	bra _IFFLoaderDone
_IFFCMAPFound:

	move.l (a0)+,d1
	sub.l d1,d0	

	movea.l OFFSET_IFFLOADER_PALETTE(a1),a3
_IFFReadCMAP:
	clr.w d2
	move.b (a0)+,d2
	lsl.w #4,d2
	move.b (a0)+,d2
	and.b #$F0,d2
	move.b (a0)+,d3
	lsr.b #4,d3
	or.b d3,d2
	move.w d2,(a3)+
	subq.b #3,d1
	bne _IFFReadCMAP

	;Lire le chunk BODY

	move.l #$59444F42,d1	;"YDOB"
	bsr _IFFSeekChunk
	tst.w d1
	bne _IFFBODYFound
	moveq #0,d0
	bra _IFFLoaderDone
_IFFBODYFound:

	lea 4(a0),a0
	move.w IFF_BMHD_HEIGHT(a2),d0
	movea.l OFFSET_IFFLOADER_BITPLANES(a1),a3
	tst.b IFF_BMHD_COMPRESSION(a2)
	bne _IFFDepack

_IFFCopy:
	movea.l a3,a4
	move.b IFF_BMHD_NBPLANES(a2),d1
_IFFCopyPlanes:
	move.w IFF_BMHD_WIDTH(a2),d2
	lsr.w #3,d2
	movea.l a4,a5
_IFFCopyRow:
	move.b (a0)+,(a5)+
	subq.w #1,d2
	bne _IFFCopyRow
	add.l OFFSET_IFFLOADER_BITPLANESMODULO(a1),a4
	subq.b #1,d1
	bne _IFFCopyPlanes
	add.l OFFSET_IFFLOADER_LINESMODULO(a1),a3
	subq.w #1,d0
	bne _IFFCopy
	bra _IFFLoaderSuccess

_IFFDepack:
	clr.w d3
	movea.l a3,a4
	move.b IFF_BMHD_NBPLANES(a2),d1
_IFFDepackPlanes:
	move.w IFF_BMHD_WIDTH(a2),d2
	lsr.w #3,d2
	movea.l a4,a5
_IFFDepackRow:
	move.b (a0)+,d3
	bge _IFFDepackRowCopy
	cmpi.b #$80,d3
	beq _IFFDepackRowStop
	neg.b d3
	sub.w d3,d2
	subq.w #1,d2
_IFFDepackReplicate:
	move.b (a0),(a5)+
	subq.b #1,d3
	bge _IFFDepackReplicate
	lea 1(a0),a0
	bra _IFFDepackRowDone
_IFFDepackRowCopy:
	move.b (a0)+,(a5)+
	subq.w #1,d2
	subq.b #1,d3
	bge _IFFDepackRowCopy
_IFFDepackRowDone:
	tst.w d2
	bne _IFFDepackRow
_IFFDepackRowStop:
	add.l OFFSET_IFFLOADER_BITPLANESMODULO(a1),a4
	subq.b #1,d1
	bne _IFFDepackPlanes
	add.l OFFSET_IFFLOADER_LINESMODULO(a1),a3
	subq.w #1,d0
	bne _IFFDepack

_IFFLoaderSuccess:
	moveq #1,d0

_IFFLoaderDone:
	movem.l (sp)+,d1-d6/a2-a5
	rts

IFFLoaderData:
OFFSET_IFFLOADER_DATA=0
OFFSET_IFFLOADER_BITPLANES=4
OFFSET_IFFLOADER_PALETTE=8
OFFSET_IFFLOADER_FILESIZE=12
OFFSET_IFFLOADER_LINESMODULO=16
OFFSET_IFFLOADER_BITPLANESMODULO=20
DATASIZE_IFFLOADER=6*4
	BLK.B DATASIZE_IFFLOADER,0

;********** Données **********

graphicsLibrary:	DC.B "graphics.library",0
					EVEN
graphicsBase:		DC.L 0
view:				DC.L 0
dmacon:				DC.W 0
intena:				DC.W 0
intreq:				DC.W 0
copperList:			DC.L 0
bitplanes:			DC.L 0
palette:			BLK.W 256,0
pictureSize:		DC.L 0
pictureData:		DC.L 0
argsTemplate:		DC.B "PICTURE/A",0	;Cf. la documentation officielle de ReadArgs() pour le format de cette chaîne
					EVEN
argsValues:			BLK.L 1,0			;Rajouter un LONG par argument supplémentaire (ex: BLK.L 3,0)
argsHelp:			DC.B "Usage : IFF <any 5 bitplanes picture IFF File width <= 320 and height <= 256>",$0A,0
					EVEN

