reorganized the source code
[dosdemo] / libs / oldmik / src / load_mod.c
1 /*
2
3 Name:
4 LOAD_MOD.C
5
6 Description:
7 Generic MOD loader
8
9 Portability:
10 All systems - all compilers (hopefully)
11
12 */
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <ctype.h>
17 #include "mikmod.h"
18
19 /*************************************************************************
20 *************************************************************************/
21
22
23 typedef struct MSAMPINFO{       /* sample header as it appears in a module */
24         char  samplename[22];
25         UWORD length;
26         UBYTE finetune;
27         UBYTE volume;
28         UWORD reppos;
29         UWORD replen;
30 } MSAMPINFO;
31
32
33 typedef struct MODULEHEADER{    /* verbatim module header */
34         char       songname[20];                /* the songname.. */
35         MSAMPINFO  samples[31];                         /* all sampleinfo */
36         UBYTE      songlength;                          /* number of patterns used */
37         UBYTE      magic1;                                      /* should be 127 */
38         UBYTE      positions[128];                      /* which pattern to play at pos */
39         UBYTE      magic2[4];                           /* string "M.K." or "FLT4" or "FLT8" */
40 } MODULEHEADER;
41
42 #define MODULEHEADERSIZE 1084
43
44
45 typedef struct MODTYPE{                         /* struct to identify type of module */
46         char    id[5];
47         UBYTE   channels;
48         char    *name;
49 } MODTYPE;
50
51
52 typedef struct MODNOTE{
53         UBYTE a,b,c,d;
54 } MODNOTE;
55
56
57 /*************************************************************************
58 *************************************************************************/
59
60
61 char protracker[]="Protracker";
62 char startracker[]="Startracker";
63 char fasttracker[]="Fasttracker";
64 char ins15tracker[]="15-instrument";
65 char oktalyzer[]="Oktalyzer";
66 char taketracker[]="TakeTracker";
67
68
69 MODTYPE modtypes[]={
70         "M.K.",4,protracker,    /* protracker 4 channel */
71         "M!K!",4,protracker,    /* protracker 4 channel */
72         "FLT4",4,startracker,   /* startracker 4 channel */
73         "4CHN",4,fasttracker,   /* fasttracker 4 channel */
74         "6CHN",6,fasttracker,   /* fasttracker 6 channel */
75         "8CHN",8,fasttracker,   /* fasttracker 8 channel */
76         "CD81",8,oktalyzer,     /* atari oktalyzer 8 channel */
77         "OKTA",8,oktalyzer,     /* atari oktalyzer 8 channel */
78         "16CN",16,taketracker,  /* taketracker 16 channel */
79         "32CN",32,taketracker,  /* taketracker 32 channel */
80         "    ",4,ins15tracker   /* 15-instrument 4 channel */
81 };
82
83 static MODULEHEADER *mh;        /* raw as-is module header */
84 static MODNOTE *patbuf;
85
86
87 BOOL MOD_Test(void)
88 {
89         int t;
90
91         char id[4];
92
93         _mm_fseek(modfp,MODULEHEADERSIZE-4,SEEK_SET);
94         if(!fread(id,4,1,modfp)) return 0;
95
96         /* find out which ID string */
97
98         for(t=0;t<10;t++){
99                 if(!memcmp(id,modtypes[t].id,4)) return 1;
100         }
101
102         return 0;
103 }
104
105
106 BOOL MOD_Init(void)
107 {
108         patbuf=NULL;
109         if(!(mh=(MODULEHEADER *)MyCalloc(1,sizeof(MODULEHEADER)))) return 0;
110         return 1;
111 }
112
113
114 void MOD_Cleanup(void)
115 {
116         if(mh!=NULL) free(mh);
117         if(patbuf!=NULL) free(patbuf);
118 }
119
120
121 /*
122
123 Old (amiga) noteinfo:
124
125  _____byte 1_____   byte2_    _____byte 3_____   byte4_
126 /                \ /      \  /                \ /      \
127 0000          0000-00000000  0000          0000-00000000
128
129 Upper four    12 bits for    Lower four    Effect command.
130 bits of sam-  note period.   bits of sam-
131 ple number.                  ple number.
132
133
134 */
135
136
137 UWORD npertab[60]={
138
139 /* -> Tuning 0 */
140
141         1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,906,
142         856,808,762,720,678,640,604,570,538,508,480,453,
143         428,404,381,360,339,320,302,285,269,254,240,226,
144         214,202,190,180,170,160,151,143,135,127,120,113,
145         107,101,95,90,85,80,75,71,67,63,60,56
146 };
147
148
149 void ConvertNote(MODNOTE *n)
150 {
151         UBYTE instrument,effect,effdat,note;
152         UWORD period;
153
154         /* extract the various information from the 4 bytes that
155            make up a single note */
156
157         instrument=(n->a&0x10)|(n->c>>4);
158         period=(((UWORD)n->a&0xf)<<8)+n->b;
159         effect=n->c&0xf;
160         effdat=n->d;
161
162         /* Convert the period to a note number */
163
164         note=0;
165         if(period!=0){
166                 for(note=0;note<60;note++){
167                         if(period>=npertab[note]) break;
168                 }
169                 note++;
170                 if(note==61) note=0;
171         }
172
173         if(instrument!=0){
174                 UniInstrument(instrument-1);
175         }
176
177         if(note!=0){
178                 UniNote(note+23);
179         }
180
181         UniPTEffect(effect,effdat);
182 }
183
184
185 UBYTE *ConvertTrack(MODNOTE *n)
186 {
187         int t;
188
189         UniReset();
190         for(t=0;t<64;t++){
191                 ConvertNote(n);
192                 UniNewline();
193                 n+=of.numchn;
194         }
195         return UniDup();
196 }
197
198
199 BOOL ML_LoadPatterns(void)
200 /*
201         Loads all patterns of a modfile and converts them into the
202         3 byte format.
203 */
204 {
205         int t,s,tracks=0;
206
207         if(!AllocPatterns()) return 0;
208         if(!AllocTracks()) return 0;
209
210         /* Allocate temporary buffer for loading
211            and converting the patterns */
212
213         if(!(patbuf=(MODNOTE *)MyCalloc(64U*of.numchn,sizeof(MODNOTE)))) return 0;
214
215         for(t=0;t<of.numpat;t++){
216
217                 /* Load the pattern into the temp buffer
218                    and convert it */
219
220                 for(s=0;s<(64U*of.numchn);s++){
221                         patbuf[s].a=_mm_read_UBYTE(modfp);
222                         patbuf[s].b=_mm_read_UBYTE(modfp);
223                         patbuf[s].c=_mm_read_UBYTE(modfp);
224                         patbuf[s].d=_mm_read_UBYTE(modfp);
225                 }
226
227                 for(s=0;s<of.numchn;s++){
228                         if(!(of.tracks[tracks++]=ConvertTrack(patbuf+s))) return 0;
229                 }
230         }
231
232         return 1;
233 }
234
235
236 BOOL MOD_Load(void)
237 {
238         int t,modtype;
239         INSTRUMENT *d;          /* new sampleinfo structure */
240         SAMPLE *q;
241         MSAMPINFO *s;           /* old module sampleinfo */
242
243         /* try to read module header */
244
245         _mm_read_str((char *)mh->songname,20,modfp);
246
247         for(t=0;t<31;t++){
248                 s=&mh->samples[t];
249                 _mm_read_str(s->samplename,22,modfp);
250                 s->length       =_mm_read_M_UWORD(modfp);
251                 s->finetune     =_mm_read_UBYTE(modfp);
252                 s->volume       =_mm_read_UBYTE(modfp);
253                 s->reppos       =_mm_read_M_UWORD(modfp);
254                 s->replen       =_mm_read_M_UWORD(modfp);
255         }
256
257         mh->songlength  =_mm_read_UBYTE(modfp);
258         mh->magic1              =_mm_read_UBYTE(modfp);
259
260         _mm_read_UBYTES(mh->positions,128,modfp);
261         _mm_read_UBYTES(mh->magic2,4,modfp);
262
263         if(feof(modfp)){
264                 myerr=ERROR_LOADING_HEADER;
265                 return 0;
266         }
267
268         /* find out which ID string */
269
270         for(modtype=0;modtype<10;modtype++){
271                 if(!memcmp(mh->magic2,modtypes[modtype].id,4)) break;
272         }
273
274         if(modtype==10){
275
276                 /* unknown modtype */
277                 myerr=ERROR_NOT_A_MODULE;
278                 return 0;
279         }
280
281         /* set module variables */
282
283         of.initspeed=6;
284         of.inittempo=125;
285         of.numchn=modtypes[modtype].channels;      /* get number of channels */
286         of.modtype=strdup(modtypes[modtype].name);      /* get ascii type of mod */
287         of.songname=DupStr(mh->songname,20);            /* make a cstr of songname */
288         of.numpos=mh->songlength;               /* copy the songlength */
289         memcpy(of.positions,mh->positions,128);         /* copy the position array */
290
291         /* Count the number of patterns */
292
293         of.numpat=0;
294
295         for(t=0;t<128;t++){             /* <-- BUGFIX... have to check ALL positions */
296                 if(of.positions[t] > of.numpat){
297                         of.numpat=of.positions[t];
298                 }
299         }
300         of.numpat++;
301         of.numtrk=of.numpat*of.numchn;
302
303         /* Finally, init the sampleinfo structures */
304
305         of.numins=31;
306
307         if(!AllocInstruments()) return 0;
308
309         s=mh->samples;   /* init source pointer */
310         d=of.instruments;  /* init dest pointer */
311
312         for(t=0;t<of.numins;t++){
313
314                 d->numsmp=1;
315                 if(!AllocSamples(d)) return 0;
316
317                 q=d->samples;
318
319                 /* convert the samplename */
320
321                 d->insname=DupStr(s->samplename,22);
322
323                 /* init the sampleinfo variables and
324                    convert the size pointers to longword format */
325
326                 q->c2spd=finetune[s->finetune&0xf];
327                 q->volume=s->volume;
328                 q->loopstart=(ULONG)s->reppos<<1;
329                 q->loopend=q->loopstart+((ULONG)s->replen<<1);
330                 q->length=(ULONG)s->length<<1;
331                 q->seekpos=0;
332
333                 q->flags=SF_SIGNED;
334                 if(s->replen>1) q->flags|=SF_LOOP;
335
336                 /* fix replen if repend>length */
337
338                 if(q->loopend>q->length) q->loopend=q->length;
339
340                 s++;    /* point to next source sampleinfo */
341                 d++;    /* point to next destiny sampleinfo */
342         }
343
344         if(!ML_LoadPatterns()) return 0;
345         return 1;
346 }
347
348
349
350 LOADER load_mod={
351         NULL,
352         "Standard module",
353         "Portable MOD loader v0.11",
354         MOD_Init,
355         MOD_Test,
356         MOD_Load,
357         MOD_Cleanup
358 };