void saveFile(Entries entries, char *filename) { BPTR f; struct IFFHandle *iff = NULL; f = Open(filename, MODE_NEWFILE); if (f == NULL) { myMsg3("couldn't open ", FileName, IoErr()); return; } iff = AllocIFF(); if (! iff) { myMsg1("couldn't alloc iff"); return; } iff -> iff_Stream = f; InitIFFasDOS(iff); if (OpenIFF(iff, IFFF_WRITE)) { myMsg1("couldn't OpenIFF(WRITE)"); return; } writeDatabaseFile(entries, iff); CloseIFF(iff); Close(iff -> iff_Stream); FreeIFF(iff); }
/************* * FUNCTION: OpenIFF * DESCRIPTION: open iff file and parse to begin of file * INPUT: iff iff handle * filename name of file * filesize size of file is returned in this variable * OUTPUT: error string *************/ static char *OpenIFF(struct IFFHandle **iff, char *filename, ULONG *filesize) { struct ContextNode *cn; // Allocate IFF_File structure. *iff = AllocIFF(); if(!*iff) return errors[ERR_MEM]; #ifdef __AMIGA__ // Set up IFF_File for AmigaDOS I/O. (*iff)->iff_Stream = Open(filename, MODE_OLDFILE); #else (*iff)->iff_Stream = Open_(filename, MODE_OLDFILE); #endif if(!(*iff)->iff_Stream) return errors[ERR_OPENFILE]; InitIFFasDOS(*iff); // Start the IFF transaction. if(OpenIFF(*iff, IFFF_READ)) return errors[ERR_LWOBFILE]; if(ParseIFF(*iff, IFFPARSE_RAWSTEP)) return errors[ERR_LWOBFILE]; cn = CurrentChunk(*iff); if((cn->cn_ID != ID_FORM) || (cn->cn_Type != ID_LWOB)) return errors[ERR_LWOBFILE]; *filesize = cn->cn_Size; return NULL; }
BOOL LoadPrefsFH(BPTR fh) { static struct SerialPrefs loadprefs; struct IFFHandle *iff; BOOL retval = FALSE; if ((iff = AllocIFF())) { iff->iff_Stream = (IPTR)fh; InitIFFasDOS(iff); if (!OpenIFF(iff, IFFF_READ)) { D(bug("LoadPrefs: OpenIFF okay.\n")); if (!StopChunk(iff, ID_PREF, ID_SERL)) { D(bug("LoadPrefs: StopChunk okay.\n")); if (!ParseIFF(iff, IFFPARSE_SCAN)) { struct ContextNode *cn; D(bug("LoadPrefs: ParseIFF okay.\n")); cn = CurrentChunk(iff); if (cn->cn_Size == sizeof(struct SerialPrefs)) { D(bug("LoadPrefs: ID_SERL chunk size okay.\n")); if (ReadChunkBytes(iff, &loadprefs, sizeof(struct SerialPrefs)) == sizeof(struct SerialPrefs)) { D(bug("LoadPrefs: Reading chunk successful.\n")); serialprefs = loadprefs; D(bug("LoadPrefs: Everything okay :-)\n")); retval = TRUE; } } } /* if (!ParseIFF(iff, IFFPARSE_SCAN)) */ } /* if (!StopChunk(iff, ID_PREF, ID_SERL)) */ CloseIFF(iff); } /* if (!OpenIFF(iff, IFFF_READ)) */ FreeIFF(iff); } /* if ((iff = AllocIFF())) */ return retval; }
/************************************************************************** MUIM_Configdata_Save **************************************************************************/ IPTR Configdata__MUIM_Save(struct IClass *cl, Object * obj, struct MUIP_Configdata_Save *msg) { struct IFFHandle *iff; if ((iff = AllocIFF())) { if (!(iff->iff_Stream = (IPTR)Open(msg->filename,MODE_NEWFILE))) { /* Try to Create the directory where the file is located */ char *path = StrDup(msg->filename); if (path) { char *path_end = PathPart(path); if (path_end != path) { BPTR lock; *path_end = 0; if ((lock = CreateDir(path))) { UnLock(lock); iff->iff_Stream = (IPTR)Open(msg->filename,MODE_NEWFILE); } } FreeVec(path); } } if (iff->iff_Stream) { InitIFFasDOS(iff); if (!OpenIFF(iff, IFFF_WRITE)) { if (!PushChunk(iff, MAKE_ID('P','R','E','F'), ID_FORM, IFFSIZE_UNKNOWN)) { Configdata_SetWindowPos(cl, obj, (APTR)msg); if (SavePrefsHeader(iff)) { DoMethod(obj,MUIM_Dataspace_WriteIFF, (IPTR)iff, 0, MAKE_ID('M','U','I','C')); } PopChunk(iff); } CloseIFF(iff); } Close((BPTR)iff->iff_Stream); } FreeIFF(iff); } return 0; }
BOOL SaveSettings(char *name, struct List *list) { struct IFFHandle *iff; struct PrefHeader header = { 0, 0, 0 }; struct Node *n; BOOL success = FALSE; if(name && (iff = AllocIFF())) { iff->iff_Stream = Open(name, MODE_NEWFILE); if(iff->iff_Stream) { InitIFFasDOS(iff); if(!OpenIFF(iff, IFFF_WRITE)) { if(! PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) { success = TRUE; // Prefs header if(! PushChunk(iff, ID_PREF, ID_PRHD, sizeof header)) { WriteChunkBytes(iff, &header, sizeof header); PopChunk(iff); } else success = FALSE; // Global prefs if(! PushChunk(iff, ID_PREF, ID_AHIG, sizeof globalprefs)) { WriteChunkBytes(iff, &globalprefs, sizeof globalprefs); PopChunk(iff); } else success = FALSE; // Units if(list != NULL) { for(n = list->lh_Head; n->ln_Succ; n = n->ln_Succ) { if(! PushChunk(iff, ID_PREF, ID_AHIU, sizeof(struct AHIUnitPrefs))) { WriteChunkBytes(iff, &((struct UnitNode *) n)->prefs, sizeof(struct AHIUnitPrefs)); PopChunk(iff); } else success = FALSE; } } } CloseIFF(iff); } Close(iff->iff_Stream); } FreeIFF(iff); } return success; }
/************************************************************************** MUIM_Configdata_Load Get the content of the file into the object. **************************************************************************/ IPTR Configdata__MUIM_Load(struct IClass *cl, Object * obj, struct MUIP_Configdata_Load *msg) { struct IFFHandle *iff; IPTR res = TRUE; if ((iff = AllocIFF())) { D(bug("loading prefs from %s\n", msg->filename)); if ((iff->iff_Stream = (IPTR)Open(msg->filename,MODE_OLDFILE))) { InitIFFasDOS(iff); if (!OpenIFF(iff, IFFF_READ)) { StopChunk( iff, MAKE_ID('P','R','E','F'), MAKE_ID('M','U','I','C')); while (!ParseIFF(iff, IFFPARSE_SCAN)) { struct ContextNode *cn; if (!(cn = CurrentChunk(iff))) continue; if (cn->cn_ID == MAKE_ID('M','U','I','C')) DoMethod(obj, MUIM_Dataspace_ReadIFF, (IPTR)iff); } CloseIFF(iff); } else { res = FALSE; } Close((BPTR)iff->iff_Stream); } else { res = FALSE; } FreeIFF(iff); } else { res = FALSE; } return res; }
/* Open preference file according to `mode' */ APTR open_prefs(STRPTR file, UBYTE mode) { struct IFFHandle * pref; if( IFFParseBase != NULL && (pref = (APTR) AllocIFF() ) ) { BPTR fh = 0; switch( mode ) { case MODE_USE: if(file == NULL) { /* First: search in local directory */ CopyMem(File, Path, sizeof(File)-1); if(NULL == (fh = Open( Path, MODE_OLDFILE ))) { /* Otherwise, look in directory ENVARC */ CopyMem(ENV, Path,sizeof(ENV)-1); CopyMem(File,Path+sizeof(ENV)-1,sizeof(File)-1); fh = Open( Path, MODE_OLDFILE ); } } else if(NULL != (fh = Open( file, MODE_OLDFILE ))) strcpy(Path, file); break; case MODE_SAVE: fh = Open(Path, MODE_NEWFILE); } /* Did we have a opened file? */ if( fh ) { pref->iff_Stream = (IPTR) fh; /* Use DOS function for accessing it */ InitIFFasDOS( pref ); /* Open it through iffparse */ if( !OpenIFF( pref, mode == MODE_SAVE ? IFFF_WRITE : IFFF_READ) ) return pref; } FreeIFF( pref ); } return NULL; }
static void readIFFFile(Gui_t gui, Entries entries, char *file) { BPTR f; struct IFFHandle *iff = NULL; if (file) strcpy(FileName, file); else getFileName(gui,FileName,getString(MSG_OPEN_FILE), FileName, Pattern); f = Open(FileName, MODE_OLDFILE); if (f == NULL) { myMsg2("couldn't open", FileName); return; } iff = AllocIFF(); if (! iff) { myMsg1("couldn't alloc iff"); return; } iff -> iff_Stream = f; InitIFFasDOS(iff); if (OpenIFF(iff, IFFF_READ)) { myMsg1("couldn't OpenIFF(READ)"); return; } readDatabaseFile(entries, iff); CloseIFF(iff); Close(iff -> iff_Stream); FreeIFF(iff); }
/************* * DESCRIPTION: save a surface definition * INPUT: filename name of surface file * OUTPUT: error string or NULL if all ok *************/ char *SURFACE::Save(char *filename) { struct IFFHandle *iff; // Allocate IFF_File structure. iff = AllocIFF(); if(!iff) return errors[ERR_MEM]; // Set up IFF_File for AmigaDOS I/O. #ifdef __AMIGA__ iff->iff_Stream = Open(filename, MODE_NEWFILE); #else iff->iff_Stream = Open_(filename, MODE_NEWFILE); #endif if(!iff->iff_Stream) { IFFCleanup(iff); return errors[ERR_OPEN]; } InitIFFasDOS(iff); // Start the IFF transaction. if(OpenIFF(iff, IFFF_WRITE)) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } PUSH_CHUNK(ID_RMAT); // write surface Write(iff); IFFCleanup(iff); return NULL; }
BOOL ReadConfig ( struct AHIDevUnit *iounit, struct AHIBase *AHIBase ) { struct IFFHandle *iff; struct StoredProperty *prhd,*ahig; struct CollectionItem *ci; if(iounit) { /* Internal defaults for device unit */ iounit->AudioMode = AHI_INVALID_ID; // See at the end of the function! iounit->Frequency = 10000; iounit->Channels = 4; iounit->MonitorVolume = ~0; iounit->InputGain = ~0; iounit->OutputVolume = ~0; iounit->Input = ~0; iounit->Output = ~0; } else { /* Internal defaults for low-level mode */ AHIBase->ahib_AudioMode = AHI_INVALID_ID; AHIBase->ahib_Frequency = 10000; AHIBase->ahib_MonitorVolume = 0x00000; AHIBase->ahib_InputGain = 0x10000; AHIBase->ahib_OutputVolume = 0x10000; AHIBase->ahib_Input = 0; AHIBase->ahib_Output = 0; } if((iff=AllocIFF())) { iff->iff_Stream=Open("ENV:Sys/ahi.prefs", MODE_OLDFILE); if(iff->iff_Stream) { InitIFFasDOS(iff); if(!OpenIFF(iff,IFFF_READ)) { if(!(PropChunk(iff,ID_PREF,ID_PRHD) || PropChunk(iff,ID_PREF,ID_AHIG) || CollectionChunk(iff,ID_PREF,ID_AHIU) || StopOnExit(iff,ID_PREF,ID_FORM))) { if(ParseIFF(iff,IFFPARSE_SCAN) == IFFERR_EOC) { prhd=FindProp(iff,ID_PREF,ID_PRHD); ahig=FindProp(iff,ID_PREF,ID_AHIG); if(ahig) { struct AHIGlobalPrefs *globalprefs; globalprefs = (struct AHIGlobalPrefs *)ahig->sp_Data; AHIBase->ahib_DebugLevel = globalprefs->ahigp_DebugLevel; AHIBase->ahib_Flags = 0; if(globalprefs->ahigp_DisableSurround) AHIBase->ahib_Flags |= AHIBF_NOSURROUND; if(globalprefs->ahigp_DisableEcho) AHIBase->ahib_Flags |= AHIBF_NOECHO; if(globalprefs->ahigp_FastEcho) AHIBase->ahib_Flags |= AHIBF_FASTECHO; if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, ahigp_MaxCPU) ) { AHIBase->ahib_MaxCPU = globalprefs->ahigp_MaxCPU; } else { AHIBase->ahib_MaxCPU = 0x10000 * 90 / 100; } if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, ahigp_ClipMasterVolume) ) { if(globalprefs->ahigp_ClipMasterVolume) AHIBase->ahib_Flags |= AHIBF_CLIPPING; } if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, ahigp_AntiClickTime ) ) { AHIBase->ahib_AntiClickTime = globalprefs->ahigp_AntiClickTime; } else { AHIBase->ahib_AntiClickTime = 0; } } ci=FindCollection(iff,ID_PREF,ID_AHIU); while(ci) { struct AHIUnitPrefs *unitprefs; unitprefs = (struct AHIUnitPrefs *)ci->ci_Data; if(iounit) { if(unitprefs->ahiup_Unit == iounit->UnitNum) { iounit->AudioMode = unitprefs->ahiup_AudioMode; iounit->Frequency = unitprefs->ahiup_Frequency; iounit->Channels = unitprefs->ahiup_Channels; iounit->MonitorVolume = unitprefs->ahiup_MonitorVolume; iounit->InputGain = unitprefs->ahiup_InputGain; iounit->OutputVolume = unitprefs->ahiup_OutputVolume; iounit->Input = unitprefs->ahiup_Input; iounit->Output = unitprefs->ahiup_Output; } } else { if(unitprefs->ahiup_Unit == AHI_NO_UNIT) { AHIBase->ahib_AudioMode = unitprefs->ahiup_AudioMode; AHIBase->ahib_Frequency = unitprefs->ahiup_Frequency; AHIBase->ahib_MonitorVolume = unitprefs->ahiup_MonitorVolume; AHIBase->ahib_InputGain = unitprefs->ahiup_InputGain; AHIBase->ahib_OutputVolume = unitprefs->ahiup_OutputVolume; AHIBase->ahib_Input = unitprefs->ahiup_Input; AHIBase->ahib_Output = unitprefs->ahiup_Output; } } ci=ci->ci_Next; } }
char *PROJECT::Load(char *filename, DISPLAY *disp) { long error = 0; struct IFFHandle *iff; struct ContextNode *cn; char *err; OBJECT *where = NULL; int dir = INSERT_HORIZ; // there is currently no active camera read camera[0] = 0; iff = AllocIFF(); if (!iff) return errors[ERR_MEM]; #ifdef __AMIGA__ iff->iff_Stream = Open(filename, MODE_OLDFILE); #else iff->iff_Stream = Open_(filename, MODE_OLDFILE); #endif if (!(iff->iff_Stream)) { IFFCleanup(iff); return errors[ERR_OPEN]; } InitIFFasDOS(iff); error = OpenIFF(iff, IFFF_READ); if (error) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } error = ParseIFF(iff, IFFPARSE_RAWSTEP); if (error) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } cn = CurrentChunk(iff); if(!cn) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } if((cn->cn_ID != ID_FORM) || (cn->cn_Type != ID_RSCN)) { IFFCleanup(iff); return errors[ERR_NORSCNFILE]; } while(!error || error == IFFERR_EOC) { error = ParseIFF(iff, IFFPARSE_RAWSTEP); if(error != IFFERR_EOC) { // Get a pointer to the context node describing the current context cn = CurrentChunk(iff); if (cn) { switch (cn->cn_ID) { case ID_VERS: if(!ReadULONG(iff,&rscn_version,1)) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } if(rscn_version > VERSION) { IFFCleanup(iff); return errors[ERR_WRONGVERS]; } break; case ID_FORM: switch(cn->cn_Type) { case ID_GNRL: err = ParseGeneral(iff,disp); if(err) { IFFCleanup(iff); return err; } break; case ID_FRAM: err = ParseFrame(iff); if(err) { IFFCleanup(iff); return err; } break; case ID_SRFS: err = ParseSurfaces(iff); if(err) { IFFCleanup(iff); return err; } break; case ID_CAMR: where = ParseCamera(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_SPHR: where = ParseSphere(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_PLAN: where = ParsePlane(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_PLGT: case ID_SLGT: case ID_DLGT: where = ParseLight(iff, where, dir, cn->cn_Type); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_MESH: where = ParseMesh(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_EXTN: where = ParseExternal(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_BOX: where = ParseBox(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_CYLR: where = ParseCylinder(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_CONE: where = ParseCone(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_CSG: where = ParseCSG(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_SOR: where = ParseSOR(iff, where, dir); if(!where) { IFFCleanup(iff); return errors[ERR_RSCNFILE]; } dir = INSERT_HORIZ; break; case ID_HIER: dir = INSERT_VERT; break; } break; } } } else { cn = CurrentChunk(iff); if (cn) { if((cn->cn_ID == ID_FORM) && (cn->cn_Type == ID_HIER)) { if(dir == INSERT_HORIZ) { while(where->GetPrev()) where = (OBJECT*)where->GetPrev(); if(where->GoUp()) where = (OBJECT*)where->GoUp(); } else dir = INSERT_HORIZ; } } } } if (error != IFFERR_EOF) { return errors[ERR_IFFPARSE]; } IFFCleanup(iff); // we have to set the active camera disp->camera = (CAMERA*)GetObjectByName(camera); if(!disp->camera) err = errors[ERR_NOCAMERA]; else err = NULL; // and translate track names to track objects // and the surface names to surface pointers TranslateNames(); return err; }
int main(int argc, char *argv[]) { struct IFFHandle *iff; struct StoredProperty *ahig; struct CollectionItem *ci; LONG unit = 0; int rc = RETURN_OK; if(argc != 3) { Printf("Usage: %s FILE UNIT\n", argv[0]); return RETURN_FAIL; } StrToLong(argv[2], &unit); if(iff = AllocIFF()) { iff->iff_Stream = Open(argv[1], MODE_OLDFILE); if(iff->iff_Stream) { InitIFFasDOS(iff); if(!OpenIFF(iff, IFFF_READ)) { if(!(PropChunk(iff,ID_PREF,ID_AHIG) || CollectionChunk(iff,ID_PREF,ID_AHIU) || StopOnExit(iff,ID_PREF,ID_FORM))) { if(ParseIFF(iff, IFFPARSE_SCAN) == IFFERR_EOC) { ahig = FindProp(iff,ID_PREF,ID_AHIG); if(ahig) { struct AHIGlobalPrefs *globalprefs; globalprefs = (struct AHIGlobalPrefs *)ahig->sp_Data; if(globalprefs->ahigp_DebugLevel != AHI_DEBUG_NONE) { Printf("Debugging is turned on.\n"); rc = RETURN_WARN; } } ci = FindCollection(iff,ID_PREF,ID_AHIU); while(ci) { struct AHIUnitPrefs *unitprefs; unitprefs = (struct AHIUnitPrefs *)ci->ci_Data; if(unitprefs->ahiup_Unit == unit) { if(unitprefs->ahiup_Channels < 2) { Printf("There are less than 2 channels selected for unit %ld.\n", unit); rc = RETURN_WARN; } } ci=ci->ci_Next; } } } CloseIFF(iff); } Close(iff->iff_Stream); } FreeIFF(iff); } return rc; }
IPTR SMEditor__MUIM_PrefsEditor_ImportFH ( Class *CLASS, Object *self, struct MUIP_PrefsEditor_ImportFH *message ) { SETUP_INST_DATA; struct ContextNode *context; struct IFFHandle *handle; struct ScreenModePrefs smp; BOOL success = TRUE; LONG error; if (!(handle = AllocIFF())) return FALSE; handle->iff_Stream = (IPTR) message->fh; InitIFFasDOS(handle); if ((error = OpenIFF(handle, IFFF_READ)) == 0) { BYTE i; // FIXME: We want some sanity checking here! for (i = 0; i < 1; i++) { if ((error = StopChunk(handle, ID_PREF, ID_SCRM)) == 0) { if ((error = ParseIFF(handle, IFFPARSE_SCAN)) == 0) { context = CurrentChunk(handle); error = ReadChunkBytes ( handle, &smp, sizeof(struct ScreenModePrefs) ); if (error < 0) { printf("Error: ReadChunkBytes() returned %ld!\n", error); } } else { printf("ParseIFF() failed, returncode %ld!\n", error); success = FALSE; break; } } else { printf("StopChunk() failed, returncode %ld!\n", error); success = FALSE; } } CloseIFF(handle); } else { //ShowError(_(MSG_CANT_OPEN_STREAM)); } FreeIFF(handle); if (success) { SMPByteSwap(&smp); nnset(data->selector, MUIA_ScreenModeSelector_Active, smp.smp_DisplayID); SetAttrs ( data->properties, MUIA_NoNotify, TRUE, MUIA_ScreenModeProperties_DisplayID, smp.smp_DisplayID, MUIA_ScreenModeProperties_Width, smp.smp_Width, MUIA_ScreenModeProperties_Height, smp.smp_Height, MUIA_ScreenModeProperties_Depth, smp.smp_Depth, MUIA_ScreenModeProperties_Autoscroll, smp.smp_Control & AUTOSCROLL, TAG_DONE ); } return success; }
BOOL ReadConfig ( struct AHIDevUnit *iounit, struct AHIBase *AHIBase ) { struct IFFHandle *iff; struct StoredProperty *prhd,*ahig; struct CollectionItem *ci; ULONG *mode; if(iounit) { /* Internal defaults for device unit */ iounit->AudioMode = AHI_INVALID_ID; // See at the end of the function! iounit->Frequency = 10000; iounit->Channels = 4; iounit->MonitorVolume = ~0; iounit->InputGain = ~0; iounit->OutputVolume = ~0; iounit->Input = ~0; iounit->Output = ~0; } else { /* Internal defaults for low-level mode */ AHIBase->ahib_AudioMode = AHI_INVALID_ID; AHIBase->ahib_Frequency = 10000; AHIBase->ahib_MonitorVolume = 0x00000; AHIBase->ahib_InputGain = 0x10000; AHIBase->ahib_OutputVolume = 0x10000; AHIBase->ahib_Input = 0; AHIBase->ahib_Output = 0; } if((iff=AllocIFF())) { iff->iff_Stream=(ULONG) Open("ENV:Sys/ahi.prefs", MODE_OLDFILE); if(iff->iff_Stream) { InitIFFasDOS(iff); if(!OpenIFF(iff,IFFF_READ)) { if(!(PropChunk(iff,ID_PREF,ID_PRHD) || PropChunk(iff,ID_PREF,ID_AHIG) || CollectionChunk(iff,ID_PREF,ID_AHIU) || StopOnExit(iff,ID_PREF,ID_FORM))) { if(ParseIFF(iff,IFFPARSE_SCAN) == IFFERR_EOC) { prhd=FindProp(iff,ID_PREF,ID_PRHD); ahig=FindProp(iff,ID_PREF,ID_AHIG); if(ahig) { struct AHIGlobalPrefs *globalprefs; UWORD debug_level; globalprefs = (struct AHIGlobalPrefs *)ahig->sp_Data; debug_level = globalprefs->ahigp_DebugLevel; EndianSwap( sizeof (UWORD), &debug_level ); AHIBase->ahib_DebugLevel = debug_level; AHIBase->ahib_Flags = 0; /* Not used in version 5: * * if(globalprefs->ahigp_DisableSurround) * AHIBase->ahib_Flags |= AHIBF_NOSURROUND; * * if(globalprefs->ahigp_DisableEcho) * AHIBase->ahib_Flags |= AHIBF_NOECHO; * * if(globalprefs->ahigp_FastEcho) * AHIBase->ahib_Flags |= AHIBF_FASTECHO; * */ if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, ahigp_MaxCPU) ) { AHIBase->ahib_MaxCPU = globalprefs->ahigp_MaxCPU; EndianSwap( sizeof (Fixed), &AHIBase->ahib_MaxCPU ); } else { AHIBase->ahib_MaxCPU = 0x10000 * 90 / 100; } /* In version 5: Clipping is always used * * if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, * ahigp_ClipMasterVolume) ) * { * if(globalprefs->ahigp_ClipMasterVolume) * AHIBase->ahib_Flags |= AHIBF_CLIPPING; * } */ if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, ahigp_AntiClickTime ) ) { AHIBase->ahib_AntiClickTime = globalprefs->ahigp_AntiClickTime; EndianSwap( sizeof (Fixed), &AHIBase->ahib_AntiClickTime ); } else { AHIBase->ahib_AntiClickTime = 0; } if( (ULONG) ahig->sp_Size > offsetof( struct AHIGlobalPrefs, ahigp_ScaleMode ) ) { AHIBase->ahib_ScaleMode = globalprefs->ahigp_ScaleMode; EndianSwap( sizeof (UWORD), &AHIBase->ahib_ScaleMode ); } else { AHIBase->ahib_ScaleMode = AHI_SCALE_FIXED_0_DB; } }
IPTR SMEditor__MUIM_PrefsEditor_ExportFH ( Class *CLASS, Object *self, struct MUIP_PrefsEditor_ExportFH *message ) { SETUP_INST_DATA; struct PrefHeader header = { 0 }; struct IFFHandle *handle; BOOL success = TRUE; LONG error = 0; if ((handle = AllocIFF())) { handle->iff_Stream = (IPTR) message->fh; InitIFFasDOS(handle); if (!(error = OpenIFF(handle, IFFF_WRITE))) /* NULL = successful! */ { struct ScreenModePrefs smp; memset(&smp, 0, sizeof(smp)); BYTE i; PushChunk(handle, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */ header.ph_Version = PHV_CURRENT; header.ph_Type = 0; PushChunk(handle, ID_PREF, ID_PRHD, IFFSIZE_UNKNOWN); /* FIXME: IFFSIZE_UNKNOWN? */ WriteChunkBytes(handle, &header, sizeof(struct PrefHeader)); PopChunk(handle); for (i = 0; i < 1; i++) { error = PushChunk(handle, ID_PREF, ID_SCRM, sizeof(struct ScreenModePrefs)); if (error != 0) // TODO: We need some error checking here! { printf("error: PushChunk() = %ld ", error); } smp.smp_DisplayID = XGET(data->properties, MUIA_ScreenModeProperties_DisplayID); smp.smp_Width = XGET(data->properties, MUIA_ScreenModeProperties_Width); smp.smp_Height = XGET(data->properties, MUIA_ScreenModeProperties_Height); smp.smp_Depth = XGET(data->properties, MUIA_ScreenModeProperties_Depth); if (XGET(data->properties, MUIA_ScreenModeProperties_Autoscroll)) smp.smp_Control = AUTOSCROLL; else smp.smp_Control = 0; SMPByteSwap(&smp); error = WriteChunkBytes(handle, &smp, sizeof(struct ScreenModePrefs)); error = PopChunk(handle); if (error != 0) // TODO: We need some error checking here! { printf("error: PopChunk() = %ld ", error); } } // Terminate the FORM PopChunk(handle); } else { //ShowError(_(MSG_CANT_OPEN_STREAM)); success = FALSE; } CloseIFF(handle); FreeIFF(handle); } else // AllocIFF() { // Do something more here - if IFF allocation has failed, something isn't right //ShowError(_(MSG_CANT_ALLOCATE_IFFPTR)); success = FALSE; } return success; }
main( int argc, char **argv ) { int colors; struct { long nplanes; long pbytes; long across; long down; long npics; long xsize; long ysize; } pdat; long pbytes; /* Bytes of data in a plane */ int i, cnt; BitMapHeader bmhd; struct IFFHandle *iff; long camg = HIRES|LACE; int tiles=0; int index; #if defined(_DCC) || defined (__GNUC__) IFFParseBase = OpenLibrary( "iffparse.library", 0 ); if( !IFFParseBase ) { error( "unable to open iffparse.library" ); exit( 1 ); } #endif if( fopen_xpm_file( argv[1], "r" ) != TRUE ) { perror( argv[1] ); return( 1 ); } nplanes = 0; i = XpmScreen.Colors - 1; while( i != 0 ) { nplanes++; i >>= 1; } planes = malloc( nplanes * sizeof( char * ) ); if( planes == 0 ) { error( "can not allocate planes pointer" ); exit( 1 ); } XpmScreen.BytesPerRow = ((XpmScreen.Width + 15)/16)*2; pbytes = XpmScreen.BytesPerRow * XpmScreen.Height; for( i = 0; i < nplanes; ++i ) { planes[ i ] = malloc( pbytes ); if( planes[ i ] == 0 ) { error( "can not allocate planes pointer" ); exit( 1 ); } memset( planes[i], 0, pbytes ); } iff = AllocIFF(); if( !iff ) { error( "Can not allocate IFFHandle" ); return( 1 ); } iff->iff_Stream = Open( argv[2], MODE_NEWFILE ); if( !iff->iff_Stream ) { error( "Can not open output file" ); return( 1 ); } InitIFFasDOS( iff ); OpenIFF( iff, IFFF_WRITE ); PushChunk( iff, ID_BMAP, ID_FORM, IFFSIZE_UNKNOWN ); bmhd.w = XpmScreen.Width; bmhd.h = XpmScreen.Height; bmhd.x = 0; bmhd.y = 0; bmhd.nPlanes = nplanes; bmhd.masking = 0; bmhd.compression = 0; bmhd.reserved1 = 0; bmhd.transparentColor = 0; bmhd.xAspect = 100; bmhd.yAspect = 100; bmhd.pageWidth = 0; /* not needed for this program */ bmhd.pageHeight = 0; /* not needed for this program */ PushChunk( iff, ID_BMAP, ID_BMHD, sizeof( bmhd ) ); WriteChunkBytes( iff, &bmhd, sizeof( bmhd ) ); PopChunk( iff ); PushChunk( iff, ID_BMAP, ID_CAMG, sizeof( camg ) ); WriteChunkBytes( iff, &camg, sizeof( camg ) ); PopChunk( iff ); #define SCALE(x) (x) cmap = malloc( (colors = (1L<<nplanes)) * sizeof(AmiColorMap) ); if(cmap == 0){ error("Can't allocate color map"); exit(1); } for(index = 0; index<256; index++){ if(ttable[index].flag){ cmap[ttable[index].slot].r = SCALE(ttable[index].r); cmap[ttable[index].slot].g = SCALE(ttable[index].g); cmap[ttable[index].slot].b = SCALE(ttable[index].b); } } #undef SCALE PushChunk( iff, ID_BMAP, ID_CMAP, IFFSIZE_UNKNOWN ); WriteChunkBytes( iff, cmap, colors*sizeof(*cmap) ); PopChunk( iff ); conv_image(); pdat.nplanes = nplanes; pdat.pbytes = pbytes; pdat.xsize = XpmScreen.Width; pdat.ysize = XpmScreen.Height; pdat.across = 0; pdat.down = 0; pdat.npics = 1; PushChunk( iff, ID_BMAP, ID_PDAT, IFFSIZE_UNKNOWN ); WriteChunkBytes( iff, &pdat, sizeof( pdat ) ); PopChunk( iff ); PushChunk( iff, ID_BMAP, ID_PLNE, IFFSIZE_UNKNOWN ); for( i = 0; i < nplanes; ++i ) WriteChunkBytes( iff, planes[i], pbytes ); PopChunk( iff ); CloseIFF( iff ); Close( iff->iff_Stream ); FreeIFF( iff ); #if defined(_DCC) || defined (__GNUC__) CloseLibrary( IFFParseBase ); #endif exit( 0 ); }
/************* * DESCRIPTION: save the current project to disk * INPUT: project projectname (the project is saved to a * directory with this name) * disp current display * OUTPUT: error string if failed, else NULL; *************/ char *PROJECT::Save(char *filename, DISPLAY *disp) { struct IFFHandle *iff; ULONG data[2]; float fdata[2]; UBYTE ubdata; VIEW *view = disp->view; OBSERVER obsv; int i; // Allocate IFF_File structure. iff = AllocIFF(); if(!iff) return errors[ERR_MEM]; // Set up IFF_File for AmigaDOS I/O. #ifdef __AMIGA__ iff->iff_Stream = Open(filename, MODE_NEWFILE); #else iff->iff_Stream = Open_(filename, MODE_NEWFILE); #endif if(!iff->iff_Stream) { IFFCleanup(iff); return errors[ERR_OPEN]; } InitIFFasDOS(iff); // Start the IFF transaction. if(OpenIFF(iff, IFFF_WRITE)) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } PUSH_CHUNK(ID_RSCN); data[0] = VERSION; WRITE_LONG_CHUNK(ID_VERS, data, 1); PUSH_CHUNK(ID_GNRL); data[0] = global.xres; data[1] = global.yres; WRITE_LONG_CHUNK(ID_RESO, data, 2); if(global.renderdpic) WRITE_CHUNK(ID_PICT, global.renderdpic, strlen(global.renderdpic)+1); if(global.picformat) WRITE_CHUNK(ID_PTYP, global.picformat, strlen(global.picformat)+1); ubdata = disp->display; WRITE_CHUNK(ID_DISP, &ubdata, sizeof(UBYTE)); // changed with v2.1: no longer current viewmode, now current view number for(i=0; i<4; i++) { if(disp->views[i] == disp->view) { ubdata = i; WRITE_CHUNK(ID_VIEW, &ubdata, sizeof(UBYTE)); } } WRITE_LONG_CHUNK(ID_GRID, &disp->gridsize, 1); data[0] = 0; if(disp->grid) data[0] |= RSCN_GENERAL_GRID; if(disp->gridsnap) data[0] |= RSCN_GENERAL_GRIDSNAP; if(disp->multiview) data[0] |= RSCN_GENERAL_VIEWFOUR; if(global.show) data[0] |= RSCN_GENERAL_SHOW; if(global.enablearea) data[0] |= RSCN_GENERAL_ENABLEAREA; if(global.enableback) data[0] |= RSCN_GENERAL_ENABLEBACK; if(global.enablerefl) data[0] |= RSCN_GENERAL_ENABLEREFL; WRITE_LONG_CHUNK(ID_FLGS, data, 1); // write views for(i=0; i<4; i++) { obsv.vpos = disp->views[i]->vpos; obsv.valign = disp->views[i]->valign; obsv.dist = disp->views[i]->dist; obsv.viewpoint = disp->views[i]->viewpoint; obsv.zoom = disp->views[i]->zoom; obsv.viewmode = disp->views[i]->viewmode; WRITE_LONG_CHUNK(ID_OBSV, &obsv, 12); } WRITE_LONG_CHUNK(ID_FILT, &disp->filter_flags, 1); WRITE_LONG_CHUNK(ID_FLEN, &global.flen, 1); WRITE_LONG_CHUNK(ID_FHGT, &global.fheight, 1); WRITE_LONG_CHUNK(ID_FCOL, &global.fog, 3); WRITE_LONG_CHUNK(ID_FILD, &global.xmin, 4); WRITE_LONG_CHUNK(ID_HSAM, &global.hyper_samples, 4); WRITE_LONG_CHUNK(ID_HMIN, &global.hyper_min_dens, 4); WRITE_LONG_CHUNK(ID_HMAX, &global.hyper_max_dens, 4); POP_CHUNK(); PUSH_CHUNK(ID_SRFS); WriteSurfaces(iff); POP_CHUNK(); PUSH_CHUNK(ID_FRAM); fdata[0] = 0.; fdata[1] = 0.; WRITE_LONG_CHUNK(ID_TIME, fdata, 2); data[0] = 0; if(global.quick) data[0] |= RSCN_FRAME_QUICK; if(global.randjit) data[0] |= RSCN_FRAME_RANDJIT; WRITE_LONG_CHUNK(ID_FLGS, data, 1); WRITE_CHUNK(ID_CAMR, disp->camera->GetName(), strlen(disp->camera->GetName())+1); WRITE_LONG_CHUNK(ID_AMBT, &global.ambient, 3); WRITE_LONG_CHUNK(ID_ANTC, &global.anticont, 3); WRITE_LONG_CHUNK(ID_ANTS, &global.antialias, 1); WRITE_LONG_CHUNK(ID_BCKC, &global.backcol, 3); WRITE_LONG_CHUNK(ID_MOBJ, &global.minobjects, 1); if(global.backpic) WRITE_CHUNK(ID_BCKP, global.backpic, strlen(global.backpic)+1); if(global.reflmap) WRITE_CHUNK(ID_REFM, global.reflmap, strlen(global.reflmap)+1); ubdata = global.softshad; WRITE_CHUNK(ID_SOFT, &ubdata, sizeof(UBYTE)); ubdata = global.distrib; WRITE_CHUNK(ID_MBLR, &ubdata, sizeof(UBYTE)); ubdata = global.octreedepth; WRITE_CHUNK(ID_ODPT, &ubdata, sizeof(UBYTE)); POP_CHUNK(); WriteObjects(iff,FALSE); POP_CHUNK(); IFFCleanup(iff); return NULL; }
BOOL SavePrefsFH(BPTR fh) { static struct SerialPrefs saveprefs; struct IFFHandle *iff; BOOL retval = FALSE, delete_if_error = FALSE; saveprefs = serialprefs; D(bug("SavePrefsFH: fh: %lx\n", fh)); //if ((iff->iff_Stream = (IPTR)Open(filename, MODE_NEWFILE))) if ((iff = AllocIFF())) { iff->iff_Stream = (IPTR) fh; D(bug("SavePrefsFH: stream opened.\n")); delete_if_error = TRUE; InitIFFasDOS(iff); if (!OpenIFF(iff, IFFF_WRITE)) { D(bug("SavePrefsFH: OpenIFF okay.\n")); if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) { D(bug("SavePrefsFH: PushChunk(FORM) okay.\n")); if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct FilePrefHeader))) { struct FilePrefHeader head; D(bug("SavePrefsFH: PushChunk(PRHD) okay.\n")); head.ph_Version = PHV_CURRENT; head.ph_Type = 0; head.ph_Flags[0] = head.ph_Flags[1] = head.ph_Flags[2] = head.ph_Flags[3] = 0; if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) { D(bug("SavePrefsFH: WriteChunkBytes(PRHD) okay.\n")); PopChunk(iff); if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct SerialPrefs))) { D(bug("SavePrefsFH: PushChunk(LCLE) okay.\n")); if (WriteChunkBytes(iff, &saveprefs, sizeof(saveprefs)) == sizeof(saveprefs)) { D(bug("SavePrefsFH: WriteChunkBytes(SERL) okay.\n")); D(bug("SavePrefsFH: Everything okay :-)\n")); retval = TRUE; } PopChunk(iff); } /* if (!PushChunk(iff, ID_PREF, ID_SERL, sizeof(struct LocalePrefs))) */ } /* if (WriteChunkBytes(iff, &head, sizeof(head)) == sizeof(head)) */ else { PopChunk(iff); } } /* if (!PushChunk(iff, ID_PREF, ID_PRHD, sizeof(struct PrefHeader))) */ PopChunk(iff); } /* if (!PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN)) */ CloseIFF(iff); } /* if (!OpenIFF(iff, IFFFWRITE)) */ FreeIFF(iff); } /* if ((iff = AllocIFF())) */ #if 0 if (!retval && delete_if_error) { DeleteFile(filename); } #endif return retval; }
static BOOL ami_print_readunit(CONST_STRPTR filename, char name[], uint32 namesize, int unitnum) { /* This is a modified version of a function from the OS4 SDK. * The README says "You can use it in your application", * no licence is specified. (c) 1999 Amiga Inc */ BPTR fp; BOOL ok; struct IFFHandle *iff; struct ContextNode *cn; struct PrefHeader phead; struct PrinterDeviceUnitPrefs pdev; SNPrintf(name,namesize,"Unit %ld",unitnum); fp = Open(filename, MODE_OLDFILE); if (fp) { iff = AllocIFF(); if (iff) { iff->iff_Stream = fp; InitIFFasDOS(iff); if (!OpenIFF(iff, IFFF_READ)) { if (!ParseIFF(iff, IFFPARSE_STEP)) { cn = CurrentChunk(iff); if (cn->cn_ID == ID_FORM && cn->cn_Type == ID_PREF) { if (!StopChunks(iff, IFFPrefChunks, IFFPrefChunkCnt)) { ok = TRUE; while (ok) { if (ParseIFF(iff, IFFPARSE_SCAN)) break; cn = CurrentChunk(iff); if (cn->cn_Type == ID_PREF) { switch (cn->cn_ID) { case ID_PRHD: if (ReadChunkBytes(iff, &phead, sizeof(struct PrefHeader)) != sizeof(struct PrefHeader)) { ok = FALSE; break; } if (phead.ph_Version != 0) { ok = FALSE; break; } break; case ID_PDEV: if (ReadChunkBytes(iff, &pdev, sizeof(pdev)) == sizeof(pdev)) { if (pdev.pd_UnitName[0]) strcpy(name,pdev.pd_UnitName); } break; default: break; } } } } } } CloseIFF(iff); } FreeIFF(iff); } Close(fp); } else return FALSE; return TRUE; }
/************* * DESCRIPTION: load a surface definition * INPUT: filename name of surface file * OUTPUT: error string or NULL if all ok *************/ char *SURFACE::Load(char *filename) { long error = 0; struct IFFHandle *iff; struct ContextNode *cn; iff = AllocIFF(); if (!iff) return errors[ERR_MEM]; #ifdef __AMIGA__ iff->iff_Stream = Open(filename, MODE_OLDFILE); #else iff->iff_Stream = Open_(filename, MODE_OLDFILE); #endif if (!(iff->iff_Stream)) { IFFCleanup(iff); return errors[ERR_OPEN]; } InitIFFasDOS(iff); error = OpenIFF(iff, IFFF_READ); if (error) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } error = ParseIFF(iff, IFFPARSE_RAWSTEP); if (error) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } cn = CurrentChunk(iff); if(!cn) { IFFCleanup(iff); return errors[ERR_IFFPARSE]; } if((cn->cn_ID != ID_FORM) || (cn->cn_Type != ID_RMAT)) { IFFCleanup(iff); return errors[ERR_NORMATFILE]; } while(!error || error == IFFERR_EOC) { error = ParseIFF(iff, IFFPARSE_RAWSTEP); if(error != IFFERR_EOC) { // Get a pointer to the context node describing the current context cn = CurrentChunk(iff); if (cn) { switch (cn->cn_ID) { case ID_FORM: switch(cn->cn_Type) { case ID_SURF: if(!Read(iff, NULL)) { IFFCleanup(iff); return errors[ERR_RMATCORRUPT]; } break; } break; } } } } if (error != IFFERR_EOF) { return errors[ERR_IFFPARSE]; } IFFCleanup(iff); return NULL; }
struct List *GetUnits(char *name) { struct List *list; struct IFFHandle *iff; BOOL devnodes[UNITNODES] = { FALSE, FALSE, FALSE, FALSE } ; BOOL lownode = FALSE; int i; globalprefs.ahigp_MaxCPU = (90 << 16) / 100; list = AllocVec(sizeof(struct List), MEMF_CLEAR); if(list) { NewList(list); if(name && (iff = AllocIFF())) { iff->iff_Stream = Open(name, MODE_OLDFILE); if(iff->iff_Stream) { InitIFFasDOS(iff); if(!OpenIFF(iff, IFFF_READ)) { if(!(PropChunk (iff, ID_PREF, ID_AHIG) || CollectionChunk(iff, ID_PREF, ID_AHIU) || StopOnExit (iff, ID_PREF, ID_FORM))) { if(ParseIFF(iff, IFFPARSE_SCAN) == IFFERR_EOC) { struct StoredProperty *global = FindProp(iff, ID_PREF, ID_AHIG); struct CollectionItem *ci = FindCollection(iff, ID_PREF, ID_AHIU); if(global != NULL) { CopyMem(global->sp_Data, &globalprefs, min( sizeof(struct AHIGlobalPrefs), global->sp_Size )); } while(ci) { struct AHIUnitPrefs *p = ci->ci_Data; struct UnitNode *u; u = AllocVec(sizeof(struct UnitNode), MEMF_CLEAR); if(u == NULL) break; CopyMem(p, &u->prefs, min( sizeof(struct AHIUnitPrefs), ci->ci_Size )); FillUnitName(u); u->node.ln_Pri = -(u->prefs.ahiup_Unit); Enqueue(list, (struct Node *) u); if(u->prefs.ahiup_Unit == AHI_NO_UNIT) { lownode = TRUE; } else if(u->prefs.ahiup_Unit < UNITNODES) { devnodes[u->prefs.ahiup_Unit] = TRUE; } ci=ci->ci_Next; } } } CloseIFF(iff); } Close(iff->iff_Stream); } FreeIFF(iff); } // Fill up to lowlevel + UNITNODES device nodes, if not found in prefs file if(!lownode) AddUnit(list, AHI_NO_UNIT); for(i = 0; i < UNITNODES; i++) { if(!devnodes[i]) AddUnit(list, i); } } return list; }
main(int argc, char **argv) { int colors; struct { long nplanes; long pbytes; long across; long down; long npics; long xsize; long ysize; } pdat; long pbytes; /* Bytes of data in a plane */ int i, cnt; BitMapHeader bmhd; struct IFFHandle *iff; long camg = HIRES | LACE; int tiles = 0; char **planes; if (argc != 3) { fprintf(stderr, "Usage: %s source destination\n", argv[0]); exit(1); } #if defined(_DCC) || defined(__GNUC__) IFFParseBase = OpenLibrary("iffparse.library", 0); if (!IFFParseBase) { error("unable to open iffparse.library"); exit(1); } #endif /* First, count the files in the file */ if (fopen_text_file(argv[1], "r") != TRUE) { perror(argv[1]); return (1); } nplanes = 0; i = colorsinmap - 1; /*IFFScreen.Colors - 1; */ while (i != 0) { nplanes++; i >>= 1; } planes = malloc(nplanes * sizeof(char *)); if (planes == 0) { error("can not allocate planes pointer"); exit(1); } while (read_text_tile(pixels) == TRUE) ++tiles; fclose_text_file(); IFFScreen.Width = COLS * TILE_X; IFFScreen.Height = ROWS * TILE_Y; pbytes = (COLS * ROWS * TILE_X + 15) / 16 * 2 * TILE_Y; for (i = 0; i < nplanes; ++i) { planes[i] = calloc(1, pbytes); if (planes[i] == 0) { error("can not allocate planes pointer"); exit(1); } } /* Now, process it */ if (fopen_text_file(argv[1], "r") != TRUE) { perror(argv[1]); return (1); } iff = AllocIFF(); if (!iff) { error("Can not allocate IFFHandle"); return (1); } iff->iff_Stream = Open(argv[2], MODE_NEWFILE); if (!iff->iff_Stream) { error("Can not open output file"); return (1); } InitIFFasDOS(iff); OpenIFF(iff, IFFF_WRITE); PushChunk(iff, ID_BMAP, ID_FORM, IFFSIZE_UNKNOWN); bmhd.w = IFFScreen.Width; bmhd.h = IFFScreen.Height; bmhd.x = 0; bmhd.y = 0; bmhd.nPlanes = nplanes; bmhd.masking = 0; bmhd.compression = 0; bmhd.reserved1 = 0; bmhd.transparentColor = 0; bmhd.xAspect = 100; bmhd.yAspect = 100; bmhd.pageWidth = TILE_X; bmhd.pageHeight = TILE_Y; PushChunk(iff, ID_BMAP, ID_BMHD, sizeof(bmhd)); WriteChunkBytes(iff, &bmhd, sizeof(bmhd)); PopChunk(iff); PushChunk(iff, ID_BMAP, ID_CAMG, sizeof(camg)); WriteChunkBytes(iff, &camg, sizeof(camg)); PopChunk(iff); /* We need to reorder the colors to get reasonable default pens but * we also need to know where some of the colors are - so go find out. */ map_colors(); cmap = malloc((colors = (1L << nplanes)) * sizeof(AmiColorMap)); for (i = 0; i < colors; ++i) { cmap[colrmap[i]].r = ColorMap[CM_RED][i]; cmap[colrmap[i]].g = ColorMap[CM_GREEN][i]; cmap[colrmap[i]].b = ColorMap[CM_BLUE][i]; } PushChunk(iff, ID_BMAP, ID_CMAP, IFFSIZE_UNKNOWN); for (i = 0; i < colors; ++i) WriteChunkBytes(iff, &cmap[i], 3); PopChunk(iff); cnt = 0; while (read_text_tile(pixels) == TRUE) { packwritebody(pixels, planes, cnt); if (cnt % 20 == 0) printf("%d..", cnt); ++cnt; fflush(stdout); } pdat.nplanes = nplanes; pdat.pbytes = pbytes; pdat.xsize = TILE_X; pdat.ysize = TILE_Y; pdat.across = COLS; pdat.down = ROWS; pdat.npics = cnt; PushChunk(iff, ID_BMAP, ID_PDAT, IFFSIZE_UNKNOWN); WriteChunkBytes(iff, &pdat, sizeof(pdat)); PopChunk(iff); PushChunk(iff, ID_BMAP, ID_PLNE, IFFSIZE_UNKNOWN); for (i = 0; i < nplanes; ++i) WriteChunkBytes(iff, planes[i], pbytes); PopChunk(iff); CloseIFF(iff); Close(iff->iff_Stream); FreeIFF(iff); printf("\n%d tiles converted\n", cnt); #if defined(_DCC) || defined(__GNUC__) CloseLibrary(IFFParseBase); #endif exit(0); }
static ULONG AddModeFile ( UBYTE *filename ) { struct IFFHandle *iff; struct StoredProperty *name,*data; struct CollectionItem *ci; struct TagItem *tag,*tstate; struct TagItem extratags[]= { { AHIDB_Driver, NULL }, { AHIDB_Data, NULL }, { TAG_MORE, NULL } }; ULONG rc=FALSE; iff = AllocIFF(); if(iff != NULL) { iff->iff_Stream = Open(filename, MODE_OLDFILE); if(iff->iff_Stream != NULL) { InitIFFasDOS(iff); if(!OpenIFF(iff, IFFF_READ)) { if(!(PropChunk(iff, ID_AHIM, ID_AUDN) || PropChunk(iff, ID_AHIM, ID_AUDD) || CollectionChunk(iff, ID_AHIM, ID_AUDM) || StopOnExit(iff, ID_AHIM, ID_FORM))) { if(ParseIFF(iff, IFFPARSE_SCAN) == IFFERR_EOC) { name = FindProp(iff, ID_AHIM, ID_AUDN); data = FindProp(iff, ID_AHIM, ID_AUDD); ci = FindCollection(iff, ID_AHIM, ID_AUDM); if(name != NULL) { extratags[0].ti_Data = (ULONG) name->sp_Data; } if(data != NULL) { extratags[1].ti_Data = (ULONG) data->sp_Data; } rc = TRUE; while(ci != NULL) { // Relocate loaded taglist tstate = (struct TagItem *) ci->ci_Data; while((tag = NextTagItem(&tstate)) != NULL ) { if(tag->ti_Tag & (AHI_TagBaseR ^ AHI_TagBase)) { tag->ti_Data += (ULONG) ci->ci_Data; } } // Link taglists extratags[2].ti_Data = (ULONG) ci->ci_Data; rc = AHI_AddAudioMode(extratags); ci = ci->ci_Next; } } } CloseIFF(iff); } Close(iff->iff_Stream); } FreeIFF(iff); } return rc; }