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;
}
