--- /dev/null
+/* MikMod sound library\r
+ (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file\r
+ AUTHORS for complete list.\r
+\r
+ This library is free software; you can redistribute it and/or modify\r
+ it under the terms of the GNU Library General Public License as\r
+ published by the Free Software Foundation; either version 2 of\r
+ the License, or (at your option) any later version.\r
+\r
+ This program is distributed in the hope that it will be useful,\r
+ but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ GNU Library General Public License for more details.\r
+\r
+ You should have received a copy of the GNU Library General Public\r
+ License along with this library; if not, write to the Free Software\r
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA\r
+ 02111-1307, USA.\r
+*/\r
+\r
+/*==============================================================================\r
+\r
+ $Id: load_imf.c,v 1.2 2004/02/06 19:29:03 raph Exp $\r
+\r
+ Imago Orpheus (IMF) module loader\r
+\r
+==============================================================================*/\r
+\r
+#ifdef HAVE_CONFIG_H\r
+#include "config.h"\r
+#endif\r
+\r
+#ifdef HAVE_UNISTD_H\r
+#include <unistd.h>\r
+#endif\r
+\r
+#include <stdio.h>\r
+#ifdef HAVE_MEMORY_H\r
+#include <memory.h>\r
+#endif\r
+#include <string.h>\r
+\r
+#include "mikmod_internals.h"\r
+\r
+#ifdef SUNOS\r
+extern int fprintf(FILE *, const char *, ...);\r
+#endif\r
+\r
+/*========== Module structure */\r
+\r
+/* module header */\r
+typedef struct IMFHEADER {\r
+ CHAR songname[32];\r
+ UWORD ordnum;\r
+ UWORD patnum;\r
+ UWORD insnum;\r
+ UWORD flags;\r
+ UBYTE initspeed;\r
+ UBYTE inittempo;\r
+ UBYTE mastervol;\r
+ UBYTE mastermult;\r
+ UBYTE orders[256];\r
+} IMFHEADER;\r
+\r
+/* channel settings */\r
+typedef struct IMFCHANNEL {\r
+ CHAR name[12];\r
+ UBYTE chorus;\r
+ UBYTE reverb;\r
+ UBYTE pan;\r
+ UBYTE status;\r
+} IMFCHANNEL;\r
+\r
+/* instrument header */\r
+#define IMFNOTECNT (10*OCTAVE)\r
+#define IMFENVCNT (16*2)\r
+typedef struct IMFINSTHEADER {\r
+ CHAR name[32];\r
+ UBYTE what[IMFNOTECNT];\r
+ UWORD volenv[IMFENVCNT];\r
+ UWORD panenv[IMFENVCNT];\r
+ UWORD pitenv[IMFENVCNT];\r
+ UBYTE volpts;\r
+ UBYTE volsus;\r
+ UBYTE volbeg;\r
+ UBYTE volend;\r
+ UBYTE volflg;\r
+ UBYTE panpts;\r
+ UBYTE pansus;\r
+ UBYTE panbeg;\r
+ UBYTE panend;\r
+ UBYTE panflg;\r
+ UBYTE pitpts;\r
+ UBYTE pitsus;\r
+ UBYTE pitbeg;\r
+ UBYTE pitend;\r
+ UBYTE pitflg;\r
+ UWORD volfade;\r
+ UWORD numsmp;\r
+ ULONG signature;\r
+} IMFINSTHEADER;\r
+\r
+/* sample header */\r
+typedef struct IMFWAVHEADER {\r
+ CHAR samplename[13];\r
+ ULONG length;\r
+ ULONG loopstart;\r
+ ULONG loopend;\r
+ ULONG samplerate;\r
+ UBYTE volume;\r
+ UBYTE pan;\r
+ UBYTE flags;\r
+} IMFWAVHEADER;\r
+\r
+typedef struct IMFNOTE {\r
+ UBYTE note,ins,eff1,dat1,eff2,dat2;\r
+} IMFNOTE;\r
+\r
+/*========== Loader variables */\r
+\r
+static CHAR IMF_Version[]="Imago Orpheus";\r
+\r
+static IMFNOTE *imfpat=NULL;\r
+static IMFHEADER *mh=NULL;\r
+\r
+/*========== Loader code */\r
+\r
+BOOL IMF_Test(void)\r
+{\r
+ UBYTE id[4];\r
+\r
+ _mm_fseek(modreader,0x3c,SEEK_SET);\r
+ if(!_mm_read_UBYTES(id,4,modreader)) return 0;\r
+ if(!memcmp(id,"IM10",4)) return 1;\r
+ return 0;\r
+}\r
+\r
+BOOL IMF_Init(void)\r
+{\r
+ if(!(imfpat=(IMFNOTE*)_mm_malloc(32*256*sizeof(IMFNOTE)))) return 0;\r
+ if(!(mh=(IMFHEADER*)_mm_malloc(sizeof(IMFHEADER)))) return 0;\r
+\r
+ return 1;\r
+}\r
+\r
+void IMF_Cleanup(void)\r
+{\r
+ FreeLinear();\r
+\r
+ _mm_free(imfpat);\r
+ _mm_free(mh);\r
+}\r
+\r
+static BOOL IMF_ReadPattern(SLONG size,UWORD rows)\r
+{\r
+ int row=0,flag,ch;\r
+ IMFNOTE *n,dummy;\r
+\r
+ /* clear pattern data */\r
+ memset(imfpat,255,32*256*sizeof(IMFNOTE));\r
+\r
+ while((size>0)&&(row<rows)) {\r
+ flag=_mm_read_UBYTE(modreader);size--;\r
+\r
+ if(_mm_eof(modreader)) {\r
+ _mm_errno=MMERR_LOADING_PATTERN;\r
+ return 0;\r
+ }\r
+\r
+ if(flag) {\r
+ ch=remap[flag&31];\r
+\r
+ if(ch!=-1)\r
+ n=&imfpat[256*ch+row];\r
+ else\r
+ n=&dummy;\r
+\r
+ if(flag&32) {\r
+ n->note=_mm_read_UBYTE(modreader);\r
+ if(n->note>=0xa0) n->note=0xa0; /* note off */\r
+ n->ins =_mm_read_UBYTE(modreader);\r
+ size-=2;\r
+ }\r
+ if(flag&64) {\r
+ size-=2;\r
+ n->eff2=_mm_read_UBYTE(modreader);\r
+ n->dat2=_mm_read_UBYTE(modreader);\r
+ }\r
+ if(flag&128) {\r
+ n->eff1=_mm_read_UBYTE(modreader);\r
+ n->dat1=_mm_read_UBYTE(modreader);\r
+ size-=2;\r
+ }\r
+ } else row++;\r
+ }\r
+ if((size)||(row!=rows)) {\r
+ _mm_errno=MMERR_LOADING_PATTERN;\r
+ return 0;\r
+ }\r
+ return 1;\r
+}\r
+\r
+static void IMF_ProcessCmd(UBYTE eff,UBYTE inf)\r
+{\r
+ if((eff)&&(eff!=255))\r
+ switch (eff) {\r
+ case 0x01: /* set tempo */\r
+ UniEffect(UNI_S3MEFFECTA,inf);\r
+ break;\r
+ case 0x02: /* set BPM */\r
+ if(inf>=0x20) UniEffect(UNI_S3MEFFECTT,inf);\r
+ break;\r
+ case 0x03: /* tone portamento */\r
+ UniEffect(UNI_ITEFFECTG,inf);\r
+ break;\r
+ case 0x04: /* porta + volslide */\r
+ UniEffect(UNI_ITEFFECTG,inf);\r
+ UniEffect(UNI_S3MEFFECTD,0);\r
+ break;\r
+ case 0x05: /* vibrato */\r
+ UniEffect(UNI_XMEFFECT4,inf);\r
+ break;\r
+ case 0x06: /* vibrato + volslide */\r
+ UniEffect(UNI_XMEFFECT6,inf);\r
+ break;\r
+ case 0x07: /* fine vibrato */\r
+ UniEffect(UNI_ITEFFECTU,inf);\r
+ break;\r
+ case 0x08: /* tremolo */\r
+ UniEffect(UNI_S3MEFFECTR,inf);\r
+ break;\r
+ case 0x09: /* arpeggio */\r
+ UniPTEffect(0x0,inf);\r
+ break;\r
+ case 0x0a: /* panning */\r
+ UniPTEffect(0x8,(inf>=128)?255:(inf<<1));\r
+ break;\r
+ case 0x0b: /* pan slide */\r
+ UniEffect(UNI_XMEFFECTP,inf);\r
+ break;\r
+ case 0x0c: /* set channel volume */\r
+ if(inf<=64) UniPTEffect(0xc,inf);\r
+ break;\r
+ case 0x0d: /* volume slide */\r
+ UniEffect(UNI_S3MEFFECTD,inf);\r
+ break;\r
+ case 0x0e: /* fine volume slide */\r
+ if(inf) {\r
+ if(inf>>4)\r
+ UniEffect(UNI_S3MEFFECTD,0x0f|inf);\r
+ else\r
+ UniEffect(UNI_S3MEFFECTD,0xf0|inf);\r
+ } else\r
+ UniEffect(UNI_S3MEFFECTD,0);\r
+ break;\r
+ case 0x0f: /* set finetune */\r
+ UniPTEffect(0xe,0x50|(inf>>4));\r
+ break;\r
+#ifdef MIKMOD_DEBUG\r
+ case 0x10: /* note slide up */\r
+ case 0x11: /* not slide down */\r
+ fprintf(stderr,"\rIMF effect 0x10/0x11 (note slide)"\r
+ " not implemented (eff=%2X inf=%2X)\n",eff,inf);\r
+ break;\r
+#endif\r
+ case 0x12: /* slide up */\r
+ UniEffect(UNI_S3MEFFECTF,inf);\r
+ break;\r
+ case 0x13: /* slide down */\r
+ UniEffect(UNI_S3MEFFECTE,inf);\r
+ break;\r
+ case 0x14: /* fine slide up */\r
+ if (inf) {\r
+ if (inf<0x40)\r
+ UniEffect(UNI_S3MEFFECTF,0xe0|(inf>>2));\r
+ else\r
+ UniEffect(UNI_S3MEFFECTF,0xf0|(inf>>4));\r
+ } else\r
+ UniEffect(UNI_S3MEFFECTF,0);\r
+ break;\r
+ case 0x15: /* fine slide down */\r
+ if (inf) {\r
+ if (inf<0x40)\r
+ UniEffect(UNI_S3MEFFECTE,0xe0|(inf>>2));\r
+ else\r
+ UniEffect(UNI_S3MEFFECTE,0xf0|(inf>>4));\r
+ } else\r
+ UniEffect(UNI_S3MEFFECTE,0);\r
+ break;\r
+ /* 0x16 set filter cutoff (awe32) */\r
+ /* 0x17 filter side + resonance (awe32) */\r
+ case 0x18: /* sample offset */\r
+ UniPTEffect(0x9,inf);\r
+ break;\r
+#ifdef MIKMOD_DEBUG\r
+ case 0x19: /* set fine sample offset */\r
+ fprintf(stderr,"\rIMF effect 0x19 (fine sample offset)"\r
+ " not implemented (inf=%2X)\n",inf);\r
+ break;\r
+#endif\r
+ case 0x1a: /* keyoff */\r
+ UniWriteByte(UNI_KEYOFF);\r
+ break;\r
+ case 0x1b: /* retrig */\r
+ UniEffect(UNI_S3MEFFECTQ,inf);\r
+ break;\r
+ case 0x1c: /* tremor */\r
+ UniEffect(UNI_S3MEFFECTI,inf);\r
+ break;\r
+ case 0x1d: /* position jump */\r
+ UniPTEffect(0xb,inf);\r
+ break;\r
+ case 0x1e: /* pattern break */\r
+ UniPTEffect(0xd,(inf>>4)*10+(inf&0xf));\r
+ break;\r
+ case 0x1f: /* set master volume */\r
+ if(inf<=64) UniEffect(UNI_XMEFFECTG,inf<<1);\r
+ break;\r
+ case 0x20: /* master volume slide */\r
+ UniEffect(UNI_XMEFFECTH,inf);\r
+ break;\r
+ case 0x21: /* extended effects */\r
+ switch(inf>>4) {\r
+ case 0x1: /* set filter */\r
+ case 0x5: /* vibrato waveform */\r
+ case 0x8: /* tremolo waveform */\r
+ UniPTEffect(0xe,inf-0x10);\r
+ break;\r
+ case 0xa: /* pattern loop */\r
+ UniPTEffect(0xe,0x60|(inf&0xf));\r
+ break;\r
+ case 0xb: /* pattern delay */\r
+ UniPTEffect(0xe,0xe0|(inf&0xf));\r
+ break;\r
+ case 0x3: /* glissando */\r
+ case 0xc: /* note cut */\r
+ case 0xd: /* note delay */\r
+ case 0xf: /* invert loop */\r
+ UniPTEffect(0xe,inf);\r
+ break;\r
+ case 0xe: /* ignore envelope */\r
+ UniEffect(UNI_ITEFFECTS0, 0x77); /* vol */\r
+ UniEffect(UNI_ITEFFECTS0, 0x79); /* pan */\r
+ UniEffect(UNI_ITEFFECTS0, 0x7b); /* pit */\r
+ break;\r
+ }\r
+ break;\r
+ /* 0x22 chorus (awe32) */\r
+ /* 0x23 reverb (awe32) */\r
+ }\r
+}\r
+\r
+static UBYTE* IMF_ConvertTrack(IMFNOTE* tr,UWORD rows)\r
+{\r
+ int t;\r
+ UBYTE note,ins;\r
+\r
+ UniReset();\r
+ for(t=0;t<rows;t++) {\r
+ note=tr[t].note;\r
+ ins=tr[t].ins;\r
+\r
+ if((ins)&&(ins!=255)) UniInstrument(ins-1);\r
+ if(note!=255) {\r
+ if(note==0xa0) {\r
+ UniPTEffect(0xc,0); /* Note cut */\r
+ if(tr[t].eff1==0x0c) tr[t].eff1=0;\r
+ if(tr[t].eff2==0x0c) tr[t].eff2=0;\r
+ } else\r
+ UniNote(((note>>4)*OCTAVE)+(note&0xf));\r
+ }\r
+\r
+ IMF_ProcessCmd(tr[t].eff1,tr[t].dat1);\r
+ IMF_ProcessCmd(tr[t].eff2,tr[t].dat2);\r
+ UniNewline();\r
+ }\r
+ return UniDup();\r
+}\r
+\r
+BOOL IMF_Load(BOOL curious)\r
+{\r
+#define IMF_SMPINCR 64\r
+ int t,u,track=0,oldnumsmp;\r
+ IMFCHANNEL channels[32];\r
+ INSTRUMENT *d;\r
+ SAMPLE *q;\r
+ IMFWAVHEADER *wh=NULL,*s=NULL;\r
+ ULONG *nextwav=NULL;\r
+ UWORD wavcnt=0;\r
+ UBYTE id[4];\r
+ (void)curious;\r
+\r
+ /* try to read the module header */\r
+ _mm_read_string(mh->songname,32,modreader);\r
+ mh->ordnum=_mm_read_I_UWORD(modreader);\r
+ mh->patnum=_mm_read_I_UWORD(modreader);\r
+ mh->insnum=_mm_read_I_UWORD(modreader);\r
+ mh->flags =_mm_read_I_UWORD(modreader);\r
+ _mm_fseek(modreader,8,SEEK_CUR);\r
+ mh->initspeed =_mm_read_UBYTE(modreader);\r
+ mh->inittempo =_mm_read_UBYTE(modreader);\r
+ mh->mastervol =_mm_read_UBYTE(modreader);\r
+ mh->mastermult=_mm_read_UBYTE(modreader);\r
+ _mm_fseek(modreader,64,SEEK_SET);\r
+\r
+ if(_mm_eof(modreader)) {\r
+ _mm_errno = MMERR_LOADING_HEADER;\r
+ return 0;\r
+ }\r
+\r
+ /* set module variables */\r
+ of.songname=DupStr(mh->songname,31,1);\r
+ of.modtype=strdup(IMF_Version);\r
+ of.numpat=mh->patnum;\r
+ of.numins=mh->insnum;\r
+ of.reppos=0;\r
+ of.initspeed=mh->initspeed;\r
+ of.inittempo=mh->inittempo;\r
+ of.initvolume=mh->mastervol<<1;\r
+ of.flags |= UF_INST | UF_ARPMEM | UF_PANNING;\r
+ if(mh->flags&1) of.flags |= UF_LINEAR;\r
+ of.bpmlimit=32;\r
+\r
+ /* read channel information */\r
+ of.numchn=0;\r
+ memset(remap,-1,32*sizeof(UBYTE));\r
+ for(t=0;t<32;t++) {\r
+ _mm_read_string(channels[t].name,12,modreader);\r
+ channels[t].chorus=_mm_read_UBYTE(modreader);\r
+ channels[t].reverb=_mm_read_UBYTE(modreader);\r
+ channels[t].pan =_mm_read_UBYTE(modreader);\r
+ channels[t].status=_mm_read_UBYTE(modreader);\r
+ }\r
+ /* bug in Imago Orpheus ? If only channel 1 is enabled, in fact we have to\r
+ enable 16 channels */\r
+ if(!channels[0].status) {\r
+ for(t=1;t<16;t++) if(channels[t].status!=1) break;\r
+ if(t==16) for(t=1;t<16;t++) channels[t].status=0;\r
+ }\r
+ for(t=0;t<32;t++) {\r
+ if(channels[t].status!=2)\r
+ remap[t]=of.numchn++;\r
+ else\r
+ remap[t]=-1;\r
+ }\r
+ for(t=0;t<32;t++)\r
+ if(remap[t]!=-1) {\r
+ of.panning[remap[t]]=channels[t].pan;\r
+ of.chanvol[remap[t]]=channels[t].status?0:64;\r
+ }\r
+\r
+ if(_mm_eof(modreader)) {\r
+ _mm_errno = MMERR_LOADING_HEADER;\r
+ return 0;\r
+ }\r
+\r
+ /* read order list */\r
+ _mm_read_UBYTES(mh->orders,256,modreader);\r
+ if(_mm_eof(modreader)) {\r
+ _mm_errno = MMERR_LOADING_HEADER;\r
+ return 0;\r
+ }\r
+\r
+ of.numpos=0;\r
+ for(t=0;t<mh->ordnum;t++)\r
+ if(mh->orders[t]!=0xff) of.numpos++;\r
+ if(!AllocPositions(of.numpos)) return 0;\r
+ for(t=u=0;t<mh->ordnum;t++)\r
+ if(mh->orders[t]!=0xff) of.positions[u++]=mh->orders[t];\r
+\r
+ /* load pattern info */\r
+ of.numtrk=of.numpat*of.numchn;\r
+ if(!AllocTracks()) return 0;\r
+ if(!AllocPatterns()) return 0;\r
+\r
+ for(t=0;t<of.numpat;t++) {\r
+ SLONG size;\r
+ UWORD rows;\r
+\r
+ size=(SLONG)_mm_read_I_UWORD(modreader);\r
+ rows=_mm_read_I_UWORD(modreader);\r
+ if((rows>256)||(size<4)) {\r
+ _mm_errno=MMERR_LOADING_PATTERN;\r
+ return 0;\r
+ }\r
+\r
+ of.pattrows[t]=rows;\r
+ if(!IMF_ReadPattern(size-4,rows)) return 0;\r
+ for(u=0;u<of.numchn;u++)\r
+ if(!(of.tracks[track++]=IMF_ConvertTrack(&imfpat[u*256],rows)))\r
+ return 0;\r
+ }\r
+\r
+ /* load instruments */\r
+ if(!AllocInstruments()) return 0;\r
+ d=of.instruments;\r
+\r
+ for(oldnumsmp=t=0;t<of.numins;t++) {\r
+ IMFINSTHEADER ih;\r
+\r
+ memset(d->samplenumber,0xff,INSTNOTES*sizeof(UWORD));\r
+\r
+ /* read instrument header */\r
+ _mm_read_string(ih.name,32,modreader);\r
+ d->insname=DupStr(ih.name,31,1);\r
+ _mm_read_UBYTES(ih.what,IMFNOTECNT,modreader);\r
+ _mm_fseek(modreader,8,SEEK_CUR);\r
+ _mm_read_I_UWORDS(ih.volenv,IMFENVCNT,modreader);\r
+ _mm_read_I_UWORDS(ih.panenv,IMFENVCNT,modreader);\r
+ _mm_read_I_UWORDS(ih.pitenv,IMFENVCNT,modreader);\r
+\r
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C\r
+#define IMF_FinishLoadingEnvelope(name) \\r
+ ih. name##pts=_mm_read_UBYTE(modreader); \\r
+ ih. name##sus=_mm_read_UBYTE(modreader); \\r
+ ih. name##beg=_mm_read_UBYTE(modreader); \\r
+ ih. name##end=_mm_read_UBYTE(modreader); \\r
+ ih. name##flg=_mm_read_UBYTE(modreader); \\r
+ _mm_read_UBYTE(modreader); \\r
+ _mm_read_UBYTE(modreader); \\r
+ _mm_read_UBYTE(modreader)\r
+#else\r
+#define IMF_FinishLoadingEnvelope(name) \\r
+ ih. name/**/pts=_mm_read_UBYTE(modreader); \\r
+ ih. name/**/sus=_mm_read_UBYTE(modreader); \\r
+ ih. name/**/beg=_mm_read_UBYTE(modreader); \\r
+ ih. name/**/end=_mm_read_UBYTE(modreader); \\r
+ ih. name/**/flg=_mm_read_UBYTE(modreader); \\r
+ _mm_read_UBYTE(modreader); \\r
+ _mm_read_UBYTE(modreader); \\r
+ _mm_read_UBYTE(modreader)\r
+#endif\r
+\r
+ IMF_FinishLoadingEnvelope(vol);\r
+ IMF_FinishLoadingEnvelope(pan);\r
+ IMF_FinishLoadingEnvelope(pit);\r
+\r
+ ih.volfade=_mm_read_I_UWORD(modreader);\r
+ ih.numsmp =_mm_read_I_UWORD(modreader);\r
+\r
+ _mm_read_UBYTES(id,4,modreader);\r
+ /* Looks like Imago Orpheus forgets the signature for empty\r
+ instruments following a multi-sample instrument... */\r
+ if(memcmp(id,"II10",4) && \r
+ (oldnumsmp && memcmp(id,"\x0\x0\x0\x0",4))) {\r
+ if(nextwav) free(nextwav);\r
+ if(wh) free(wh);\r
+ _mm_errno=MMERR_LOADING_SAMPLEINFO;\r
+ return 0;\r
+ }\r
+ oldnumsmp=ih.numsmp;\r
+\r
+ if((ih.numsmp>16)||(ih.volpts>IMFENVCNT/2)||(ih.panpts>IMFENVCNT/2)||\r
+ (ih.pitpts>IMFENVCNT/2)||(_mm_eof(modreader))) {\r
+ if(nextwav) free(nextwav);\r
+ if(wh) free(wh);\r
+ _mm_errno=MMERR_LOADING_SAMPLEINFO;\r
+ return 0;\r
+ }\r
+\r
+ for(u=0;u<IMFNOTECNT;u++)\r
+ d->samplenumber[u]=ih.what[u]>ih.numsmp?0xffff:ih.what[u]+of.numsmp;\r
+ d->volfade=ih.volfade;\r
+\r
+#if defined __STDC__ || defined _MSC_VER || defined MPW_C\r
+#define IMF_ProcessEnvelope(name) \\r
+ for (u = 0; u < (IMFENVCNT >> 1); u++) { \\r
+ d-> name##env[u].pos = ih. name##env[u << 1]; \\r
+ d-> name##env[u].val = ih. name##env[(u << 1)+ 1]; \\r
+ } \\r
+ if (ih. name##flg&1) d-> name##flg|=EF_ON; \\r
+ if (ih. name##flg&2) d-> name##flg|=EF_SUSTAIN; \\r
+ if (ih. name##flg&4) d-> name##flg|=EF_LOOP; \\r
+ d-> name##susbeg=d-> name##susend=ih. name##sus; \\r
+ d-> name##beg=ih. name##beg; \\r
+ d-> name##end=ih. name##end; \\r
+ d-> name##pts=ih. name##pts; \\r
+ \\r
+ if ((d-> name##flg&EF_ON)&&(d-> name##pts<2)) \\r
+ d-> name##flg&=~EF_ON\r
+#else\r
+#define IMF_ProcessEnvelope(name) \\r
+ for (u = 0; u < (IMFENVCNT >> 1); u++) { \\r
+ d-> name/**/env[u].pos = ih. name/**/env[u << 1]; \\r
+ d-> name/**/env[u].val = ih. name/**/env[(u << 1)+ 1]; \\r
+ } \\r
+ if (ih. name/**/flg&1) d-> name/**/flg|=EF_ON; \\r
+ if (ih. name/**/flg&2) d-> name/**/flg|=EF_SUSTAIN; \\r
+ if (ih. name/**/flg&4) d-> name/**/flg|=EF_LOOP; \\r
+ d-> name/**/susbeg=d-> name/**/susend=ih. name/**/sus; \\r
+ d-> name/**/beg=ih. name/**/beg; \\r
+ d-> name/**/end=ih. name/**/end; \\r
+ d-> name/**/pts=ih. name/**/pts; \\r
+ \\r
+ if ((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2)) \\r
+ d-> name/**/flg&=~EF_ON\r
+#endif\r
+\r
+ IMF_ProcessEnvelope(vol);\r
+ IMF_ProcessEnvelope(pan);\r
+ IMF_ProcessEnvelope(pit);\r
+#undef IMF_ProcessEnvelope\r
+\r
+ if(ih.pitflg&1) {\r
+ d->pitflg&=~EF_ON;\r
+#ifdef MIKMOD_DEBUG\r
+ fprintf(stderr, "\rFilter envelopes not supported yet\n");\r
+#endif\r
+ }\r
+\r
+ /* gather sample information */\r
+ for(u=0;u<ih.numsmp;u++,s++) {\r
+ /* allocate more room for sample information if necessary */\r
+ if(of.numsmp+u==wavcnt) {\r
+ wavcnt+=IMF_SMPINCR;\r
+ if(!(nextwav=realloc(nextwav,wavcnt*sizeof(ULONG)))) {\r
+ if(wh) free(wh);\r
+ _mm_errno=MMERR_OUT_OF_MEMORY;\r
+ return 0;\r
+ }\r
+ if(!(wh=realloc(wh,wavcnt*sizeof(IMFWAVHEADER)))) {\r
+ free(nextwav);\r
+ _mm_errno=MMERR_OUT_OF_MEMORY;\r
+ return 0;\r
+ }\r
+ s=wh+(wavcnt-IMF_SMPINCR);\r
+ }\r
+\r
+ _mm_read_string(s->samplename,13,modreader);\r
+ _mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);\r
+ s->length =_mm_read_I_ULONG(modreader);\r
+ s->loopstart =_mm_read_I_ULONG(modreader);\r
+ s->loopend =_mm_read_I_ULONG(modreader);\r
+ s->samplerate=_mm_read_I_ULONG(modreader);\r
+ s->volume =_mm_read_UBYTE(modreader)&0x7f;\r
+ s->pan =_mm_read_UBYTE(modreader);\r
+ _mm_fseek(modreader,14,SEEK_CUR);\r
+ s->flags =_mm_read_UBYTE(modreader);\r
+ _mm_fseek(modreader,11,SEEK_CUR);\r
+ _mm_read_UBYTES(id,4,modreader);\r
+ if(((memcmp(id,"IS10",4))&&(memcmp(id,"IW10",4)))||\r
+ (_mm_eof(modreader))) {\r
+ free(nextwav);free(wh);\r
+ _mm_errno=MMERR_LOADING_SAMPLEINFO;\r
+ return 0;\r
+ }\r
+ nextwav[of.numsmp+u]=_mm_ftell(modreader);\r
+ _mm_fseek(modreader,s->length,SEEK_CUR);\r
+ }\r
+\r
+ of.numsmp+=ih.numsmp;\r
+ d++;\r
+ }\r
+\r
+ /* sanity check */\r
+ if(!of.numsmp) {\r
+ if(nextwav) free(nextwav);\r
+ if(wh) free(wh);\r
+ _mm_errno=MMERR_LOADING_SAMPLEINFO;\r
+ return 0;\r
+ }\r
+\r
+ /* load samples */\r
+ if(!AllocSamples()) {\r
+ free(nextwav);free(wh);\r
+ return 0;\r
+ }\r
+ if(!AllocLinear()) {\r
+ free(nextwav);free(wh);\r
+ return 0;\r
+ }\r
+ q=of.samples;\r
+ s=wh;\r
+ for(u=0;u<of.numsmp;u++,s++,q++) {\r
+ q->samplename=DupStr(s->samplename,12,1);\r
+ q->length =s->length;\r
+ q->loopstart=s->loopstart;\r
+ q->loopend =s->loopend;\r
+ q->volume =s->volume;\r
+ q->speed =s->samplerate;\r
+ if(of.flags&UF_LINEAR)\r
+ q->speed=speed_to_finetune(s->samplerate<<1,u);\r
+ q->panning =s->pan;\r
+ q->seekpos =nextwav[u];\r
+\r
+ q->flags|=SF_SIGNED;\r
+ if(s->flags&0x1) q->flags|=SF_LOOP;\r
+ if(s->flags&0x2) q->flags|=SF_BIDI;\r
+ if(s->flags&0x8) q->flags|=SF_OWNPAN;\r
+ if(s->flags&0x4) {\r
+ q->flags|=SF_16BITS;\r
+ q->length >>=1;\r
+ q->loopstart>>=1;\r
+ q->loopend >>=1;\r
+ }\r
+ }\r
+\r
+ d=of.instruments;\r
+ s=wh;\r
+ for(u=0;u<of.numins;u++,d++) {\r
+ for(t=0;t<IMFNOTECNT;t++) {\r
+ if(d->samplenumber[t]>=of.numsmp)\r
+ d->samplenote[t]=255;\r
+ else if (of.flags&UF_LINEAR) {\r
+ int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];\r
+ d->samplenote[u]=(note<0)?0:(note>255?255:note);\r
+ } else\r
+ d->samplenote[t]=t;\r
+ }\r
+ }\r
+\r
+ free(wh);free(nextwav);\r
+ return 1;\r
+}\r
+\r
+CHAR *IMF_LoadTitle(void)\r
+{\r
+ CHAR s[31];\r
+\r
+ _mm_fseek(modreader,0,SEEK_SET);\r
+ if(!_mm_read_UBYTES(s,31,modreader)) return NULL;\r
+\r
+ return(DupStr(s,31,1));\r
+}\r
+\r
+/*========== Loader information */\r
+\r
+MIKMODAPI MLOADER load_imf={\r
+ NULL,\r
+ "IMF",\r
+ "IMF (Imago Orpheus)",\r
+ IMF_Init,\r
+ IMF_Test,\r
+ IMF_Load,\r
+ IMF_Cleanup,\r
+ IMF_LoadTitle\r
+};\r
+\r
+/* ex:set ts=4: */\r
projects / mikmod-rockbox.git / blobdiff