char TIOBase::ReadComment() {
if(pFile) { return ReadComment(pFile);
} else {
cerr << "Error in ReadComment(). No File "
<< cFilename << " to read comment from.\n";
return 1; }
}
/// <summary>Reads all objects in the file</summary>
/// <returns></returns>
/// <exception cref="Logic::FileFormatException">File contains a syntax error</exception>
/// <exception cref="Logic::IOException">An I/O error occurred</exception>
TFilePtr ReadFile(MainType t, GameVersion v)
{
// Skip comments
while (ReadComment())
{}
// Parse header
int ver = ReadInt(L"File version");
int count = ReadInt(L"Number of objects");
// TODO: Validate version
// Create file
TFile<OBJ>* file = new TFile<OBJ>(count);
TFilePtr output(file);
// Parse objects
for (int i = 0; i < count; ++i)
{
OBJ obj(t);
// Read header/contents/footer
ReadHeader(obj);
ReadObject(obj, v);
ReadFooter(obj);
// Add to file
file->Objects.push_back(obj);
}
// Return non-generic file
return output;
}
void CFileImageStream::ReadImageFileHeader(bool readAllocMap)
{
fImageHeader.ReadHeaderFromFile(fHandle);
CheckIfInfoFromFileHeaderIsSupported();
unsigned __int64 clusterBitmapOffset, clusterBitmapLength;
fUsedSize = fImageHeader.GetVolumeUsedSize();
fSize = fImageHeader.GetVolumeSize();
if (readAllocMap) {
fImageHeader.GetClusterBitmapOffsetAndLength(clusterBitmapOffset, clusterBitmapLength);
if (clusterBitmapOffset != 0 && clusterBitmapLength != 0) {
fAllocMapReader = new CompressedRunLengthStreamReader(fFileName.c_str(), clusterBitmapOffset, (DWORD)clusterBitmapLength);
}
}
ReadCrc32Checksum();
ReadComment();
}
//
// ReadHeader()
//
void JLSInputStream::ReadHeader()
{
if (ReadByte() != 0xFF)
throw JlsException(InvalidCompressedData);
if (ReadByte() != JPEG_SOI)
throw JlsException(InvalidCompressedData);
for (;;)
{
if (ReadByte() != 0xFF)
throw JlsException(InvalidCompressedData);
BYTE marker = (BYTE)ReadByte();
size_t cbyteStart = _cbyteOffset;
LONG cbyteMarker = ReadWord();
switch (marker)
{
case JPEG_SOS: ReadStartOfScan(); break;
case JPEG_SOF: ReadStartOfFrame(); break;
case JPEG_COM: ReadComment(); break;
case JPEG_LSE: ReadPresetParameters(); break;
case JPEG_APP0: ReadJfif(); break;
case JPEG_APP7: ReadColorSpace(); break;
case JPEG_APP8: ReadColorXForm(); break;
// Other tags not supported (among which DNL DRI)
default: throw JlsException(ImageTypeNotSupported);
}
if (marker == JPEG_SOS)
{
_cbyteOffset = cbyteStart - 2;
return;
}
_cbyteOffset = cbyteStart + cbyteMarker;
}
}
// This assumes that the characters just read from xmlStream were "<!", and
// determines if this is the start of a comment or a CDATA structure or
// just malformed XML. If it is a comment, it reads until the end of the
// comment, discarding all the characters of the comment, and true is
// returned. If it is a CDATA structure, characters are read in until the
// end of the structure, and all the characters read are put into
// destinationForReadCharacters if it is not NULL, and true is returned.
// If the XML was malformed (including being unable to close a comment or
// CDATA structure), false is returned.
inline void RestrictedXmlParser::CloseExclamationMark(
std::ostream* destinationForReadCharacters )
{
if( !(xmlStream->get( currentCharacter ).good()) )
{
throw
std::runtime_error( "Failed to close structure following \"<!\"" );
}
if( currentCharacter == '-' )
{
ReadComment();
}
else if( currentCharacter == '[' )
{
ReadCdata( destinationForReadCharacters );
}
else
{
if( destinationForReadCharacters != NULL )
{
(*destinationForReadCharacters) << '<' << currentCharacter;
}
}
}
BOOL IT_Load(BOOL curious)
{
int t,u,lp;
INSTRUMENT *d;
SAMPLE *q;
BOOL compressed=0;
numtrk=0;
filters=0;
/* try to read module header */
_mm_read_I_ULONG(modreader); /* kill the 4 byte header */
_mm_read_string(mh->songname,26,modreader);
_mm_read_UBYTES(mh->blank01,2,modreader);
mh->ordnum =_mm_read_I_UWORD(modreader);
mh->insnum =_mm_read_I_UWORD(modreader);
mh->smpnum =_mm_read_I_UWORD(modreader);
mh->patnum =_mm_read_I_UWORD(modreader);
mh->cwt =_mm_read_I_UWORD(modreader);
mh->cmwt =_mm_read_I_UWORD(modreader);
mh->flags =_mm_read_I_UWORD(modreader);
mh->special =_mm_read_I_UWORD(modreader);
mh->globvol =_mm_read_UBYTE(modreader);
mh->mixvol =_mm_read_UBYTE(modreader);
mh->initspeed =_mm_read_UBYTE(modreader);
mh->inittempo =_mm_read_UBYTE(modreader);
mh->pansep =_mm_read_UBYTE(modreader);
mh->zerobyte =_mm_read_UBYTE(modreader);
mh->msglength =_mm_read_I_UWORD(modreader);
mh->msgoffset =_mm_read_I_ULONG(modreader);
_mm_read_UBYTES(mh->blank02,4,modreader);
_mm_read_UBYTES(mh->pantable,64,modreader);
_mm_read_UBYTES(mh->voltable,64,modreader);
if(_mm_eof(modreader)) {
_mm_errno=MMERR_LOADING_HEADER;
return 0;
}
/* set module variables */
of.songname = DupStr(mh->songname,26,0); /* make a cstr of songname */
of.reppos = 0;
of.numpat = mh->patnum;
of.numins = mh->insnum;
of.numsmp = mh->smpnum;
of.initspeed = mh->initspeed;
of.inittempo = mh->inittempo;
of.initvolume = mh->globvol;
of.flags |= UF_BGSLIDES|UF_ARPMEM;
if(mh->songname[25]) {
of.numvoices=1+mh->songname[25];
#ifdef MIKMOD_DEBUG
fprintf(stderr,"Embedded IT limitation to %d voices\n",of.numvoices);
#endif
}
/* set the module type */
/* 2.17 : IT 2.14p4 */
/* 2.16 : IT 2.14p3 with resonant filters */
/* 2.15 : IT 2.14p3 (improved compression) */
if((mh->cwt<=0x219)&&(mh->cwt>=0x217))
of.modtype=strdup(IT_Version[mh->cmwt<0x214?4:5]);
else if (mh->cwt>=0x215)
of.modtype=strdup(IT_Version[mh->cmwt<0x214?2:3]);
else {
of.modtype = strdup(IT_Version[mh->cmwt<0x214?0:1]);
of.modtype[mh->cmwt<0x214?15:26] = (mh->cwt>>8)+'0';
of.modtype[mh->cmwt<0x214?17:28] = ((mh->cwt>>4)&0xf)+'0';
of.modtype[mh->cmwt<0x214?18:29] = ((mh->cwt)&0xf)+'0';
}
if(mh->flags&8)
of.flags|=(UF_XMPERIODS | UF_LINEAR);
if((mh->cwt>=0x106)&&(mh->flags&16))
old_effect=1;
else
old_effect=0;
/* set panning positions */
for(t=0;t<64;t++) {
mh->pantable[t]&=0x7f;
if(mh->pantable[t]<64)
of.panning[t]=mh->pantable[t]<<2;
else if(mh->pantable[t]==64)
of.panning[t]=255;
else if(mh->pantable[t]==100)
of.panning[t]=PAN_SURROUND;
else if(mh->pantable[t]==127)
of.panning[t]=PAN_CENTER;
else {
_mm_errno=MMERR_LOADING_HEADER;
return 0;
}
}
/* set channel volumes */
memcpy(of.chanvol,mh->voltable,64);
/* read the order data */
if(!AllocPositions(mh->ordnum)) return 0;
if(!(origpositions=_mm_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
for(t=0;t<mh->ordnum;t++) {
origpositions[t]=_mm_read_UBYTE(modreader);
if((origpositions[t]>mh->patnum)&&(origpositions[t]<254))
origpositions[t]=255;
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
poslookupcnt=(UBYTE)mh->ordnum;
S3MIT_CreateOrders(curious);
if(!(paraptr=(ULONG*)_mm_malloc((mh->insnum+mh->smpnum+of.numpat)*
sizeof(ULONG)))) return 0;
/* read the instrument, sample, and pattern parapointers */
_mm_read_I_ULONGS(paraptr,mh->insnum+mh->smpnum+of.numpat,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* Check for and load midi information for resonant filters */
if(mh->cmwt>=0x216) {
if(mh->special&8) {
IT_LoadMidiConfiguration(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else
IT_LoadMidiConfiguration(NULL);
filters=1;
}
/* Check for and load song comment */
if((mh->special&1)&&(mh->cwt>=0x104)&&(mh->msglength)) {
_mm_fseek(modreader,(long)(mh->msgoffset),SEEK_SET);
if(!ReadComment(mh->msglength)) return 0;
}
if(!(mh->flags&4)) of.numins=of.numsmp;
if(!AllocSamples()) return 0;
if(!AllocLinear()) return 0;
/* Load all samples */
q = of.samples;
for(t=0;t<mh->smpnum;t++) {
ITSAMPLE s;
/* seek to sample position */
_mm_fseek(modreader,(long)(paraptr[mh->insnum+t]+4),SEEK_SET);
/* load sample info */
_mm_read_string(s.filename,12,modreader);
s.zerobyte = _mm_read_UBYTE(modreader);
s.globvol = _mm_read_UBYTE(modreader);
s.flag = _mm_read_UBYTE(modreader);
s.volume = _mm_read_UBYTE(modreader);
_mm_read_string(s.sampname,26,modreader);
s.convert = _mm_read_UBYTE(modreader);
s.panning = _mm_read_UBYTE(modreader);
s.length = _mm_read_I_ULONG(modreader);
s.loopbeg = _mm_read_I_ULONG(modreader);
s.loopend = _mm_read_I_ULONG(modreader);
s.c5spd = _mm_read_I_ULONG(modreader);
s.susbegin = _mm_read_I_ULONG(modreader);
s.susend = _mm_read_I_ULONG(modreader);
s.sampoffset = _mm_read_I_ULONG(modreader);
s.vibspeed = _mm_read_UBYTE(modreader);
s.vibdepth = _mm_read_UBYTE(modreader);
s.vibrate = _mm_read_UBYTE(modreader);
s.vibwave = _mm_read_UBYTE(modreader);
/* Generate an error if c5spd is > 512k, or samplelength > 256 megs
(nothing would EVER be that high) */
if(_mm_eof(modreader)||(s.c5spd>0x7ffffL)||(s.length>0xfffffffUL)||
(s.loopbeg>0xfffffffUL)||(s.loopend>0xfffffffUL)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
q->samplename = DupStr(s.sampname,26,0);
q->speed = s.c5spd / 2;
q->panning = ((s.panning&127)==64)?255:(s.panning&127)<<2;
q->length = s.length;
q->loopstart = s.loopbeg;
q->loopend = s.loopend;
q->volume = s.volume;
q->globvol = s.globvol;
q->seekpos = s.sampoffset;
/* Convert speed to XM linear finetune */
if(of.flags&UF_LINEAR)
q->speed=speed_to_finetune(s.c5spd,t);
if(s.panning&128) q->flags|=SF_OWNPAN;
if(s.vibrate) {
q->vibflags |= AV_IT;
q->vibtype = s.vibwave;
q->vibsweep = s.vibrate * 2;
q->vibdepth = s.vibdepth;
q->vibrate = s.vibspeed;
}
if(s.flag&2) q->flags|=SF_16BITS;
if((s.flag&8)&&(mh->cwt>=0x214)) {
q->flags|=SF_ITPACKED;
compressed=1;
}
if(s.flag&16) q->flags|=SF_LOOP;
if(s.flag&64) q->flags|=SF_BIDI;
if(mh->cwt>=0x200) {
if(s.convert&1) q->flags|=SF_SIGNED;
if(s.convert&4) q->flags|=SF_DELTA;
}
q++;
}
/* Load instruments if instrument mode flag enabled */
if(mh->flags&4) {
if(!AllocInstruments()) return 0;
d=of.instruments;
of.flags|=UF_NNA|UF_INST;
for(t=0;t<mh->insnum;t++) {
ITINSTHEADER ih;
/* seek to instrument position */
_mm_fseek(modreader,paraptr[t]+4,SEEK_SET);
/* load instrument info */
_mm_read_string(ih.filename,12,modreader);
ih.zerobyte = _mm_read_UBYTE(modreader);
if(mh->cwt<0x200) {
/* load IT 1.xx inst header */
ih.volflg = _mm_read_UBYTE(modreader);
ih.volbeg = _mm_read_UBYTE(modreader);
ih.volend = _mm_read_UBYTE(modreader);
ih.volsusbeg = _mm_read_UBYTE(modreader);
ih.volsusend = _mm_read_UBYTE(modreader);
_mm_read_I_UWORD(modreader);
ih.fadeout = _mm_read_I_UWORD(modreader);
ih.nna = _mm_read_UBYTE(modreader);
ih.dnc = _mm_read_UBYTE(modreader);
} else {
/* Read IT200+ header */
ih.nna = _mm_read_UBYTE(modreader);
ih.dct = _mm_read_UBYTE(modreader);
ih.dca = _mm_read_UBYTE(modreader);
ih.fadeout = _mm_read_I_UWORD(modreader);
ih.ppsep = _mm_read_UBYTE(modreader);
ih.ppcenter = _mm_read_UBYTE(modreader);
ih.globvol = _mm_read_UBYTE(modreader);
ih.chanpan = _mm_read_UBYTE(modreader);
ih.rvolvar = _mm_read_UBYTE(modreader);
ih.rpanvar = _mm_read_UBYTE(modreader);
}
ih.trkvers = _mm_read_I_UWORD(modreader);
ih.numsmp = _mm_read_UBYTE(modreader);
_mm_read_UBYTE(modreader);
_mm_read_string(ih.name,26,modreader);
_mm_read_UBYTES(ih.blank01,6,modreader);
_mm_read_I_UWORDS(ih.samptable,ITNOTECNT,modreader);
if(mh->cwt<0x200) {
/* load IT 1xx volume envelope */
_mm_read_UBYTES(ih.volenv,200,modreader);
for(lp=0;lp<ITENVCNT;lp++) {
ih.oldvoltick[lp] = _mm_read_UBYTE(modreader);
ih.volnode[lp] = _mm_read_UBYTE(modreader);
}
} else {
/* load IT 2xx volume, pan and pitch envelopes */
ih.volflg =_mm_read_UBYTE(modreader);
ih.volpts =_mm_read_UBYTE(modreader);
ih.volbeg =_mm_read_UBYTE(modreader);
ih.volend =_mm_read_UBYTE(modreader);
ih.volsusbeg=_mm_read_UBYTE(modreader);
ih.volsusend=_mm_read_UBYTE(modreader);
for(lp=0;lp<ITENVCNT;lp++) {
ih.volnode[lp]=_mm_read_UBYTE(modreader);
ih.voltick[lp]=_mm_read_I_UWORD(modreader);
}
_mm_read_UBYTE(modreader);
ih.panflg =_mm_read_UBYTE(modreader);
ih.panpts =_mm_read_UBYTE(modreader);
ih.panbeg =_mm_read_UBYTE(modreader);
ih.panend =_mm_read_UBYTE(modreader);
ih.pansusbeg=_mm_read_UBYTE(modreader);
ih.pansusend=_mm_read_UBYTE(modreader);
for(lp=0;lp<ITENVCNT;lp++) {
ih.pannode[lp]=_mm_read_SBYTE(modreader);
ih.pantick[lp]=_mm_read_I_UWORD(modreader);
}
_mm_read_UBYTE(modreader);
ih.pitflg =_mm_read_UBYTE(modreader);
ih.pitpts =_mm_read_UBYTE(modreader);
ih.pitbeg =_mm_read_UBYTE(modreader);
ih.pitend =_mm_read_UBYTE(modreader);
ih.pitsusbeg=_mm_read_UBYTE(modreader);
ih.pitsusend=_mm_read_UBYTE(modreader);
for(lp=0;lp < ITENVCNT; lp++) {
ih.pitnode[lp]=_mm_read_SBYTE(modreader);
ih.pittick[lp]=_mm_read_I_UWORD(modreader);
}
_mm_read_UBYTE(modreader);
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
d->volflg|=EF_VOLENV;
d->insname = DupStr(ih.name,26,0);
d->nnatype = ih.nna & NNA_MASK;
if(mh->cwt<0x200) {
d->volfade=ih.fadeout<< 6;
if(ih.dnc) {
d->dct=DCT_NOTE;
d->dca=DCA_CUT;
}
if(ih.volflg&1) d->volflg|=EF_ON;
if(ih.volflg&2) d->volflg|=EF_LOOP;
if(ih.volflg&4) d->volflg|=EF_SUSTAIN;
/* XM conversion of IT envelope Array */
d->volbeg = ih.volbeg;
d->volend = ih.volend;
d->volsusbeg = ih.volsusbeg;
d->volsusend = ih.volsusend;
if(ih.volflg&1) {
for(u=0;u<ITENVCNT;u++)
if(ih.oldvoltick[d->volpts]!=0xff) {
d->volenv[d->volpts].val=(ih.volnode[d->volpts]<<2);
d->volenv[d->volpts].pos=ih.oldvoltick[d->volpts];
d->volpts++;
} else
break;
}
} else {
d->panning=((ih.chanpan&127)==64)?255:(ih.chanpan&127)<<2;
if(!(ih.chanpan&128)) d->flags|=IF_OWNPAN;
if(!(ih.ppsep & 128)) {
d->pitpansep=ih.ppsep<<2;
d->pitpancenter=ih.ppcenter;
d->flags|=IF_PITCHPAN;
}
d->globvol=ih.globvol>>1;
d->volfade=ih.fadeout<<5;
d->dct =ih.dct;
d->dca =ih.dca;
if(mh->cwt>=0x204) {
d->rvolvar = ih.rvolvar;
d->rpanvar = ih.rpanvar;
}
if(ih.volflg&1) d->volflg|=EF_ON;
if(ih.volflg&2) d->volflg|=EF_LOOP;
if(ih.volflg&4) d->volflg|=EF_SUSTAIN;
d->volpts=ih.volpts;
d->volbeg=ih.volbeg;
d->volend=ih.volend;
d->volsusbeg=ih.volsusbeg;
d->volsusend=ih.volsusend;
for(u=0;u<ih.volpts;u++)
d->volenv[u].pos=ih.voltick[u]; if((d->volflg&EF_ON)&&(d->volpts<2))
d->volflg&=~EF_ON;
for(u=0;u<ih.volpts;u++)
d->volenv[u].val=(ih.volnode[u]<<2);
if(ih.panflg&1) d->panflg|=EF_ON;
if(ih.panflg&2) d->panflg|=EF_LOOP;
if(ih.panflg&4) d->panflg|=EF_SUSTAIN;
d->panpts=ih.panpts;
d->panbeg=ih.panbeg;
d->panend=ih.panend;
d->pansusbeg=ih.pansusbeg;
d->pansusend=ih.pansusend;
for(u=0;u<ih.panpts;u++)
d->panenv[u].pos=ih.pantick[u];
if((d->panflg&EF_ON)&&(d->panpts<2))
d->panflg&=~EF_ON;
for(u=0;u<ih.panpts;u++)
d->panenv[u].val=ih.pannode[u]==32?255:(ih.pannode[u]+32)<<2;
if(ih.pitflg&1) d->pitflg|=EF_ON;
if(ih.pitflg&2) d->pitflg|=EF_LOOP;
if(ih.pitflg&4) d->pitflg|=EF_SUSTAIN;
d->pitpts=ih.pitpts;
d->pitbeg=ih.pitbeg;
d->pitend=ih.pitend;
d->pitsusbeg=ih.pitsusbeg;
d->pitsusend=ih.pitsusend;
for(u=0;u<ih.pitpts;u++)
d->pitenv[u].pos=ih.pittick[u];
if((d->pitflg&EF_ON)&&(d->pitpts<2))
d->pitflg&=~EF_ON;
for(u=0;u<ih.pitpts;u++)
d->pitenv[u].val=ih.pitnode[u]+32;
if(ih.pitflg&0x80) {
/* filter envelopes not supported yet */
d->pitflg&=~EF_ON;
ih.pitpts=ih.pitbeg=ih.pitend=0;
#ifdef MIKMOD_DEBUG
{
static int warn=0;
if(!warn)
fputs("\rFilter envelopes not supported yet\n",stderr);
warn=1;
}
#endif
}
}
for(u=0;u<ITNOTECNT;u++) {
d->samplenote[u]=(ih.samptable[u]&255);
d->samplenumber[u]=
(ih.samptable[u]>>8)?((ih.samptable[u]>>8)-1):0xffff;
if(d->samplenumber[u]>=of.numsmp)
d->samplenote[u]=255;
else if (of.flags&UF_LINEAR) {
int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
d->samplenote[u]=(note<0)?0:(note>255?255:note);
}
}
d++;
}
} else if(of.flags & UF_LINEAR) {
BOOL
FAR_Load (BOOL curious)
{
int t, u, tracks = 0;
SAMPLE *q;
FARSAMPLE s;
FARNOTE *crow;
UBYTE smap[8];
/* try to read module header (first part) */
_mm_read_UBYTES (mh1->id, 4, modreader);
_mm_read_SBYTES (mh1->songname, 40, modreader);
_mm_read_SBYTES (mh1->blah, 3, modreader);
mh1->headerlen = _mm_read_I_UWORD (modreader);
mh1->version = _mm_read_UBYTE (modreader);
_mm_read_UBYTES (mh1->onoff, 16, modreader);
_mm_read_UBYTES (mh1->edit1, 9, modreader);
mh1->speed = _mm_read_UBYTE (modreader);
_mm_read_UBYTES (mh1->panning, 16, modreader);
_mm_read_UBYTES (mh1->edit2, 4, modreader);
mh1->stlen = _mm_read_I_UWORD (modreader);
/* init modfile data */
of.modtype = strdup (FAR_Version);
of.songname = DupStr (mh1->songname, 40, 1);
of.numchn = 16;
of.initspeed = mh1->speed;
of.inittempo = 80;
of.reppos = 0;
for (t = 0; t < 16; t++)
of.panning[t] = mh1->panning[t] << 4;
/* read songtext into comment field */
if (mh1->stlen)
if (!ReadComment (mh1->stlen))
return 0;
/* try to read module header (second part) */
_mm_read_UBYTES (mh2->orders, 256, modreader);
mh2->numpat = _mm_read_UBYTE (modreader);
mh2->snglen = _mm_read_UBYTE (modreader);
mh2->loopto = _mm_read_UBYTE (modreader);
_mm_read_I_UWORDS (mh2->patsiz, 256, modreader);
of.numpos = mh2->snglen;
if (!AllocPositions (of.numpos))
return 0;
for (t = 0; t < of.numpos; t++)
{
if (mh2->orders[t] == 0xff)
break;
of.positions[t] = mh2->orders[t];
}
/* count number of patterns stored in file */
of.numpat = 0;
for (t = 0; t < 256; t++)
if (mh2->patsiz[t])
if ((t + 1) > of.numpat)
of.numpat = t + 1;
of.numtrk = of.numpat * of.numchn;
/* seek across eventual new data */
_mm_fseek (modreader, mh1->headerlen - (869 + mh1->stlen), SEEK_CUR);
/* alloc track and pattern structures */
if (!AllocTracks ())
return 0;
if (!AllocPatterns ())
return 0;
for (t = 0; t < of.numpat; t++)
{
UBYTE rows = 0;
memset (pat, 0, 256 * 16 * 4 * sizeof (FARNOTE));
if (mh2->patsiz[t])
{
rows = _mm_read_UBYTE (modreader);
/* tempo = */ _mm_read_UBYTE (modreader);
crow = pat;
/* file often allocates 64 rows even if there are less in pattern */
if (mh2->patsiz[t] < 2 + (rows * 16 * 4))
{
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
for (u = (mh2->patsiz[t] - 2) / 4; u; u--, crow++)
{
crow->note = _mm_read_UBYTE (modreader);
crow->ins = _mm_read_UBYTE (modreader);
crow->vol = _mm_read_UBYTE (modreader);
crow->eff = _mm_read_UBYTE (modreader);
}
if (_mm_eof (modreader))
{
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
crow = pat;
of.pattrows[t] = rows;
for (u = 16; u; u--, crow++)
if (!(of.tracks[tracks++] = FAR_ConvertTrack (crow, rows)))
{
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
}
else
tracks += 16;
}
/* read sample map */
if (!_mm_read_UBYTES (smap, 8, modreader))
{
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* count number of samples used */
of.numins = 0;
for (t = 0; t < 64; t++)
if (smap[t >> 3] & (1 << (t & 7)))
of.numins = t + 1;
of.numsmp = of.numins;
/* alloc sample structs */
if (!AllocSamples ())
return 0;
q = of.samples;
for (t = 0; t < of.numsmp; t++)
{
q->speed = 8363;
q->flags = SF_SIGNED;
if (smap[t >> 3] & (1 << (t & 7)))
{
_mm_read_SBYTES (s.samplename, 32, modreader);
s.length = _mm_read_I_ULONG (modreader);
s.finetune = _mm_read_UBYTE (modreader);
s.volume = _mm_read_UBYTE (modreader);
s.reppos = _mm_read_I_ULONG (modreader);
s.repend = _mm_read_I_ULONG (modreader);
s.type = _mm_read_UBYTE (modreader);
s.loop = _mm_read_UBYTE (modreader);
q->samplename = DupStr (s.samplename, 32, 1);
q->length = s.length;
q->loopstart = s.reppos;
q->loopend = s.repend;
q->volume = s.volume << 2;
if (s.type & 1)
q->flags |= SF_16BITS;
if (s.loop & 8)
q->flags |= SF_LOOP;
q->seekpos = _mm_ftell (modreader);
_mm_fseek (modreader, q->length, SEEK_CUR);
}
else
q->samplename = DupStr (NULL, 0, 0);
q++;
}
static BOOL ULT_Load(void)
{
int t,u,tracks=0;
INSTRUMENT *d;
SAMPLE *q;
ULTSAMPLE s;
ULTHEADER mh;
UBYTE nos,noc,nop;
/* try to read module header */
_mm_read_str(mh.id,15);
_mm_read_str(mh.songtitle,32);
mh.reserved=_mm_read_UBYTE();
if(modpos > modsize){
gModPlayerErrorMessage=ERROR_LOADING_HEADER;
return 0;
}
if(mh.id[14]<'1' || mh.id[14]>'4'){
//printf("This version is not yet supported\n");
return 0;
}
of.modtype=strdup(ULT_Version[mh.id[14]-'1']);
of.initspeed=6;
of.inittempo=125;
/* read songtext */
if(!ReadComment((UWORD)(mh.reserved * 32))) return 0;
nos=_mm_read_UBYTE();
if(modpos > modsize){
gModPlayerErrorMessage=ERROR_LOADING_HEADER;
return 0;
}
of.songname=DupStr(mh.songtitle,32);
of.numins=nos;
if(!AllocInstruments()) return 0;
d=of.instruments;
for(t=0;t<nos;t++){
d->numsmp=1;
if(!AllocSamples(d)) return 0;
q=d->samples;
/* try to read sample info */
_mm_read_str(s.samplename,32);
_mm_read_str(s.dosname,12);
s.loopstart =_mm_read_I_ULONG();
s.loopend =_mm_read_I_ULONG();
s.sizestart =_mm_read_I_ULONG();
s.sizeend =_mm_read_I_ULONG();
s.volume =_mm_read_UBYTE();
s.flags =_mm_read_UBYTE();
s.finetune =_mm_read_I_SWORD();
if(modpos > modsize){
gModPlayerErrorMessage=ERROR_LOADING_SAMPLEINFO;
return 0;
}
d->insname=DupStr(s.samplename,32);
q->seekpos=0;
q->c2spd=8363;
if(mh.id[14]>='4'){
_mm_read_I_UWORD(); /* read 1.6 extra info(??) word */
q->c2spd=s.finetune;
}
q->length=s.sizeend-s.sizestart;
q->volume=s.volume>>2;
q->loopstart=s.loopstart;
q->loopend=s.loopend;
q->flags=SF_SIGNED;
if(s.flags&ULTS_LOOP){
q->flags|=SF_LOOP;
}
if(s.flags&ULTS_16BITS){
q->flags|=SF_16BITS;
q->loopstart>>=1;
q->loopend>>=1;
}
/* printf("Sample %d %s length %ld\n",t,d->samplename,d->length); */
d++;
}
char TNeuralNetBase::LoadPar()
{
#ifdef DEBUG
cout<<"TNeuralNetBase::LoadPar......."<<endl;//ddd
#endif
int errStatus = 0;
fstream pF;// = new ifstream();
sprintf(cBuf,PARFILE);
if (OpenFile(&pF,cBuf,ios::in)) return 1;
if (ReadComment(&pF)) return 1;
errStatus = loadOnePara( "NbTrials:", pF, NbTrials );
errStatus = loadOnePara( "RandomSeed:", pF, RandomSeed );
errStatus = loadOnePara( "MaxEpochs:", pF, MaxEpochs );
errStatus = loadOnePara( "AverageTrainBuf:", pF, AverageTrainBuf );
errStatus = loadOnePara( "MaxOnlineStreamLengthTrain:", pF, MaxOnlineStreamLengthTrain );
errStatus = loadOnePara( "MaxOnlineStreamLengthTest:", pF, MaxOnlineStreamLengthTest );
errStatus = loadOnePara( "EpochsAfterLearned:", pF, EpochsAfterLearned );
errStatus = loadOnePara( "MaxMSE:", pF, MaxMSE );
errStatus = loadOnePara( "MaxMSEGenTest:", pF, MaxMSEGenTest );
errStatus = loadOnePara( "MSEStop:", pF, MSEStop );
errStatus = loadOnePara( "WinnerTakesAll:", pF, WinnerTakesAll );
errStatus = loadOnePara( "TestEach_Epo:", pF, TestEach_Epo );
errStatus = loadOnePara( "TestMaxEach_Epo:", pF, TestMaxEach_Epo );
errStatus = loadOnePara( "TestMinEach_Epo:", pF, TestMinEach_Epo );
errStatus = loadOnePara( "TestEpochs:", pF, TestEpochs );
errStatus = loadOnePara( "DumpBestNotLastTest:", pF, DumpBestNotLastTest );
errStatus = loadOnePara( "AlphaBase:", pF, AlphaBase );
errStatus = loadOnePara( "Alpha_ROH:", pF, Alpha_ROH );
errStatus = loadOnePara( "Alpha_MUE:", pF, Alpha_MUE );
errStatus = loadOnePara( "AlphaError:", pF, AlphaError );
errStatus = loadOnePara( "SetStepTarget:", pF, SetStepTarget );
errStatus = loadOnePara( "AllTimeTarget:", pF, AllTimeTarget );
errStatus = loadOnePara( "NoClassesOnlyPredict:", pF, NoClassesOnlyPredict );
errStatus = loadOnePara( "PredictionOffset:", pF, PredictionOffset );
errStatus = loadOnePara( "PredictAllUntilOffset:", pF, PredictAllUntilOffset );
errStatus = loadOnePara( "PredictDiff:", pF, PredictDiff );
errStatus = loadOnePara( "PredictOnlyDiff:", pF, PredictOnlyDiff );
errStatus = loadOnePara( "RandomPrediction:", pF, RandomPrediction );
errStatus = loadOnePara( "Reverse_Input:", pF, Reverse_Input );
errStatus = loadOnePara( "ClampOutPredictSteps:", pF, ClampOutPredictSteps );
errStatus = loadOnePara( "ClampOutTrainPredictSteps:", pF, ClampOutTrainPredictSteps );
errStatus = loadOnePara( "TimeWindowSize:", pF, TimeWindowSize );
errStatus = loadOnePara( "TimeWindowStepSize:", pF, TimeWindowStepSize );
errStatus = loadOnePara( "NoResetBeforeTest:", pF, NoResetBeforeTest );
errStatus = loadOnePara( "GrowNet:", pF, GrowNet );
errStatus = loadOnePara( "FreezeAndGrow:", pF, FreezeAndGrow );
errStatus = loadOnePara( "GrowFullyNotCascade:", pF, GrowFullyNotCascade );
errStatus = loadOnePara( "GrowFirstOrder:", pF, GrowFirstOrder );
errStatus = loadOnePara( "LogErrRecSize:", pF, LogErrRecSize );
errStatus = loadOnePara( "PartLogErrRecSize:", pF, PartLogErrRecSize );
errStatus = loadOnePara( "TRAINPATFILE:", pF, cTrainPatFilename );
errStatus = loadOnePara( "TESTPATFILE:", pF, cTestPatFilename );
errStatus = loadOnePara( "MixTrainSeqs:", pF, MixTrainSeqs );
errStatus = loadOnePara( "Generate_Pat:", pF, Generate_Pat );
errStatus = loadOnePara( "Generate_Pat_Each_Epoch:", pF, Generate_Pat_Each_Epoch );
errStatus = loadOnePara( "Generate_Pat_NbLoopAllSeqs_Test:", pF, Generate_Pat_NbLoopAllSeqs_Test );
errStatus = loadOnePara( "Generate_Pat_NbLoopAllSeqs_Train:", pF, Generate_Pat_NbLoopAllSeqs_Train );
errStatus = loadOnePara( "Test_Generalize:", pF, Test_Generalize );
errStatus = loadOnePara( "Pat_FuncName:", pF, Pat_FuncName );
errStatus = loadOnePara( "NbIn:", pF, NbIn );
errStatus = loadOnePara( "NbOut:", pF, NbOut );
errStatus = loadOnePara( "NbStatOut:", pF, NbStatOut );
errStatus = loadOnePara( "NbHidden:", pF, NbHidden );
errStatus = loadOnePara( "InitWeightRange:", pF, InitWeightRange );
errStatus = loadOnePara( "OutUnitBiasInitWeight:", pF, OutUnitBiasInitWeight );
errStatus = loadOnePara( "InOutBiasForMatchingUnits:", pF, InOutBiasForMatchingUnits );
errStatus = loadOnePara( "HiddenUnitBiasInitWeight:", pF, HiddenUnitBiasInitWeight );
// cout<<"HiddenUnitBiasInitWeight:"<<HiddenUnitBiasInitWeight<<endl;//ddd
// cout<<"NbOut:"<<NbOut<<endl;//ddd
// cout<<"NbStatOut:"<<NbStatOut<<endl;//ddd
// cout<<"TNeuralNetBase::LoadPar done.\n"<<endl;//ddd
CloseFile(&pF);
return errStatus;
}
/**********************************************************************************************
* NextToken
*********************************************************************************************/
XMLScanner::TOKEN XMLScanner::NextToken () {
if (state == STATE_STREAM_END)
return TOKEN_STREAM_END;
do {
switch (state) {
/* Content */
case STATE_CONTENT:
switch (current) {
/* Element tag */
case '<' :
state = STATE_ELEMENT_TAG;
if (! output.isEmpty ()) {
// TODO : check for whitespace only elements ...
return TOKEN_CHARACTER_DATA;
}
break;
case '&' :
ReadReference ();
break;
case ']' :
/* checks for invalid CDATA section end */
ReadCharacter ();
if (current == ']') {
ReadCharacter ();
if (current == '>') {
ReadCharacter ();
throw IllegalCharacterException ();
} else {
output.Append (']');
output.Append (']');
output.Append (current);
}
} else {
output.Append (']');
output.Append (current);
}
break;
default :
output.Append (current);
break;
}
break;
/* Element Tag */
case STATE_ELEMENT_START_OPENING:
if (current == '!') {
ReadCharacter ();
state = STATE_SPECIAL_ELEMENT;
} else if (current == '?') {
ReadCharacter ();
state = STATE_CONTENT;
return ReadProcessingInstruction ();
} else if (current == '/') {
ReadCharacter ();
state = STATE_ELEMENT_END_NAME;
return TOKEN_ELEMENT_END_TAG;
} else if (isNameFirst (current)) {
state = STATE_ELEMENT_START_NAME;
return TOKEN_ELEMENT_START_OPENING;
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* Special elements (comments and CDATA sections etc ...) */
/* '<!' ... */
case STATE_SPECIAL_ELEMENT:
if (current == '-') {
ReadComment ();
} else if (current == '[') {
ReadCDATASection ();
} else {
throw UnsupportedFeatureException (position);
}
state = STATE_CONTENT;
break;
/* Element start name target */
/* '<' ... */
case STATE_ELEMENT_START_NAME:
if (isNameFirst (current)) {
state = STATE_ELEMENT_ATTRIBUTES_START;
return ReadQualifiedName ();
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* Element start name target */
/* '</' ... */
case STATE_ELEMENT_END_NAME:
if (isNameFirst (current)) {
state = STATE_ELEMENT_END_TAG;
return ReadQualifiedName ();
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* Attributes */
case STATE_ATTRIBUTES_START:
if (isWhitespace (current)) {
state = STATE_ATTRIBUTES;
} else if (current == '/') {
state = STATE_ELEMENT_END_CLOSING;
} else if (current == '>') {
state = STATE_CONTENT;
return TOKEN_ELEMENT_START_CLOSING;
} else {
throw UnexpectedCharacterException (previous);
}
break;
/* '<' QualifiedName ... */
case STATE_ATTRIBUTES :
if (isWhitespace (current)) {
break;
} else if (isNameFirst (current)) {
state = STATE_ATTRIBUTE_EQUAL;
return ReadQualifiedName ();
} else {
throw UnexpectedCharacterException (previous);
}
break;
case STATE_ELEMENT_END_CLOSING:
if (current == '>') {
state = STATE_CONTENT;
return TOKEN_ELEMENT_END_CLOSING;
} else {
throw UnexpectedCharacterException (previous);
}
break;
case STATE_ATTRIBUTE_EQUAL:
if (current == '\'' || current == '\"') {
state = STATE_ATTRIBUTES_START;
return ReadLiteral ();
}
break;
case STATE_ELEMENT_END_TAG:
if (current == '>') {
state = STATE_CONTENT;
return TOKEN_ELEMENT_END_TAG_CLOSING;
}
break;
}
} while (ReadCharacter ());
/* Stream end */
return TOKEN_STREAM_END;
}
void ReadChunks()
{
Context context;
while (!stream.Eof())
{
dword id = stream.Read32();
const dword length = stream.Read32();
NST_VERIFY( length <= SIZE_1K * 4096UL );
switch (id)
{
case AsciiId<'N','A','M','E'>::V: id = (context( 0, id ) ? ReadName ( ) : 0); break;
case AsciiId<'R','E','A','D'>::V: id = (context( 1, id ) ? ReadComment ( ) : 0); break;
case AsciiId<'D','I','N','F'>::V: id = (context( 2, id ) ? ReadDumper ( ) : 0); break;
case AsciiId<'T','V','C','I'>::V: id = (context( 3, id ) ? ReadSystem ( context ) : 0); break;
case AsciiId<'B','A','T','R'>::V: id = (context( 4, id ) ? ReadBattery ( ) : 0); break;
case AsciiId<'M','A','P','R'>::V: id = (context( 5, id ) ? ReadBoard ( ) : 0); break;
case AsciiId<'M','I','R','R'>::V: id = (context( 6, id ) ? ReadMirroring ( ) : 0); break;
case AsciiId<'C','T','R','L'>::V: id = (context( 7, id ) ? ReadController ( ) : 0); break;
case AsciiId<'V','R','O','R'>::V: id = (context( 8, id ) ? ReadChrRam ( ) : 0); break;
default: switch (id & 0x00FFFFFF)
{
case AsciiId<'P','C','K'>::V:
case AsciiId<'C','C','K'>::V:
case AsciiId<'P','R','G'>::V:
case AsciiId<'C','H','R'>::V:
{
uint index = id >> 24 & 0xFF;
if (index >= Ascii<'0'>::V && index <= Ascii<'9'>::V)
{
index -= Ascii<'0'>::V;
}
else if (index >= Ascii<'A'>::V && index <= Ascii<'F'>::V)
{
index = index - Ascii<'A'>::V + 10;
}
else
{
index = ~0U;
}
if (index < 16)
{
switch (dword part = (id & 0x00FFFFFF))
{
case AsciiId<'P','C','K'>::V:
case AsciiId<'C','C','K'>::V:
part = (part == AsciiId<'C','C','K'>::V);
id = (context( 9 + (part << 4) + index, id) ? ReadChecksum( part, index, context.roms[part][index] ) : 0);
break;
case AsciiId<'P','R','G'>::V:
case AsciiId<'C','H','R'>::V:
part = (part == AsciiId<'C','H','R'>::V);
id = (context( 9 + 32 + (part << 4) + index, id ) ? ReadRom( part, index, length, context.roms[part] ) : 0);
break;
}
break;
}
}
default:
id = ReadUnknown( id );
break;
}
}
if (id < length)
{
for (id = length - id; id > 0x7FFFFFFF; id -= 0x7FFFFFFF)
stream.Seek( 0x7FFFFFFF );
if (id)
stream.Seek( id );
}
else if (id > length)
{
throw RESULT_ERR_CORRUPT_FILE;
}
}
for (uint i=0; i < 2; ++i)
{
uint count = 0;
dword size = 0;
for (uint j=0; j < 16; ++j)
{
if (const dword n=context.roms[i][j].data.Size())
{
count++;
size += n;
}
}
if (count)
{
Profile::Board::Roms& rom = (i ? profile.board.chr : profile.board.prg);
rom.resize( count );
Ram& dst = (i ? chr : prg);
dst.Set( size );
if (!rom.empty())
{
for (Profile::Board::Pins::const_iterator it(rom.front().pins.begin()), end(rom.front().pins.end()); it != end; ++it)
dst.Pin(it->number) = it->function.c_str();
}
size = 0;
for (uint j=0, k=0; j < 16; ++j)
{
const Context::Rom& src = context.roms[i][j];
if (src.data.Size())
{
rom[k].id = k;
rom[k].size = src.data.Size();
rom[k].hash.Assign( NULL, src.crc );
k++;
std::memcpy( dst.Mem(size), src.data.Mem(), src.data.Size() );
size += src.data.Size();
}
}
}
}
if (profileEx.nmt == ProfileEx::NMT_HORIZONTAL)
{
profile.board.solderPads = Profile::Board::SOLDERPAD_V;
}
else if (profileEx.nmt == ProfileEx::NMT_HORIZONTAL)
{
profile.board.solderPads = Profile::Board::SOLDERPAD_H;
}
switch (context.system)
{
case Context::SYSTEM_NTSC:
if (favoredSystem == FAVORED_FAMICOM)
{
profile.system.type = Profile::System::FAMICOM;
}
if (favoredSystem == FAVORED_DENDY)
{
profile.system.type = Profile::System::DENDY;
profile.system.cpu = Profile::System::CPU_DENDY;
profile.system.ppu = Profile::System::PPU_DENDY;
}
else
{
profile.system.type = Profile::System::NES_NTSC;
}
break;
default:
profile.multiRegion = true;
if (favoredSystem == FAVORED_FAMICOM)
{
profile.system.type = Profile::System::FAMICOM;
break;
}
else if (favoredSystem != FAVORED_NES_PAL && favoredSystem != FAVORED_DENDY)
{
profile.system.type = Profile::System::NES_NTSC;
break;
}
case Context::SYSTEM_PAL:
if (favoredSystem == FAVORED_DENDY)
{
profile.system.type = Profile::System::DENDY;
profile.system.cpu = Profile::System::CPU_DENDY;
profile.system.ppu = Profile::System::PPU_DENDY;
}
else
{
profile.system.type = Profile::System::NES_PAL;
profile.system.cpu = Profile::System::CPU_RP2A07;
profile.system.ppu = Profile::System::PPU_RP2C07;
}
break;
}
}
