1 /*
2 * Schism Tracker - a cross-platform Impulse Tracker clone
3 * copyright (c) 2003-2005 Storlek <storlek@rigelseven.com>
4 * copyright (c) 2005-2008 Mrs. Brisby <mrs.brisby@nimh.org>
5 * copyright (c) 2009 Storlek & Mrs. Brisby
6 * copyright (c) 2010-2012 Storlek
7 * URL: http://schismtracker.org/
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #define NEED_BYTESWAP
25 #define NEED_TIME
26 #include "headers.h"
27
28 #include <math.h>
29 #include <stdint.h>
30 #include <assert.h>
31
32 #include "sndfile.h"
33 #include "log.h"
34 #include "util.h"
35 #include "fmt.h" // for it_decompress8 / it_decompress16
36
37
_csf_reset(song_t * csf)38 static void _csf_reset(song_t *csf)
39 {
40 unsigned int i;
41
42 csf->flags = 0;
43 csf->pan_separation = 128;
44 csf->num_voices = 0;
45 csf->freq_factor = csf->tempo_factor = 128;
46 csf->initial_global_volume = 128;
47 csf->current_global_volume = 128;
48 csf->initial_speed = 6;
49 csf->initial_tempo = 125;
50 csf->process_row = 0;
51 csf->row = 0;
52 csf->current_pattern = 0;
53 csf->current_order = 0;
54 csf->process_order = 0;
55 csf->mixing_volume = 0x30;
56 memset(csf->message, 0, sizeof(csf->message));
57
58 csf->row_highlight_major = 16;
59 csf->row_highlight_minor = 4;
60
61 /* This is intentionally crappy quality, so that it's very obvious if it didn't get initialized */
62 csf->mix_flags = 0;
63 csf->mix_frequency = 4000;
64 csf->mix_bits_per_sample = 8;
65 csf->mix_channels = 1;
66
67 memset(csf->voices, 0, sizeof(csf->voices));
68 memset(csf->voice_mix, 0, sizeof(csf->voice_mix));
69 memset(csf->samples, 0, sizeof(csf->samples));
70 memset(csf->instruments, 0, sizeof(csf->instruments));
71 memset(csf->orderlist, 0xFF, sizeof(csf->orderlist));
72 memset(csf->patterns, 0, sizeof(csf->patterns));
73
74 csf_reset_midi_cfg(csf);
75 csf_forget_history(csf);
76
77 for (i = 0; i < MAX_PATTERNS; i++) {
78 csf->pattern_size[i] = 64;
79 csf->pattern_alloc_size[i] = 64;
80 }
81 for (i = 0; i < MAX_SAMPLES; i++) {
82 csf->samples[i].c5speed = 8363;
83 csf->samples[i].volume = 64 * 4;
84 csf->samples[i].global_volume = 64;
85 }
86 for (i = 0; i < MAX_CHANNELS; i++) {
87 csf->channels[i].panning = 128;
88 csf->channels[i].volume = 64;
89 csf->channels[i].flags = 0;
90 }
91 }
92
93 //////////////////////////////////////////////////////////
94 // song_t
95
csf_allocate(void)96 song_t *csf_allocate(void)
97 {
98 song_t *csf = mem_calloc(1, sizeof(song_t));
99 _csf_reset(csf);
100 return csf;
101 }
102
csf_free(song_t * csf)103 void csf_free(song_t *csf)
104 {
105 if (csf) {
106 csf_destroy(csf);
107 free(csf);
108 }
109 }
110
111
_init_envelope(song_envelope_t * env,int n)112 static void _init_envelope(song_envelope_t *env, int n)
113 {
114 env->nodes = 2;
115 env->ticks[0] = 0;
116 env->ticks[1] = 100;
117 env->values[0] = n;
118 env->values[1] = n;
119 }
120
csf_init_instrument(song_instrument_t * ins,int samp)121 void csf_init_instrument(song_instrument_t *ins, int samp)
122 {
123 int n;
124
125 memset(ins, 0, sizeof(*ins));
126 _init_envelope(&ins->vol_env, 64);
127 _init_envelope(&ins->pan_env, 32);
128 _init_envelope(&ins->pitch_env, 32);
129 ins->global_volume = 128;
130 ins->panning = 128;
131 ins->midi_bank = -1;
132 ins->midi_program = -1;
133 ins->pitch_pan_center = 60; // why does pitch/pan not use the same note values as everywhere else?!
134 for (n = 0; n < 128; n++) {
135 ins->sample_map[n] = samp;
136 ins->note_map[n] = n + 1;
137 }
138 }
139
csf_allocate_instrument(void)140 song_instrument_t *csf_allocate_instrument(void)
141 {
142 song_instrument_t *ins = mem_alloc(sizeof(song_instrument_t));
143 csf_init_instrument(ins, 0);
144 return ins;
145 }
146
csf_free_instrument(song_instrument_t * i)147 void csf_free_instrument(song_instrument_t *i)
148 {
149 free(i);
150 }
151
152
csf_destroy(song_t * csf)153 void csf_destroy(song_t *csf)
154 {
155 int i;
156
157 for (i = 0; i < MAX_PATTERNS; i++) {
158 if (csf->patterns[i]) {
159 csf_free_pattern(csf->patterns[i]);
160 csf->patterns[i] = NULL;
161 }
162 }
163 for (i = 1; i < MAX_SAMPLES; i++) {
164 song_sample_t *pins = &csf->samples[i];
165 if (pins->data) {
166 csf_free_sample(pins->data);
167 pins->data = NULL;
168 }
169 }
170 for (i = 0; i < MAX_INSTRUMENTS; i++) {
171 if (csf->instruments[i]) {
172 csf_free_instrument(csf->instruments[i]);
173 csf->instruments[i] = NULL;
174 }
175 }
176
177 _csf_reset(csf);
178 }
179
csf_allocate_pattern(uint32_t rows)180 song_note_t *csf_allocate_pattern(uint32_t rows)
181 {
182 return mem_calloc(rows * MAX_CHANNELS, sizeof(song_note_t));
183 }
184
csf_free_pattern(void * pat)185 void csf_free_pattern(void *pat)
186 {
187 free(pat);
188 }
189
190 /* Note: this function will appear in valgrind to be a sieve for memory leaks.
191 It isn't; it's just being confused by the adjusted pointer being stored. */
csf_allocate_sample(uint32_t nbytes)192 signed char *csf_allocate_sample(uint32_t nbytes)
193 {
194 signed char *p = mem_calloc(1, (nbytes + 39) & ~7); // magic
195 if (p)
196 p += 16;
197 return p;
198 }
199
csf_free_sample(void * p)200 void csf_free_sample(void *p)
201 {
202 if (p)
203 free(p - 16);
204 }
205
csf_forget_history(song_t * csf)206 void csf_forget_history(song_t *csf)
207 {
208 free(csf->histdata);
209 csf->histdata = NULL;
210 csf->histlen = 0;
211 gettimeofday(&csf->editstart, NULL);
212 }
213
214 /* --------------------------------------------------------------------------------------------------------- */
215 /* Counting and checking stuff. */
216
name_is_blank(char * name)217 static int name_is_blank(char *name)
218 {
219 int n;
220 for (n = 0; n < 25; n++) {
221 if (name[n] != '\0' && name[n] != ' ')
222 return 0;
223 }
224 return 1;
225 }
226
227 const song_note_t blank_pattern[64 * 64];
228 const song_note_t *blank_note = blank_pattern; // Same thing, really.
229
csf_note_is_empty(song_note_t * note)230 int csf_note_is_empty(song_note_t *note)
231 {
232 return !memcmp(note, blank_pattern, sizeof(song_note_t));
233 }
234
csf_pattern_is_empty(song_t * csf,int n)235 int csf_pattern_is_empty(song_t *csf, int n)
236 {
237 if (!csf->patterns[n])
238 return 1;
239 if (csf->pattern_size[n] != 64)
240 return 0;
241 return !memcmp(csf->patterns[n], blank_pattern, sizeof(blank_pattern));
242 }
243
csf_sample_is_empty(song_sample_t * smp)244 int csf_sample_is_empty(song_sample_t *smp)
245 {
246 return (smp->data == NULL
247 && name_is_blank(smp->name)
248 && smp->filename[0] == '\0'
249 && smp->c5speed == 8363
250 && smp->volume == 64*4 //mphack
251 && smp->global_volume == 64
252 && smp->panning == 0
253 && !(smp->flags & (CHN_LOOP | CHN_SUSTAINLOOP | CHN_PANNING))
254 && smp->length == 0
255 && smp->loop_start == 0
256 && smp->loop_end == 0
257 && smp->sustain_start == 0
258 && smp->sustain_end == 0
259 && smp->vib_type == VIB_SINE
260 && smp->vib_rate == 0
261 && smp->vib_depth == 0
262 && smp->vib_speed == 0
263 );
264 }
265
env_is_blank(song_envelope_t * env,int value)266 static int env_is_blank(song_envelope_t *env, int value)
267 {
268 return (env->nodes == 2
269 && env->loop_start == 0
270 && env->loop_end == 0
271 && env->sustain_start == 0
272 && env->sustain_end == 0
273 && env->ticks[0] == 0
274 && env->ticks[1] == 100
275 && env->values[0] == value
276 && env->values[1] == value
277 );
278 }
279
csf_instrument_is_empty(song_instrument_t * ins)280 int csf_instrument_is_empty(song_instrument_t *ins)
281 {
282 int n;
283 if (!ins)
284 return 1;
285
286 for (n = 0; n < NOTE_LAST - NOTE_FIRST; n++) {
287 if (ins->sample_map[n] != 0 || ins->note_map[n] != (n + NOTE_FIRST))
288 return 0;
289 }
290 return (name_is_blank(ins->name)
291 && ins->filename[0] == '\0'
292 && ins->flags == 0 /* No envelopes, loop points, panning, or carry flags set */
293 && ins->nna == NNA_NOTECUT
294 && ins->dct == DCT_NONE
295 && ins->dca == DCA_NOTECUT
296 && env_is_blank(&ins->vol_env, 64)
297 && ins->global_volume == 128
298 && ins->fadeout == 0
299 && ins->vol_swing == 0
300 && env_is_blank(&ins->pan_env, 32)
301 && ins->panning == 32*4 //mphack
302 && ins->pitch_pan_center == 60 // C-5 (blah)
303 && ins->pitch_pan_separation == 0
304 && ins->pan_swing == 0
305 && env_is_blank(&ins->pitch_env, 32)
306 && ins->ifc == 0
307 && ins->ifr == 0
308 && ins->midi_channel_mask == 0
309 && ins->midi_program == -1
310 && ins->midi_bank == -1
311 );
312 }
313
314 // IT-compatible: last order of "main song", or 0
csf_last_order(song_t * csf)315 int csf_last_order(song_t *csf)
316 {
317 int n = 0;
318 while (n < MAX_ORDERS && csf->orderlist[n] != ORDER_LAST)
319 n++;
320 return n ? n - 1 : 0;
321 }
322
323 // Total count of orders in orderlist before end of data
csf_get_num_orders(song_t * csf)324 int csf_get_num_orders(song_t *csf)
325 {
326 int n = MAX_ORDERS;
327 while (n >= 0 && csf->orderlist[--n] == ORDER_LAST) {
328 }
329 return n + 1;
330 }
331
332 // Total number of non-empty patterns in song, according to csf_pattern_is_empty
csf_get_num_patterns(song_t * csf)333 int csf_get_num_patterns(song_t *csf)
334 {
335 int n = MAX_PATTERNS - 1;
336 while (n && csf_pattern_is_empty(csf, n))
337 n--;
338 return n+ 1;
339 }
340
csf_get_num_samples(song_t * csf)341 int csf_get_num_samples(song_t *csf)
342 {
343 int n = MAX_SAMPLES - 1;
344 while (n > 0 && csf_sample_is_empty(csf->samples + n))
345 n--;
346 return n;
347 }
348
csf_get_num_instruments(song_t * csf)349 int csf_get_num_instruments(song_t *csf)
350 {
351 int n = MAX_INSTRUMENTS - 1;
352 while (n > 0 && csf_instrument_is_empty(csf->instruments[n]))
353 n--;
354 return n;
355 }
356
357
csf_first_blank_sample(song_t * csf,int start)358 int csf_first_blank_sample(song_t *csf, int start)
359 {
360 int n;
361 for (n = MAX(start, 1); n < MAX_SAMPLES; n++) {
362 if (csf_sample_is_empty(csf->samples + n))
363 return n;
364 }
365 return -1;
366 }
367
csf_first_blank_instrument(song_t * csf,int start)368 int csf_first_blank_instrument(song_t *csf, int start)
369 {
370 int n;
371 for (n = MAX(start, 1); n < MAX_INSTRUMENTS; n++) {
372 if (csf_instrument_is_empty(csf->instruments[n]))
373 return n;
374 }
375 return -1;
376 }
377
378
379 // FIXME this function sucks
csf_get_highest_used_channel(song_t * csf)380 int csf_get_highest_used_channel(song_t *csf)
381 {
382 int highchan = 0, ipat, j, jmax;
383 song_note_t *p;
384
385 for (ipat = 0; ipat < MAX_PATTERNS; ipat++) {
386 p = csf->patterns[ipat];
387 if (!p)
388 continue;
389 jmax = csf->pattern_size[ipat] * MAX_CHANNELS;
390 for (j = 0; j < jmax; j++, p++) {
391 if (NOTE_IS_NOTE(p->note)) {
392 if ((j % MAX_CHANNELS) > highchan)
393 highchan = j % MAX_CHANNELS;
394 }
395 }
396 }
397
398 return highchan;
399 }
400
401 //////////////////////////////////////////////////////////////////////////
402 // Misc functions
403
404 midi_config_t default_midi_config;
405
406
csf_reset_midi_cfg(song_t * csf)407 void csf_reset_midi_cfg(song_t *csf)
408 {
409 memcpy(&csf->midi_config, &default_midi_config, sizeof(default_midi_config));
410 }
411
csf_copy_midi_cfg(song_t * dest,song_t * src)412 void csf_copy_midi_cfg(song_t *dest, song_t *src)
413 {
414 memcpy(&dest->midi_config, &src->midi_config, sizeof(midi_config_t));
415 }
416
417
csf_set_wave_config(song_t * csf,uint32_t rate,uint32_t bits,uint32_t channels)418 int csf_set_wave_config(song_t *csf, uint32_t rate,uint32_t bits,uint32_t channels)
419 {
420 int reset = ((csf->mix_frequency != rate)
421 || (csf->mix_bits_per_sample != bits)
422 || (csf->mix_channels != channels));
423 csf->mix_channels = channels;
424 csf->mix_frequency = rate;
425 csf->mix_bits_per_sample = bits;
426 csf_init_player(csf, reset);
427 return 1;
428 }
429
430
csf_set_resampling_mode(song_t * csf,uint32_t mode)431 int csf_set_resampling_mode(song_t *csf, uint32_t mode)
432 {
433 uint32_t d = csf->mix_flags & ~(SNDMIX_NORESAMPLING|SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE);
434 switch(mode) {
435 case SRCMODE_NEAREST: d |= SNDMIX_NORESAMPLING; break;
436 case SRCMODE_LINEAR: break;
437 case SRCMODE_SPLINE: d |= SNDMIX_HQRESAMPLER; break;
438 case SRCMODE_POLYPHASE: d |= (SNDMIX_HQRESAMPLER|SNDMIX_ULTRAHQSRCMODE); break;
439 default: return 0;
440 }
441 csf->mix_flags = d;
442 return 1;
443 }
444
445
446 // This used to use some retarded positioning based on the total number of rows elapsed, which is useless.
447 // However, the only code calling this function is in this file, to set it to the start, so I'm optimizing
448 // out the row count.
set_current_pos_0(song_t * csf)449 static void set_current_pos_0(song_t *csf)
450 {
451 song_voice_t *v = csf->voices;
452 for (uint32_t i = 0; i < MAX_VOICES; i++, v++) {
453 memset(v, 0, sizeof(*v));
454 v->cutoff = 0x7F;
455 v->volume = 256;
456 if (i < MAX_CHANNELS) {
457 v->panning = csf->channels[i].panning;
458 v->global_volume = csf->channels[i].volume;
459 v->flags = csf->channels[i].flags;
460 } else {
461 v->panning = 128;
462 v->global_volume = 64;
463 }
464 }
465 csf->current_global_volume = csf->initial_global_volume;
466 csf->current_speed = csf->initial_speed;
467 csf->current_tempo = csf->initial_tempo;
468 }
469
470
csf_set_current_order(song_t * csf,uint32_t position)471 void csf_set_current_order(song_t *csf, uint32_t position)
472 {
473 for (uint32_t j = 0; j < MAX_VOICES; j++) {
474 song_voice_t *v = csf->voices + j;
475
476 v->frequency = 0;
477 v->note = v->new_note = v->new_instrument = 0;
478 v->portamento_target = 0;
479 v->n_command = 0;
480 v->cd_patloop = 0;
481 v->patloop_row = 0;
482 v->cd_tremor = 0;
483 // modplug sets vib pos to 16 in old effects mode for some reason *shrug*
484 v->vibrato_position = (csf->flags & SONG_ITOLDEFFECTS) ? 0 : 0x10;
485 v->tremolo_position = 0;
486 }
487 if (position > MAX_ORDERS)
488 position = 0;
489 if (!position)
490 set_current_pos_0(csf);
491
492 csf->process_order = position - 1;
493 csf->process_row = PROCESS_NEXT_ORDER;
494 csf->row = 0;
495 csf->break_row = 0; /* set this to whatever row to jump to */
496 csf->tick_count = 1;
497 csf->row_count = 0;
498 csf->buffer_count = 0;
499
500 csf->flags &= ~(SONG_PATTERNLOOP|SONG_ENDREACHED);
501 }
502
csf_reset_playmarks(song_t * csf)503 void csf_reset_playmarks(song_t *csf)
504 {
505 int n;
506
507 for (n = 1; n < MAX_SAMPLES; n++) {
508 csf->samples[n].played = 0;
509 }
510 for (n = 1; n < MAX_INSTRUMENTS; n++) {
511 if (csf->instruments[n])
512 csf->instruments[n]->played = 0;
513 }
514 }
515
516
csf_loop_pattern(song_t * csf,int pat,int row)517 void csf_loop_pattern(song_t *csf, int pat, int row)
518 {
519 if (pat < 0 || pat >= MAX_PATTERNS || !csf->patterns[pat]) {
520 csf->flags &= ~SONG_PATTERNLOOP;
521 } else {
522 if (row < 0 || row >= csf->pattern_size[pat])
523 row = 0;
524
525 csf->process_order = 0; // hack - see increment_order in sndmix.c
526 csf->process_row = PROCESS_NEXT_ORDER;
527 csf->break_row = row;
528 csf->tick_count = 1;
529 csf->row_count = 0;
530 csf->current_pattern = pat;
531 csf->buffer_count = 0;
532 csf->flags |= SONG_PATTERNLOOP;
533 }
534 }
535
536 /* --------------------------------------------------------------------------------------------------------- */
537
538 #define SF_FAIL(name, n) \
539 ({ log_appendf(4, "%s: internal error: unsupported %s %d", __FUNCTION__, name, n); return 0; })
540
csf_write_sample(disko_t * fp,song_sample_t * sample,uint32_t flags,uint32_t maxlengthmask)541 uint32_t csf_write_sample(disko_t *fp, song_sample_t *sample, uint32_t flags, uint32_t maxlengthmask)
542 {
543 uint32_t pos, len = sample->length;
544 if(maxlengthmask != UINT32_MAX)
545 len = len > maxlengthmask ? maxlengthmask : (len & maxlengthmask);
546 int stride = 1; // how much to add to the left/right pointer per sample written
547 int byteswap = 0; // should the sample data be byte-swapped?
548 int add = 0; // how much to add to the sample data (for converting to unsigned)
549 int channel; // counter.
550
551 // validate the write flags, and set up the save params
552 switch (flags & SF_CHN_MASK) {
553 case SF_SI:
554 if (!(sample->flags & CHN_STEREO))
555 SF_FAIL("channel mask", flags & SF_CHN_MASK);
556 len *= 2;
557 break;
558 case SF_SS:
559 if (!(sample->flags & CHN_STEREO))
560 SF_FAIL("channel mask", flags & SF_CHN_MASK);
561 stride = 2;
562 break;
563 case SF_M:
564 if (sample->flags & CHN_STEREO)
565 SF_FAIL("channel mask", flags & SF_CHN_MASK);
566 break;
567 default:
568 SF_FAIL("channel mask", flags & SF_CHN_MASK);
569 }
570
571 // TODO allow converting bit width, this will be useful
572 if ((flags & SF_BIT_MASK) != ((sample->flags & CHN_16BIT) ? SF_16 : SF_8))
573 SF_FAIL("bit width", flags & SF_BIT_MASK);
574
575 switch (flags & SF_END_MASK) {
576 #if WORDS_BIGENDIAN
577 case SF_LE:
578 byteswap = 1;
579 break;
580 case SF_BE:
581 break;
582 #else
583 case SF_LE:
584 break;
585 case SF_BE:
586 byteswap = 1;
587 break;
588 #endif
589 default:
590 SF_FAIL("endianness", flags & SF_END_MASK);
591 }
592
593 switch (flags & SF_ENC_MASK) {
594 case SF_PCMU:
595 add = ((flags & SF_BIT_MASK) == SF_16) ? 32768 : 128;
596 break;
597 case SF_PCMS:
598 break;
599 default:
600 SF_FAIL("encoding", flags & SF_ENC_MASK);
601 }
602
603 if ((flags & ~(SF_BIT_MASK | SF_CHN_MASK | SF_END_MASK | SF_ENC_MASK)) != 0) {
604 SF_FAIL("extra flag", flags & ~(SF_BIT_MASK | SF_CHN_MASK | SF_END_MASK | SF_ENC_MASK));
605 }
606
607 if (!sample || sample->length < 1 || sample->length > MAX_SAMPLE_LENGTH || !sample->data)
608 return 0;
609
610 // No point buffering the processing here -- the disk output already SHOULD have a 64kb buffer
611 if ((flags & SF_BIT_MASK) == SF_16) {
612 // 16-bit data.
613 const int16_t *data;
614 int16_t v;
615
616 for (channel = 0; channel < stride; channel++) {
617 data = (const int16_t *) sample->data + channel;
618 for (pos = 0; pos < len; pos++) {
619 v = *data + add;
620 if (byteswap)
621 v = bswap_16(v);
622 disko_write(fp, &v, 2);
623 data += stride;
624 }
625 }
626
627 len *= 2;
628 } else {
629 // 8-bit data. Mostly the same as above, but a little bit simpler since
630 // there's no byteswapping, and the values can be written with putc.
631 const int8_t *data;
632
633 for (channel = 0; channel < stride; channel++) {
634 data = (const int8_t *) sample->data + channel;
635 for (pos = 0; pos < len; pos++) {
636 disko_putc(fp, *data + add);
637 data += stride;
638 }
639 }
640 }
641
642 len *= stride;
643 return len;
644 }
645
646
csf_read_sample(song_sample_t * sample,uint32_t flags,const void * filedata,uint32_t memsize)647 uint32_t csf_read_sample(song_sample_t *sample, uint32_t flags, const void *filedata, uint32_t memsize)
648 {
649 uint32_t len = 0, mem;
650 const char *buffer = (const char *) filedata;
651
652 if (sample->flags & CHN_ADLIB) return 0; // no sample data
653
654 if (!sample || sample->length < 1 || !buffer) return 0;
655
656 // validate the read flags before anything else
657 switch (flags & SF_BIT_MASK) {
658 case SF_7: case SF_8: case SF_16: case SF_24: case SF_32: break;
659 default: SF_FAIL("bit width", flags & SF_BIT_MASK);
660 }
661 switch (flags & SF_CHN_MASK) {
662 case SF_M: case SF_SI: case SF_SS: break;
663 default: SF_FAIL("channel mask", flags & SF_CHN_MASK);
664 }
665 switch (flags & SF_END_MASK) {
666 case SF_LE: case SF_BE: break;
667 default: SF_FAIL("endianness", flags & SF_END_MASK);
668 }
669 switch (flags & SF_ENC_MASK) {
670 case SF_PCMS: case SF_PCMU: case SF_PCMD: case SF_IT214: case SF_IT215:
671 case SF_AMS: case SF_DMF: case SF_MDL: case SF_PTM: case SF_PCMD16:
672 break;
673 default: SF_FAIL("encoding", flags & SF_ENC_MASK);
674 }
675 if ((flags & ~(SF_BIT_MASK | SF_CHN_MASK | SF_END_MASK | SF_ENC_MASK)) != 0) {
676 SF_FAIL("extra flag", flags & ~(SF_BIT_MASK | SF_CHN_MASK | SF_END_MASK | SF_ENC_MASK));
677 }
678
679 if (sample->length > MAX_SAMPLE_LENGTH) sample->length = MAX_SAMPLE_LENGTH;
680 mem = sample->length+6;
681 sample->flags &= ~(CHN_16BIT|CHN_STEREO);
682 switch (flags & SF_BIT_MASK) {
683 case SF_16: case SF_24: case SF_32:
684 // these are all stuffed into 16 bits.
685 mem *= 2;
686 sample->flags |= CHN_16BIT;
687 }
688 switch (flags & SF_CHN_MASK) {
689 case SF_SI: case SF_SS:
690 mem *= 2;
691 sample->flags |= CHN_STEREO;
692 }
693 if ((sample->data = csf_allocate_sample(mem)) == NULL) {
694 sample->length = 0;
695 return 0;
696 }
697 switch(flags) {
698 // 1: 8-bit unsigned PCM data
699 case RS_PCM8U:
700 {
701 len = sample->length;
702 if (len > memsize) len = sample->length = memsize;
703 signed char *data = sample->data;
704 for (uint32_t j=0; j<len; j++) data[j] = (signed char)(buffer[j] - 0x80);
705 }
706 break;
707
708 // 2: 8-bit ADPCM data with linear table
709 case RS_PCM8D:
710 {
711 len = sample->length;
712 if (len > memsize) break;
713 signed char *data = sample->data;
714 const signed char *p = (const signed char *)buffer;
715 int delta = 0;
716 for (uint32_t j=0; j<len; j++) {
717 delta += p[j];
718 *data++ = (signed char)delta;
719 }
720 }
721 break;
722
723 // 4: 16-bit ADPCM data with linear table
724 case RS_PCM16D:
725 {
726 len = sample->length * 2;
727 if (len > memsize) break;
728 short *data = (short *)sample->data;
729 short *p = (short *)buffer;
730 unsigned short tmp;
731 int delta16 = 0;
732 for (uint32_t j=0; j<len; j+=2) {
733 tmp = *((unsigned short *)p++);
734 delta16 += bswapLE16(tmp);
735 *data++ = (short) delta16;
736 }
737 }
738 break;
739
740 // 5: 16-bit signed PCM data
741 case RS_PCM16S:
742 {
743 len = sample->length * 2;
744 if (len <= memsize) memcpy(sample->data, buffer, len);
745 short int *data = (short int *)sample->data;
746 for (uint32_t j=0; j<len; j+=2) {
747 *data = bswapLE16(*data);
748 data++;
749 }
750 }
751 break;
752
753 // 16-bit signed mono PCM motorola byte order
754 case RS_PCM16M:
755 len = sample->length * 2;
756 if (len > memsize) len = memsize & ~1;
757 if (len > 1) {
758 signed char *data = (signed char *)sample->data;
759 signed char *src = (signed char *)buffer;
760 for (uint32_t j=0; j<len; j+=2) {
761 // data[j] = src[j+1];
762 // data[j+1] = src[j];
763 *((unsigned short *)(data+j)) = bswapBE16(*((unsigned short *)(src+j)));
764 }
765 }
766 break;
767
768 // 6: 16-bit unsigned PCM data
769 case RS_PCM16U:
770 {
771 len = sample->length * 2;
772 if (len <= memsize) memcpy(sample->data, buffer, len);
773 short int *data = (short int *)sample->data;
774 for (uint32_t j=0; j<len; j+=2) {
775 *data = bswapLE16(*data) - 0x8000;
776 data++;
777 }
778 }
779 break;
780
781 // 16-bit signed stereo big endian
782 case RS_STPCM16M:
783 len = sample->length * 2;
784 if (len*2 <= memsize) {
785 signed char *data = (signed char *)sample->data;
786 signed char *src = (signed char *)buffer;
787 for (uint32_t j=0; j<len; j+=2) {
788 // data[j*2] = src[j+1];
789 // data[j*2+1] = src[j];
790 // data[j*2+2] = src[j+1+len];
791 // data[j*2+3] = src[j+len];
792 *((unsigned short *)(data+j*2))
793 = bswapBE16(*((unsigned short *)(src+j)));
794 *((unsigned short *)(data+j*2+2))
795 = bswapBE16(*((unsigned short *)(src+j+len)));
796 }
797 len *= 2;
798 }
799 break;
800
801 // 8-bit stereo samples
802 case RS_STPCM8S:
803 case RS_STPCM8U:
804 case RS_STPCM8D:
805 {
806 int iadd_l, iadd_r;
807 iadd_l = iadd_r = (flags == RS_STPCM8U) ? -128 : 0;
808 len = sample->length;
809 signed char *psrc = (signed char *)buffer;
810 signed char *data = (signed char *)sample->data;
811 if (len*2 > memsize) break;
812 for (uint32_t j=0; j<len; j++) {
813 data[j*2] = (signed char)(psrc[0] + iadd_l);
814 data[j*2+1] = (signed char)(psrc[len] + iadd_r);
815 psrc++;
816 if (flags == RS_STPCM8D) {
817 iadd_l = data[j*2];
818 iadd_r = data[j*2+1];
819 }
820 }
821 len *= 2;
822 }
823 break;
824
825 // 16-bit stereo samples
826 case RS_STPCM16S:
827 case RS_STPCM16U:
828 case RS_STPCM16D:
829 {
830 int iadd_l, iadd_r;
831 iadd_l = iadd_r = (flags == RS_STPCM16U) ? -0x8000 : 0;
832 len = sample->length;
833 short int *psrc = (short int *)buffer;
834 short int *data = (short int *)sample->data;
835 if (len*4 > memsize) break;
836 for (uint32_t j=0; j<len; j++) {
837 data[j*2] = (short int) (bswapLE16(psrc[0]) + iadd_l);
838 data[j*2+1] = (short int) (bswapLE16(psrc[len]) + iadd_r);
839 psrc++;
840 if (flags == RS_STPCM16D) {
841 iadd_l = data[j*2];
842 iadd_r = data[j*2+1];
843 }
844 }
845 len *= 4;
846 }
847 break;
848
849 // IT 2.14 compressed samples
850 case RS_IT2148:
851 case RS_IT21416:
852 case RS_IT2158:
853 case RS_IT21516:
854 len = memsize;
855 if (len < 2) break;
856 if (flags == RS_IT2148 || flags == RS_IT2158) {
857 it_decompress8(sample->data, sample->length,
858 buffer, memsize, (flags == RS_IT2158), 1);
859 } else {
860 it_decompress16(sample->data, sample->length,
861 buffer, memsize, (flags == RS_IT21516), 1);
862 }
863 break;
864 case RS_IT2148S:
865 case RS_IT21416S:
866 case RS_IT2158S:
867 case RS_IT21516S:
868 len = memsize;
869 if (len < 4) break;
870 if (flags == RS_IT2148S || flags == RS_IT2158S) {
871 uint32_t offset = it_decompress8(sample->data, sample->length,
872 buffer, memsize, (flags == RS_IT2158S), 2);
873 it_decompress8(sample->data + 1, sample->length,
874 buffer + offset, memsize - offset, (flags == RS_IT2158S), 2);
875 } else {
876 uint32_t offset = it_decompress16(sample->data, sample->length,
877 buffer, memsize, (flags == RS_IT21516S), 2);
878 it_decompress16(sample->data + 2, sample->length,
879 buffer + offset, memsize - offset, (flags == RS_IT21516S), 2);
880 }
881 break;
882
883 // 8-bit interleaved stereo samples
884 case RS_STIPCM8S:
885 case RS_STIPCM8U:
886 {
887 int iadd = 0;
888 if (flags == RS_STIPCM8U) { iadd = -0x80; }
889 len = sample->length;
890 if (len*2 > memsize) len = memsize >> 1;
891 uint8_t * psrc = (uint8_t *)buffer;
892 uint8_t * data = (uint8_t *)sample->data;
893 for (uint32_t j=0; j<len; j++) {
894 data[j*2] = (signed char)(psrc[0] + iadd);
895 data[j*2+1] = (signed char)(psrc[1] + iadd);
896 psrc+=2;
897 }
898 len *= 2;
899 }
900 break;
901
902 // 16-bit interleaved stereo samples
903 case RS_STIPCM16S:
904 case RS_STIPCM16U:
905 {
906 int iadd = 0;
907 if (flags == RS_STIPCM16U) iadd = -32768;
908 len = sample->length;
909 if (len*4 > memsize) len = memsize >> 2;
910 short int *psrc = (short int *)buffer;
911 short int *data = (short int *)sample->data;
912 for (uint32_t j=0; j<len; j++) {
913 data[j*2] = (short int)(bswapLE16(psrc[0]) + iadd);
914 data[j*2+1] = (short int)(bswapLE16(psrc[1]) + iadd);
915 psrc += 2;
916 }
917 len *= 4;
918 }
919 break;
920
921 #if 0
922 // AMS compressed samples
923 case RS_AMS8:
924 case RS_AMS16:
925 len = 9;
926 if (memsize > 9) {
927 const char *psrc = buffer;
928 char packcharacter = buffer[8], *pdest = (char *)sample->data;
929 len += bswapLE32(*((uint32_t *)(buffer+4)));
930 if (len > memsize) len = memsize;
931 uint32_t dmax = sample->length;
932 if (sample->flags & CHN_16BIT) dmax <<= 1;
933 AMSUnpack(psrc+9, len-9, pdest, dmax, packcharacter);
934 }
935 break;
936 #endif
937
938 // PTM 8bit delta to 16-bit sample
939 case RS_PTM8DTO16:
940 {
941 len = sample->length * 2;
942 if (len > memsize) break;
943 signed char *data = (signed char *)sample->data;
944 signed char delta8 = 0;
945 for (uint32_t j=0; j<len; j++) {
946 delta8 += buffer[j];
947 *data++ = delta8;
948 }
949 uint16_t *data16 = (uint16_t *)sample->data;
950 for (uint32_t j=0; j<len; j+=2) {
951 *data16 = bswapLE16(*data16);
952 data16++;
953 }
954 }
955 break;
956
957 // Huffman MDL compressed samples
958 case RS_MDL8:
959 case RS_MDL16:
960 if (memsize >= 8) {
961 // first 4 bytes indicate packed length
962 len = bswapLE32(*((uint32_t *) buffer));
963 len = MIN(len, memsize) + 4;
964 uint8_t * data = (uint8_t *)sample->data;
965 uint8_t * ibuf = (uint8_t *)(buffer + 4);
966 uint32_t bitbuf = bswapLE32(*((uint32_t *)ibuf));
967 uint32_t bitnum = 32;
968 uint8_t dlt = 0, lowbyte = 0;
969 ibuf += 4;
970 // TODO move all this junk to fmt/compression.c
971 for (uint32_t j=0; j<sample->length; j++) {
972 uint8_t hibyte;
973 uint8_t sign;
974 if (flags == RS_MDL16)
975 lowbyte = (uint8_t)mdl_read_bits(&bitbuf, &bitnum, &ibuf, 8);
976 sign = (uint8_t)mdl_read_bits(&bitbuf, &bitnum, &ibuf, 1);
977 if (mdl_read_bits(&bitbuf, &bitnum, &ibuf, 1)) {
978 hibyte = (uint8_t)mdl_read_bits(&bitbuf, &bitnum, &ibuf, 3);
979 } else {
980 hibyte = 8;
981 while (!mdl_read_bits(&bitbuf, &bitnum, &ibuf, 1)) hibyte += 0x10;
982 hibyte += mdl_read_bits(&bitbuf, &bitnum, &ibuf, 4);
983 }
984 if (sign) hibyte = ~hibyte;
985 dlt += hibyte;
986 if (flags == RS_MDL8) {
987 data[j] = dlt;
988 } else {
989 #ifdef WORDS_BIGENDIAN
990 data[j<<1] = dlt;
991 data[(j<<1)+1] = lowbyte;
992 #else
993 data[j<<1] = lowbyte;
994 data[(j<<1)+1] = dlt;
995 #endif
996 }
997 }
998 }
999 break;
1000
1001 #if 0
1002 case RS_DMF8:
1003 case RS_DMF16:
1004 len = memsize;
1005 if (len >= 4) {
1006 uint32_t maxlen = sample->length;
1007 if (sample->flags & CHN_16BIT) maxlen <<= 1;
1008 uint8_t * ibuf = (uint8_t *)buffer;
1009 uint8_t * ibufmax = (uint8_t *)(buffer+memsize);
1010 len = DMFUnpack((uint8_t *)sample->data, ibuf, ibufmax, maxlen);
1011 }
1012 break;
1013 #endif
1014
1015 // PCM 24-bit signed -> load sample, and normalize it to 16-bit
1016 case RS_PCM24S:
1017 case RS_PCM32S:
1018 len = sample->length * 3;
1019 if (flags == RS_PCM32S) len += sample->length;
1020 if (len > memsize) break;
1021 if (len > 4*8) {
1022 uint32_t slsize = (flags == RS_PCM32S) ? 4 : 3;
1023 uint8_t * src = (uint8_t *)buffer;
1024 int32_t max = 255;
1025 if (flags == RS_PCM32S) src++;
1026 for (uint32_t j=0; j<len; j+=slsize) {
1027 int32_t l = ((((src[j+2] << 8) + src[j+1]) << 8) + src[j]) << 8;
1028 l /= 256;
1029 if (l > max) max = l;
1030 if (-l > max) max = -l;
1031 }
1032 max = (max / 128) + 1;
1033 signed short *dest = (signed short *)sample->data;
1034 for (uint32_t k=0; k<len; k+=slsize) {
1035 int32_t l = ((((src[k+2] << 8) + src[k+1]) << 8) + src[k]) << 8;
1036 *dest++ = (signed short)(l / max);
1037 }
1038 }
1039 break;
1040
1041
1042 // Stereo PCM 24-bit signed -> load sample, and normalize it to 16-bit
1043 case RS_STIPCM24S:
1044 case RS_STIPCM32S:
1045 len = sample->length * 6;
1046 if (flags == RS_STIPCM32S) len += sample->length * 2;
1047 if (len > memsize) break;
1048 if (len > 8*8) {
1049 uint32_t slsize = (flags == RS_STIPCM32S) ? 4 : 3;
1050 uint8_t * src = (uint8_t *)buffer;
1051 int32_t max = 255;
1052 if (flags == RS_STIPCM32S) src++;
1053 for (uint32_t j=0; j<len; j+=slsize) {
1054 int32_t l = ((((src[j+2] << 8) + src[j+1]) << 8) + src[j]) << 8;
1055 l /= 256;
1056 if (l > max) max = l;
1057 if (-l > max) max = -l;
1058 }
1059 max = (max / 128) + 1;
1060 signed short *dest = (signed short *)sample->data;
1061 for (uint32_t k=0; k<len; k+=slsize) {
1062 int32_t ll = ((((src[k+2] << 8) + src[k+1]) << 8) + src[k]) << 8;
1063 k += slsize;
1064 int32_t lr = ((((src[k+2] << 8) + src[k+1]) << 8) + src[k]) << 8;
1065 dest[0] = (signed short)(ll/max);
1066 dest[1] = (signed short)(lr/max);
1067 dest += 2;
1068 }
1069 }
1070 break;
1071
1072
1073 // 16-bit signed big endian interleaved stereo
1074 case RS_STIPCM16M:
1075 {
1076 len = sample->length;
1077 if (len*4 > memsize) len = memsize >> 2;
1078 const uint8_t * psrc = (const uint8_t *)buffer;
1079 short int *data = (short int *)sample->data;
1080 for (uint32_t j=0; j<len; j++) {
1081 data[j*2] = (signed short)(((uint32_t)psrc[0] << 8) | (psrc[1]));
1082 data[j*2+1] = (signed short)(((uint32_t)psrc[2] << 8) | (psrc[3]));
1083 psrc += 4;
1084 }
1085 len *= 4;
1086 }
1087 break;
1088
1089 // 7-bit (data shifted one bit left)
1090 case SF(7,M,BE,PCMS):
1091 case SF(7,M,LE,PCMS):
1092 sample->flags &= ~(CHN_16BIT | CHN_STEREO);
1093 len = sample->length = MIN(sample->length, memsize);
1094 for (uint32_t j = 0; j < len; j++)
1095 sample->data[j] = CLAMP(buffer[j] * 2, -128, 127);
1096 break;
1097
1098 // 8-bit ADPCM data w/ 16-byte table (MOD ADPCM)
1099 case RS_PCM8D16:
1100 {
1101 len = (sample->length + 1) / 2 + 16;
1102 if (len > memsize) break;
1103
1104 const signed char *p = (const signed char *)buffer;
1105 signed char *data = sample->data, smpval = 0;
1106 for (uint32_t j=16; j<len; j++) {
1107 smpval += p[p[j] & 0xF];
1108 *data++ = smpval;
1109 smpval += p[(p[j] >> 4) & 0xF];
1110 *data++ = smpval;
1111 }
1112 }
1113 break;
1114
1115 // Default: 8-bit signed PCM data
1116 default:
1117 printf("DEFAULT: %d\n", flags);
1118 case SF(8,M,BE,PCMS): /* endianness is irrelevant for 8-bit samples */
1119 case SF(8,M,LE,PCMS):
1120 sample->flags &= ~(CHN_16BIT | CHN_STEREO);
1121 len = sample->length;
1122 if (len > memsize) len = sample->length = memsize;
1123 memcpy(sample->data, buffer, len);
1124 break;
1125 }
1126 if (len > memsize) {
1127 if (sample->data) {
1128 sample->length = 0;
1129 csf_free_sample(sample->data);
1130 sample->data = NULL;
1131 }
1132 return 0;
1133 }
1134 csf_adjust_sample_loop(sample);
1135 return len;
1136 }
1137
1138 /* --------------------------------------------------------------------------------------------------------- */
1139
csf_adjust_sample_loop(song_sample_t * sample)1140 void csf_adjust_sample_loop(song_sample_t *sample)
1141 {
1142 if (!sample->data || sample->length < 1) return;
1143 if (sample->loop_end > sample->length) sample->loop_end = sample->length;
1144 if (sample->loop_start+2 >= sample->loop_end) {
1145 sample->loop_start = sample->loop_end = 0;
1146 sample->flags &= ~CHN_LOOP;
1147 }
1148
1149 // poopy, removing all that loop-hacking code has produced... very nasty sounding loops!
1150 // so I guess I should rewrite the crap at the end of the sample at least.
1151 uint32_t len = sample->length;
1152 if (sample->flags & CHN_16BIT) {
1153 short int *data = (short int *)sample->data;
1154 // Adjust end of sample
1155 if (sample->flags & CHN_STEREO) {
1156 data[len*2+6]
1157 = data[len*2+4]
1158 = data[len*2+2]
1159 = data[len*2]
1160 = data[len*2-2];
1161 data[len*2+7]
1162 = data[len*2+5]
1163 = data[len*2+3]
1164 = data[len*2+1]
1165 = data[len*2-1];
1166 } else {
1167 data[len+4]
1168 = data[len+3]
1169 = data[len+2]
1170 = data[len+1]
1171 = data[len]
1172 = data[len-1];
1173 }
1174 } else {
1175 signed char *data = sample->data;
1176 // Adjust end of sample
1177 if (sample->flags & CHN_STEREO) {
1178 data[len*2+6]
1179 = data[len*2+4]
1180 = data[len*2+2]
1181 = data[len*2]
1182 = data[len*2-2];
1183 data[len*2+7]
1184 = data[len*2+5]
1185 = data[len*2+3]
1186 = data[len*2+1]
1187 = data[len*2-1];
1188 } else {
1189 data[len+4]
1190 = data[len+3]
1191 = data[len+2]
1192 = data[len+1]
1193 = data[len]
1194 = data[len-1];
1195 }
1196 }
1197 }
1198
1199
1200
csf_stop_sample(song_t * csf,song_sample_t * smp)1201 void csf_stop_sample(song_t *csf, song_sample_t *smp)
1202 {
1203 song_voice_t *v = csf->voices;
1204
1205 if (!smp->data)
1206 return;
1207 for (int i = 0; i < MAX_VOICES; i++, v++) {
1208 if (v->ptr_sample == smp || v->current_sample_data == smp->data) {
1209 v->note = v->new_note = v->new_instrument = 0;
1210 v->fadeout_volume = 0;
1211 v->flags |= CHN_KEYOFF | CHN_NOTEFADE;
1212 v->frequency = 0;
1213 v->position = v->length = 0;
1214 v->loop_start = 0;
1215 v->loop_end = 0;
1216 v->rofs = v->lofs = 0;
1217 v->current_sample_data = NULL;
1218 v->ptr_sample = NULL;
1219 v->ptr_instrument = NULL;
1220 v->left_volume = v->right_volume = 0;
1221 v->left_volume_new = v->right_volume_new = 0;
1222 v->left_ramp = v->right_ramp = 0;
1223 }
1224 }
1225 }
1226
csf_destroy_sample(song_t * csf,uint32_t nsmp)1227 int csf_destroy_sample(song_t *csf, uint32_t nsmp)
1228 {
1229 song_sample_t *smp = csf->samples + nsmp;
1230 signed char *data;
1231
1232 if (nsmp >= MAX_SAMPLES)
1233 return 0;
1234 data = smp->data;
1235 if (!data)
1236 return 1;
1237 csf_stop_sample(csf, smp);
1238 smp->data = NULL;
1239 smp->length = 0;
1240 smp->flags &= ~CHN_16BIT;
1241 csf_free_sample(data);
1242 return 1;
1243 }
1244
1245
1246
csf_import_mod_effect(song_note_t * m,int from_xm)1247 void csf_import_mod_effect(song_note_t *m, int from_xm)
1248 {
1249 uint32_t effect = m->effect, param = m->param;
1250
1251 // strip no-op effect commands that have memory in IT but not MOD/XM.
1252 // arpeggio is safe since it's handled in the next switch.
1253 if (!param || (effect == 0x0E && !(param & 0xF))) {
1254 switch(effect) {
1255 case 0x01:
1256 case 0x02:
1257 case 0x0A:
1258 if (!from_xm) effect = 0;
1259 break;
1260 case 0x0E:
1261 switch(param & 0xF0) {
1262 case 0x10:
1263 case 0x20:
1264 case 0xA0:
1265 case 0xB0:
1266 if (from_xm) break;
1267 case 0x90:
1268 effect = param = 0;
1269 break;
1270 }
1271 break;
1272 }
1273 }
1274
1275 switch(effect) {
1276 case 0x00: if (param) effect = FX_ARPEGGIO; break;
1277 case 0x01: effect = FX_PORTAMENTOUP; break;
1278 case 0x02: effect = FX_PORTAMENTODOWN; break;
1279 case 0x03: effect = FX_TONEPORTAMENTO; break;
1280 case 0x04: effect = FX_VIBRATO; break;
1281 case 0x05: effect = FX_TONEPORTAVOL; if (param & 0xF0) param &= 0xF0; break;
1282 case 0x06: effect = FX_VIBRATOVOL; if (param & 0xF0) param &= 0xF0; break;
1283 case 0x07: effect = FX_TREMOLO; break;
1284 case 0x08: effect = FX_PANNING; break;
1285 case 0x09: effect = FX_OFFSET; break;
1286 case 0x0A: effect = FX_VOLUMESLIDE; if (param & 0xF0) param &= 0xF0; break;
1287 case 0x0B: effect = FX_POSITIONJUMP; break;
1288 case 0x0C:
1289 if (from_xm) {
1290 effect = FX_VOLUME;
1291 } else {
1292 m->voleffect = VOLFX_VOLUME;
1293 m->volparam = param;
1294 if (m->voleffect > 64)
1295 m->voleffect = 64;
1296 effect = param = 0;
1297 }
1298 break;
1299 case 0x0D: effect = FX_PATTERNBREAK; param = ((param >> 4) * 10) + (param & 0x0F); break;
1300 case 0x0E:
1301 effect = FX_SPECIAL;
1302 switch(param & 0xF0) {
1303 case 0x10: effect = FX_PORTAMENTOUP; param |= 0xF0; break;
1304 case 0x20: effect = FX_PORTAMENTODOWN; param |= 0xF0; break;
1305 case 0x30: param = (param & 0x0F) | 0x10; break;
1306 case 0x40: param = (param & 0x0F) | 0x30; break;
1307 case 0x50: param = (param & 0x0F) | 0x20; break;
1308 case 0x60: param = (param & 0x0F) | 0xB0; break;
1309 case 0x70: param = (param & 0x0F) | 0x40; break;
1310 case 0x90: effect = FX_RETRIG; param &= 0x0F; break;
1311 case 0xA0:
1312 effect = FX_VOLUMESLIDE;
1313 if (param & 0x0F) {
1314 param = (param << 4) | 0x0F;
1315 } else {
1316 param = 0;
1317 }
1318 break;
1319 case 0xB0:
1320 effect = FX_VOLUMESLIDE;
1321 if (param & 0x0F) {
1322 param |= 0xF0;
1323 } else {
1324 param = 0;
1325 }
1326 break;
1327 }
1328 break;
1329 case 0x0F:
1330 // FT2 processes 0x20 as Txx; ST3 loads it as Axx
1331 effect = (param < (from_xm ? 0x20 : 0x21)) ? FX_SPEED : FX_TEMPO;
1332 break;
1333 // Extension for XM extended effects
1334 case 'G' - 55:
1335 effect = FX_GLOBALVOLUME;
1336 param = MIN(param << 1, 0x80);
1337 break;
1338 case 'H' - 55:
1339 effect = FX_GLOBALVOLSLIDE;
1340 //if (param & 0xF0) param &= 0xF0;
1341 param = MIN((param & 0xf0) << 1, 0xf0) | MIN((param & 0xf) << 1, 0xf);
1342 break;
1343 case 'K' - 55: effect = FX_KEYOFF; break;
1344 case 'L' - 55: effect = FX_SETENVPOSITION; break;
1345 case 'M' - 55: effect = FX_CHANNELVOLUME; break;
1346 case 'N' - 55: effect = FX_CHANNELVOLSLIDE; break;
1347 case 'P' - 55:
1348 effect = FX_PANNINGSLIDE;
1349 // ft2 does Pxx backwards! skjdfjksdfkjsdfjk
1350 if (param & 0xF0)
1351 param >>= 4;
1352 else
1353 param = (param & 0xf) << 4;
1354 break;
1355 case 'R' - 55: effect = FX_RETRIG; break;
1356 case 'T' - 55: effect = FX_TREMOR; break;
1357 case 'X' - 55:
1358 switch (param & 0xf0) {
1359 case 0x10:
1360 effect = FX_PORTAMENTOUP;
1361 param = 0xe0 | (param & 0xf);
1362 break;
1363 case 0x20:
1364 effect = FX_PORTAMENTODOWN;
1365 param = 0xe0 | (param & 0xf);
1366 break;
1367 default:
1368 effect = param = 0;
1369 break;
1370 }
1371 break;
1372 case 'Y' - 55: effect = FX_PANBRELLO; break;
1373 case 'Z' - 55: effect = FX_MIDI; break;
1374 case '[' - 55:
1375 // FT2 shows this weird effect as -xx, and it can even be inserted
1376 // by typing "-", although it doesn't appear to do anything.
1377 default: effect = 0;
1378 }
1379 m->effect = effect;
1380 m->param = param;
1381 }
1382
csf_export_mod_effect(const song_note_t * m,int to_xm)1383 uint16_t csf_export_mod_effect(const song_note_t *m, int to_xm)
1384 {
1385 uint32_t effect = m->effect & 0x3F, param = m->param;
1386
1387 switch(effect) {
1388 case 0: effect = param = 0; break;
1389 case FX_ARPEGGIO: effect = 0; break;
1390 case FX_PORTAMENTOUP:
1391 if ((param & 0xF0) == 0xE0) {
1392 if (to_xm) {
1393 effect = 'X' - 55;
1394 param = 0x10 | (param & 0xf);
1395 } else {
1396 effect = 0x0E;
1397 param = 0x10 | ((param & 0xf) >> 2);
1398 }
1399 } else if ((param & 0xF0) == 0xF0) {
1400 effect = 0x0E;
1401 param = 0x10 | (param & 0xf);
1402 } else {
1403 effect = 0x01;
1404 }
1405 break;
1406 case FX_PORTAMENTODOWN:
1407 if ((param & 0xF0) == 0xE0) {
1408 if (to_xm) {
1409 effect = 'X' - 55;
1410 param = 0x20 | (param & 0xf);
1411 } else {
1412 effect = 0x0E;
1413 param = 0x20 | ((param & 0xf) >> 2);
1414 }
1415 } else if ((param & 0xF0) == 0xF0) {
1416 effect = 0x0E;
1417 param = 0x20 | (param & 0xf);
1418 } else {
1419 effect = 0x02;
1420 }
1421 break;
1422 case FX_TONEPORTAMENTO: effect = 0x03; break;
1423 case FX_VIBRATO: effect = 0x04; break;
1424 case FX_TONEPORTAVOL: effect = 0x05; break;
1425 case FX_VIBRATOVOL: effect = 0x06; break;
1426 case FX_TREMOLO: effect = 0x07; break;
1427 case FX_PANNING: effect = 0x08; break;
1428 case FX_OFFSET: effect = 0x09; break;
1429 case FX_VOLUMESLIDE: effect = 0x0A; break;
1430 case FX_POSITIONJUMP: effect = 0x0B; break;
1431 case FX_VOLUME: effect = 0x0C; break;
1432 case FX_PATTERNBREAK: effect = 0x0D; param = ((param / 10) << 4) | (param % 10); break;
1433 case FX_SPEED: effect = 0x0F; if (param > 0x20) param = 0x20; break;
1434 case FX_TEMPO: if (param > 0x20) { effect = 0x0F; break; } return 0;
1435 case FX_GLOBALVOLUME: effect = 'G' - 55; break;
1436 case FX_GLOBALVOLSLIDE: effect = 'H' - 55; break; // FIXME this needs to be adjusted
1437 case FX_KEYOFF: effect = 'K' - 55; break;
1438 case FX_SETENVPOSITION: effect = 'L' - 55; break;
1439 case FX_CHANNELVOLUME: effect = 'M' - 55; break;
1440 case FX_CHANNELVOLSLIDE: effect = 'N' - 55; break;
1441 case FX_PANNINGSLIDE: effect = 'P' - 55; break;
1442 case FX_RETRIG: effect = 'R' - 55; break;
1443 case FX_TREMOR: effect = 'T' - 55; break;
1444 case FX_PANBRELLO: effect = 'Y' - 55; break;
1445 case FX_MIDI: effect = 'Z' - 55; break;
1446 case FX_SPECIAL:
1447 switch (param & 0xF0) {
1448 case 0x10: effect = 0x0E; param = (param & 0x0F) | 0x30; break;
1449 case 0x20: effect = 0x0E; param = (param & 0x0F) | 0x50; break;
1450 case 0x30: effect = 0x0E; param = (param & 0x0F) | 0x40; break;
1451 case 0x40: effect = 0x0E; param = (param & 0x0F) | 0x70; break;
1452 case 0x90: effect = 'X' - 55; break;
1453 case 0xB0: effect = 0x0E; param = (param & 0x0F) | 0x60; break;
1454 case 0xA0:
1455 case 0x50:
1456 case 0x70:
1457 case 0x60: effect = param = 0; break;
1458 default: effect = 0x0E; break;
1459 }
1460 break;
1461 default: effect = param = 0;
1462 }
1463 return (uint16_t)((effect << 8) | (param));
1464 }
1465
1466
csf_import_s3m_effect(song_note_t * m,int from_it)1467 void csf_import_s3m_effect(song_note_t *m, int from_it)
1468 {
1469 uint32_t effect = m->effect;
1470 uint32_t param = m->param;
1471 switch (effect + 0x40)
1472 {
1473 case 'A': effect = FX_SPEED; break;
1474 case 'B': effect = FX_POSITIONJUMP; break;
1475 case 'C':
1476 effect = FX_PATTERNBREAK;
1477 if (!from_it)
1478 param = (param >> 4) * 10 + (param & 0x0F);
1479 break;
1480 case 'D': effect = FX_VOLUMESLIDE; break;
1481 case 'E': effect = FX_PORTAMENTODOWN; break;
1482 case 'F': effect = FX_PORTAMENTOUP; break;
1483 case 'G': effect = FX_TONEPORTAMENTO; break;
1484 case 'H': effect = FX_VIBRATO; break;
1485 case 'I': effect = FX_TREMOR; break;
1486 case 'J': effect = FX_ARPEGGIO; break;
1487 case 'K': effect = FX_VIBRATOVOL; break;
1488 case 'L': effect = FX_TONEPORTAVOL; break;
1489 case 'M': effect = FX_CHANNELVOLUME; break;
1490 case 'N': effect = FX_CHANNELVOLSLIDE; break;
1491 case 'O': effect = FX_OFFSET; break;
1492 case 'P': effect = FX_PANNINGSLIDE; break;
1493 case 'Q': effect = FX_RETRIG; break;
1494 case 'R': effect = FX_TREMOLO; break;
1495 case 'S':
1496 effect = FX_SPECIAL;
1497 // convert old SAx to S8x
1498 if (!from_it && ((param & 0xf0) == 0xa0))
1499 param = 0x80 | ((param & 0xf) ^ 8);
1500 break;
1501 case 'T': effect = FX_TEMPO; break;
1502 case 'U': effect = FX_FINEVIBRATO; break;
1503 case 'V':
1504 effect = FX_GLOBALVOLUME;
1505 if (!from_it)
1506 param *= 2;
1507 break;
1508 case 'W': effect = FX_GLOBALVOLSLIDE; break;
1509 case 'X':
1510 effect = FX_PANNING;
1511 if (!from_it) {
1512 if (param == 0xa4) {
1513 effect = FX_SPECIAL;
1514 param = 0x91;
1515 } else if (param > 0x7f) {
1516 param = 0xff;
1517 } else {
1518 param *= 2;
1519 }
1520 }
1521 break;
1522 case 'Y': effect = FX_PANBRELLO; break;
1523 case '\\': // OpenMPT smooth MIDI macro
1524 case 'Z': effect = FX_MIDI; break;
1525 default: effect = 0;
1526 }
1527 m->effect = effect;
1528 m->param = param;
1529 }
1530
csf_export_s3m_effect(uint8_t * pcmd,uint8_t * pprm,int to_it)1531 void csf_export_s3m_effect(uint8_t *pcmd, uint8_t *pprm, int to_it)
1532 {
1533 uint8_t effect = *pcmd;
1534 uint8_t param = *pprm;
1535 switch (effect) {
1536 case FX_SPEED: effect = 'A'; break;
1537 case FX_POSITIONJUMP: effect = 'B'; break;
1538 case FX_PATTERNBREAK: effect = 'C';
1539 if (!to_it) param = ((param / 10) << 4) + (param % 10); break;
1540 case FX_VOLUMESLIDE: effect = 'D'; break;
1541 case FX_PORTAMENTODOWN: effect = 'E'; break;
1542 case FX_PORTAMENTOUP: effect = 'F'; break;
1543 case FX_TONEPORTAMENTO: effect = 'G'; break;
1544 case FX_VIBRATO: effect = 'H'; break;
1545 case FX_TREMOR: effect = 'I'; break;
1546 case FX_ARPEGGIO: effect = 'J'; break;
1547 case FX_VIBRATOVOL: effect = 'K'; break;
1548 case FX_TONEPORTAVOL: effect = 'L'; break;
1549 case FX_CHANNELVOLUME: effect = 'M'; break;
1550 case FX_CHANNELVOLSLIDE: effect = 'N'; break;
1551 case FX_OFFSET: effect = 'O'; break;
1552 case FX_PANNINGSLIDE: effect = 'P'; break;
1553 case FX_RETRIG: effect = 'Q'; break;
1554 case FX_TREMOLO: effect = 'R'; break;
1555 case FX_SPECIAL:
1556 if (!to_it && param == 0x91) {
1557 effect = 'X';
1558 param = 0xA4;
1559 } else {
1560 effect = 'S';
1561 }
1562 break;
1563 case FX_TEMPO: effect = 'T'; break;
1564 case FX_FINEVIBRATO: effect = 'U'; break;
1565 case FX_GLOBALVOLUME: effect = 'V'; if (!to_it) param >>= 1;break;
1566 case FX_GLOBALVOLSLIDE: effect = 'W'; break;
1567 case FX_PANNING:
1568 effect = 'X';
1569 if (!to_it)
1570 param >>= 1;
1571 break;
1572 case FX_PANBRELLO: effect = 'Y'; break;
1573 case FX_MIDI: effect = 'Z'; break;
1574 default: effect = 0;
1575 }
1576 effect &= ~0x40;
1577 *pcmd = effect;
1578 *pprm = param;
1579 }
1580
1581
csf_insert_restart_pos(song_t * csf,uint32_t restart_order)1582 void csf_insert_restart_pos(song_t *csf, uint32_t restart_order)
1583 {
1584 int n, max, row;
1585 int ord, pat, newpat;
1586 int used; // how many times it was used (if >1, copy it)
1587
1588 if (!restart_order)
1589 return;
1590
1591 // find the last pattern, also look for one that's not being used
1592 for (max = ord = n = 0; n < MAX_ORDERS && csf->orderlist[n] < MAX_PATTERNS; ord = n, n++)
1593 if (csf->orderlist[n] > max)
1594 max = csf->orderlist[n];
1595 newpat = max + 1;
1596 pat = csf->orderlist[ord];
1597 if (pat >= MAX_PATTERNS || !csf->patterns[pat] || !csf->pattern_size[pat])
1598 return;
1599 for (max = n, used = 0, n = 0; n < max; n++)
1600 if (csf->orderlist[n] == pat)
1601 used++;
1602
1603 if (used > 1) {
1604 // copy the pattern so we don't screw up the playback elsewhere
1605 while (newpat < MAX_PATTERNS && csf->patterns[newpat])
1606 newpat++;
1607 if (newpat >= MAX_PATTERNS)
1608 return; // no more patterns? sux
1609 //log_appendf(2, "Copying pattern %d to %d for restart position", pat, newpat);
1610 csf->patterns[newpat] = csf_allocate_pattern(csf->pattern_size[pat]);
1611 csf->pattern_size[newpat] = csf->pattern_alloc_size[newpat] = csf->pattern_size[pat];
1612 memcpy(csf->patterns[newpat], csf->patterns[pat],
1613 sizeof(song_note_t) * MAX_CHANNELS * csf->pattern_size[pat]);
1614 csf->orderlist[ord] = pat = newpat;
1615 } else {
1616 //log_appendf(2, "Modifying pattern %d to add restart position", pat);
1617 }
1618
1619
1620 max = csf->pattern_size[pat] - 1;
1621 for (row = 0; row <= max; row++) {
1622 song_note_t *note = csf->patterns[pat] + MAX_CHANNELS * row;
1623 song_note_t *empty = NULL; // where's an empty effect?
1624 int has_break = 0, has_jump = 0;
1625
1626 for (n = 0; n < MAX_CHANNELS; n++, note++) {
1627 switch (note->effect) {
1628 case FX_POSITIONJUMP:
1629 has_jump = 1;
1630 break;
1631 case FX_PATTERNBREAK:
1632 has_break = 1;
1633 if (!note->param)
1634 empty = note; // always rewrite C00 with Bxx (it's cleaner)
1635 break;
1636 case FX_NONE:
1637 if (!empty)
1638 empty = note;
1639 break;
1640 }
1641 }
1642
1643 // if there's not already a Bxx, and we have a spare channel,
1644 // AND either there's a Cxx or it's the last row of the pattern,
1645 // then stuff in a jump back to the restart position.
1646 if (!has_jump && empty && (has_break || row == max)) {
1647 empty->effect = FX_POSITIONJUMP;
1648 empty->param = restart_order;
1649 }
1650 }
1651 }
1652
1653