git.mutantstargoat.com Git - dosrtxon/blob - libs/mikmod/loaders/load_s3m.c

   1 /*      MikMod sound library
   2         (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
   3         AUTHORS for complete list.
   4
   5         This library is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU Library General Public License as
   7         published by the Free Software Foundation; either version 2 of
   8         the License, or (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13         GNU Library General Public License for more details.
  14
  15         You should have received a copy of the GNU Library General Public
  16         License along with this library; if not, write to the Free Software
  17         Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18         02111-1307, USA.
  19 */
  20
  21 /*==============================================================================
  22
  23   $Id$
  24
  25   Screamtracker (S3M) module loader
  26
  27 ==============================================================================*/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #include <stdio.h>
  38 #ifdef HAVE_MEMORY_H
  39 #include <memory.h>
  40 #endif
  41 #include <string.h>
  42
  43 #include "mikmod_internals.h"
  44
  45 #ifdef SUNOS
  46 extern int fprintf(FILE *, const char *, ...);
  47 #endif
  48
  49 /*========== Module structure */
  50
  51 /* header */
  52 typedef struct S3MHEADER {
  53         CHAR  songname[28];
  54         UBYTE t1a;
  55         UBYTE type;
  56         UBYTE unused1[2];
  57         UWORD ordnum;
  58         UWORD insnum;
  59         UWORD patnum;
  60         UWORD flags;
  61         UWORD tracker;
  62         UWORD fileformat;
  63         CHAR  scrm[4];
  64         UBYTE mastervol;
  65         UBYTE initspeed;
  66         UBYTE inittempo;
  67         UBYTE mastermult;
  68         UBYTE ultraclick;
  69         UBYTE pantable;
  70         UBYTE unused2[8];
  71         UWORD special;
  72         UBYTE channels[32];
  73 } S3MHEADER;
  74
  75 /* sample information */
  76 typedef struct S3MSAMPLE {
  77         UBYTE type;
  78         CHAR  filename[12];
  79         UBYTE memsegh;
  80         UWORD memsegl;
  81         ULONG length;
  82         ULONG loopbeg;
  83         ULONG loopend;
  84         UBYTE volume;
  85         UBYTE dsk;
  86         UBYTE pack;
  87         UBYTE flags;
  88         ULONG c2spd;
  89         UBYTE unused[12];
  90         CHAR  sampname[28];
  91         CHAR  scrs[4];
  92 } S3MSAMPLE;
  93
  94 typedef struct S3MNOTE {
  95         UBYTE note,ins,vol,cmd,inf;
  96 } S3MNOTE;
  97
  98 /*========== Loader variables */
  99
 100 static S3MNOTE   *s3mbuf  = NULL; /* pointer to a complete S3M pattern */
 101 static S3MHEADER *mh      = NULL;
 102 static UWORD     *paraptr = NULL; /* parapointer array (see S3M docs) */
 103 static unsigned int tracker;    /* tracker id */
 104
 105 /* tracker identifiers */
 106 #define NUMTRACKERS 4
 107 static const CHAR * S3M_Version[] = {
 108         "Screamtracker x.xx",
 109         "Imago Orpheus x.xx (S3M format)",
 110         "Impulse Tracker x.xx (S3M format)",
 111         "Unknown tracker x.xx (S3M format)",
 112         "Impulse Tracker 2.14p3 (S3M format)",
 113         "Impulse Tracker 2.14p4 (S3M format)"
 114 };
 115 /* version number position in above array */
 116 static const int numeric[NUMTRACKERS]={14,14,16,16};
 117
 118 /*========== Loader code */
 119
 120 static BOOL S3M_Test(void)
 121 {
 122         UBYTE id[4];
 123
 124         _mm_fseek(modreader,0x2c,SEEK_SET);
 125         if(!_mm_read_UBYTES(id,4,modreader)) return 0;
 126         if(!memcmp(id,"SCRM",4)) return 1;
 127         return 0;
 128 }
 129
 130 static BOOL S3M_Init(void)
 131 {
 132         if(!(s3mbuf=(S3MNOTE*)MikMod_malloc(32*64*sizeof(S3MNOTE)))) return 0;
 133         if(!(mh=(S3MHEADER*)MikMod_malloc(sizeof(S3MHEADER)))) return 0;
 134         if(!(poslookup=(UBYTE*)MikMod_malloc(sizeof(UBYTE)*256))) return 0;
 135         memset(poslookup,-1,256);
 136
 137         return 1;
 138 }
 139
 140 static void S3M_Cleanup(void)
 141 {
 142         MikMod_free(s3mbuf);
 143         MikMod_free(paraptr);
 144         MikMod_free(poslookup);
 145         MikMod_free(mh);
 146         MikMod_free(origpositions);
 147         s3mbuf=NULL;
 148         paraptr=NULL;
 149         poslookup=NULL;
 150         mh=NULL;
 151         origpositions=NULL;
 152 }
 153
 154 /* Because so many s3m files have 16 channels as the set number used, but really
 155    only use far less (usually 8 to 12 still), I had to make this function, which
 156    determines the number of channels that are actually USED by a pattern.
 157
 158    For every channel that's used, it sets the appropriate array entry of the
 159    global variable 'remap'
 160
 161    NOTE: You must first seek to the file location of the pattern before calling
 162    this procedure.
 163
 164    Returns 0 on fail. */
 165 static BOOL S3M_GetNumChannels(void)
 166 {
 167         int row=0,flag,ch;
 168
 169         while(row<64) {
 170                 flag=_mm_read_UBYTE(modreader);
 171
 172                 if(_mm_eof(modreader)) {
 173                         _mm_errno = MMERR_LOADING_PATTERN;
 174                         return 0;
 175                 }
 176
 177                 if(flag) {
 178                         ch=flag&31;
 179                         if(mh->channels[ch]<32) remap[ch] = 0;
 180                         if(flag&32) {_mm_skip_BYTE(modreader);_mm_skip_BYTE(modreader);}
 181                         if(flag&64) _mm_skip_BYTE(modreader);
 182                         if(flag&128){_mm_skip_BYTE(modreader);_mm_skip_BYTE(modreader);}
 183                 } else row++;
 184         }
 185         return 1;
 186 }
 187
 188 static BOOL S3M_ReadPattern(void)
 189 {
 190         int row=0,flag,ch;
 191         S3MNOTE *n,dummy;
 192
 193         /* clear pattern data */
 194         memset(s3mbuf,255,32*64*sizeof(S3MNOTE));
 195
 196         while(row<64) {
 197                 flag=_mm_read_UBYTE(modreader);
 198
 199                 if(_mm_eof(modreader)) {
 200                         _mm_errno = MMERR_LOADING_PATTERN;
 201                         return 0;
 202                 }
 203
 204                 if(flag) {
 205                         ch=remap[flag&31];
 206
 207                         if(ch!=-1)
 208                                 n=&s3mbuf[(64U*ch)+row];
 209                         else
 210                                 n=&dummy;
 211
 212                         if(flag&32) {
 213                                 n->note=_mm_read_UBYTE(modreader);
 214                                 n->ins=_mm_read_UBYTE(modreader);
 215                         }
 216                         if(flag&64) {
 217                                 n->vol=_mm_read_UBYTE(modreader);
 218                                 if (n->vol>64) n->vol=64;
 219                         }
 220                         if(flag&128) {
 221                                 n->cmd=_mm_read_UBYTE(modreader);
 222                                 n->inf=_mm_read_UBYTE(modreader);
 223                         }
 224                 } else row++;
 225         }
 226         return 1;
 227 }
 228
 229 static UBYTE* S3M_ConvertTrack(S3MNOTE* tr)
 230 {
 231         int t;
 232
 233         UniReset();
 234         for(t=0;t<64;t++) {
 235                 UBYTE note,ins,vol;
 236
 237                 note=tr[t].note;
 238                 ins=tr[t].ins;
 239                 vol=tr[t].vol;
 240
 241                 if((ins)&&(ins!=255)) UniInstrument(ins-1);
 242                 if(note!=255) {
 243                         if(note==254) {
 244                                 UniPTEffect(0xc,0);     /* note cut command */
 245                                 vol=255;
 246                         } else
 247                                 UniNote(((note>>4)*OCTAVE)+(note&0xf)); /* normal note */
 248                 }
 249                 if(vol<255) UniPTEffect(0xc,vol);
 250
 251                 S3MIT_ProcessCmd(tr[t].cmd,tr[t].inf,
 252                         tracker == 1 ? S3MIT_OLDSTYLE | S3MIT_SCREAM : S3MIT_OLDSTYLE);
 253                 UniNewline();
 254         }
 255         return UniDup();
 256 }
 257
 258 static BOOL S3M_Load(BOOL curious)
 259 {
 260         int t,u,track = 0;
 261         SAMPLE *q;
 262         UBYTE pan[32];
 263
 264         /* try to read module header */
 265         _mm_read_string(mh->songname,28,modreader);
 266         mh->t1a         =_mm_read_UBYTE(modreader);
 267         mh->type        =_mm_read_UBYTE(modreader);
 268         _mm_read_UBYTES(mh->unused1,2,modreader);
 269         mh->ordnum      =_mm_read_I_UWORD(modreader);
 270         mh->insnum      =_mm_read_I_UWORD(modreader);
 271         mh->patnum      =_mm_read_I_UWORD(modreader);
 272         mh->flags       =_mm_read_I_UWORD(modreader);
 273         mh->tracker     =_mm_read_I_UWORD(modreader);
 274         mh->fileformat  =_mm_read_I_UWORD(modreader);
 275         _mm_read_string(mh->scrm,4,modreader);
 276         mh->mastervol   =_mm_read_UBYTE(modreader);
 277         mh->initspeed   =_mm_read_UBYTE(modreader);
 278         mh->inittempo   =_mm_read_UBYTE(modreader);
 279         mh->mastermult  =_mm_read_UBYTE(modreader);
 280         mh->ultraclick  =_mm_read_UBYTE(modreader);
 281         mh->pantable    =_mm_read_UBYTE(modreader);
 282         _mm_read_UBYTES(mh->unused2,8,modreader);
 283         mh->special     =_mm_read_I_UWORD(modreader);
 284         _mm_read_UBYTES(mh->channels,32,modreader);
 285
 286         if(_mm_eof(modreader)) {
 287                 _mm_errno = MMERR_LOADING_HEADER;
 288                 return 0;
 289         }
 290
 291         /* then we can decide the module type */
 292         tracker=mh->tracker>>12;
 293         if((!tracker)||(tracker>=NUMTRACKERS))
 294                 tracker=NUMTRACKERS-1; /* unknown tracker */
 295         else {
 296                 if(mh->tracker>=0x3217)
 297                         tracker=NUMTRACKERS+1; /* IT 2.14p4 */
 298                 else if(mh->tracker>=0x3216)
 299                         tracker=NUMTRACKERS; /* IT 2.14p3 */
 300                 else tracker--;
 301         }
 302         of.modtype = MikMod_strdup(S3M_Version[tracker]);
 303         if(tracker<NUMTRACKERS) {
 304                 of.modtype[numeric[tracker]] = ((mh->tracker>>8) &0xf)+'0';
 305                 of.modtype[numeric[tracker]+2] = ((mh->tracker>>4)&0xf)+'0';
 306                 of.modtype[numeric[tracker]+3] = ((mh->tracker)&0xf)+'0';
 307         }
 308         /* set module variables */
 309         of.songname    = DupStr(mh->songname,28,0);
 310         of.numpat      = mh->patnum;
 311         of.reppos      = 0;
 312         of.numins      = of.numsmp = mh->insnum;
 313         of.initspeed   = mh->initspeed;
 314         of.inittempo   = mh->inittempo;
 315         of.initvolume  = mh->mastervol<<1;
 316         of.flags      |= UF_ARPMEM | UF_PANNING;
 317         if((mh->tracker==0x1300)||(mh->flags&64))
 318                 of.flags|=UF_S3MSLIDES;
 319         of.bpmlimit    = 32;
 320
 321         /* read the order data */
 322         if(!AllocPositions(mh->ordnum)) return 0;
 323         if(!(origpositions=(UWORD*)MikMod_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
 324
 325         for(t=0;t<mh->ordnum;t++) {
 326                 origpositions[t]=_mm_read_UBYTE(modreader);
 327                 if((origpositions[t]>=mh->patnum)&&(origpositions[t]<254))
 328                         origpositions[t]=255/*mh->patnum-1*/;
 329         }
 330
 331         if(_mm_eof(modreader)) {
 332                 _mm_errno = MMERR_LOADING_HEADER;
 333                 return 0;
 334         }
 335
 336         poslookupcnt=mh->ordnum;
 337         S3MIT_CreateOrders(curious);
 338
 339         if(!(paraptr=(UWORD*)MikMod_malloc((of.numins+of.numpat)*sizeof(UWORD))))
 340                 return 0;
 341
 342         /* read the instrument+pattern parapointers */
 343         _mm_read_I_UWORDS(paraptr,of.numins+of.numpat,modreader);
 344
 345         if(mh->pantable==252) {
 346                 /* read the panning table (ST 3.2 addition.  See below for further
 347                    portions of channel panning [past reampper]). */
 348                 _mm_read_UBYTES(pan,32,modreader);
 349         }
 350
 351         if(_mm_eof(modreader)) {
 352                 _mm_errno = MMERR_LOADING_HEADER;
 353                 return 0;
 354         }
 355
 356         /* load samples */
 357         if(!AllocSamples()) return 0;
 358         q = of.samples;
 359         for(t=0;t<of.numins;t++) {
 360                 S3MSAMPLE s;
 361
 362                 /* seek to instrument position */
 363                 _mm_fseek(modreader,((long)paraptr[t])<<4,SEEK_SET);
 364                 /* and load sample info */
 365                 s.type      =_mm_read_UBYTE(modreader);
 366                 _mm_read_string(s.filename,12,modreader);
 367                 s.memsegh   =_mm_read_UBYTE(modreader);
 368                 s.memsegl   =_mm_read_I_UWORD(modreader);
 369                 s.length    =_mm_read_I_ULONG(modreader);
 370                 s.loopbeg   =_mm_read_I_ULONG(modreader);
 371                 s.loopend   =_mm_read_I_ULONG(modreader);
 372                 s.volume    =_mm_read_UBYTE(modreader);
 373                 s.dsk       =_mm_read_UBYTE(modreader);
 374                 s.pack      =_mm_read_UBYTE(modreader);
 375                 s.flags     =_mm_read_UBYTE(modreader);
 376                 s.c2spd     =_mm_read_I_ULONG(modreader);
 377                 _mm_read_UBYTES(s.unused,12,modreader);
 378                 _mm_read_string(s.sampname,28,modreader);
 379                 _mm_read_string(s.scrs,4,modreader);
 380
 381                 /* ScreamTracker imposes a 64000 bytes (not 64k !) limit */
 382                 /* enforce it, if we'll use S3MIT_SCREAM in S3M_ConvertTrack() */
 383                 if (s.length > 64000 && tracker == 1)
 384                         s.length = 64000;
 385
 386                 if(_mm_eof(modreader)) {
 387                         _mm_errno = MMERR_LOADING_SAMPLEINFO;
 388                         return 0;
 389                 }
 390
 391                 q->samplename = DupStr(s.sampname,28,0);
 392                 q->speed      = s.c2spd;
 393                 q->length     = s.length;
 394                 q->loopstart  = s.loopbeg;
 395                 q->loopend    = s.loopend;
 396                 q->volume     = s.volume;
 397                 q->seekpos    = (((ULONG)s.memsegh)<<16|s.memsegl)<<4;
 398
 399                 if(s.flags&1) q->flags |= SF_LOOP;
 400                 if(s.flags&4) q->flags |= SF_16BITS;
 401                 if(mh->fileformat==1) q->flags |= SF_SIGNED;
 402
 403                 /* don't load sample if it doesn't have the SCRS tag */
 404                 if(memcmp(s.scrs,"SCRS",4)) q->length = 0;
 405
 406                 q++;
 407         }
 408
 409         /* determine the number of channels actually used. */
 410         of.numchn = 0;
 411         memset(remap,-1,32*sizeof(UBYTE));
 412         for(t=0;t<of.numpat;t++) {
 413                 /* seek to pattern position (+2 skip pattern length) */
 414                 _mm_fseek(modreader,(long)((paraptr[of.numins+t])<<4)+2,SEEK_SET);
 415                 if(!S3M_GetNumChannels()) return 0;
 416         }
 417
 418         /* build the remap array  */
 419         for(t=0;t<32;t++)
 420                 if(!remap[t])
 421                         remap[t]=of.numchn++;
 422
 423         /* set panning positions after building remap chart! */
 424         for(t=0;t<32;t++)
 425                 if((mh->channels[t]<32)&&(remap[t]!=-1)) {
 426                         if(mh->channels[t]<8)
 427                                 of.panning[remap[t]]=0x30;
 428                         else
 429                                 of.panning[remap[t]]=0xc0;
 430                 }
 431         if(mh->pantable==252)
 432                 /* set panning positions according to panning table (new for st3.2) */
 433                 for(t=0;t<32;t++)
 434                         if((pan[t]&0x20)&&(mh->channels[t]<32)&&(remap[t]!=-1))
 435                                 of.panning[remap[t]]=(pan[t]&0xf)<<4;
 436
 437         /* load pattern info */
 438         of.numtrk=of.numpat*of.numchn;
 439         if(!AllocTracks()) return 0;
 440         if(!AllocPatterns()) return 0;
 441
 442         for(t=0;t<of.numpat;t++) {
 443                 /* seek to pattern position (+2 skip pattern length) */
 444                 _mm_fseek(modreader,(((long)paraptr[of.numins+t])<<4)+2,SEEK_SET);
 445                 if(!S3M_ReadPattern()) return 0;
 446                 for(u=0;u<of.numchn;u++)
 447                         if(!(of.tracks[track++]=S3M_ConvertTrack(&s3mbuf[u*64]))) return 0;
 448         }
 449
 450         return 1;
 451 }
 452
 453 static CHAR *S3M_LoadTitle(void)
 454 {
 455         CHAR s[28];
 456
 457         _mm_fseek(modreader,0,SEEK_SET);
 458         if(!_mm_read_UBYTES(s,28,modreader)) return NULL;
 459
 460         return(DupStr(s,28,0));
 461 }
 462
 463 /*========== Loader information */
 464
 465 MIKMODAPI MLOADER load_s3m={
 466         NULL,
 467         "S3M",
 468         "S3M (Scream Tracker 3)",
 469         S3M_Init,
 470         S3M_Test,
 471         S3M_Load,
 472         S3M_Cleanup,
 473         S3M_LoadTitle
 474 };
 475
 476 /* ex:set ts=4: */