#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <iostream.h>
#include <PR/libaudio.h>

#include "GList.h"
#include "AeWaveFile.h"
#include "AeAsset.h"
#include "AeErr.h"


double	_AFConvertFromIeeeExtended (char *bytes);


AeWaveFile::AeWaveFile (char * name)
    : AeAssetFile (name)
{
    fWave = NULL;
    fKeymap = NULL;
}

AeWaveFile::~AeWaveFile (void)
{
}


// try to use the Audio File library to read the file
// otherwise use our own parser to read the file.
AeErr
AeWaveFile::ReadList (GList<AeAsset *> *& list)
{
    AeErr err;

#ifdef NOT_IN_USE
    if ((err = afRead ()) == kAeFileCantOpen)
	err = aeRead ();
#endif

    err = aeRead ();

    if (!err)
    {
	if (list = new GList<AeAsset *>)
	{
	    list->Append (fWave);
	    list->Append (fKeymap);
	}
	else
	    err = kAeLowMemErr;
    }

    if (err)
	ReportError (err);

    return err;
}


// try to use the Audio File library to read the file
// otherwise use our own parser to read the file.
AeErr
AeWaveFile::Read (AeAsset *& asset)
{
    AeErr err;

#ifdef NOT_IN_USE
    if ((err = afRead ()) == kAeFileCantOpen)
	err = aeRead ();
#endif

    err = aeRead ();

    if (!err)
	asset = fWave;
    else
	ReportError (err);

    return err;
}


AeErr
AeWaveFile::ReadSampleData (char *& buffer, long & nbytes)
{
    AeErr err;

#ifdef NOT_IN_USE
    if ((err = afReadSampleData (buffer, nbytes)) == kAeFileCantOpen)
	err = aeReadSampleData (buffer, nbytes);
#endif

    if (err = aeReadSampleData (buffer, nbytes))
	ReportError (err);

    return err;
}



AeErr
AeWaveFile::afRead (void)
{
    AFfilehandle	fileRef;
    AeErr		err = kAeNoErr;

    if ((fileRef = AFopenfile (fFullName, "r", NULL)) == AF_NULL_FILEHANDLE)
    {
	err = kAeFileCantOpen;
	goto Abort;
    }

    // create the wave asset based on the file type
    if (err = newWaveAsset (fileRef))
	goto Abort;

    // read the generic wave parameters
    afReadWaveParams (fileRef, fWave);
    afReadInstParams (fileRef);

    // read the specific wave parameters
    if (fWave->GetWaveType () == kRaw16WaveType)
	afReadRaw16Params (fileRef, (AeRaw16WaveAsset *)fWave);
    else
	afReadADPCMParams (fileRef, (AeADPCMWaveAsset *)fWave);

Abort:
    if (fileRef != AF_NULL_FILEHANDLE)
	AFclosefile (fileRef);

    return err;
}


AeErr
AeWaveFile::newWaveAsset (AFfilehandle fileRef)
{
    AeWaveAsset *	asset;
    long  	     	fileFmt;
    long       		compFmt;
    long       		version;
    AeErr		err = kAeNoErr;

    fileFmt = AFgetfilefmt (fileRef, &version);

    switch (fileFmt)
    {
	case AF_FILE_AIFF:
	    fWave = (AeWaveAsset *)new AeRaw16WaveAsset (this);
	    break;

	case AF_FILE_AIFFC:
	    compFmt = AFgetcompression (fileRef, AF_DEFAULT_TRACK);
	    switch (compFmt)
	    {
		case AF_COMPRESSION_NONE:
		    fWave = (AeWaveAsset *)new AeRaw16WaveAsset (this);
		    break;

		default:
		    fWave = (AeWaveAsset *)new AeADPCMWaveAsset (this);
		    break;
	    }

	default:
	    fWave = NULL;
	    err = kAeFileNoSupport;
	    break;
    }

    if (!err && fWave == NULL)
	err = kAeLowMemErr;

    return err;
}


AeErr
AeWaveFile::newKeymapAsset (void)
{
    AeErr err = kAeNoErr;
    char name[64];
    char * prefix = MakeFilePrefix ();
    char * p;

    // hack to replace periods with underscores
    // periods are illegal in the ic tool
    p = prefix;
    while (*p)
    {
	if (*p == '.')
	    *p = '_';
	p++;
    }

    sprintf (name, "%s_key", prefix);

    if ((fKeymap = new AeKeymapAsset (name)) == NULL)
	err = kAeLowMemErr;

    free (prefix);

    return err;
}


void
AeWaveFile::afReadWaveParams (AFfilehandle fileRef, AeWaveAsset * asset)
{
    long	sampleFmt;
    long       	sampleSize;
    long	sampleFrames;

    assert (fileRef != AF_NULL_FILEHANDLE);
    assert (asset);

    // must be uncompressed data so that sample frames = data bytes * 2
    assert (asset->GetWaveType () == kRaw16WaveType);

    AFgetsampfmt (fileRef, AF_DEFAULT_TRACK, &sampleFmt, &sampleSize);
    sampleFrames = AFgetframecnt (fileRef, AF_DEFAULT_TRACK);

    asset->SetSampleSize (sampleSize);
    asset->SetSampleRate (AFgetrate (fileRef, AF_DEFAULT_TRACK));
    asset->SetSampleFrames (sampleFrames);
    asset->SetNDataBytes (sampleFrames * sampleSize / 8);
}


void
AeWaveFile::afReadInstParams (AFfilehandle fileRef)
{
    if (AFgetinstids (fileRef, NULL))
    {
	if (!fKeymap)
	    newKeymapAsset ();

	assert (fKeymap);

	fKeymap->SetKeyMin (AFgetinstparamlong (fileRef, AF_DEFAULT_INST,
						AF_INST_MIDI_LONOTE));
	fKeymap->SetKeyMax (AFgetinstparamlong (fileRef, AF_DEFAULT_INST,
						AF_INST_MIDI_HINOTE));
	fKeymap->SetKeyBase (AFgetinstparamlong (fileRef, AF_DEFAULT_INST,
						 AF_INST_MIDI_BASENOTE));
	fKeymap->SetVelMin (AFgetinstparamlong (fileRef, AF_DEFAULT_INST,
						AF_INST_MIDI_LOVELOCITY));
	fKeymap->SetVelMax (AFgetinstparamlong (fileRef, AF_DEFAULT_INST,
						AF_INST_MIDI_HIVELOCITY));
	fKeymap->SetDetune (AFgetinstparamlong (fileRef, AF_DEFAULT_INST,
						AF_INST_NUMCENTS_DETUNE));
    }
}

void
AeWaveFile::afReadRaw16Params (AFfilehandle fileRef, AeRaw16WaveAsset * asset)
{
    assert (fileRef != AF_NULL_FILEHANDLE);
    assert (asset);

    AeLoopAsset * loop = new AeLoopAsset ("");
    afReadLoop (fileRef, loop);
    asset->SetLoop (loop);
}


void
AeWaveFile::afReadLoop (AFfilehandle fileRef, AeLoopAsset * asset)
{
    long loopID;
    long loopMode;
    long loopStart;
    long loopEnd;

    assert (fileRef != AF_NULL_FILEHANDLE);
    assert (asset);

    loopID = AFgetinstparamlong (fileRef, AF_DEFAULT_INST, AF_INST_SUSLOOPID);

    loopMode = AFgetloopmode (fileRef, AF_DEFAULT_INST, loopID);

    if (loopMode == AF_LOOP_MODE_FORW)
    {
	loopStart = AFgetloopstart (fileRef, AF_DEFAULT_INST, loopID);
	loopEnd   = AFgetloopend (fileRef, AF_DEFAULT_INST, loopID);
    
	asset->SetStart (loopStart);
	asset->SetEnd (loopEnd);
	asset->SetCount (-1);		// make if loop forever
    }
}


void
AeWaveFile::afReadADPCMParams (AFfilehandle fileRef, AeADPCMWaveAsset * asset)
{
    long	miscCnt;
    long *	miscIDs;
    long	miscType;
    long	miscSize;
    void *	miscData;
    void *	miscDataPtr;
    char *	miscName;
    long	applType;
    int		i;
 
    assert (fileRef != AF_NULL_FILEHANDLE);
    assert (asset);

    miscCnt = AFgetmiscids(fileRef, NULL);
    miscIDs = (long *)malloc (miscCnt * sizeof(long));
    FailNIL (miscIDs);

    AFgetmiscids (fileRef, miscIDs);

    for (i=0; i<miscCnt; i++)
    {
	miscType = AFgetmisctype (fileRef, miscIDs[i]);

	if (miscType == AF_MISC_AIFF_APPL)
	{
	    miscSize = AFgetmiscsize (fileRef, miscIDs[i]);
	    miscData = malloc (miscSize);
	    FailNIL (miscData);
	    miscDataPtr = miscData;

	    AFreadmisc (fileRef, miscIDs[i], miscData, miscSize);

	    applType = afReadLong (miscData);

	    if (applType == 'stoc')
	    {
		miscData = afReadPString (miscData, miscName);

		if (!strcmp (LOOP_NAME, miscName))
		{
		    AeADPCMLoopAsset * loop = new AeADPCMLoopAsset ("");
		    afReadADPCMLoop (miscData, loop);		    
		    asset->SetLoop (loop);
		}
		else if (!strcmp (CODE_NAME, miscName))
		{
		    AeADPCMBookAsset * book = new AeADPCMBookAsset ("");
		    afReadADPCMBook (miscData, book);
		    asset->SetBook (book);
		}

		if (miscName)
		    free (miscName);
	    }
	    
	    if (miscDataPtr)
		free (miscDataPtr);
	}
    }

    if (miscIDs)
	free (miscIDs);
}


void
AeWaveFile::afReadADPCMLoop (void * data, AeADPCMLoopAsset * asset)
{
    short	version;
    short	nloops;
    ALADPCMloop loopChunk;
    int		i;

    assert (data);
    assert (asset);

    version = afReadShort (data);

    if (version == VERSION)
    {
	nloops = afReadShort (data);

	if (nloops > 1)
	{
	    ReportError (kAeFileTooManyLoops);
	    nloops = 1;
	}
                        
	for (i=0; i<nloops; i++)
	    memcpy (&loopChunk, (char *)data, sizeof (ALADPCMloop));
                        
	asset->SetStart (loopChunk.start);
	asset->SetEnd (loopChunk.end);
	asset->SetCount (loopChunk.count);
	asset->SetStateData (sizeof (ADPCM_STATE), loopChunk.state);
    }
    else
	ReportError (kAeFileBadLoopVersion);
}


void
AeWaveFile::afReadADPCMBook (void * data, AeADPCMBookAsset * asset)
{
    short	version;
    short 	order;
    short 	npredictors;
    int		bookSize;

    assert (data);
    assert (asset);

    version = afReadShort (data);

    if (version == VERSION)
    {
	order = afReadShort (data);
	npredictors = afReadShort (data);
	bookSize = npredictors * order * ADPCMVSIZE;
	asset->SetBook (order, npredictors, ADPCMVSIZE, (short *)data);
    }
    else
	ReportError (kAeFileBadBookVersion);
}


void *
AeWaveFile::afReadPString (void * data, char *& string)
{
    int len = *(char *)data;

    string = (char *)malloc (len + 1);

    strncpy (string, (char *)data+1, len);

    string[len] = 0;

    return (void *)((char *)data + len + 1);
}


long
AeWaveFile::afReadLong (void * data)
{
    long l = *((long *)data);
    char * p = (char *)data;

    p += sizeof (long);
    return l;
}
    
short
AeWaveFile::afReadShort (void * data)
{
    short s = *((short *)data);
    char * p = (char *)data;

    p += sizeof (long);
    return s;
}
    

AeErr
AeWaveFile::aeRead (void)
{
    FILE *		fileRef;
    long        	offset;
    int         	i;
    Chunk       	FormChunk;
    CommonChunk 	comm;
    ChunkHeader 	Header;
    char *      	nameChunk;
    SoundDataChunk      data;
    ALADPCMloop 	loopChunk;
    int         	done=0;
    long        	skip;
    long        	ts;
    int         	num;
    short       	nmarkers;
    Marker      	*markers;
    unsigned long 	compressionType;
    long		sampleFrames, nbytes;
    double		sampleRate;
    AeLoopAsset *	loop = NULL;
    AeADPCMBookAsset *	book = NULL;
    AeErr		err = kAeNoErr;


    // open the file for reading
    if ((fileRef = fopen(fFullName, "r")) == NULL)
    {
	err = kAeFileCantOpen;
	goto Abort;
    }

    // read the form chunk
    fread(&FormChunk, sizeof(FormChunk), 1, fileRef);
    
    if ((FormChunk.ckID != IFF_ID_FORM) ||
        ((FormChunk.formType != IFF_ID_AIFC) &&
        (FormChunk.formType != IFF_ID_AIFF))) {
	err = kAeFileNoSupport;
	goto Abort;
    }

    // read file chunks until there are no more
    while (!done)
    {
        if ((num = fread(&Header, sizeof(ChunkHeader), 1, fileRef)) < 1)
	    break;

        skip = (Header.ckSize + 1) & ~1; /* account for pad byte */
        
        switch (Header.ckID)
	{
            case (IFF_ID_COMM):
		offset = ftell(fileRef);
                
		num = fread (&comm, sizeof(CommonChunk), 1, fileRef);
		if (num < 1) {
		    err = kAeFileBadRead;
		    goto Abort;
		}

		fseek(fileRef, offset + skip, SEEK_SET);
                break;
                
            case (IFF_ID_MARK):
                offset = ftell(fileRef);
		aeReadMarkers (fileRef, &markers, &nmarkers);
                fseek(fileRef, offset + skip, SEEK_SET);
                break;
            
            case (IFF_ID_SSND):
                offset = ftell(fileRef);

                fread(&data, sizeof (data), 1, fileRef);
                assert(data.offset == 0);
                assert(data.blockSize == 0);             
 		nbytes = Header.ckSize - sizeof (data);

                fseek(fileRef, offset + skip, SEEK_SET);
                break;
                
            case (IFF_ID_INST):
                offset = ftell(fileRef);
		aeReadInstParams (fileRef);
		fseek(fileRef, offset + skip, SEEK_SET);
                break;

            case (IFF_ID_APPL):
                offset = ftell(fileRef);

                fread(&ts, sizeof(ts), 1, fileRef);
                if (ts == 'stoc')
		{
                    nameChunk = aeReadPString(fileRef);

                    if (!strcmp(LOOP_NAME, nameChunk))
		    {
			loop = (AeLoopAsset *)new AeADPCMLoopAsset ("");
			aeReadADPCMLoop (fileRef, (AeADPCMLoopAsset *)loop);
                    }
		    else if (!strcmp(CODE_NAME, nameChunk))
		    {
			book = new AeADPCMBookAsset ("");
			aeReadADPCMBook (fileRef, book);
                    }

		    if (nameChunk)
			free (nameChunk);
                }
                
                fseek(fileRef, offset + Header.ckSize, SEEK_SET);
                break;
                
            default:                
                /* skip chunks we don't know about */
                fseek(fileRef, skip, SEEK_CUR);                
                break;
        }        
    }

    if (FormChunk.formType != IFF_ID_AIFF)
	compressionType = comm.compressionTypeH<<16 | comm.compressionTypeL;
    else
	compressionType = 'NONE';
                    
    if (compressionType == 'NONE')
    {
	fWave = (AeWaveAsset *)new AeRaw16WaveAsset (this);
	loop = new AeLoopAsset ("");
	aeReadLoop (loop, markers, nmarkers);
	fWave->SetLoop (loop);
    }

    else if (compressionType == 'VAPC')
    {
	fWave = (AeWaveAsset *)new AeADPCMWaveAsset (this);
	
	if (!loop)
	    loop = (AeLoopAsset *)new AeADPCMLoopAsset ("");
	fWave->SetLoop ((AeADPCMLoopAsset *)loop);
	
	if (book)
	    ((AeADPCMWaveAsset *)fWave)->SetBook (book);
	else
	{
	    assert (False);		// adpcm files must have books
	    err = kAeFileBadRead;
	}
    }
    else
    {
	err = kAeFileNoSupport;
	goto Abort;
    }

    sampleFrames = (comm.numFramesH<<16) + comm.numFramesL;
    sampleRate = _AFConvertFromIeeeExtended (comm.sampleRate);

    fWave->SetSampleSize (comm.sampleSize);
    fWave->SetSampleFrames (sampleFrames);
    fWave->SetSampleRate (sampleRate);
    fWave->SetNDataBytes (nbytes);

Abort:
    if (fileRef)
	fclose(fileRef);    

    return err;
}


void
AeWaveFile::aeReadInstParams (FILE * fileRef)
{
    InstrumentChunk     inst;

    fread (&inst, sizeof(InstrumentChunk), 1, fileRef);

    if (!fKeymap)
	newKeymapAsset ();

    assert (fKeymap);

    fKeymap->SetKeyMin (inst.lowNote);
    fKeymap->SetKeyMax (inst.highNote);
    fKeymap->SetKeyBase (inst.baseNote);
    fKeymap->SetVelMin (inst.lowVelocity);
    fKeymap->SetVelMax (inst.highVelocity);
    fKeymap->SetDetune (inst.detune);

    fLoop = inst.sustainLoop;
}



// Set up the loop point from the Marker definitions.
// Note: only pay attention to a Sustain loop in forward mode
void
AeWaveFile::aeReadLoop (AeLoopAsset * asset, Marker * markers, short nmarkers)
{
    long        start;
    long        end;
        
    if (fLoop.playMode == ForwardLooping)
    {
	if (findMarkerSample (&start, fLoop.beginLoop, markers, nmarkers))
	    ReportError (kAeFileBadMarker);
            
	if (findMarkerSample (&end, fLoop.endLoop, markers, nmarkers))
	    ReportError (kAeFileBadMarker);
            
	asset->SetStart (start);
	asset->SetEnd (end);
	asset->SetCount (-1);		// default to loop forever
    }
}


void
AeWaveFile::aeReadADPCMLoop (FILE * fileRef, AeADPCMLoopAsset * asset)
{
    short	version;
    short 	nloops;
    ALADPCMloop	loopChunk;
    int		i;

    assert (fileRef);
    assert (asset);

    fread(&version, sizeof(short), 1, fileRef);

    if (version == VERSION)
    {
	fread (&nloops, sizeof(short), 1, fileRef);

	if (nloops > 1)
	{
	    ReportError (kAeFileTooManyLoops);
	    nloops = 1;
	}
                        
	for (i=0; i<nloops; i++)
	    fread (&loopChunk, sizeof(ALADPCMloop),1, fileRef);
                       
	asset->SetStart (loopChunk.start);
	asset->SetEnd (loopChunk.end);
	asset->SetCount (loopChunk.count);
	asset->SetStateData (sizeof(ADPCM_STATE), loopChunk.state);
    }
    else
	ReportError (kAeFileBadLoopVersion);
}


void
AeWaveFile::aeReadADPCMBook (FILE * fileRef, AeADPCMBookAsset * asset)
{
    short	version;
    short	order;
    short	npredictors;
    int		bookSize;
    short *	bookData;

    assert (fileRef);
    assert (asset);

    fread(&version, sizeof(short), 1, fileRef);

    if (version == VERSION)
    {
	fread (&order, sizeof(short), 1, fileRef);
	fread (&npredictors, sizeof(short), 1, fileRef);

	bookSize = npredictors*order*ADPCMVSIZE;
	bookData = (short *)malloc(bookSize*sizeof(short));
	FailNIL (bookData);

	fread (bookData, sizeof(short), bookSize, fileRef);

	asset->SetBook (order, npredictors, ADPCMVSIZE, bookData);

	free (bookData);
    }
    else
	ReportError (kAeFileBadBookVersion);
}


void
AeWaveFile::aeReadMarkers (FILE * fileRef, Marker ** markers, short * nmarkers)
{
    char *	nameChunk;
    int		i;

    assert (fileRef);

    fread(nmarkers, sizeof(short), 1, fileRef);

    *markers = (Marker *)calloc(*nmarkers, sizeof(Marker));
    for (i=0; i<*nmarkers; i++)
    {
	fread (&(*markers)[i], sizeof(Marker), 1, fileRef);

	if (nameChunk = aeReadPString(fileRef))
	    free(nameChunk);            // Junk the marker name
    }
}


int
AeWaveFile::findMarkerSample(long *sample, MarkerID loopPoint, Marker *markers, int nmarkers)
{
    for (int i=0; i<nmarkers; i++)
    {
        if (loopPoint == markers[i].id)
	{
            *sample = (markers[i].positionH<<16) + markers[i].positionL;
            return 0;
        }
    }

    return 1;
}

char *
AeWaveFile::aeReadPString (FILE * fileRef)
{
    unsigned char c;
    char        *st;

    assert (fileRef);

    fread(&c, 1, 1, fileRef);
    st = (char *) malloc(c+1);
    fread(st, c, 1, fileRef);
    *(st+c) = 0;
    
    // Read the pad byte if necessary
    if (!(c & 1))
        fread(&c, 1, 1, fileRef);

    return st;
}



AeErr
AeWaveFile::afReadSampleData (char * & buffer, long & nbytes)
{
    AFfilehandle	fileRef;
    long		sampleFmt;
    long       		sampleSize;
    long		sampleFrames;
    long		readFrames;
    AeErr		err = kAeNoErr;

    if ((fileRef = AFopenfile (fFullName, "r", NULL)) == AF_NULL_FILEHANDLE)
    {
	err = kAeFileCantOpen;
	goto Abort;
    }

    AFgetsampfmt (fileRef, AF_DEFAULT_TRACK, &sampleFmt, &sampleSize);

    sampleFrames = AFgetframecnt (fileRef, AF_DEFAULT_TRACK);

    // currently we only handles sample sizes in multiples of 8
    assert ((sampleSize % 8) == 0);

    nbytes = sampleFrames * sampleSize / 8;
    buffer = (char *)malloc (nbytes);

    readFrames = AFreadframes (fileRef, AF_DEFAULT_TRACK, buffer, sampleFrames);

    // if we didn't read all the samples, pretend that we didn't
    // read any data since no data clearly indicates a problem
    // rather than partially good data.
    assert (readFrames == sampleFrames);
    
Abort:
    if (fileRef != AF_NULL_FILEHANDLE)
	AFclosefile (fileRef);

    return err;
    
}


AeErr
AeWaveFile::aeReadSampleData (char *& buffer, long & nbytes)
{
    FILE *		fileRef;
    long        	offset;
    Chunk       	FormChunk;
    ChunkHeader 	Header;
    SoundDataChunk      data;
    int         	done = 0;
    long        	skip, nbytesRead;
    int         	num;
    AeErr		err = kAeNoErr;

    // open the file for reading
    if ((fileRef = fopen(fFullName, "r")) == NULL)
    {
	err = kAeFileCantOpen;
	goto Abort;
    }

    // read the form chunk
    fread (&FormChunk, sizeof(FormChunk), 1, fileRef);
    
    if ((FormChunk.ckID != IFF_ID_FORM) ||
        ((FormChunk.formType != IFF_ID_AIFC) &&
        (FormChunk.formType != IFF_ID_AIFF))) {
	err = kAeFileNoSupport;
	goto Abort;
    }

    // read file chunks until we find the sample sound chunk
    while (!done)
    {
        if ((num = fread(&Header, sizeof(ChunkHeader), 1, fileRef)) < 1)
	    break;

        skip = (Header.ckSize + 1) & ~1; /* account for pad byte */
        
        switch (Header.ckID)
	{
            case (IFF_ID_SSND):
                offset = ftell (fileRef);
                fread (&data, sizeof (data), 1, fileRef);

                assert (data.offset == 0);
                assert (data.blockSize == 0);
              
		nbytes = Header.ckSize - sizeof (data);
		buffer = (char *)malloc (nbytes);
		FailNIL (buffer);

		nbytesRead = fread (buffer, sizeof(char), nbytes, fileRef);
		assert (nbytesRead == nbytes);

                fseek (fileRef, offset + skip, SEEK_SET);

		done = True;
                break;
              
		// skip chunks we don't care about
            default:                
                fseek(fileRef, skip, SEEK_CUR);                
                break;
        }        
    }

Abort:
    if (fileRef)
	fclose (fileRef);    

    return err;    
}


void
AeWaveFile::ReportError (AeErr err)
{
    switch (err)
    {
	case kAeFileTooManyLoops:
	    cout << "warning: multiple loop points found in " << fFileName;
	    cout << ". only 1 loop supported\n";
	    break;

	case kAeFileBadLoopVersion:
	    cout << "warning: non-identical loop chunk versions in ";
	    cout << fFileName << '\n';
	    break;

	case kAeFileBadBookVersion:
	    cout << "warning: bad codebook chunk version in ";
	    cout << fFileName << '\n';
	    break;

	case kAeFileBadMarker:
	    cout << "warning: expected loop marker not found in ";
	    cout << fFileName << '\n';
	    break;

	default:
	    AeFile::ReportError (err);
	    break;
    }

    cout.flush ();
}