summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--Source/SaveClip.S681
1 files changed, 271 insertions, 410 deletions
diff --git a/Source/SaveClip.S b/Source/SaveClip.S
index ecc4925..f8e81ad 100644
--- a/Source/SaveClip.S
+++ b/Source/SaveClip.S
@@ -1,11 +1,11 @@
**
-** $Id: SaveClip.S,v 1.1 92/05/12 22:26:45 chris Exp $
-** $Revision: 1.1 $
+** $Id: SaveClip.S,v 21.1 92/05/15 03:22:11 chris Exp $
+** $Revision: 21.1 $
**
** $Filename: SaveClip.S $
** $Author: chris $
** $Release: 19.1 $
-** $Date: 92/05/12 22:26:45 $
+** $Date: 92/05/15 03:22:11 $
**
** iff.library/IFFL_SaveClip
**
@@ -54,14 +54,14 @@
* height - height in lines of the rectangle
*
* RESULTS
-* Non-zero if successful, 0 if error, Call IFFL_IFFError() to
-* know more about the reason of the failure
+* Non-zero if successful, 0 if an error occurred. You can then call
+* IFFL_IFFError() to know more about the reason of the failure.
*
* NOTE
-* This routine needs 650 bytes of stack space
+* Up to V19 this routine needs at least 650 bytes of stack space
*
* BUGS
-* The width of the rectangle will be rounded to WORD boundaries,
+* The width of the rectangle will be truncated to WORD boundaries,
* because DPAINT wants it!
*
* SEE ALSO
@@ -69,423 +69,284 @@
*
*****************************************************************************
-MAXPLANES: EQU 24 ; Höchstens 24 Bitplanes
+MAXPLANES EQU 32 ; Höchstens 32 Bitplanes
+BUFFERSIZE EQU 10240 ; Write-Buffer
+BUFFERFULL EQU BUFFERSIZE-2048 ; naja...
-iffhd: equ 0 ; FORM
-iffsize: equ 4 ; .... ILBM
+ STRUCTURE Stack,0
+ STRUCT stk_BMHD,bmh_SIZEOF ; Muss am Anfang sein
+ ULONG stk_CAMG
+ STRUCT stk_Planes,4*MAXPLANES
+ LABEL stk_SIZEOF
-bmhdchunk: equ iffsize+8 ; BMHD
-bmhdsize: equ bmhdchunk+4 ; ....
-bmhd: equ bmhdsize+4 ; bmhd-Struktur
-
-camgchunk: equ bmhd+bmh_SIZEOF ; CAMG
-camgsize: equ camgchunk+4 ; ....
-camg: equ camgsize+4 ; 0000ViewModes
-
-cmapchunk: equ camg+4 ; CMAP
-cmapsize: equ cmapchunk+4 ; ....
-cmap: equ cmapsize+4 ; Farbwerte
-
-bodychunk: equ cmap+(3*512) ; BODY
-bodysize: equ bodychunk+4 ; ....
+SaveClipFunc: movem.l d2-d7/a2-a6,-(SP)
+ suba.w #stk_SIZEOF,SP ; Platz schaffen
+ move.l d0,d6 ; D6 : Flags
+ move.l a2,d5 ; D5 : Farbtabelle oder NULL
+ move.l a0,a2 ; A2 : Filename
+ movea.l a6,a5 ; A5 : IFFBase
+ movea.l a1,a4 ; A4 : BitMap
-xoffset: equ bodysize+4
-yoffset: equ xoffset+2
-width: equ yoffset+2
-height: equ width+2
+ *** BMHD erstellen auf dem Stack und Parameter eintragen
-sb_datasize: equ height+2 ; Gesamt-Datengrösse
+ andi.w #15,d0 ; A rough guess :-)
+ move.b d0,bmh_Compression(SP)
+ lsl.w #3,d1 ; Aus Bytes mach Pixel
+ movem.w d1/d2,bmh_XPos(SP) ; X und Y-Position
-SaveClipFunc: movem.l d2-d7/a2-a6,-(SP)
- suba.w #sb_datasize,SP ; Speicher reservieren
- movea.l a6,a5 ; IFFBase
- move.l a0,d6 ; D6 : Filename
- movea.l a1,a3 ; A3 : BitMap
- movea.l SP,a4 ; A4 : wird BitMapHeader
-
- move.w d1,xoffset(SP)
- move.w d2,yoffset(SP)
bclr #0,d3 ; Breite WORD align für DPaint
- move.w d3,width(SP)
- move.w d4,height(SP)
-
- *** FORM....ILBM-Header & BMHD-Chunk initialisieren (im Speicher)
-
- move.l #'FORM',(a4)+ ; Ein IFF-Formular
- moveq.l #cmap,d7 ; 'ILBM'+BMHD+CAMG+CMAP+BODY
- move.l d7,(a4)+ ; eintragen
- move.l #'ILBM',(a4)+ ; File-Typ
-
- move.l #'BMHD',(a4)+ ; Chunk-Name eintragen
- moveq.l #bmh_SIZEOF,d7
- move.l d7,(a4)+ ; Chunk-Size eintragen
- move.b d0,bmh_Compression(a4) ; Cruncher-Typ merken
-
- clr.b bmh_Masking(a4)
- clr.b bmh_Pad1(a4)
- clr.w bmh_TranspCol(a4)
- move.w xoffset(SP),d0
- lsl.w #3,d0 ; Pixel
- move.w d0,bmh_XPos(a4) ; X-Position
- move.w yoffset(SP),bmh_YPos(a4) ; X-Position
- move.w #$0A0B,bmh_XAspect(a4) ; X- und Y-Aspect zusammen!
- move.b bm_Depth(a3),bmh_nPlanes(a4)
-
- lsl.w #3,d3 ; Breite mal 8
- move.w d3,bmh_Width(a4) ; gibt Breite in Pixel
- move.w d3,bmh_PageWidth(a4)
-
- move.w d4,bmh_Height(a4) ; Bildhöhe eintragen
- move.w d4,bmh_PageHeight(a4)
-
- *** CAMG-Chunk generieren (immer)
-
- move.l #'CAMG',camgchunk(SP) ; Chunk-Name
- moveq #4,d7
- move.l d7,camgsize(SP) ; Chunk-Size
- movea.l a4,a0 ; struct BitMapHeader
- bsr CalcViewModes ; ViewModes nach d0
- bclr.b #7,bmh_Compression(a4) ; HAM gewünscht ?
- beq.s 1$ ; nein --->
- bset #11,d0 ; HAM-Bit setzen
-1$: move.l d0,camg(SP) ; ViewModes eintragen
-
- *** CMAP-Chunk generieren, falls notwendig (im Speicher)
-
- move.l #-8,cmapsize(SP) ; falls no CMAP: -'CMAP....'
-
- move.l a2,d0 ; tst.l a2
- beq.s nocmap
-
- lea cmapchunk(SP),a1 ; Hierhin will ich den Chunk
- move.l #'CMAP',(a1)+ ; Chunkname
- moveq #1,d0
- moveq #0,d1
- move.b bm_Depth(a3),d1
- cmpi.b #24,d1 ; Ist's ein 24-Bitplane-Bild ?
- bne.s .No24 ; nein --->
- moveq #8,d1 ; Sonst immer 256 Farben
+ lsl.w #3,d3 ; Aus Bytes mach Pixel
+ movem.w d3/d4,bmh_Width(SP) ; Breite und Höhe
+ movem.w d3/d4,bmh_XAspect(SP) ; Aspect ratio
+
+ move.w bm_BytesPerRow(a4),d0
+ lsl.w #3,d0
+ move.w d0,bmh_PageWidth(SP)
+ move.w bm_Rows(a4),bmh_PageHeight(SP)
+
+ move.w bm_Depth(a4),bmh_nPlanes(SP)
+
+ clr.b bmh_Masking(SP)
+ clr.b bmh_Pad1(SP)
+ clr.w bmh_TranspCol(SP)
+
+ *** Puffer für Body-Daten (und CMAP) allozieren
+
+ moveq.l #IFFL_ERROR_NOMEM,d4 ; D4 : Default-Error-Code
+ move.l #BUFFERSIZE,d0
+ moveq.l #MEMF_PUBLIC,d1 ; No VMem! :-)
+ movea.l iffb_SysBase(a5),a6
+ JSRLIB AllocMem
+ tst.l d0
+ beq .NoMemory
+ movea.l d0,a3 ; A3 : Buffer
+
+ *** IFF-File zum Schreiben öffnen
+
+ moveq.l #IFFL_ERROR_WRITE,d4 ; D4 : Default-Error-Code
+ movea.l a2,a0 ; Filename
+ moveq.l #IFFL_MODE_WRITE,d0
+ movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_OpenIFF
+ tst.l d0
+ beq .OpenError
+ movea.l d0,a2 ; A2 : IFF-Handle
+
+ *** BMHD-Chunk schreiben
+
+ move.l #ID_ILBM,d0
+ move.l #ID_BMHD,d1
+ moveq.l #bmh_SIZEOF,d2
+ movea.l SP,a1 ; BMHD-Struktur
+ bsr WriteChunk
+ beq .WriteError
+
+ *** CAMG-Chunk generieren
+
+ movea.l SP,a0 ; BMHD-Struktur
+ bsr CalcViewModes ; ViewModes nach D0
+
+ btst.l #7,d6 ; HAM gewünscht ?
+ beq.b .NoHAM ; nein --->
+ bset.l #11,d0 ; HAM-Bit setzen
+.NoHAM: move.l d0,stk_CAMG(SP) ; ViewModes auf Stack
+
+ *** CAMG-Chunk schreiben
+
+ ;; move.l #ID_ILBM,d0
+ move.l #ID_CAMG,d1
+ moveq.l #4,d2 ; 1 LONG
+ lea stk_CAMG(SP),a1 ; CAMG-Langwort
+ bsr WriteChunk
+ beq .WriteError
+
+ *** CMAP-Chunk generieren und schreiben, falls notwendig
+
+ tst.l d5 ; CMAP vorhanden ?
+ beq .NoCMap ; nein --->
+
+ moveq.l #0,d0
+ move.b bm_Depth(a4),d0 ; Anzahl Planes
+ cmpi.b #8,d0 ; Mehr als 256 Farben (z.b. 24 bit)?
+ blo.b .No24 ; nein --->
+ moveq #8,d0 ; Sonst maximal 256 Farben
.No24:
- lsl.w d1,d0 ; d0 := 2 ^ D1 = Anzahl Farben
- move.w d0,d2 ; D2 : Anzahl Farben
- mulu.w #3,d0 ; 3 Bytes pro Farbe
- addq.l #2,d0
- andi.w #~3,d0 ; auf LONG alignen
- move.l d0,(a1)+ ; Chunklänge
-
- subq.w #1,d2 ; für dbf
-3$: move.w (a2)+,d0
- lsl.w #4,d0
- move.b d0,2(a1) ; blau
- lsr.w #4,d0
- andi.b #$f0,d0
- move.b d0,1(a1) ; grün
- lsr.w #4,d0
- andi.b #$f0,d0
- move.b d0,(a1) ; rot
- addq.w #3,a1
- dbf d2,3$
-
- *** File öffnen, IFF-Header auf Disk schreiben (vorläufig!)
-
-nocmap: move.l d6,d1 ; FileName
- move.l #MODE_NEWFILE,d2
- movea.l iffb_DOSBase(a5),a6
- JSRLIB Open
- move.l d0,d7 ; D7 : FileHandle
- beq writeerror
-
- move.l cmapsize(SP),d0 ; CMAP-Grösse
- add.l d0,iffsize(SP) ; zu Header-Grösse dazu
-
- move.l d7,d1 ; File
- move.l SP,d2 ; Adr : IFF-Header
- moveq #cmap+8,d3 ; Länge des Headers + 8
- add.l cmapsize(SP),d3 ; Plus Länge des CMAP-Chunks
- JSRLIB Write ; schreiben
- tst.l d0 ; Fehler ?
- bmi.s writeerror ; ja!
-
- *** BODY-Daten schreiben, evtl. komprimiert
-
- tst.b bmh_Compression(a4) ; compacten ?
- bne.s 1$ ; ja!
- bsr VanillaSave
- bra.s 2$
-1$: bsr CrunchSave
-2$: tst.l d0 ; Fehler ?
- bmi.s writeerror ; ja!
-
- move.l d0,d3 ; Body-Länge
- addq.l #3,d3 ; auf nächstes LONG aufrunden
- and.b #%11111100,d3 ; und LONG-alignen
- move.l d3,bodysize(SP) ; aligned BODY-Grösse
- add.l d3,iffsize(SP) ; zu Header-Grösse dazu
- sub.l d0,d3 ; D3 := Wieviele Bytes zuviel
-
- tst.l d3 ; Align-Grösse = 0 ?
- beq.s 3$ ; ja -> nichts schreiben
- move.l d7,d1 ; File
- clr.l -(SP) ; Nullen machen
- move.l SP,d2 ; adr
- JSRLIB Write ; schreiben
- addq.l #4,SP ; Stack cleanen
- tst.l d0 ; Fehler ?
- bmi.s writeerror ; ja!
-
- *** IFF-Header nochmals schreiben & BODY-Header, diesmal korrekt
-
-3$: move.l d7,d1 ; File
- moveq.l #0,d2 ; Position
- moveq.l #OFFSET_BEGINNING,d3 ; Modus
- JSRLIB Seek
-
- move.l d7,d1 ; File
- move.l SP,d2 ; Adr : IFF-Header
- moveq.l #cmap,d3 ; Länge des Headers
- add.l cmapsize(SP),d3 ; Plus Länge des CMAP-Chunks
- JSRLIB Write ; schreiben
- tst.l d0 ; Fehler ?
- bmi.s writeerror ; ja!
-
- lea bodychunk(SP),a0
- move.l #'BODY',(a0) ; Chunk-Namen eintragen
- move.l d7,d1 ; File
- move.l a0,d2 ; Adr
- moveq #8,d3 ; Len
- JSRLIB Write ; Body-Header schreiben
- tst.l d0 ; Fehler ?
- bmi.s writeerror ; ja!
-
- move.l d7,d1 ; File
- JSRLIB Close
- ;; moveq.l #0,d7 ; File ungültig
-
- bsr ClearError ; Error löschen, D0 := 1
- bra.s SaveClip_End
-
-writeerror: move.l d7,d1 ; File
- beq.s 1$ ; schon / nochzu!
- JSRLIB Close
-1$: moveq #IFFL_ERROR_WRITE,d0
+ moveq.l #1,d1 ; Bit-Maske zum Shiften
+ lsl.w d0,d1 ; D1 := 2^D0 = Anzahl Farben
+ move.l d1,d2 ; D2 : Anzahl Farben
+
+ movea.l d5,a0 ; Amiga-Farbpalette
+ movea.l a3,a1 ; Destination-Buffer
+ bra.b .CMapDBF ; ---> für DBF
+.CMapLoop: move.w (a0),d0
+ lsr.w #8,d0 ; Rot-Anteil
+ mulu.w #17,d0 ; aus 0n mach nn
+ move.b d0,(a1)+
+
+ move.w (a0),d0
+ lsr.w #4,d0 ; Grün-Anteil
+ andi.w #15,d0
+ mulu.w #17,d0 ; aus 0n mach nn
+ move.b d0,(a1)+
+
+ move.w (a0)+,d0
+ ;; lsr.w #0,d0 ; Blau-Anteil
+ andi.w #15,d0
+ mulu.w #17,d0 ; aus 0n mach nn
+ move.b d0,(a1)+
+
+.CMapDBF: dbf d1,.CMapLoop
+
+ ;; move.l #ID_ILBM,d0
+ move.l #ID_CMAP,d1
+ mulu.w #3,d2 ; 3 Bytes pro Farbe gibt Size
+ movea.l a3,a1 ; CMAP-Daten
+ ;; movea.l a5,a6 ; IFFBase
+ bsr WriteChunk
+ tst.l d0
+ beq .WriteError
+.NoCMap:
+
+ *** BODY-Chunk eröffnen
+
+ movea.l a2,a0 ; IFF-Handle
+ ;; move.l #ID_ILBM,d0
+ move.l #ID_BODY,d1
+ movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_PushChunk
+ tst.l d0
+ beq .WriteError
+
+ *** PlanePtrs auf den Stack kopieren & X,Y-Offsets dazuaddieren
+
+ moveq.l #0,d0 ; D1 nicht nötig wegen mulu
+ movem.w bmh_XPos(SP),d0/d1 ; X- und Y-Offset
+ lsr.w #3,d0 ; X: aus Pixel mach Bytes
+ mulu.w bm_BytesPerRow(a4),d1 ; Y mal Bildbreite
+ add.l d0,d1 ; D1 : Total-Offset
+
+ lea bm_Planes(a4),a0 ; Source
+ lea stk_Planes(SP),a1 ; Destination
+ moveq.l #MAXPLANES-1,d2 ; Alle PlanePtrs (naja...)
+.CopyPlanes: move.l (a0)+,d0 ; PlanePtr
+ add.l d1,d0 ; Offset dazu
+ move.l d0,(a1)+ ; speichern
+ dbf d2,.CopyPlanes
+
+ *** Tada! BODY-Daten schreiben
+
+ movem.w bmh_Width(SP),d3/d4 ; Breite & Höhe
+ lsr.w #3,d3 ; D3 : Bytes per row to write
+ moveq.l #0,d5
+ move.b bm_Depth(a4),d5
+ subq.w #1,d5 ; D5 : Depth-1 (für dbf)
+ move.w bm_BytesPerRow(a4),d6 ; D6 : BytesPerRow der BitMap
+ moveq.l #0,d7 ; D7 : Buffer-Füllstand
+ bra.b .RowDBF
+
+.RowLoop: lea stk_Planes(SP),a4 ; A4 : Plane-Array
+ move.l d5,d2 ; Depth-1
+
+.PlaneLoop: cmpi.w #BUFFERFULL,d7 ; Zeit den Puffer zu leeren ?
+ blo.b .NoDump ; noch nicht --->
+ movea.l a2,a0 ; IFF-Handle
+ movea.l a3,a1 ; Buffer
+ move.l d7,d0 ; Len
+ ;; movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_WriteChunkBytes
+ tst.l d0
+ beq.b .WriteError
+ moveq.l #0,d7 ; Buffer ist wieder leer
+.NoDump:
+ movea.l (a4),a0 ; Source: Nächste Linie/Plane
+ lea 0(a3,d7.l),a1 ; Destination: Buffer
+ move.l d3,d0 ; Len
+ moveq.l #0,d1
+ move.b bmh_Compression(SP),d1
+ ;; movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_CompressBlock
+ tst.l d0
+ beq.b .WriteError
+ add.l d0,d7 ; Buffersize += komprimierte Länge
+ add.l d6,(a4)+ ; auf nächste Linie
+
+ dbf d2,.PlaneLoop ; ---> Loop
+.RowDBF: dbf d4,.RowLoop ; ---> Loop
+
+ *** Buffer ein letztes Mal leeren
+
+ movea.l a2,a0 ; IFF-Handle
+ movea.l a3,a1 ; Buffer
+ move.l d7,d0 ; Len
+ ;; movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_WriteChunkBytes
+ tst.l d0
+ beq.b .WriteError
+
+ *** BODY-Chunk abschliessen
+
+ movea.l a2,a0 ; IFF-Handle
+ ;; movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_PopChunk
+ tst.l d0
+ beq.b .WriteError
+
+ moveq.l #0,d4 ; D4 : Error-Code: OK!!
+
+ *** IFF-File schliessen
+
+.WriteError: movea.l a2,a1 ; IFF-Handle
+ ;; movea.l a5,a6 ; IFFBase
+ JSRLIB IFFL_CloseIFF
+
+ *** Buffer freigeben
+
+.OpenError: move.l #BUFFERSIZE,d0
+ movea.l a3,a1
+ movea.l iffb_SysBase(a5),a6
+ JSRLIB FreeMem
+
+ *** Fehlerkode setzen falls nötig
+
+.NoMemory: move.l d4,d0 ; Error ?
+ beq.b .Okay ; noe --->
bsr SetError ; Error setzen, D0 := 0
+ bra.b .End
+.Okay: bsr ClearError
-SaveClip_End: adda.w #sb_datasize,SP ; Speicher wirder freigeben
- movem.l (SP)+,d2-d7/a2-a6
- rts
-
+ *** Routine beenden
-***************************************************************************
-************** V A N I L L A S A V E ************************************
-***************************************************************************
-
-vs_planes: equ 0 ; ARRAY[0..MAXPLANES-1] OF PlanePtr
-vs_chunksize: equ vs_planes+4*MAXPLANES
-vs_linksize: equ vs_chunksize+4
-
-VanillaSave: movem.l d2-d6/a2-a4,-(SP) ; 8 Register retten
- lea 8*4+4(SP),a4 ; A4 : Global data Ptr
- suba.w #vs_linksize,SP ; lokalen Datenraum schaffen
-
- *** Chunk-Grösse berechnen und merken
-
- move.w width(a4),d0 ; Breite in Bytes
- moveq #0,d1
- move.b bm_Depth(a3),d1
- mulu d1,d0 ; mal Anzahl Planes
- move.w height(a4),d1
- mulu d1,d0 ; mal Anzahl Linien
- move.l d0,vs_chunksize(SP) ; merken
-
- *** PlanePtrs kopieren & X,Y-Offsets dazuaddieren
-
- move.w yoffset(a4),d1 ; Y-Offset im Bild
- mulu bm_BytesPerRow(a3),d1 ; mal Bildbreite
- moveq #0,d0
- move.w xoffset(a4),d0
- add.l d0,d1 ; plus X-Offset
-
- lea bm_Planes(a3),a0 ; Source
- move.l SP,a1 ; Destination
- moveq #MAXPLANES-1,d0 ; Alle PlanePtrs
-1$: move.l (a0)+,d2 ; PlanePtr
- add.l d1,d2 ; Offset dazu
- move.l d2,(a1)+ ; speichern
- dbf d0,1$
-
- moveq #0,d3
- moveq #0,d4
- moveq #0,d5
- move.w bm_BytesPerRow(a3),d5 ; D5 : BytesPerRow (linesize)
- move.b bm_Depth(a3),d3 ; move.b ea,Ax geht ja nicht
- move.w d3,a3 ; A3 : Depth (lieber D8 als A3)
- move.w width(a4),d3 ; D3 : BytesPerRow (to write)
- move.w height(a4),d4 ; D4 : Rows (to write)
-
- subq.w #1,d4 ; für dbf
- subq.w #1,a3 ; für dbf
-vs_loop1: movea.l SP,a2 ; Zeiger auf Planes
- move.l a3,d6 ; d6 : Depth für dbf
-
-vs_loop2: move.l d7,d1 ; File
- move.l (a2),d2 ; Adr : Nächste Linie/Plane
- JSRLIB Write ; (len ist schon in D3)
- tst.l d0 ; Fehler ?
- bmi.s vs_error ; ja!
- add.l d5,(a2)+ ; auf nächste Linie
- dbf d6,vs_loop2 ; next plane
- dbf d4,vs_loop1 ; next row
-
- move.l vs_chunksize(SP),d0 ; Return-Wert: Chunk-Länge
-vs_error: adda.w #vs_linksize,SP ; Datenraum freigeben
- movem.l (SP)+,d2-d6/a2-a4
- rts
-
-
-***************************************************************************
-************** C R U N C H S A V E **************************************
-***************************************************************************
-
-cs_planes: equ 0 ; ARRAY[0..MAXPLANES-1] OF PlanePtr
-cs_buffer: equ cs_planes+4*MAXPLANES ; ARRAY[0..511] OF BYTE
-cs_bodysize: equ cs_buffer+512 ; LONG bodysize
-cs_linksize: equ cs_bodysize+4
-
-CrunchSave: movem.l d2-d6/a2-a4,-(SP) ; 8 Register retten
- lea 8*4+4(SP),a4 ; A4 : Global data Ptr
- suba.w #cs_linksize,SP ; lokalen Datenraum schaffen
-
- clr.l cs_bodysize(SP)
-
- *** PlanePtrs kopieren & X,Y-Offsets dazuaddieren
-
- move.w yoffset(a4),d1 ; Y-Offset im Bild
- mulu bm_BytesPerRow(a3),d1 ; mal Bildbreite
- moveq #0,d0
- move.w xoffset(a4),d0
- add.l d0,d1 ; plus X-Offset
-
- lea bm_Planes(a3),a0 ; Source
- movea.l SP,a1 ; Destination (unsauber!)
- moveq #MAXPLANES-1,d0 ; Alle Planeptrs
-1$: move.l (a0)+,d2 ; PlanePtr
- add.l d1,d2 ; Offset dazu
- move.l d2,(a1)+ ; speichern
- dbf d0,1$
-
- moveq #0,d3
- moveq #0,d4
- moveq #0,d5
- move.w bm_BytesPerRow(a3),d5 ; D5 : BytesPerRow (linesize)
- move.b bm_Depth(a3),d3 ; move.b ea,Ax geht ja nicht
- move.l d3,a3 ; A3 : Depth (lieber D8 als A3)
- move.w width(a4),d3 ; D3 : BytesPerRow (to write)
- move.w height(a4),d4 ; D4 : Rows (to write)
-
- subq.w #1,d4 ; für dbf
- subq.l #1,a3 ; für dbf
-
-cs_loop1: move.l SP,a2 ; PlanePtr
- move.l a3,d6 ; d6 : Depth für dbf
-
-cs_loop2: move.w d3,d0 ; Len für CrunchRow()
- move.l (a2),a0 ; Source für CrunchRow()
- lea cs_buffer(SP),a1 ; Destination für CrunchRow()
- bsr.s CrunchRow
- add.l d0,cs_bodysize(SP) ; für calcbodysize()
-
- move.l d7,d1 ; File
- lea cs_buffer(SP),a1 ; Daten-Puffer
- move.l a1,d2 ; Adr : cs_buffer(SP)
- move.l d3,-(SP)
- move.l d0,d3 ; Länge, von CrunchRow()
- JSRLIB Write
- move.l (SP)+,d3
- tst.l d0 ; Fehler ?
- bmi.s cs_error ; ja!
-
- add.l d5,(a2)+ ; auf nächste Linie
- dbf d6,cs_loop2 ; next plane
- dbf d4,cs_loop1 ; next row
-
- move.l cs_bodysize(SP),d0 ; return-value
-cs_error: adda.w #cs_linksize,SP ; Speicher freigeben
- movem.l (SP)+,d2-d6/a2-a4
+.End: adda.w #stk_SIZEOF,SP ; Stack aufräumen
+ movem.l (SP)+,d2-d7/a2-a6
rts
-*********************************************************************
-** **
-** C R U N C H R O W - eine Zeile CmpByteRun1 crunchen **
-** **
-** Parameter : A0.L : Zeiger auf Source-Adresse in Plane **
-** A1.L : Zeiger auf Destination-Buffer **
-** D0.W : Anzahl Bytes einer Source-Linie **
-** Resultat : D0.L : Anzahl gecrunchte Bytes **
-** **
-*********************************************************************
-
-CrunchRow: movem.l d2-d3/a2-a3,-(SP)
- lea (a0,d0.w),a2 ; A2 : Source-Endadresse der Linie
- moveq #0,d3 ; Byte-Zähler
-
-crunchloop: bsr.s CountEq ; wieviele gleiche Bytes folgen ?
- cmp.w #3,d0 ; genug gleiche Bytes zum runnen ?
- blt.s countdump ; nee, lohnt sich nicht -> Dumpen
-
- addq.l #2,d3 ; Markierbyte & Anzahl
- move.b (a0),d1 ; Wert
- adda.w d0,a0 ; Source anpassen
- subq.w #1,d0 ; muss .w sein und nicht .b !!!!!!!
- neg.b d0 ; negieren (= "Run"-Code)
- move.b d0,(a1)+ ; und eintragen
- move.b d1,(a1)+ ; Wert eintragen
- bra.s crunchcont ; weitermachen
-
-countdump: movea.l a0,a3 ; Source-Pointer retten
- moveq #0,d2 ; D2 : Länge des Dump-Blocks
-1$: addq.b #1,d2
- bmi.s 2$ ; höchstens 127 Bytes pro Block
- addq.l #1,a0
- cmpa.l a2,a0 ; Ende der Linie erreicht ?
- bge.s 3$ ; ja -> abbrechen
- bsr.s CountEq
- cmp.w #3,d0 ; Ende des Dump-Blocks ?
- blt.s 1$ ; noch nicht
- bra.s 3$ ; Ende
-2$: moveq #127,d2
-3$: movea.l a3,a0 ; Source-Pointer restaurieren
-
- add.l d2,d3 ; zur Gesamtanzahl dazuzählen
- addq.l #1,d3 ; Markierbyte nicht vergessen
- subq.w #1,d2 ; aus 1..128 mach 0..127
- move.b d2,(a1)+ ; Markierbyte eintragen
-4$: move.b (a0)+,(a1)+ ; Datenbytes eintragen
- dbf d2,4$
-
-
-crunchcont: cmpa.l a2,a0 ; Ende der Linie erreicht ?
- blt.s crunchloop ; noch nicht!
-
- move.l d3,d0 ; Return: Anzahl Destination-Bytes
- movem.l (SP)+,d2-d3/a2-a3
- rts
-
- *** Anzahl gleicher Zeichen ab (a0) zählen und nach D0
-
-CountEq: move.l a0,-(SP)
- moveq #1,d0 ; D0 : Anzahl gleiche Bytes
-1$: move.b (a0)+,d1 ; erstes Byte
-2$: cmp.b (a0)+,d1 ; Byte gleich wie letztes Byte ?
- bne.s 3$ ; nein -> abbrechen
- cmp.w #128,d0
- bge.s 3$ ; höchstens 128 gleiche
- addq.w #1,d0 ; Anzahl erhöhen
- cmpa.l a2,a0 ; Ende der Linie erreicht ?
- blt.s 2$ ; noch nicht -> weiterzählen
-3$: move.l (SP)+,a0
- rts
+*****************************************************************************
+** Chunk in File schreiben:
+** A1=Adresse, A2=Handle, D0=TYPE, D1=ID, D2=Size, A6=IFFBase
+** Zerstört D0/D1/A0/A1.
+** Resultat: D0>0 und Z=0 falls OK, D0=0 und Z=1 falls Error
+
+WriteChunk: move.l a1,-(SP) ; Adresse retten
+ movea.l a2,a0 ; IFF-Handle
+ JSRLIB IFFL_PushChunk
+ movea.l (SP)+,a1
+ tst.l d0
+ beq.b .Error
+
+ movea.l a2,a0 ; IFF-Handle
+ move.l d2,d0 ; Grösse
+ JSRLIB IFFL_WriteChunkBytes
+ tst.l d0
+ beq.b .Error
+
+ movea.l a2,a0 ; IFF-Handle
+ JSRLIB IFFL_PopChunk
+ tst.l d0
+ ;; beq.b .Error
+
+.Error: rts
END