?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
FS#12756 by Marek Salaba - update Czech translation
[maemo-rb.git] / apps / plugins / mikmod / load_m15.c
blobb5d5329bf047dadd6cebdb9b77b7a425ba5f3aee
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_m15.c,v 1.3 2005/04/07 19:57:38 realtech Exp $
24
25 15 instrument MOD loader
26 Also supports Ultimate Sound Tracker (old M15 format)
27
28 ==============================================================================*/
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #include <ctype.h>
39 #include <stdio.h>
40 #ifdef HAVE_MEMORY_H
41 #include <memory.h>
42 #endif
43 #include <string.h>
44
45 #include "mikmod_internals.h"
46
47 #ifdef SUNOS
48 extern int fprintf(FILE *, const char *, ...);
49 #endif
50
51 /*========== Module Structure */
52
53 typedef struct MSAMPINFO {
54 CHAR samplename[23]; /* 22 in module, 23 in memory */
55 UWORD length;
56 UBYTE finetune;
57 UBYTE volume;
58 UWORD reppos;
59 UWORD replen;
60 } MSAMPINFO;
61
62 typedef struct MODULEHEADER {
63 CHAR songname[21]; /* the songname.., 20 in module, 21 in memory */
64 MSAMPINFO samples[15]; /* all sampleinfo */
65 UBYTE songlength; /* number of patterns used */
66 UBYTE magic1; /* should be 127 */
67 UBYTE positions[128]; /* which pattern to play at pos */
68 } MODULEHEADER;
69
70 typedef struct MODNOTE {
71 UBYTE a,b,c,d;
72 } MODNOTE;
73
74 /*========== Loader variables */
75
76 static MODULEHEADER *mh = NULL;
77 static MODNOTE *patbuf = NULL;
78 static int ust_loader = 0; /* if TRUE, load as an ust module. */
79
80 /* known file formats which can confuse the loader */
81 #define REJECT 2
82 static char *signatures[REJECT]={
83 "CAKEWALK", /* cakewalk midi files */
84 "SZDD" /* Microsoft compressed files */
85 };
86 static int siglen[REJECT]={8,4};
87
88 /*========== Loader code */
89
90 static int LoadModuleHeader(MODULEHEADER *mh)
91 {
92 int t,u;
93
94 _mm_read_string(mh->songname,20,modreader);
95 mh->songname[20]=0; /* just in case */
96
97 /* sanity check : title should contain printable characters and a bunch
98 of null chars */
99 for(t=0;t<20;t++)
100 if((mh->songname[t])&&(mh->songname[t]<32)) return 0;
101 for(t=0;(mh->songname[t])&&(t<20);t++);
102 if(t<20) for(;t<20;t++) if(mh->songname[t]) return 0;
103
104 for(t=0;t<15;t++) {
105 MSAMPINFO *s=&mh->samples[t];
106
107 _mm_read_string(s->samplename,22,modreader);
108 s->samplename[22]=0; /* just in case */
109 s->length =_mm_read_M_UWORD(modreader);
110 s->finetune =_mm_read_UBYTE(modreader);
111 s->volume =_mm_read_UBYTE(modreader);
112 s->reppos =_mm_read_M_UWORD(modreader);
113 s->replen =_mm_read_M_UWORD(modreader);
114
115 /* sanity check : sample title should contain printable characters and
116 a bunch of null chars */
117 for(u=0;u<20;u++)
118 if((s->samplename[u])&&(s->samplename[u]</*32*/14)) return 0;
119 for(u=0;(s->samplename[u])&&(u<20);u++);
120 if(u<20) for(;u<20;u++) if(s->samplename[u]) return 0;
121
122 /* sanity check : finetune values */
123 if(s->finetune>>4) return 0;
124 }
125
126 mh->songlength =_mm_read_UBYTE(modreader);
127 mh->magic1 =_mm_read_UBYTE(modreader); /* should be 127 */
128
129 /* sanity check : no more than 128 positions, restart position in range */
130 if((!mh->songlength)||(mh->songlength>128)) return 0;
131 /* values encountered so far are 0x6a and 0x78 */
132 if(((mh->magic1&0xf8)!=0x78)&&(mh->magic1!=0x6a)&&(mh->magic1>mh->songlength)) return 0;
133
134 _mm_read_UBYTES(mh->positions,128,modreader);
135
136 /* sanity check : pattern range is 0..63 */
137 for(t=0;t<128;t++)
138 if(mh->positions[t]>63) return 0;
139
140 return(!_mm_eof(modreader));
141 }
142
143 /* Checks the patterns in the modfile for UST / 15-inst indications.
144 For example, if an effect 3xx is found, it is assumed that the song
145 is 15-inst. If a 1xx effect has dat greater than 0x20, it is UST.
146
147 Returns: 0 indecisive; 1 = UST; 2 = 15-inst */
148 static int CheckPatternType(int numpat)
149 {
150 unsigned int t;
151 UBYTE eff, dat;
152
153 for(t=0;t<numpat*(64U*4);t++) {
154 /* Load the pattern into the temp buffer and scan it */
155 (void)_mm_read_UBYTE(modreader);(void)_mm_read_UBYTE(modreader);
156 eff = _mm_read_UBYTE(modreader);
157 dat = _mm_read_UBYTE(modreader);
158
159 switch(eff) {
160 case 1:
161 if(dat>0x1f) return 1;
162 if(dat<0x3) return 2;
163 break;
164 case 2:
165 if(dat>0x1f) return 1;
166 return 2;
167 case 3:
168 if (dat) return 2;
169 break;
170 default:
171 return 2;
172 }
173 }
174 return 0;
175 }
176
177 static int M15_Test(void)
178 {
179 int t, numpat;
180 MODULEHEADER mh;
181
182 ust_loader = 0;
183 if(!LoadModuleHeader(&mh)) return 0;
184
185 /* reject other file types */
186 for(t=0;t<REJECT;t++)
187 if(!memcmp(mh.songname,signatures[t],siglen[t])) return 0;
188
189 if(mh.magic1>127) return 0;
190 if((!mh.songlength)||(mh.songlength>mh.magic1)) return 0;
191
192 for(t=0;t<15;t++) {
193 /* all finetunes should be zero */
194 if(mh.samples[t].finetune) return 0;
195
196 /* all volumes should be <= 64 */
197 if(mh.samples[t].volume>64) return 0;
198
199 /* all instrument names should begin with s, st-, or a number */
200 if((mh.samples[t].samplename[0]=='s')||
201 (mh.samples[t].samplename[0]=='S')) {
202 if((memcmp(mh.samples[t].samplename,"st-",3)) &&
203 (memcmp(mh.samples[t].samplename,"ST-",3)) &&
204 (*mh.samples[t].samplename))
205 ust_loader = 1;
206 } else
207 if(!isdigit((int)mh.samples[t].samplename[0]))
208 ust_loader = 1;
209
210 if(mh.samples[t].length>4999||mh.samples[t].reppos>9999) {
211 ust_loader = 0;
212 if(mh.samples[t].length>32768) return 0;
213 }
214
215 /* if loop information is incorrect as words, but correct as bytes,
216 this is likely to be an ust-style module */
217 if((mh.samples[t].reppos+mh.samples[t].replen>mh.samples[t].length)&&
218 (mh.samples[t].reppos+mh.samples[t].replen<(mh.samples[t].length<<1))){
219 ust_loader = 1;
220 return 1;
221 }
222
223 if(!ust_loader) return 1;
224 }
225
226 for(numpat=0,t=0;t<mh.songlength;t++)
227 if(mh.positions[t]>numpat)
228 numpat = mh.positions[t];
229 numpat++;
230 switch(CheckPatternType(numpat)) {
231 case 0: /* indecisive, so check more clues... */
232 break;
233 case 1:
234 ust_loader = 1;
235 break;
236 case 2:
237 ust_loader = 0;
238 break;
239 }
240 return 1;
241 }
242
243 static int M15_Init(void)
244 {
245 if(!(mh=(MODULEHEADER*)MikMod_malloc(sizeof(MODULEHEADER)))) return 0;
246 return 1;
247 }
248
249 static void M15_Cleanup(void)
250 {
251 MikMod_free(mh);
252 MikMod_free(patbuf);
253 }
254
255 /*
256 Old (amiga) noteinfo:
257
258 _____byte 1_____ byte2_ _____byte 3_____ byte4_
259 / \ / \ / \ / \
260 0000 0000-00000000 0000 0000-00000000
261
262 Upper four 12 bits for Lower four Effect command.
263 bits of sam- note period. bits of sam-
264 ple number. ple number.
265 */
266
267 static UBYTE M15_ConvertNote(MODNOTE* n, UBYTE lasteffect)
268 {
269 UBYTE instrument,effect,effdat,note;
270 UWORD period;
271 UBYTE lastnote=0;
272
273 /* decode the 4 bytes that make up a single note */
274 instrument = n->c>>4;
275 period = (((UWORD)n->a&0xf)<<8)+n->b;
276 effect = n->c&0xf;
277 effdat = n->d;
278
279 /* Convert the period to a note number */
280 note=0;
281 if(period) {
282 for(note=0;note<7*OCTAVE;note++)
283 if(period>=npertab[note]) break;
284 if(note==7*OCTAVE) note=0;
285 else note++;
286 }
287
288 if(instrument) {
289 /* if instrument does not exist, note cut */
290 if((instrument>15)||(!mh->samples[instrument-1].length)) {
291 UniPTEffect(0xc,0);
292 if(effect==0xc) effect=effdat=0;
293 } else {
294 /* if we had a note, then change instrument... */
295 if(note)
296 UniInstrument(instrument-1);
297 /* ...otherwise, only adjust volume... */
298 else {
299 /* ...unless an effect was specified, which forces a new note
300 to be played */
301 if(effect||effdat) {
302 UniInstrument(instrument-1);
303 note=lastnote;
304 } else
305 UniPTEffect(0xc,mh->samples[instrument-1].volume&0x7f);
306 }
307 }
308 }
309 if(note) {
310 UniNote(note+2*OCTAVE-1);
311 lastnote=note;
312 }
313
314 /* Convert pattern jump from Dec to Hex */
315 if(effect == 0xd)
316 effdat=(((effdat&0xf0)>>4)*10)+(effdat&0xf);
317
318 /* Volume slide, up has priority */
319 if((effect==0xa)&&(effdat&0xf)&&(effdat&0xf0))
320 effdat&=0xf0;
321
322 /* Handle ``heavy'' volumes correctly */
323 if ((effect == 0xc) && (effdat > 0x40))
324 effdat = 0x40;
325
326 if(ust_loader) {
327 switch(effect) {
328 case 0:
329 case 3:
330 break;
331 case 1:
332 UniPTEffect(0,effdat);
333 break;
334 case 2:
335 if(effdat&0xf) UniPTEffect(1,effdat&0xf);
336 else if(effdat>>2) UniPTEffect(2,effdat>>2);
337 break;
338 default:
339 UniPTEffect(effect,effdat);
340 break;
341 }
342 } else {
343 /* An isolated 100, 200 or 300 effect should be ignored (no
344 "standalone" porta memory in mod files). However, a sequence
345 such as 1XX, 100, 100, 100 is fine. */
346 if ((!effdat) && ((effect == 1)||(effect == 2)||(effect ==3)) &&
347 (lasteffect < 0x10) && (effect != lasteffect))
348 effect = 0;
349
350 UniPTEffect(effect,effdat);
351 }
352 if (effect == 8)
353 of.flags |= UF_PANNING;
354
355 return effect;
356 }
357
358 static UBYTE *M15_ConvertTrack(MODNOTE* n)
359 {
360 int t;
361 UBYTE lasteffect = 0x10; /* non existant effect */
362
363 UniReset();
364 for(t=0;t<64;t++) {
365 lasteffect = M15_ConvertNote(n,lasteffect);
366 UniNewline();
367 n+=4;
368 }
369 return UniDup();
370 }
371
372 /* Loads all patterns of a modfile and converts them into the 3 byte format. */
373 static int M15_LoadPatterns(void)
374 {
375 int t,tracks=0;
376 unsigned int s;
377
378 if(!AllocPatterns()) return 0;
379 if(!AllocTracks()) return 0;
380
381 /* Allocate temporary buffer for loading and converting the patterns */
382 if(!(patbuf=(MODNOTE*)MikMod_calloc(64U*4,sizeof(MODNOTE)))) return 0;
383
384 for(t=0;t<of.numpat;t++) {
385 /* Load the pattern into the temp buffer and convert it */
386 for(s=0;s<(64U*4);s++) {
387 patbuf[s].a=_mm_read_UBYTE(modreader);
388 patbuf[s].b=_mm_read_UBYTE(modreader);
389 patbuf[s].c=_mm_read_UBYTE(modreader);
390 patbuf[s].d=_mm_read_UBYTE(modreader);
391 }
392
393 for(s=0;s<4;s++)
394 if(!(of.tracks[tracks++]=M15_ConvertTrack(patbuf+s))) return 0;
395 }
396 return 1;
397 }
398
399 static int M15_Load(int curious)
400 {
401 int t,scan;
402 SAMPLE *q;
403 MSAMPINFO *s;
404
405 /* try to read module header */
406 if(!LoadModuleHeader(mh)) {
407 _mm_errno = MMERR_LOADING_HEADER;
408 return 0;
409 }
410
411 if(ust_loader)
412 of.modtype = StrDup("Ultimate Soundtracker");
413 else
414 of.modtype = StrDup("Soundtracker");
415
416 /* set module variables */
417 of.initspeed = 6;
418 of.inittempo = 125;
419 of.numchn = 4;
420 of.songname = DupStr(mh->songname,21,1);
421 of.numpos = mh->songlength;
422 of.reppos = 0;
423
424 /* Count the number of patterns */
425 of.numpat = 0;
426 for(t=0;t<of.numpos;t++)
427 if(mh->positions[t]>of.numpat)
428 of.numpat=mh->positions[t];
429 /* since some old modules embed extra patterns, we have to check the
430 whole list to get the samples' file offsets right - however we can find
431 garbage here, so check carefully */
432 scan=1;
433 for(t=of.numpos;t<128;t++)
434 if(mh->positions[t]>=0x80) scan=0;
435 if (scan)
436 for(t=of.numpos;t<128;t++) {
437 if(mh->positions[t]>of.numpat)
438 of.numpat=mh->positions[t];
439 if((curious)&&(mh->positions[t])) of.numpos=t+1;
440 }
441 of.numpat++;
442 of.numtrk = of.numpat*of.numchn;
443
444 if(!AllocPositions(of.numpos)) return 0;
445 for(t=0;t<of.numpos;t++)
446 of.positions[t]=mh->positions[t];
447
448 /* Finally, init the sampleinfo structures */
449 of.numins=of.numsmp=15;
450 if(!AllocSamples()) return 0;
451
452 s = mh->samples;
453 q = of.samples;
454
455 for(t=0;t<of.numins;t++) {
456 /* convert the samplename */
457 q->samplename = DupStr(s->samplename,23,1);
458
459 /* init the sampleinfo variables and convert the size pointers */
460 q->speed = finetune[s->finetune&0xf];
461 q->volume = s->volume;
462 if(ust_loader)
463 q->loopstart = s->reppos;
464 else
465 q->loopstart = s->reppos<<1;
466 q->loopend = q->loopstart+(s->replen<<1);
467 q->length = s->length<<1;
468
469 q->flags = SF_SIGNED;
470 if(ust_loader) q->flags |= SF_UST_LOOP;
471 if(s->replen>2) q->flags |= SF_LOOP;
472
473 s++;
474 q++;
475 }
476
477 if(!M15_LoadPatterns()) return 0;
478 ust_loader = 0;
479
480 return 1;
481 }
482
483 static CHAR *M15_LoadTitle(void)
484 {
485 CHAR s[21];
486
487 _mm_fseek(modreader,0,SEEK_SET);
488 if(!_mm_read_UBYTES(s,20,modreader)) return NULL;
489 s[20]=0; /* just in case */
490 return(DupStr(s,21,1));
491 }
492
493 /*========== Loader information */
494
495 MIKMODAPI MLOADER load_m15={
496 NULL,
497 "15-instrument module",
498 "MOD (15 instrument)",
499 M15_Init,
500 M15_Test,
501 M15_Load,
502 M15_Cleanup,
503 M15_LoadTitle
504 };
505
506 /* ex:set ts=4: */
thomasjfox's rockbox modifications (mameo port)