apps/plugins/mikmod/load_ult.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: load_ult.c,v 1.3 2010/01/12 03:30:32 realtech Exp $
  24
  25   Ultratracker (ULT) 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 ULTHEADER {
  53         CHAR  id[16];
  54         CHAR  songtitle[32];
  55         UBYTE reserved;
  56 } ULTHEADER;
  57
  58 /* sample information */
  59 typedef struct ULTSAMPLE {
  60         CHAR  samplename[32];
  61         CHAR  dosname[12];
  62         SLONG loopstart;
  63         SLONG loopend;
  64         SLONG sizestart;
  65         SLONG sizeend;
  66         UBYTE volume;
  67         UBYTE flags;
  68         UWORD speed;
  69         SWORD finetune;
  70 } ULTSAMPLE;
  71
  72 typedef struct ULTEVENT {
  73         UBYTE note,sample,eff,dat1,dat2;
  74 } ULTEVENT;
  75
  76 /*========== Loader variables */
  77
  78 #define ULTS_16BITS     4
  79 #define ULTS_LOOP       8
  80 #define ULTS_REVERSE    16
  81
  82 #define ULT_VERSION_LEN 18
  83 static  CHAR ULT_Version[ULT_VERSION_LEN]="Ultra Tracker v1.x";
  84
  85 static  ULTEVENT ev;
  86
  87 /*========== Loader code */
  88
  89 int ULT_Test(void)
  90 {
  91         CHAR id[16];
  92
  93         if(!_mm_read_string(id,15,modreader)) return 0;
  94         if(strncmp(id,"MAS_UTrack_V00",14)) return 0;
  95         if((id[14]<'1')||(id[14]>'4')) return 0;
  96         return 1;
  97 }
  98
  99 int ULT_Init(void)
 100 {
 101         return 1;
 102 }
 103
 104 void ULT_Cleanup(void)
 105 {
 106 }
 107
 108 static UBYTE ReadUltEvent(ULTEVENT* event)
 109 {
 110         UBYTE flag,rep=1;
 111
 112         flag = _mm_read_UBYTE(modreader);
 113         if(flag==0xfc) {
 114                 rep = _mm_read_UBYTE(modreader);
 115                 event->note =_mm_read_UBYTE(modreader);
 116         } else
 117                 event->note = flag;
 118
 119         event->sample   =_mm_read_UBYTE(modreader);
 120         event->eff      =_mm_read_UBYTE(modreader);
 121         event->dat1     =_mm_read_UBYTE(modreader);
 122         event->dat2     =_mm_read_UBYTE(modreader);
 123
 124         return rep;
 125 }
 126
 127 int ULT_Load(int curious)
 128 {
 129         int t,u,tracks=0;
 130         SAMPLE *q;
 131         ULTSAMPLE s;
 132         ULTHEADER mh;
 133         UBYTE nos,noc,rbnop;
 134     (void)curious;
 135
 136         /* try to read module header */
 137         _mm_read_string(mh.id,15,modreader);
 138         _mm_read_string(mh.songtitle,32,modreader);
 139         mh.reserved=_mm_read_UBYTE(modreader);
 140
 141         if(_mm_eof(modreader)) {
 142                 _mm_errno = MMERR_LOADING_HEADER;
 143                 return 0;
 144         }
 145
 146         ULT_Version[ULT_VERSION_LEN-1]='3'+(mh.id[14]-'1');
 147         of.modtype   = DupStr(ULT_Version,ULT_VERSION_LEN,1);
 148         of.initspeed = 6;
 149         of.inittempo = 125;
 150         of.reppos    = 0;
 151
 152         /* read songtext */
 153         if ((mh.id[14]>'1')&&(mh.reserved))
 154                 if(!ReadLinedComment(mh.reserved * 32, 32)) return 0;
 155
 156         nos=_mm_read_UBYTE(modreader);
 157         if(_mm_eof(modreader)) {
 158                 _mm_errno = MMERR_LOADING_HEADER;
 159                 return 0;
 160         }
 161
 162         of.songname=DupStr(mh.songtitle,32,1);
 163         of.numins=of.numsmp=nos;
 164
 165         if(!AllocSamples()) return 0;
 166         q = of.samples;
 167         for(t=0;t<nos;t++) {
 168                 /* try to read sample info */
 169                 _mm_read_string(s.samplename,32,modreader);
 170                 _mm_read_string(s.dosname,12,modreader);
 171                 s.loopstart     =_mm_read_I_ULONG(modreader);
 172                 s.loopend       =_mm_read_I_ULONG(modreader);
 173                 s.sizestart     =_mm_read_I_ULONG(modreader);
 174                 s.sizeend       =_mm_read_I_ULONG(modreader);
 175                 s.volume        =_mm_read_UBYTE(modreader);
 176                 s.flags         =_mm_read_UBYTE(modreader);
 177                 s.speed         =(mh.id[14]>='4')?_mm_read_I_UWORD(modreader):8363;
 178                 s.finetune      =_mm_read_I_SWORD(modreader);
 179
 180                 if(_mm_eof(modreader)) {
 181                         _mm_errno = MMERR_LOADING_SAMPLEINFO;
 182                         return 0;
 183                 }
 184
 185                 q->samplename=DupStr(s.samplename,32,1);
 186                 /* The correct formula for the coefficient would be
 187                    pow(2,(double)s.finetume/OCTAVE/32768), but to avoid floating point
 188                    here, we'll use a first order approximation here.
 189                    1/567290 == Ln(2)/OCTAVE/32768 */
 190                 q->speed=s.speed+s.speed*(((SLONG)s.speed*(SLONG)s.finetune)/567290);
 191                 q->length    = s.sizeend-s.sizestart;
 192                 q->volume    = s.volume>>2;
 193                 q->loopstart = s.loopstart;
 194                 q->loopend   = s.loopend;
 195                 q->flags = SF_SIGNED;
 196                 if(s.flags&ULTS_LOOP) q->flags|=SF_LOOP;
 197                 if(s.flags&ULTS_16BITS) {
 198                         s.sizeend+=(s.sizeend-s.sizestart);
 199                         s.sizestart<<=1;
 200                         q->flags|=SF_16BITS;
 201                         q->loopstart>>=1;
 202                         q->loopend>>=1;
 203                 }
 204                 q++;
 205         }
 206
 207         if(!AllocPositions(256)) return 0;
 208         for(t=0;t<256;t++)
 209                 of.positions[t]=_mm_read_UBYTE(modreader);
 210         for(t=0;t<256;t++)
 211                 if(of.positions[t]==255) {
 212                         of.positions[t]=LAST_PATTERN;
 213                         break;
 214                 }
 215         of.numpos=t;
 216
 217         noc=_mm_read_UBYTE(modreader);
 218         rbnop=_mm_read_UBYTE(modreader);
 219
 220         of.numchn=++noc;
 221         of.numpat=++rbnop;
 222         of.numtrk=of.numchn*of.numpat;
 223         if(!AllocTracks()) return 0;
 224         if(!AllocPatterns()) return 0;
 225         for(u=0;u<of.numchn;u++)
 226                 for(t=0;t<of.numpat;t++)
 227                         of.patterns[(t*of.numchn)+u]=tracks++;
 228
 229         // SA37775
 230         if (of.numchn>=UF_MAXCHAN)
 231                 of.numchn=UF_MAXCHAN - 1;
 232
 233         /* read pan position table for v1.5 and higher */
 234         if(mh.id[14]>='3') {
 235                 for(t=0;t<of.numchn;t++) of.panning[t]=_mm_read_UBYTE(modreader)<<4;
 236                 of.flags |= UF_PANNING;
 237         }
 238
 239         for(t=0;t<of.numtrk;t++) {
 240                 int rep,row=0;
 241
 242                 UniReset();
 243                 while(row<64) {
 244                         rep=ReadUltEvent(&ev);
 245
 246                         if(_mm_eof(modreader)) {
 247                                 _mm_errno = MMERR_LOADING_TRACK;
 248                                 return 0;
 249                         }
 250
 251                         while(rep--) {
 252                                 UBYTE eff;
 253                                 int offset;
 254
 255                                 if(ev.sample) UniInstrument(ev.sample-1);
 256                                 if(ev.note)   UniNote(ev.note+2*OCTAVE-1);
 257
 258                                 /* first effect - various fixes by Alexander Kerkhove and
 259                                                   Thomas Neumann */
 260                                 eff = ev.eff>>4;
 261                                 switch(eff) {
 262                                         case 0x3: /* tone portamento */
 263                                                 UniEffect(UNI_ITEFFECTG,ev.dat2);
 264                                                 break;
 265                                         case 0x5:
 266                                                 break;
 267                                         case 0x9: /* sample offset */
 268                                                 offset=(ev.dat2<<8)|((ev.eff&0xf)==9?ev.dat1:0);
 269                                                 UniEffect(UNI_ULTEFFECT9,offset);
 270                                                 break;
 271                                         case 0xb: /* panning */
 272                                                 UniPTEffect(8,ev.dat2*0xf);
 273                                                 of.flags |= UF_PANNING;
 274                                                 break;
 275                                         case 0xc: /* volume */
 276                                                 UniPTEffect(eff,ev.dat2>>2);
 277                                                 break;
 278                                         default:
 279                                                 UniPTEffect(eff,ev.dat2);
 280                                                 break;
 281                                 }
 282
 283                                 /* second effect */
 284                                 eff=ev.eff&0xf;
 285                                 switch(eff) {
 286                                         case 0x3: /* tone portamento */
 287                                                 UniEffect(UNI_ITEFFECTG,ev.dat1);
 288                                                 break;
 289                                         case 0x5:
 290                                                 break;
 291                                         case 0x9: /* sample offset */
 292                                                 if((ev.eff>>4)!=9)
 293                                                         UniEffect(UNI_ULTEFFECT9,((UWORD)ev.dat1)<<8);
 294                                                 break;
 295                                         case 0xb: /* panning */
 296                                                 UniPTEffect(8,ev.dat1*0xf);
 297                                                 of.flags |= UF_PANNING;
 298                                                 break;
 299                                         case 0xc: /* volume */
 300                                                 UniPTEffect(eff,ev.dat1>>2);
 301                                                 break;
 302                                         default:
 303                                                 UniPTEffect(eff,ev.dat1);
 304                                                 break;
 305                                 }
 306
 307                                 UniNewline();
 308                                 row++;
 309                         }
 310                 }
 311                 if(!(of.tracks[t]=UniDup())) return 0;
 312         }
 313         return 1;
 314 }
 315
 316 CHAR *ULT_LoadTitle(void)
 317 {
 318         CHAR s[32];
 319
 320         _mm_fseek(modreader,15,SEEK_SET);
 321         if(!_mm_read_UBYTES(s,32,modreader)) return NULL;
 322
 323         return(DupStr(s,32,1));
 324 }
 325
 326 /*========== Loader information */
 327
 328 MIKMODAPI MLOADER load_ult={
 329         NULL,
 330         "ULT",
 331         "ULT (UltraTracker)",
 332         ULT_Init,
 333         ULT_Test,
 334         ULT_Load,
 335         ULT_Cleanup,
 336         ULT_LoadTitle
 337 };
 338
 339
 340 /* ex:set ts=4: */