1 /* _______ ____ __ ___ ___
2 * \ _ \ \ / \ / \ \ / / ' ' '
3 * | | \ \ | | || | \/ | . .
4 * | | | | | | || ||\ /| |
5 * | | | | | | || || \/ | | ' ' '
6 * | | | | | | || || | | . .
7 * | |_/ / \ \__// || | |
8 * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque
9 * / \
10 * / . \
11 * readstm.c - Code to read a ScreamTracker 2 / / \ \
12 * module from an open file. | < / \_
13 * | \/ /\ /
14 * By Chris Moeller. \_ / > /
15 * | \ / /
16 * | ' /
17 * \__/
18 */
19
20 // IT_STEREO... :o
21 #include <stdlib.h>
22 #include <string.h>
23 #include <limits.h>
24
25 #include "dumb.h"
26 #include "internal/it.h"
27
28 #ifdef _MSC_VER
29 #define strnicmp _strnicmp
30 #else
31 #if defined(unix) || defined(__unix__) || defined(__unix)
32 #include <strings.h>
33 #endif
34 #define strnicmp strncasecmp
35 #endif
36
it_stm_read_sample_header(IT_SAMPLE * sample,DUMBFILE * f,unsigned short * offset)37 static int it_stm_read_sample_header( IT_SAMPLE *sample, DUMBFILE *f, unsigned short *offset )
38 {
39 dumbfile_getnc( (char *) sample->filename, 12, f );
40 sample->filename[12] = 0;
41
42 memcpy( sample->name, sample->filename, 13 );
43
44 dumbfile_skip( f, 2 );
45
46 *offset = dumbfile_igetw( f );
47
48 sample->length = dumbfile_igetw( f );
49 sample->loop_start = dumbfile_igetw( f );
50 sample->loop_end = dumbfile_igetw( f );
51
52 sample->default_volume = dumbfile_getc( f );
53
54 dumbfile_skip( f, 1 );
55
56 sample->C5_speed = dumbfile_igetw( f ) << 3;
57
58 dumbfile_skip( f, 6 );
59
60 if ( sample->length < 4 || !sample->default_volume ) {
61 /* Looks like no-existy. */
62 sample->flags &= ~IT_SAMPLE_EXISTS;
63 sample->length = 0;
64 *offset = 0;
65 return dumbfile_error( f );
66 }
67
68 sample->flags = IT_SAMPLE_EXISTS;
69 sample->global_volume = 64;
70 sample->default_pan = 0; // 0 = don't use, or 160 = centre?
71
72 if ( ( sample->loop_start < sample->length ) &&
73 ( sample->loop_end > sample->loop_start ) &&
74 ( sample->loop_end != 0xFFFF ) ) {
75 sample->flags |= IT_SAMPLE_LOOP;
76 if ( sample->loop_end > sample->length ) sample->loop_end = sample->length;
77 }
78
79 //Do we need to set all these?
80 sample->vibrato_speed = 0;
81 sample->vibrato_depth = 0;
82 sample->vibrato_rate = 0;
83 sample->vibrato_waveform = IT_VIBRATO_SINE;
84 sample->finetune = 0;
85 sample->max_resampling_quality = -1;
86
87 return dumbfile_error(f);
88 }
89
it_stm_read_sample_data(IT_SAMPLE * sample,DUMBFILE * f)90 static int it_stm_read_sample_data( IT_SAMPLE *sample, DUMBFILE * f )
91 {
92 if ( ! sample->length ) return 0;
93
94 sample->data = malloc( sample->length );
95 if (!sample->data)
96 return -1;
97
98 dumbfile_getnc( sample->data, sample->length, f );
99
100 return dumbfile_error( f );
101 }
102
it_stm_read_pattern(IT_PATTERN * pattern,DUMBFILE * f,unsigned char * buffer)103 static int it_stm_read_pattern( IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer )
104 {
105 int pos;
106 int channel;
107 int row;
108 IT_ENTRY *entry;
109
110 pattern->n_rows = 64;
111
112 if ( dumbfile_getnc( (char *) buffer, 64 * 4 * 4, f ) != 64 * 4 * 4 )
113 return -1;
114
115 pattern->n_entries = 64;
116 pos = 0;
117 for ( row = 0; row < 64; ++row ) {
118 for ( channel = 0; channel < 4; ++channel ) {
119 if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] )
120 ++pattern->n_entries;
121 pos += 4;
122 }
123 }
124
125 pattern->entry = malloc( pattern->n_entries * sizeof( *pattern->entry ) );
126 if ( !pattern->entry )
127 return -1;
128
129 entry = pattern->entry;
130 pos = 0;
131 for ( row = 0; row < 64; ++row ) {
132 for ( channel = 0; channel < 4; ++channel ) {
133 if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) {
134 unsigned note;
135 note = buffer[ pos + 0 ];
136 entry->channel = channel;
137 entry->mask = 0;
138 entry->instrument = buffer[ pos + 1 ] >> 3;
139 entry->volpan = ( buffer[ pos + 1 ] & 0x07 ) + ( buffer[ pos + 2 ] >> 1 );
140 entry->effect = buffer[ pos + 2 ] & 0x0F;
141 entry->effectvalue = buffer[ pos + 3 ];
142 if ( entry->instrument && entry->instrument < 32 )
143 entry->mask |= IT_ENTRY_INSTRUMENT;
144 if ( note < 251 ) {
145 entry->mask |= IT_ENTRY_NOTE;
146 entry->note = ( note >> 4 ) * 12 + ( note & 0x0F );
147 }
148 if ( entry->volpan <= 64 )
149 entry->mask |= IT_ENTRY_VOLPAN;
150 entry->mask |= IT_ENTRY_EFFECT;
151 switch ( entry->effect ) {
152 case IT_SET_SPEED:
153 /* taken care of in the renderer */
154 break;
155
156 case IT_BREAK_TO_ROW:
157 entry->effectvalue -= (entry->effectvalue >> 4) * 6;
158 break;
159
160 case IT_JUMP_TO_ORDER:
161 case IT_VOLUME_SLIDE:
162 case IT_PORTAMENTO_DOWN:
163 case IT_PORTAMENTO_UP:
164 case IT_TONE_PORTAMENTO:
165 case IT_VIBRATO:
166 case IT_TREMOR:
167 case IT_ARPEGGIO:
168 case IT_VOLSLIDE_VIBRATO:
169 case IT_VOLSLIDE_TONEPORTA:
170 break;
171
172 default:
173 entry->mask &= ~IT_ENTRY_EFFECT;
174 break;
175 }
176 if ( entry->mask ) ++entry;
177 }
178 pos += 4;
179 }
180 IT_SET_END_ROW(entry);
181 ++entry;
182 }
183
184 pattern->n_entries = entry - pattern->entry;
185
186 return 0;
187 }
188
189
190
it_stm_load_sigdata(DUMBFILE * f,int * version)191 static DUMB_IT_SIGDATA *it_stm_load_sigdata(DUMBFILE *f, int * version)
192 {
193 DUMB_IT_SIGDATA *sigdata;
194
195 char tracker_name[ 8 ];
196
197 unsigned short sample_offset[ 31 ];
198
199 int n;
200
201 sigdata = malloc(sizeof(*sigdata));
202 if (!sigdata) return NULL;
203
204 /* Skip song name. */
205 dumbfile_getnc((char *)sigdata->name, 20, f);
206 sigdata->name[20] = 0;
207
208 dumbfile_getnc(tracker_name, 8, f);
209 n = dumbfile_getc(f);
210 if ( n != 0x02 && n != 0x1A && n != 0x1B )
211 {
212 free( sigdata );
213 return NULL;
214 }
215 if ( dumbfile_getc(f) != 2 ) /* only support modules */
216 {
217 free( sigdata );
218 return NULL;
219 }
220 if ( strnicmp( tracker_name, "!Scream!", 8 ) &&
221 strnicmp( tracker_name, "BMOD2STM", 8 ) &&
222 strnicmp( tracker_name, "WUZAMOD!", 8 ) )
223 {
224 free( sigdata );
225 return NULL;
226 }
227
228 *version = dumbfile_mgetw(f);
229
230 sigdata->song_message = NULL;
231 sigdata->order = NULL;
232 sigdata->instrument = NULL;
233 sigdata->sample = NULL;
234 sigdata->pattern = NULL;
235 sigdata->midi = NULL;
236 sigdata->checkpoint = NULL;
237
238 sigdata->n_instruments = 0;
239 sigdata->n_samples = 31;
240 sigdata->n_pchannels = 4;
241
242 sigdata->tempo = 125;
243 sigdata->mixing_volume = 48;
244 sigdata->pan_separation = 128;
245
246 /** WARNING: which ones? */
247 sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M | IT_WAS_AN_STM | IT_STEREO;
248
249 n = dumbfile_getc(f);
250 if ( n < 32 ) n = 32;
251 sigdata->speed = n;
252 sigdata->n_patterns = dumbfile_getc(f);
253 sigdata->global_volume = dumbfile_getc(f) << 1;
254 if ( sigdata->global_volume > 128 ) sigdata->global_volume = 128;
255
256 dumbfile_skip(f, 13);
257
258 if ( dumbfile_error(f) || sigdata->n_patterns < 1 || sigdata->n_patterns > 99 ) {
259 _dumb_it_unload_sigdata(sigdata);
260 return NULL;
261 }
262
263 sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));
264 if (!sigdata->sample) {
265 _dumb_it_unload_sigdata(sigdata);
266 return NULL;
267 }
268 for (n = 0; n < sigdata->n_samples; n++)
269 sigdata->sample[n].data = NULL;
270
271 if (sigdata->n_patterns) {
272 sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));
273 if (!sigdata->pattern) {
274 _dumb_it_unload_sigdata(sigdata);
275 return NULL;
276 }
277 for (n = 0; n < sigdata->n_patterns; n++)
278 sigdata->pattern[n].entry = NULL;
279 }
280
281 memset( sigdata->channel_volume, 64, 4 );
282 n = 32 * dumb_it_default_panning_separation / 100;
283 sigdata->channel_pan[ 0 ] = 32 + n;
284 sigdata->channel_pan[ 1 ] = 32 - n;
285 sigdata->channel_pan[ 2 ] = 32 + n;
286 sigdata->channel_pan[ 3 ] = 32 - n;
287
288 for ( n = 0; n < sigdata->n_samples; ++n ) {
289 if ( it_stm_read_sample_header( &sigdata->sample[ n ], f, &sample_offset[ n ] ) ) {
290 _dumb_it_unload_sigdata( sigdata );
291 return NULL;
292 }
293 }
294
295 sigdata->order = malloc( 128 );
296 if ( !sigdata->order ) {
297 _dumb_it_unload_sigdata( sigdata );
298 return NULL;
299 }
300
301 /* Orders, byte each, length = sigdata->n_orders (should be even) */
302 dumbfile_getnc( (char *) sigdata->order, *version >= 0x200 ? 128 : 64, f );
303 if (*version < 0x200) memset( sigdata->order + 64, 0xFF, 64 );
304 sigdata->restart_position = 0;
305
306 for ( n = 127; n >= 0; --n ) {
307 if ( sigdata->order[ n ] < sigdata->n_patterns ) break;
308 }
309 if ( n < 0 ) {
310 _dumb_it_unload_sigdata( sigdata );
311 return NULL;
312 }
313 sigdata->n_orders = n + 1;
314
315 for ( n = 0; n < 128; ++n ) {
316 if ( sigdata->order[ n ] >= 99 ) sigdata->order[ n ] = 0xFF;
317 }
318
319 if ( sigdata->n_patterns ) {
320 unsigned char * buffer = malloc( 64 * 4 * 4 );
321 if ( ! buffer ) {
322 _dumb_it_unload_sigdata( sigdata );
323 return NULL;
324 }
325 for ( n = 0; n < sigdata->n_patterns; ++n ) {
326 if ( it_stm_read_pattern( &sigdata->pattern[ n ], f, buffer ) ) {
327 free( buffer );
328 _dumb_it_unload_sigdata( sigdata );
329 return NULL;
330 }
331 }
332 free( buffer );
333 }
334
335 for ( n = 0; n < sigdata->n_samples; ++n ) {
336 if ( sample_offset[ n ] )
337 {
338 if ( dumbfile_seek( f, sample_offset[ n ] * 16, DFS_SEEK_SET ) ||
339 it_stm_read_sample_data( &sigdata->sample[ n ], f ) ) {
340 _dumb_it_unload_sigdata( sigdata );
341 return NULL;
342 }
343 }
344 else
345 {
346 sigdata->sample[ n ].flags = 0;
347 sigdata->sample[ n ].length = 0;
348 }
349 }
350
351 _dumb_it_fix_invalid_orders(sigdata);
352
353 return sigdata;
354 }
355
dumb_read_stm_quick(DUMBFILE * f)356 DUH *dumb_read_stm_quick(DUMBFILE *f)
357 {
358 sigdata_t *sigdata;
359 int ver;
360
361 DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;
362
363 sigdata = it_stm_load_sigdata(f , &ver);
364
365 if (!sigdata)
366 return NULL;
367
368 {
369 char version[16];
370 const char *tag[2][2];
371 tag[0][0] = "TITLE";
372 tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name);
373 tag[1][0] = "FORMAT";
374 version[0] = 'S';
375 version[1] = 'T';
376 version[2] = 'M';
377 version[3] = ' ';
378 version[4] = 'v';
379 version[5] = '0' + ((ver >> 8) & 15);
380 version[6] = '.';
381 if ((ver & 255) > 99)
382 {
383 version[7] = '0' + ((ver & 255) / 100 );
384 version[8] = '0' + (((ver & 255) / 10) % 10);
385 version[9] = '0' + ((ver & 255) % 10);
386 version[10] = 0;
387 }
388 else
389 {
390 version[7] = '0' + ((ver & 255) / 10);
391 version[8] = '0' + ((ver & 255) % 10);
392 version[9] = 0;
393 }
394 tag[1][1] = (const char *) &version;
395 return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);
396 }
397 }
398