?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version numbers for 3.13
[maemo-rb.git] / apps / plugins / mikmod / load_stx.c
blobac6e51f4c7096ba0ef4a94655356a8aae493e85f
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_stx.c,v 1.3 2005/04/07 19:57:38 realtech Exp $
24
25 STMIK 0.2 (STX) module loader
26
27 ==============================================================================*/
28
29 /*
30
31 Written by Claudio Matsuoka <claudio@helllabs.org>
32
33 */
34
35 #ifdef HAVE_CONFIG_H
36 #include "config.h"
37 #endif
38
39 #ifdef HAVE_UNISTD_H
40 #include <unistd.h>
41 #endif
42
43 #include <stdio.h>
44 #ifdef HAVE_MEMORY_H
45 #include <memory.h>
46 #endif
47 #include <string.h>
48
49 #include "mikmod_internals.h"
50
51 #ifdef SUNOS
52 extern int fprintf(FILE *, const char *, ...);
53 #endif
54
55 /*========== Module structure */
56
57 /* header */
58 typedef struct STXHEADER {
59 CHAR songname[20];
60 CHAR trackername[8];
61 UWORD patsize;
62 UWORD unknown1;
63 UWORD patptr;
64 UWORD insptr;
65 UWORD chnptr; /* not sure */
66 UWORD unknown2;
67 UWORD unknown3;
68 UBYTE mastermult;
69 UBYTE initspeed;
70 UWORD unknown4;
71 UWORD unknown5;
72 UWORD patnum;
73 UWORD insnum;
74 UWORD ordnum;
75 UWORD unknown6;
76 UWORD unknown7;
77 UWORD unknown8;
78 CHAR scrm[4];
79 } STXHEADER;
80
81 /* sample information */
82 typedef struct STXSAMPLE {
83 UBYTE type;
84 CHAR filename[12];
85 UBYTE memsegh;
86 UWORD memsegl;
87 ULONG length;
88 ULONG loopbeg;
89 ULONG loopend;
90 UBYTE volume;
91 UBYTE dsk;
92 UBYTE pack;
93 UBYTE flags;
94 ULONG c2spd;
95 UBYTE unused[12];
96 CHAR sampname[28];
97 CHAR scrs[4];
98 } STXSAMPLE;
99
100 typedef struct STXNOTE {
101 UBYTE note,ins,vol,cmd,inf;
102 } STXNOTE;
103
104 /*========== Loader variables */
105
106 static STXNOTE *stxbuf = NULL; /* pointer to a complete STX pattern */
107 static STXHEADER *mh = NULL;
108 static UWORD *paraptr = NULL; /* parapointer array (see STX docs) */
109
110 /*========== Loader code */
111
112 static int STX_Test(void)
113 {
114 UBYTE id[8];
115 int t;
116
117 _mm_fseek(modreader,0x3C,SEEK_SET);
118 if(!_mm_read_UBYTES(id,4,modreader)) return 0;
119 if(memcmp(id,"SCRM",4)) return 0;
120
121 _mm_fseek(modreader,0x14,SEEK_SET);
122 if(!_mm_read_UBYTES(id,8,modreader)) return 0;
123
124 for(t=0;t<STM_NTRACKERS;t++)
125 if(!memcmp(id,STM_Signatures[t],8)) return 1;
126
127 return 0;
128 }
129
130 static int STX_Init(void)
131 {
132 if(!(stxbuf=(STXNOTE*)MikMod_malloc(4*64*sizeof(STXNOTE)))) return 0;
133 if(!(mh=(STXHEADER*)MikMod_malloc(sizeof(STXHEADER)))) 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 STX_Cleanup(void)
141 {
142 MikMod_free(stxbuf);
143 MikMod_free(paraptr);
144 MikMod_free(poslookup);
145 MikMod_free(mh);
146 }
147
148 static int STX_ReadPattern(void)
149 {
150 int row=0,flag,ch;
151 STXNOTE *n,dummy;
152
153 /* clear pattern data */
154 memset(stxbuf,255,4*64*sizeof(STXNOTE));
155
156 while(row<64) {
157 flag=_mm_read_UBYTE(modreader);
158
159 if(_mm_eof(modreader)) {
160 _mm_errno = MMERR_LOADING_PATTERN;
161 return 0;
162 }
163
164 if(flag) {
165 ch=flag&31;
166
167 if((ch>=0)&&(ch<4))
168 n=&stxbuf[(64U*ch)+row];
169 else
170 n=&dummy;
171
172 if(flag&32) {
173 n->note=_mm_read_UBYTE(modreader);
174 n->ins=_mm_read_UBYTE(modreader);
175 }
176 if(flag&64) {
177 n->vol=_mm_read_UBYTE(modreader);
178 if(n->vol>64) n->vol=64;
179 }
180 if(flag&128) {
181 n->cmd=_mm_read_UBYTE(modreader);
182 n->inf=_mm_read_UBYTE(modreader);
183 }
184 } else row++;
185 }
186 return 1;
187 }
188
189 static UBYTE* STX_ConvertTrack(STXNOTE* tr)
190 {
191 int t;
192
193 UniReset();
194 for(t=0;t<64;t++) {
195 UBYTE note,ins,vol,cmd,inf;
196
197 note=tr[t].note;
198 ins=tr[t].ins;
199 vol=tr[t].vol;
200 cmd=tr[t].cmd;
201 inf=tr[t].inf;
202
203 if((ins)&&(ins!=255)) UniInstrument(ins-1);
204 if((note)&&(note!=255)) {
205 if(note==254) {
206 UniPTEffect(0xc,0); /* note cut command */
207 vol=255;
208 } else UniNote(24+((note>>4)*OCTAVE)+(note&0xf)); /* normal note */
209 }
210
211 if(vol<255) UniPTEffect(0xc,vol);
212
213 if(cmd<255) switch(cmd) {
214 case 1: /* Axx set speed to xx */
215 UniPTEffect(0xf,inf>>4);
216 break;
217 case 2: /* Bxx position jump */
218 UniPTEffect(0xb,inf);
219 break;
220 case 3: /* Cxx patternbreak to row xx */
221 UniPTEffect(0xd,(((inf&0xf0)>>4)*10)+(inf&0xf));
222 break;
223 case 4: /* Dxy volumeslide */
224 UniEffect(UNI_S3MEFFECTD,inf);
225 break;
226 case 5: /* Exy toneslide down */
227 UniEffect(UNI_S3MEFFECTE,inf);
228 break;
229 case 6: /* Fxy toneslide up */
230 UniEffect(UNI_S3MEFFECTF,inf);
231 break;
232 case 7: /* Gxx Tone portamento,speed xx */
233 UniPTEffect(0x3,inf);
234 break;
235 case 8: /* Hxy vibrato */
236 UniPTEffect(0x4,inf);
237 break;
238 case 9: /* Ixy tremor, ontime x, offtime y */
239 UniEffect(UNI_S3MEFFECTI,inf);
240 break;
241 case 0: /* protracker arpeggio */
242 if(!inf) break;
243 /* fall through */
244 case 0xa: /* Jxy arpeggio */
245 UniPTEffect(0x0,inf);
246 break;
247 case 0xb: /* Kxy Dual command H00 & Dxy */
248 UniPTEffect(0x4,0);
249 UniEffect(UNI_S3MEFFECTD,inf);
250 break;
251 case 0xc: /* Lxy Dual command G00 & Dxy */
252 UniPTEffect(0x3,0);
253 UniEffect(UNI_S3MEFFECTD,inf);
254 break;
255 /* Support all these above, since ST2 can LOAD these values but can
256 actually only play up to J - and J is only half-way implemented
257 in ST2 */
258 case 0x18: /* Xxx amiga panning command 8xx */
259 UniPTEffect(0x8,inf);
260 of.flags |= UF_PANNING;
261 break;
262 }
263 UniNewline();
264 }
265 return UniDup();
266 }
267
268 static int STX_Load(int curious)
269 {
270 int t,u,track = 0;
271 int version = 0;
272 SAMPLE *q;
273
274 /* try to read module header */
275 _mm_read_string(mh->songname,20,modreader);
276 _mm_read_string(mh->trackername,8,modreader);
277 mh->patsize =_mm_read_I_UWORD(modreader);
278 mh->unknown1 =_mm_read_I_UWORD(modreader);
279 mh->patptr =_mm_read_I_UWORD(modreader);
280 mh->insptr =_mm_read_I_UWORD(modreader);
281 mh->chnptr =_mm_read_I_UWORD(modreader);
282 mh->unknown2 =_mm_read_I_UWORD(modreader);
283 mh->unknown3 =_mm_read_I_UWORD(modreader);
284 mh->mastermult =_mm_read_UBYTE(modreader);
285 mh->initspeed =_mm_read_UBYTE(modreader)>>4;
286 mh->unknown4 =_mm_read_I_UWORD(modreader);
287 mh->unknown5 =_mm_read_I_UWORD(modreader);
288 mh->patnum =_mm_read_I_UWORD(modreader);
289 mh->insnum =_mm_read_I_UWORD(modreader);
290 mh->ordnum =_mm_read_I_UWORD(modreader);
291 mh->unknown6 =_mm_read_I_UWORD(modreader);
292 mh->unknown7 =_mm_read_I_UWORD(modreader);
293 mh->unknown8 =_mm_read_I_UWORD(modreader);
294 _mm_read_string(mh->scrm,4,modreader);
295
296 if(_mm_eof(modreader)) {
297 _mm_errno = MMERR_LOADING_HEADER;
298 return 0;
299 }
300
301 /* set module variables */
302 of.songname = DupStr(mh->songname,20,1);
303 of.numpat = mh->patnum;
304 of.reppos = 0;
305 of.numins = of.numsmp = mh->insnum;
306 of.initspeed = mh->initspeed;
307 of.inittempo = 125;
308 of.numchn = 4;
309 of.flags |= UF_S3MSLIDES;
310 of.bpmlimit = 32;
311
312 if(!(paraptr=(UWORD*)MikMod_malloc((of.numins+of.numpat)*sizeof(UWORD))))
313 return 0;
314
315 /* read the instrument+pattern parapointers */
316 _mm_fseek(modreader,mh->insptr<<4,SEEK_SET);
317 _mm_read_I_UWORDS(paraptr,of.numins,modreader);
318 _mm_fseek(modreader,mh->patptr<<4,SEEK_SET);
319 _mm_read_I_UWORDS(paraptr+of.numins,of.numpat,modreader);
320
321 /* check module version */
322 _mm_fseek(modreader,paraptr[of.numins]<<4,SEEK_SET);
323 version=_mm_read_I_UWORD(modreader);
324 if(version==mh->patsize) {
325 version = 0x10;
326 of.modtype = StrDup("STMIK 0.2 (STM2STX 1.0)");
327 } else {
328 version = 0x11;
329 of.modtype = StrDup("STMIK 0.2 (STM2STX 1.1)");
330 }
331
332 /* read the order data */
333 _mm_fseek(modreader,(mh->chnptr<<4)+32,SEEK_SET);
334 if(!AllocPositions(mh->ordnum)) return 0;
335 for(t=0;t<mh->ordnum;t++) {
336 of.positions[t]=_mm_read_UBYTE(modreader);
337 _mm_fseek(modreader,4,SEEK_CUR);
338 }
339
340 of.numpos=0;poslookupcnt=mh->ordnum;
341 for(t=0;t<mh->ordnum;t++) {
342 int order=of.positions[t];
343 if(order==255) order=LAST_PATTERN;
344 of.positions[of.numpos]=order;
345 poslookup[t]=of.numpos; /* bug fix for freaky S3Ms */
346 if(of.positions[t]<254) of.numpos++;
347 else
348 /* special end of song pattern */
349 if((order==LAST_PATTERN)&&(!curious)) break;
350 }
351
352 if(_mm_eof(modreader)) {
353 _mm_errno = MMERR_LOADING_HEADER;
354 return 0;
355 }
356
357 /* load samples */
358 if(!AllocSamples()) return 0;
359 for(q=of.samples,t=0;t<of.numins;t++,q++) {
360 STXSAMPLE 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 if(_mm_eof(modreader)) {
382 _mm_errno = MMERR_LOADING_SAMPLEINFO;
383 return 0;
384 }
385
386 q->samplename = DupStr(s.sampname,28,1);
387 q->speed = (s.c2spd * 8363) / 8448;
388 q->length = s.length;
389 q->loopstart = s.loopbeg;
390 q->loopend = s.loopend;
391 q->volume = s.volume;
392 q->seekpos = (((long)s.memsegh)<<16|s.memsegl)<<4;
393 q->flags |= SF_SIGNED;
394
395 if(s.flags&1) q->flags |= SF_LOOP;
396 if(s.flags&4) q->flags |= SF_16BITS;
397 }
398
399 /* load pattern info */
400 of.numtrk=of.numpat*of.numchn;
401 if(!AllocTracks()) return 0;
402 if(!AllocPatterns()) return 0;
403
404 for(t=0;t<of.numpat;t++) {
405 /* seek to pattern position (+2 skip pattern length) */
406 _mm_fseek(modreader,(((long)paraptr[of.numins+t])<<4)+
407 (version==0x10?2:0),SEEK_SET);
408 if(!STX_ReadPattern()) return 0;
409 for(u=0;u<of.numchn;u++)
410 if(!(of.tracks[track++]=STX_ConvertTrack(&stxbuf[u*64]))) return 0;
411 }
412
413 return 1;
414 }
415
416 static CHAR *STX_LoadTitle(void)
417 {
418 CHAR s[28];
419
420 _mm_fseek(modreader,0,SEEK_SET);
421 if(!_mm_read_UBYTES(s,20,modreader)) return NULL;
422
423 return(DupStr(s,28,1));
424 }
425
426 /*========== Loader information */
427
428 MIKMODAPI MLOADER load_stx={
429 NULL,
430 "STX",
431 "STX (Scream Tracker Music Interface Kit)",
432 STX_Init,
433 STX_Test,
434 STX_Load,
435 STX_Cleanup,
436 STX_LoadTitle
437 };
438
439 /* ex:set ts=4: */
thomasjfox's rockbox modifications (mameo port)