CoCalc -- seqplayer.c

GitHub Repository: MorsGames/sm64plus
Path: blob/master/src/audio/seqplayer.c
⁷⁸⁵⁷ views
1
#include <PR/ultratypes.h>
2

3
#include "data.h"
4
#include "effects.h"
5
#include "external.h"
6
#include "heap.h"
7
#include "load.h"
8
#include "seqplayer.h"
9

10
#include "game/settings.h"
11

12
#define PORTAMENTO_IS_SPECIAL(x) ((x).mode & 0x80)
13
#define PORTAMENTO_MODE(x) ((x).mode & ~0x80)
14
#define PORTAMENTO_MODE_1 1
15
#define PORTAMENTO_MODE_2 2
16
#define PORTAMENTO_MODE_3 3
17
#define PORTAMENTO_MODE_4 4
18
#define PORTAMENTO_MODE_5 5
19

20
#ifdef VERSION_SH
21
void seq_channel_layer_process_script_part1(struct SequenceChannelLayer *layer);
22
s32 seq_channel_layer_process_script_part2(struct SequenceChannelLayer *layer);
23
s32 seq_channel_layer_process_script_part3(struct SequenceChannelLayer *layer, s32 cmd);
24
s32 seq_channel_layer_process_script_part4(struct SequenceChannelLayer *layer, s32 cmd);
25
s32 seq_channel_layer_process_script_part5(struct SequenceChannelLayer *layer, s32 cmd);
26
#endif
27
void seq_channel_layer_process_script(struct SequenceChannelLayer *layer);
28
void sequence_channel_process_script(struct SequenceChannel *seqChannel);
29
u8 get_instrument(struct SequenceChannel *seqChannel, u8 instId, struct Instrument **instOut,
30
                  struct AdsrSettings *adsr);
31

32
void sequence_channel_init(struct SequenceChannel *seqChannel) {
33
    s32 i;
34

35
    seqChannel->enabled = FALSE;
36
    seqChannel->finished = FALSE;
37
    seqChannel->stopScript = FALSE;
38
    seqChannel->stopSomething2 = FALSE;
39
    seqChannel->hasInstrument = FALSE;
40
    seqChannel->stereoHeadsetEffects = FALSE;
41
    seqChannel->transposition = 0;
42
    seqChannel->largeNotes = FALSE;
43
#if defined(VERSION_EU) || defined(VERSION_SH)
44
    seqChannel->bookOffset = 0;
45
    seqChannel->changes.as_u8 = 0xff;
46
    seqChannel->scriptState.depth = 0;
47
    seqChannel->newPan = 0x40;
48
    seqChannel->panChannelWeight = 0x80;
49
    seqChannel->noteUnused = NULL;
50
    seqChannel->reverbIndex = 0;
51
#else
52
    seqChannel->scriptState.depth = 0;
53
    seqChannel->volume = 1.0f;
54
    seqChannel->volumeScale = 1.0f;
55
    seqChannel->freqScale = 1.0f;
56
    seqChannel->pan = 0.5f;
57
    seqChannel->panChannelWeight = 1.0f;
58
    seqChannel->noteUnused = NULL;
59
#endif
60
    seqChannel->reverbVol = 0;
61
#ifdef VERSION_SH
62
    seqChannel->synthesisVolume = 0;
63
#endif
64
    seqChannel->notePriority = NOTE_PRIORITY_DEFAULT;
65
#ifdef VERSION_SH
66
    seqChannel->unkSH06 = 1;
67
#endif
68
    seqChannel->delay = 0;
69
    seqChannel->adsr.envelope = gDefaultEnvelope;
70
    seqChannel->adsr.releaseRate = 0x20;
71
    seqChannel->adsr.sustain = 0;
72
#if defined(VERSION_JP) || defined(VERSION_US)
73
    seqChannel->updatesPerFrameUnused = gAudioUpdatesPerFrame;
74
#endif
75
    seqChannel->vibratoRateTarget = 0x800;
76
    seqChannel->vibratoRateStart = 0x800;
77
    seqChannel->vibratoExtentTarget = 0;
78
    seqChannel->vibratoExtentStart = 0;
79
    seqChannel->vibratoRateChangeDelay = 0;
80
    seqChannel->vibratoExtentChangeDelay = 0;
81
    seqChannel->vibratoDelay = 0;
82
#ifdef VERSION_SH
83
    seqChannel->filter = NULL;
84
#endif
85
#if defined(VERSION_EU) || defined(VERSION_SH)
86
    seqChannel->volume = 1.0f;
87
    seqChannel->volumeScale = 1.0f;
88
    seqChannel->freqScale = 1.0f;
89
#endif
90

91
    for (i = 0; i < 8; i++) {
92
        seqChannel->soundScriptIO[i] = -1;
93
    }
94

95
    seqChannel->unused = FALSE;
96
    init_note_lists(&seqChannel->notePool);
97
}
98

99
s32 seq_channel_set_layer(struct SequenceChannel *seqChannel, s32 layerIndex) {
100
    struct SequenceChannelLayer *layer;
101

102
    if (seqChannel->layers[layerIndex] == NULL) {
103
#if defined(VERSION_EU) || defined(VERSION_SH)
104
        struct SequenceChannelLayer *layer;
105
#endif
106
        layer = audio_list_pop_back(&gLayerFreeList);
107
        seqChannel->layers[layerIndex] = layer;
108
        if (layer == NULL) {
109
            seqChannel->layers[layerIndex] = NULL;
110
            return -1;
111
        }
112
    } else {
113
        seq_channel_layer_note_decay(seqChannel->layers[layerIndex]);
114
    }
115

116
    layer = seqChannel->layers[layerIndex];
117
    layer->seqChannel = seqChannel;
118
    layer->adsr = seqChannel->adsr;
119
    layer->adsr.releaseRate = 0;
120
    layer->enabled = TRUE;
121
    layer->stopSomething = FALSE;
122
    layer->continuousNotes = FALSE;
123
    layer->finished = FALSE;
124
#if defined(VERSION_EU) || defined(VERSION_SH)
125
    layer->ignoreDrumPan = FALSE;
126
#endif
127
#ifdef VERSION_SH
128
    layer->reverbBits.asByte = 0x40;
129
#endif
130
    layer->portamento.mode = 0;
131
    layer->scriptState.depth = 0;
132
    layer->status = SOUND_LOAD_STATUS_NOT_LOADED;
133
    layer->noteDuration = 0x80;
134
#if defined(VERSION_EU) || defined(VERSION_SH)
135
    layer->pan = 0x40;
136
#endif
137
    layer->transposition = 0;
138
    layer->delay = 0;
139
    layer->duration = 0;
140
    layer->delayUnused = 0;
141
    layer->note = NULL;
142
    layer->instrument = NULL;
143
#if defined(VERSION_EU) || defined(VERSION_SH)
144
    layer->freqScale = 1.0f;
145
    layer->velocitySquare = 0.0f;
146
#ifdef VERSION_SH
147
    layer->freqScaleMultiplier = 1.0f;
148
#endif
149
    layer->instOrWave = 0xff;
150
#else
151
    layer->velocitySquare = 0.0f;
152
    layer->pan = 0.5f;
153
#endif
154
    return 0;
155
}
156

157
void seq_channel_layer_disable(struct SequenceChannelLayer *layer) {
158
    if (layer != NULL) {
159
        seq_channel_layer_note_decay(layer);
160
        layer->enabled = FALSE;
161
        layer->finished = TRUE;
162
    }
163
}
164

165
void seq_channel_layer_free(struct SequenceChannel *seqChannel, s32 layerIndex) {
166
    struct SequenceChannelLayer *layer = seqChannel->layers[layerIndex];
167

168
    if (layer != NULL) {
169
#if defined(VERSION_EU) || defined(VERSION_SH)
170
        audio_list_push_back(&gLayerFreeList, &layer->listItem);
171
#else
172
        struct AudioListItem *item = &layer->listItem;
173
        if (item->prev == NULL) {
174
            gLayerFreeList.prev->next = item;
175
            item->prev = gLayerFreeList.prev;
176
            item->next = &gLayerFreeList;
177
            gLayerFreeList.prev = item;
178
            gLayerFreeList.u.count++;
179
            item->pool = gLayerFreeList.pool;
180
        }
181
#endif
182
        seq_channel_layer_disable(layer);
183
        seqChannel->layers[layerIndex] = NULL;
184
    }
185
}
186

187
void sequence_channel_disable(struct SequenceChannel *seqChannel) {
188
    s32 i;
189
    for (i = 0; i < LAYERS_MAX; i++) {
190
        seq_channel_layer_free(seqChannel, i);
191
    }
192

193
    note_pool_clear(&seqChannel->notePool);
194
    seqChannel->enabled = FALSE;
195
    seqChannel->finished = TRUE;
196
}
197

198
struct SequenceChannel *allocate_sequence_channel(void) {
199
    s32 i;
200
    for (i = 0; i < ARRAY_COUNT(gSequenceChannels); i++) {
201
        if (gSequenceChannels[i].seqPlayer == NULL) {
202
#if defined(VERSION_EU) || defined(VERSION_SH)
203
            return &gSequenceChannels[i];
204
#else
205
            return gSequenceChannels + i;
206
#endif
207
        }
208
    }
209
    return &gSequenceChannelNone;
210
}
211

212
void sequence_player_init_channels(struct SequencePlayer *seqPlayer, u16 channelBits) {
213
    struct SequenceChannel *seqChannel;
214
    s32 i;
215

216
    for (i = 0; i < CHANNELS_MAX; i++) {
217
        if (channelBits & 1) {
218
            seqChannel = seqPlayer->channels[i];
219
            if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == TRUE && seqChannel->seqPlayer == seqPlayer) {
220
                sequence_channel_disable(seqChannel);
221
                seqChannel->seqPlayer = NULL;
222
            }
223
            seqChannel = allocate_sequence_channel();
224
            if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == FALSE) {
225
                eu_stubbed_printf_0("Audio:Track:Warning: No Free Notetrack\n");
226
                gAudioErrorFlags = i + 0x10000;
227
                seqPlayer->channels[i] = seqChannel;
228
            } else {
229
                sequence_channel_init(seqChannel);
230
                seqPlayer->channels[i] = seqChannel;
231
                seqChannel->seqPlayer = seqPlayer;
232
                seqChannel->bankId = seqPlayer->defaultBank[0];
233
                seqChannel->muteBehavior = seqPlayer->muteBehavior;
234
                seqChannel->noteAllocPolicy = seqPlayer->noteAllocPolicy;
235
            }
236
        }
237
#if defined(VERSION_EU) || defined(VERSION_SH)
238
        channelBits = channelBits >> 1;
239
#else
240
        channelBits >>= 1;
241
#endif
242
    }
243
}
244

245
void sequence_player_disable_channels(struct SequencePlayer *seqPlayer, u16 channelBits) {
246
    struct SequenceChannel *seqChannel;
247
    s32 i;
248

249
    eu_stubbed_printf_0("SUBTRACK DIM\n");
250
    for (i = 0; i < CHANNELS_MAX; i++) {
251
        if (channelBits & 1) {
252
            seqChannel = seqPlayer->channels[i];
253
            if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == TRUE) {
254
                if (seqChannel->seqPlayer == seqPlayer) {
255
                    sequence_channel_disable(seqChannel);
256
                    seqChannel->seqPlayer = NULL;
257
                }
258
#if defined(VERSION_EU) || defined(VERSION_SH)
259
                else {
260
#ifdef VERSION_EU
261
                    stubbed_printf("Audio:Track: Warning SUBTRACK PARENT CHANGED\n");
262
#endif
263
                }
264
#endif
265
                seqPlayer->channels[i] = &gSequenceChannelNone;
266
            }
267
        }
268
#if defined(VERSION_EU) || defined(VERSION_SH)
269
        channelBits = channelBits >> 1;
270
#else
271
        channelBits >>= 1;
272
#endif
273
    }
274
}
275

276
void sequence_channel_enable(struct SequencePlayer *seqPlayer, u8 channelIndex, void *script) {
277
    struct SequenceChannel *seqChannel = seqPlayer->channels[channelIndex];
278
    s32 i;
279
    if (IS_SEQUENCE_CHANNEL_VALID(seqChannel) == FALSE) {
280
#ifdef VERSION_EU
281
        struct SequencePlayer *bgMusic = &gSequencePlayers[0];
282
        struct SequencePlayer *miscMusic = &gSequencePlayers[1];
283

284
        if (seqPlayer == bgMusic) {
285
            stubbed_printf("GROUP 0:");
286
        } else if (seqPlayer == miscMusic) {
287
            stubbed_printf("GROUP 1:");
288
        } else {
289
            stubbed_printf("SEQID %d,BANKID %d\n",
290
                    seqPlayer->seqId, seqPlayer->defaultBank[0]);
291
        }
292
        stubbed_printf("ERR:SUBTRACK %d NOT ALLOCATED\n", channelIndex);
293
#endif
294
    } else {
295
        seqChannel->enabled = TRUE;
296
        seqChannel->finished = FALSE;
297
        seqChannel->scriptState.depth = 0;
298
        seqChannel->scriptState.pc = script;
299
        seqChannel->delay = 0;
300
        for (i = 0; i < LAYERS_MAX; i++) {
301
            if (seqChannel->layers[i] != NULL) {
302
                seq_channel_layer_free(seqChannel, i);
303
            }
304
        }
305
    }
306
}
307

308
void sequence_player_disable(struct SequencePlayer *seqPlayer) {
309
    sequence_player_disable_channels(seqPlayer, 0xffff);
310
    note_pool_clear(&seqPlayer->notePool);
311
    seqPlayer->finished = TRUE;
312
    seqPlayer->enabled = FALSE;
313

314
    if (IS_SEQ_LOAD_COMPLETE(seqPlayer->seqId)
315
#ifdef VERSION_SH
316
        && gSeqLoadStatus[seqPlayer->seqId] != 5
317
#endif
318
    ) {
319
        gSeqLoadStatus[seqPlayer->seqId] = SOUND_LOAD_STATUS_DISCARDABLE;
320
    }
321

322
    if (IS_BANK_LOAD_COMPLETE(seqPlayer->defaultBank[0])
323
#ifdef VERSION_SH
324
        && gBankLoadStatus[seqPlayer->defaultBank[0]] != 5
325
#endif
326
    ) {
327
#ifdef VERSION_SH
328
        gBankLoadStatus[seqPlayer->defaultBank[0]] = 4;
329
#else
330
        gBankLoadStatus[seqPlayer->defaultBank[0]] = SOUND_LOAD_STATUS_DISCARDABLE;
331
#endif
332
    }
333

334
    // (Note that if this is called from alloc_bank_or_seq, the side will get swapped
335
    // later in that function. Thus, we signal that we want to load into the slot
336
    // of the bank that we no longer need.)
337
#if defined(VERSION_EU) || defined(VERSION_SH)
338
    if (seqPlayer->defaultBank[0] == gBankLoadedPool.temporary.entries[0].id) {
339
        gBankLoadedPool.temporary.nextSide = 1;
340
    } else if (seqPlayer->defaultBank[0] == gBankLoadedPool.temporary.entries[1].id) {
341
        gBankLoadedPool.temporary.nextSide = 0;
342
    }
343
#else
344
    if (gBankLoadedPool.temporary.entries[0].id == seqPlayer->defaultBank[0]) {
345
        gBankLoadedPool.temporary.nextSide = 1;
346
    } else if (gBankLoadedPool.temporary.entries[1].id == seqPlayer->defaultBank[0]) {
347
        gBankLoadedPool.temporary.nextSide = 0;
348
    }
349
#endif
350
}
351

352
/**
353
 * Add an item to the end of a list, if it's not already in any list.
354
 */
355
void audio_list_push_back(struct AudioListItem *list, struct AudioListItem *item) {
356
    if (item->prev != NULL) {
357
        eu_stubbed_printf_0("Error:Same List Add\n");
358
    } else {
359
        list->prev->next = item;
360
        item->prev = list->prev;
361
        item->next = list;
362
        list->prev = item;
363
        list->u.count++;
364
        item->pool = list->pool;
365
    }
366
}
367

368
/**
369
 * Remove the last item from a list, and return it (or NULL if empty).
370
 */
371
void *audio_list_pop_back(struct AudioListItem *list) {
372
    struct AudioListItem *item = list->prev;
373
    if (item == list) {
374
        return NULL;
375
    }
376
    item->prev->next = list;
377
    list->prev = item->prev;
378
    item->prev = NULL;
379
    list->u.count--;
380
    return item->u.value;
381
}
382

383
void init_layer_freelist(void) {
384
    s32 i;
385

386
    gLayerFreeList.prev = &gLayerFreeList;
387
    gLayerFreeList.next = &gLayerFreeList;
388
    gLayerFreeList.u.count = 0;
389
    gLayerFreeList.pool = NULL;
390

391
    for (i = 0; i < ARRAY_COUNT(gSequenceLayers); i++) {
392
#if defined(VERSION_EU) || defined(VERSION_SH)
393
        gSequenceLayers[i].listItem.u.value = &gSequenceLayers[i];
394
#else
395
        gSequenceLayers[i].listItem.u.value = gSequenceLayers + i;
396
#endif
397
        gSequenceLayers[i].listItem.prev = NULL;
398
        audio_list_push_back(&gLayerFreeList, &gSequenceLayers[i].listItem);
399
    }
400
}
401

402
u8 m64_read_u8(struct M64ScriptState *state) {
403
#if defined(VERSION_EU) || defined(VERSION_SH)
404
    return *(state->pc++);
405
#else
406
    u8 *midiArg = state->pc++;
407
    return *midiArg;
408
#endif
409
}
410

411
s16 m64_read_s16(struct M64ScriptState *state) {
412
    s16 ret = *(state->pc++) << 8;
413
    ret = *(state->pc++) | ret;
414
    return ret;
415
}
416

417
u16 m64_read_compressed_u16(struct M64ScriptState *state) {
418
    u16 ret = *(state->pc++);
419
    if (ret & 0x80) {
420
        ret = (ret << 8) & 0x7f00;
421
        ret = *(state->pc++) | ret;
422
    }
423
    return ret;
424
}
425

426
#if defined(VERSION_SH)
427
void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
428
    s32 cmd;
429

430
    if (layer->enabled == FALSE) {
431
        return;
432
    }
433

434
    if (layer->delay > 1) {
435
        layer->delay--;
436
        if (!layer->stopSomething && layer->delay <= layer->duration) {
437
            seq_channel_layer_note_decay(layer);
438
            layer->stopSomething = TRUE;
439
        }
440
        return;
441
    }
442

443
    seq_channel_layer_process_script_part1(layer);
444
    cmd = seq_channel_layer_process_script_part2(layer);
445
    if (cmd != -1) {
446
        cmd = seq_channel_layer_process_script_part3(layer, cmd);
447
        if (cmd != -1) {
448
            cmd = seq_channel_layer_process_script_part4(layer, cmd);
449
        }
450
        if (cmd != -1) {
451
            seq_channel_layer_process_script_part5(layer, cmd);
452
        }
453

454
        if (layer->stopSomething == TRUE) {
455
            if (layer->note != NULL || layer->continuousNotes) {
456
                seq_channel_layer_note_decay(layer);
457
            }
458
        }
459
    }
460
}
461
#elif defined(VERSION_EU)
462
void seq_channel_layer_process_script(struct SequenceChannelLayer *layer) {
463
    struct SequencePlayer *seqPlayer;
464
    struct SequenceChannel *seqChannel;
465
#ifdef VERSION_EU
466
    UNUSED u32 pad0;
467
#endif
468
    struct M64ScriptState *state;
469
    struct Portamento *portamento;
470
    struct AudioBankSound *sound;
471
    struct Instrument *instrument;
472
    struct Drum *drum;
473
    s32 temp_a0_5;
474
#ifdef VERSION_EU
475
    u16 sp3A;
476
    s32 sameSound;
477
#endif
478
    UNUSED u32 pad1;
479
#ifndef VERSION_EU
480
    u8 sameSound;
481
#endif
482
    u8 cmd;
483
    UNUSED u8 cmdSemitone;
484
#ifndef VERSION_EU
485
    u16 sp3A;
486
#endif
487
    f32 tuning;
488
    s32 vel;
489
    UNUSED s32 usedSemitone;
490
    f32 freqScale;
491
#ifndef VERSION_EU
492
    UNUSED f32 sp24;
493
#endif
494
    f32 temp_f12;
495
    f32 temp_f2;
496

497
    sameSound = TRUE;
498
    if (layer->enabled == FALSE) {
499
        return;
500
    }
501

502
    if (layer->delay > 1) {
503
        layer->delay--;
504
        if (!layer->stopSomething && layer->delay <= layer->duration) {
505
            seq_channel_layer_note_decay(layer);
506
            layer->stopSomething = TRUE;
507
        }
508
        return;
509
    }
510

511
    if (!layer->continuousNotes) {
512
        seq_channel_layer_note_decay(layer);
513
    }
514

515
    if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 ||
516
        PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2) {
517
        layer->portamento.mode = 0;
518
    }
519

520
    seqChannel = layer->seqChannel;
521
    seqPlayer = seqChannel->seqPlayer;
522
#if defined(VERSION_EU) || defined(VERSION_SH)
523
    layer->notePropertiesNeedInit = TRUE;
524
#endif
525

526
    for (;;) {
527
        state = &layer->scriptState;
528
        cmd = m64_read_u8(state);
529

530
        if (cmd <= 0xc0) {
531
            break;
532
        }
533

534
        switch (cmd) {
535
            case 0xff: // layer_end; function return or end of script
536
                if (state->depth == 0) {
537
                    // N.B. this function call is *not* inlined even though it's
538
                    // within the same file, unlike in the rest of this function.
539
                    seq_channel_layer_disable(layer);
540
                    return;
541
                }
542
                state->pc = state->stack[--state->depth];
543
                break;
544

545
            case 0xfc: // layer_call
546
                if (0 && state->depth >= 4) {
547
                    eu_stubbed_printf_0("Macro Level Over Error!\n");
548
                }
549
                sp3A = m64_read_s16(state);
550
                state->stack[state->depth++] = state->pc;
551
                state->pc = seqPlayer->seqData + sp3A;
552
                break;
553

554
            case 0xf8: // layer_loop; loop start, N iterations (or 256 if N = 0)
555
                if (0 && state->depth >= 4) {
556
                    eu_stubbed_printf_0("Macro Level Over Error!\n");
557
                }
558
                state->remLoopIters[state->depth] = m64_read_u8(state);
559
                state->stack[state->depth++] = state->pc;
560
                break;
561

562
            case 0xf7: // layer_loopend
563
                if (--state->remLoopIters[state->depth - 1] != 0) {
564
                    state->pc = state->stack[state->depth - 1];
565
                } else {
566
                    state->depth--;
567
                }
568
                break;
569

570
            case 0xfb: // layer_jump
571
                sp3A = m64_read_s16(state);
572
                state->pc = seqPlayer->seqData + sp3A;
573
                break;
574

575
#if defined(VERSION_EU) || defined(VERSION_SH)
576
            case 0xf4:
577
                state->pc += (s8)m64_read_u8(state);
578
                break;
579
#endif
580

581
            case 0xc1: // layer_setshortnotevelocity
582
            case 0xca: // layer_setpan
583
                temp_a0_5 = *(state->pc++);
584
                if (cmd == 0xc1) {
585
                    layer->velocitySquare = (f32)(temp_a0_5 * temp_a0_5);
586
                } else {
587
#if defined(VERSION_EU) || defined(VERSION_SH)
588
                    layer->pan = temp_a0_5;
589
#else
590
                    layer->pan = (f32) temp_a0_5 / US_FLOAT(128.0);
591
#endif
592
                }
593
                break;
594

595
            case 0xc2: // layer_transpose; set transposition in semitones
596
            case 0xc9: // layer_setshortnoteduration
597
                temp_a0_5 = *(state->pc++);
598
                if (cmd == 0xc9) {
599
                    layer->noteDuration = temp_a0_5;
600
                } else {
601
                    layer->transposition = temp_a0_5;
602
                }
603
                break;
604

605
            case 0xc4: // layer_somethingon
606
            case 0xc5: // layer_somethingoff
607
                if (cmd == 0xc4) {
608
                    layer->continuousNotes = TRUE;
609
                } else {
610
                    layer->continuousNotes = FALSE;
611
                }
612
                seq_channel_layer_note_decay(layer);
613
                break;
614

615
            case 0xc3: // layer_setshortnotedefaultplaypercentage
616
                sp3A = m64_read_compressed_u16(state);
617
                layer->shortNoteDefaultPlayPercentage = sp3A;
618
                break;
619

620
            case 0xc6: // layer_setinstr
621
                cmd = m64_read_u8(state);
622
#if defined(VERSION_JP) || defined(VERSION_US)
623
                if (cmd < 127) {
624
                    cmd = get_instrument(seqChannel, cmd, &layer->instrument, &layer->adsr);
625
                }
626
#else
627
                if (cmd >= 0x7f) {
628
                    if (cmd == 0x7f) {
629
                        layer->instOrWave = 0;
630
                    } else {
631
                        layer->instOrWave = cmd;
632
                        layer->instrument = NULL;
633
                    }
634

635
                    if (1) {
636
                    }
637

638
                    if (cmd == 0xff) {
639
                        layer->adsr.releaseRate = 0;
640
                    }
641
                    break;
642
                }
643

644
                if ((layer->instOrWave = get_instrument(seqChannel, cmd, &layer->instrument, &layer->adsr)) == 0) {
645
                    eu_stubbed_printf_1("WARNING: NPRG: cannot change %d\n", cmd);
646
                    layer->instOrWave = 0xff;
647
                }
648
#endif
649
                break;
650

651
            case 0xc7: // layer_portamento
652
                layer->portamento.mode = m64_read_u8(state);
653

654
                // cmd is reused for the portamento's semitone
655
                cmd = m64_read_u8(state) + seqChannel->transposition +
656
                    layer->transposition + seqPlayer->transposition;
657

658
                if (cmd >= 0x80) {
659
                    cmd = 0;
660
                }
661

662
                layer->portamentoTargetNote = cmd;
663

664
                // If special, the next param is u8 instead of var
665
                if (PORTAMENTO_IS_SPECIAL(layer->portamento)) {
666
                    layer->portamentoTime = *((state)->pc++);
667
                    break;
668
                }
669

670
                sp3A = m64_read_compressed_u16(state);
671
                layer->portamentoTime = sp3A;
672
                break;
673

674
            case 0xc8: // layer_disableportamento
675
                layer->portamento.mode = 0;
676
                break;
677

678
#if defined(VERSION_EU) || defined(VERSION_SH)
679
            case 0xcb:
680
                sp3A = m64_read_s16(state);
681
                layer->adsr.envelope = (struct AdsrEnvelope *) (seqPlayer->seqData + sp3A);
682
                layer->adsr.releaseRate = m64_read_u8(state);
683
                break;
684

685
            case 0xcc:
686
                layer->ignoreDrumPan = TRUE;
687
                break;
688
#endif
689

690
            default:
691
                switch (cmd & 0xf0) {
692
                    case 0xd0: // layer_setshortnotevelocityfromtable
693
                        sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xf];
694
                        layer->velocitySquare = (f32)(sp3A * sp3A);
695
                        break;
696
                    case 0xe0: // layer_setshortnotedurationfromtable
697
                        layer->noteDuration = seqPlayer->shortNoteDurationTable[cmd & 0xf];
698
                        break;
699
                    default:
700
                        eu_stubbed_printf_1("Audio:Track:NOTE:UNDEFINED NOTE COM. %x\n", cmd);
701
                        break;
702
                }
703
        }
704
    }
705

706
    if (cmd == 0xc0) { // layer_delay
707
        layer->delay = m64_read_compressed_u16(state);
708
        layer->stopSomething = TRUE;
709
    } else {
710
        layer->stopSomething = FALSE;
711

712
        if (seqChannel->largeNotes == TRUE) {
713
            switch (cmd & 0xc0) {
714
                case 0x00: // layer_note0 (play percentage, velocity, duration)
715
                    sp3A = m64_read_compressed_u16(state);
716
                    vel = *(state->pc++);
717
                    layer->noteDuration = *(state->pc++);
718
                    layer->playPercentage = sp3A;
719
                    break;
720

721
                case 0x40: // layer_note1 (play percentage, velocity)
722
                    sp3A = m64_read_compressed_u16(state);
723
                    vel = *(state->pc++);
724
                    layer->noteDuration = 0;
725
                    layer->playPercentage = sp3A;
726
                    break;
727

728
                case 0x80: // layer_note2 (velocity, duration; uses last play percentage)
729
                    sp3A = layer->playPercentage;
730
                    vel = *(state->pc++);
731
                    layer->noteDuration = *(state->pc++);
732
                    break;
733
            }
734

735
            // the remaining bits are used for the semitone
736
            cmd -= (cmd & 0xc0);
737
#if defined(VERSION_EU) || defined(VERSION_SH)
738
            layer->velocitySquare = (f32)(vel) * (f32)vel;
739
#else
740
            layer->velocitySquare = vel * vel;
741
#endif
742
        } else {
743
            switch (cmd & 0xc0) {
744
                case 0x00: // play note, type 0 (play percentage)
745
                    sp3A = m64_read_compressed_u16(state);
746
                    layer->playPercentage = sp3A;
747
                    break;
748

749
                case 0x40: // play note, type 1 (uses default play percentage)
750
                    sp3A = layer->shortNoteDefaultPlayPercentage;
751
                    break;
752

753
                case 0x80: // play note, type 2 (uses last play percentage)
754
                    sp3A = layer->playPercentage;
755
                    break;
756
            }
757

758
            // the remaining bits are used for the semitone
759
            cmd -= cmd & 0xc0;
760
        }
761

762
        layer->delay = sp3A;
763
#if defined(VERSION_EU) || defined(VERSION_SH)
764
        layer->duration = layer->noteDuration * sp3A >> 8;
765
#else
766
        layer->duration = layer->noteDuration * sp3A / 256;
767
#endif
768
        if ((seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_STOP_NOTES) != 0)
769
            || seqChannel->stopSomething2
770
#if defined(VERSION_JP) || defined(VERSION_US)
771
            || !seqChannel->hasInstrument
772
#endif
773
        ) {
774
            layer->stopSomething = TRUE;
775
        } else {
776
#if defined(VERSION_EU) || defined(VERSION_SH)
777
            s32 temp = layer->instOrWave;
778
            if (temp == 0xff) temp = seqChannel->instOrWave;
779
            if (temp == 0)
780
#else
781
            if (seqChannel->instOrWave == 0)
782
#endif
783
            { // drum
784
                // cmd is reused for the drum semitone
785
                cmd += seqChannel->transposition + layer->transposition;
786

787
#if defined(VERSION_EU)
788
                drum = get_drum(seqChannel->bankId, cmd);
789
#else
790
                if (cmd >= gCtlEntries[seqChannel->bankId].numDrums) {
791
                    cmd = gCtlEntries[seqChannel->bankId].numDrums;
792
                    if (cmd == 0) {
793
                        // this goto looks a bit like a function return...
794
                        layer->stopSomething = TRUE;
795
                        goto skip;
796
                    }
797

798
                    cmd--;
799
                }
800

801
                drum = gCtlEntries[seqChannel->bankId].drums[cmd];
802
#endif
803
                if (drum == NULL) {
804
                    layer->stopSomething = TRUE;
805
                } else {
806
                    layer->adsr.envelope = drum->envelope;
807
                    layer->adsr.releaseRate = drum->releaseRate;
808
#if defined(VERSION_EU) || defined(VERSION_SH)
809
                    if (!layer->ignoreDrumPan) {
810
                        layer->pan = drum->pan;
811
                    }
812
#else
813
                    layer->pan = FLOAT_CAST(drum->pan) / US_FLOAT(128.0);
814
#endif
815
                    layer->sound = &drum->sound;
816
                    layer->freqScale = layer->sound->tuning;
817
                }
818
#if defined(VERSION_JP) || defined(VERSION_US) || defined(VERSION_SH)
819
            skip:;
820
#endif
821
            } else { // instrument
822
                // cmd is reused for the instrument semitone
823
                cmd += seqPlayer->transposition + seqChannel->transposition + layer->transposition;
824

825
                if (cmd >= 0x80) {
826
                    layer->stopSomething = TRUE;
827
                } else {
828
#if defined(VERSION_EU) || defined(VERSION_SH)
829
                    if (layer->instOrWave == 0xffu) {
830
                        instrument = seqChannel->instrument;
831
                    } else {
832
                        instrument = layer->instrument;
833
                    }
834
#else
835
                    instrument = layer->instrument;
836
                    if (instrument == NULL) {
837
                        instrument = seqChannel->instrument;
838
                    }
839
#endif
840

841
                    if (layer->portamento.mode != 0) {
842
                        if (layer->portamentoTargetNote < cmd) {
843
                            vel = cmd;
844
                        } else {
845
                            vel = layer->portamentoTargetNote;
846
                        }
847

848
                        if (instrument != NULL) {
849
#if defined(VERSION_EU)
850
                            sound = instrument_get_audio_bank_sound(instrument, vel);
851
#else
852
                            sound = (u8) vel <  instrument->normalRangeLo ? &instrument->lowNotesSound
853
                                  : (u8) vel <= instrument->normalRangeHi ?
854
                                        &instrument->normalNotesSound : &instrument->highNotesSound;
855
#endif
856
                            sameSound = (sound == layer->sound);
857
                            layer->sound = sound;
858
                            tuning = sound->tuning;
859
                        } else {
860
                            layer->sound = NULL;
861
                            tuning = 1.0f;
862
                        }
863

864
                        temp_f2 = gNoteFrequencies[cmd] * tuning;
865
                        temp_f12 = gNoteFrequencies[layer->portamentoTargetNote] * tuning;
866

867
                        portamento = &layer->portamento;
868
                        switch (PORTAMENTO_MODE(layer->portamento)) {
869
                            case PORTAMENTO_MODE_1:
870
                            case PORTAMENTO_MODE_3:
871
                            case PORTAMENTO_MODE_5:
872
#if defined(VERSION_JP) || defined(VERSION_US)
873
                                sp24 = temp_f2;
874
#endif
875
                                freqScale = temp_f12;
876
                                break;
877

878
                            case PORTAMENTO_MODE_2:
879
                            case PORTAMENTO_MODE_4:
880
#if defined(VERSION_EU) || defined(VERSION_SH)
881
                            default:
882
#endif
883
                                freqScale = temp_f2;
884
#if defined(VERSION_JP) || defined(VERSION_US)
885
                                sp24 = temp_f12;
886
#endif
887
                                break;
888
                        }
889

890
#if defined(VERSION_EU) || defined(VERSION_SH)
891
                        portamento->extent = temp_f2 / freqScale - 1.0f;
892
#else
893
                        portamento->extent = sp24 / freqScale - US_FLOAT(1.0);
894
#endif
895

896
                        if (PORTAMENTO_IS_SPECIAL(layer->portamento)) {
897
                            portamento->speed = US_FLOAT(32512.0) * FLOAT_CAST(seqPlayer->tempo)
898
                                                / ((f32) layer->delay * (f32) gTempoInternalToExternal
899
                                                   * FLOAT_CAST(layer->portamentoTime));
900
                        } else {
901
                            portamento->speed = US_FLOAT(127.0) / FLOAT_CAST(layer->portamentoTime);
902
                        }
903
                        portamento->cur = 0.0f;
904
                        layer->freqScale = freqScale;
905
                        if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_5) {
906
                            layer->portamentoTargetNote = cmd;
907
                        }
908
                    } else if (instrument != NULL) {
909
#if defined(VERSION_EU)
910
                        sound = instrument_get_audio_bank_sound(instrument, cmd);
911
#else
912
                        sound = cmd < instrument->normalRangeLo ?
913
                                         &instrument->lowNotesSound : cmd <= instrument->normalRangeHi ?
914
                                         &instrument->normalNotesSound : &instrument->highNotesSound;
915
#endif
916
                        sameSound = (sound == layer->sound);
917
                        layer->sound = sound;
918
                        layer->freqScale = gNoteFrequencies[cmd] * sound->tuning;
919
                    } else {
920
                        layer->sound = NULL;
921
                        layer->freqScale = gNoteFrequencies[cmd];
922
                    }
923
                }
924
            }
925
            layer->delayUnused = layer->delay;
926
        }
927
    }
928

929
    if (layer->stopSomething == TRUE) {
930
        if (layer->note != NULL || layer->continuousNotes) {
931
            seq_channel_layer_note_decay(layer);
932
        }
933
        return;
934
    }
935

936
    cmd = FALSE;
937
    if (!layer->continuousNotes) {
938
        cmd = TRUE;
939
    } else if (layer->note == NULL || layer->status == SOUND_LOAD_STATUS_NOT_LOADED) {
940
        cmd = TRUE;
941
    } else if (sameSound == FALSE) {
942
        seq_channel_layer_note_decay(layer);
943
        cmd = TRUE;
944
    }
945
#if defined(VERSION_EU) || defined(VERSION_SH)
946
    else if (layer != layer->note->parentLayer) {
947
        cmd = TRUE;
948
    }
949
#endif
950
    else if (layer->sound == NULL) {
951
        init_synthetic_wave(layer->note, layer);
952
    }
953

954
    if (cmd != FALSE) {
955
        layer->note = alloc_note(layer);
956
    }
957

958
    if (layer->note != NULL && layer->note->parentLayer == layer) {
959
        note_vibrato_init(layer->note);
960
    }
961
#if defined(VERSION_EU) || defined(VERSION_SH)
962
    if (seqChannel) {
963
    }
964
#endif
965
}
966

967
#ifdef VERSION_EU
968
u8 audioString106[] = "Audio: Note:Velocity Error %d\n";
969
u8 audioString107[] = "Error: Your assignchannel is stolen.\n";
970
#endif
971

972
#else
973
// US/JP version with macros to simulate inlining by copt. Edit if you dare.
974
#include "copt/seq_channel_layer_process_script_copt.inc.c"
975
#endif
976

977
#ifdef VERSION_SH
978
void seq_channel_layer_process_script_part1(struct SequenceChannelLayer *layer) {
979
    if (!layer->continuousNotes) {
980
        seq_channel_layer_note_decay(layer);
981
    } else if (layer->note != NULL && layer->note->wantedParentLayer == layer) {
982
        seq_channel_layer_note_decay(layer);
983
    }
984

985
    if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_1 ||
986
        PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_2) {
987
        layer->portamento.mode = 0;
988
    }
989

990
    layer->notePropertiesNeedInit = TRUE;
991
}
992

993
s32 seq_channel_layer_process_script_part5(struct SequenceChannelLayer *layer, s32 cmd) {
994
    if (!layer->stopSomething && layer->sound != NULL && layer->sound->sample->codec == CODEC_SKIP &&
995
        layer->sound->sample->medium != 0) {
996
        layer->stopSomething = TRUE;
997
        return -1;
998
    }
999

1000
    if (layer->continuousNotes == 1 && layer->note != NULL && layer->status && cmd == 1 &&
1001
        layer->note->parentLayer == layer) {
1002
        if (layer->sound == NULL) {
1003
            init_synthetic_wave(layer->note, layer);
1004
        }
1005
    } else {
1006
        if (cmd == 0) {
1007
            seq_channel_layer_note_decay(layer);
1008
        }
1009
        layer->note = alloc_note(layer);
1010
    }
1011
    if (layer->note != NULL && layer->note->parentLayer == layer) {
1012
        note_vibrato_init(layer->note);
1013
    }
1014
    return 0;
1015
}
1016

1017
s32 seq_channel_layer_process_script_part2(struct SequenceChannelLayer *layer) {
1018
    struct SequenceChannel *seqChannel = layer->seqChannel;
1019
    struct SequencePlayer *seqPlayer = seqChannel->seqPlayer;
1020
    struct M64ScriptState *state;
1021
    s32 temp_a0_5;
1022
    u16 sp3A;
1023
    u8 cmd;
1024

1025
    for (;;) {
1026
        state = &layer->scriptState;
1027
        cmd = m64_read_u8(state);
1028

1029
        if (cmd <= 0xc0) {
1030
            return cmd;
1031
        }
1032

1033
        switch (cmd) {
1034
            case 0xff: // layer_end; function return or end of script
1035
                if (state->depth == 0) {
1036
                    // N.B. this function call is *not* inlined even though it's
1037
                    // within the same file, unlike in the rest of this function.
1038
                    seq_channel_layer_disable(layer);
1039
                    return -1;
1040
                }
1041
                state->pc = state->stack[--state->depth];
1042
                break;
1043

1044
            case 0xfc: // layer_call
1045
                if (0 && state->depth >= 4) {
1046
                    eu_stubbed_printf_0("Macro Level Over Error!\n");
1047
                }
1048
                sp3A = m64_read_s16(state);
1049
                state->stack[state->depth++] = state->pc;
1050
                state->pc = seqPlayer->seqData + sp3A;
1051
                break;
1052

1053
            case 0xf8: // layer_loop; loop start, N iterations (or 256 if N = 0)
1054
                if (0 && state->depth >= 4) {
1055
                    eu_stubbed_printf_0("Macro Level Over Error!\n");
1056
                }
1057
                state->remLoopIters[state->depth] = m64_read_u8(state);
1058
                state->stack[state->depth++] = state->pc;
1059
                break;
1060

1061
            case 0xf7: // layer_loopend
1062
                if (--state->remLoopIters[state->depth - 1] != 0) {
1063
                    state->pc = state->stack[state->depth - 1];
1064
                } else {
1065
                    state->depth--;
1066
                }
1067
                break;
1068

1069
            case 0xfb: // layer_jump
1070
                sp3A = m64_read_s16(state);
1071
                state->pc = seqPlayer->seqData + sp3A;
1072
                break;
1073

1074
            case 0xf4:
1075
                state->pc += (s8)m64_read_u8(state);
1076
                break;
1077

1078
            case 0xc1: // layer_setshortnotevelocity
1079
            case 0xca: // layer_setpan
1080
                temp_a0_5 = *(state->pc++);
1081
                if (cmd == 0xc1) {
1082
                    layer->velocitySquare = (f32) (temp_a0_5 * temp_a0_5) / (f32) (127 * 127);
1083
                } else {
1084
                    layer->pan = temp_a0_5;
1085
                }
1086
                break;
1087

1088
            case 0xc2: // layer_transpose; set transposition in semitones
1089
            case 0xc9: // layer_setshortnoteduration
1090
                temp_a0_5 = *(state->pc++);
1091
                if (cmd == 0xc9) {
1092
                    layer->noteDuration = temp_a0_5;
1093
                } else {
1094
                    layer->transposition = temp_a0_5;
1095
                }
1096
                break;
1097

1098
            case 0xc4: // layer_somethingon
1099
            case 0xc5: // layer_somethingoff
1100
                if (cmd == 0xc4) {
1101
                    layer->continuousNotes = TRUE;
1102
                } else {
1103
                    layer->continuousNotes = FALSE;
1104
                }
1105
                seq_channel_layer_note_decay(layer);
1106
                break;
1107

1108
            case 0xc3: // layer_setshortnotedefaultplaypercentage
1109
                sp3A = m64_read_compressed_u16(state);
1110
                layer->shortNoteDefaultPlayPercentage = sp3A;
1111
                break;
1112

1113
            case 0xc6: // layer_setinstr
1114
                cmd = m64_read_u8(state);
1115
                if (cmd >= 0x7f) {
1116
                    if (cmd == 0x7f) {
1117
                        layer->instOrWave = 0;
1118
                    } else {
1119
                        layer->instOrWave = cmd;
1120
                        layer->instrument = NULL;
1121
                    }
1122

1123
                    if (1) {
1124
                    }
1125

1126
                    if (cmd == 0xff) {
1127
                        layer->adsr.releaseRate = 0;
1128
                    }
1129
                    break;
1130
                }
1131

1132
                if ((layer->instOrWave = get_instrument(seqChannel, cmd, &layer->instrument, &layer->adsr)) == 0) {
1133
                    eu_stubbed_printf_1("WARNING: NPRG: cannot change %d\n", cmd);
1134
                    layer->instOrWave = 0xff;
1135
                }
1136
                break;
1137

1138
            case 0xc7: // layer_portamento
1139
                layer->portamento.mode = m64_read_u8(state);
1140

1141
                // cmd is reused for the portamento's semitone
1142
                cmd = m64_read_u8(state) + seqChannel->transposition +
1143
                    layer->transposition + seqPlayer->transposition;
1144

1145
                if (cmd >= 0x80) {
1146
                    cmd = 0;
1147
                }
1148

1149
                layer->portamentoTargetNote = cmd;
1150

1151
                // If special, the next param is u8 instead of var
1152
                if (PORTAMENTO_IS_SPECIAL(layer->portamento)) {
1153
                    layer->portamentoTime = *((state)->pc++);
1154
                    break;
1155
                }
1156

1157
                sp3A = m64_read_compressed_u16(state);
1158
                layer->portamentoTime = sp3A;
1159
                break;
1160

1161
            case 0xc8: // layer_disableportamento
1162
                layer->portamento.mode = 0;
1163
                break;
1164

1165
            case 0xcb:
1166
                sp3A = m64_read_s16(state);
1167
                layer->adsr.envelope = (struct AdsrEnvelope *) (seqPlayer->seqData + sp3A);
1168
                layer->adsr.releaseRate = m64_read_u8(state);
1169
                break;
1170

1171
            case 0xcc:
1172
                layer->ignoreDrumPan = TRUE;
1173
                break;
1174

1175
            case 0xcd:
1176
                layer->reverbBits.asByte = m64_read_u8(state);
1177
                break;
1178

1179
            case 0xce:
1180
                cmd = m64_read_u8(state) + 0x80;
1181
                layer->freqScaleMultiplier = unk_sh_data_1[cmd];
1182
                // missing break :)
1183

1184
            default:
1185
                switch (cmd & 0xf0) {
1186
                    case 0xd0: // layer_setshortnotevelocityfromtable
1187
                        sp3A = seqPlayer->shortNoteVelocityTable[cmd & 0xf];
1188
                        layer->velocitySquare = (f32) (sp3A * sp3A) / (f32) (127 * 127);
1189
                        break;
1190
                    case 0xe0: // layer_setshortnotedurationfromtable
1191
                        layer->noteDuration = seqPlayer->shortNoteDurationTable[cmd & 0xf];
1192
                        break;
1193
                    default:
1194
                        eu_stubbed_printf_1("Audio:Track:NOTE:UNDEFINED NOTE COM. %x\n", cmd);
1195
                        break;
1196
                }
1197
        }
1198
    }
1199
    return cmd;
1200
}
1201

1202
s32 seq_channel_layer_process_script_part4(struct SequenceChannelLayer *layer, s32 cmd1) {
1203
    s32 sameSound = TRUE;
1204
    struct SequenceChannel *seqChannel = layer->seqChannel;
1205
    struct Portamento *portamento;
1206
    struct AudioBankSound *sound;
1207
    struct Instrument *instrument;
1208
    struct Drum *drum;
1209
    f32 tuning;
1210
    s32 vel;
1211
    f32 freqScale;
1212
    f32 sp24;
1213
    f32 temp_f12;
1214
    UNUSED s32 pad[2];
1215
    struct SequencePlayer *seqPlayer = seqChannel->seqPlayer;
1216
    u8 cmd = cmd1;
1217
    f32 temp_f2;
1218

1219
    s32 temp = layer->instOrWave;
1220
    if (temp == 0xff) {
1221
        if (!seqChannel->hasInstrument) {
1222
            return -1;
1223
        }
1224
        temp = seqChannel->instOrWave;
1225
    }
1226
    if (temp == 0) { // drum
1227
        // cmd is reused for the drum semitone
1228
        cmd += seqChannel->transposition + layer->transposition;
1229

1230
        drum = get_drum(seqChannel->bankId, cmd);
1231
        if (drum == NULL) {
1232
            layer->stopSomething = TRUE;
1233
            layer->delayUnused = layer->delay;
1234
            return -1;
1235
        } else {
1236
            layer->adsr.envelope = drum->envelope;
1237
            layer->adsr.releaseRate = drum->releaseRate;
1238
            if (!layer->ignoreDrumPan) {
1239
                layer->pan = drum->pan;
1240
            }
1241
            layer->sound = &drum->sound;
1242
            layer->freqScale = layer->sound->tuning;
1243
        }
1244
    } else { // instrument
1245
        // cmd is reused for the instrument semitone
1246
        cmd += seqPlayer->transposition + seqChannel->transposition + layer->transposition;
1247

1248
        if (cmd >= 0x80) {
1249
            layer->stopSomething = TRUE;
1250
            return -1;
1251
        } else {
1252
            if (layer->instOrWave == 0xff) {
1253
                instrument = seqChannel->instrument;
1254
            } else {
1255
                instrument = layer->instrument;
1256
            }
1257

1258
            if (layer->portamento.mode != 0) {
1259
                if (layer->portamentoTargetNote < cmd) {
1260
                    vel = cmd;
1261
                } else {
1262
                    vel = layer->portamentoTargetNote;
1263
                }
1264

1265
                if (instrument != NULL) {
1266
                    sound = instrument_get_audio_bank_sound(instrument, vel);
1267
                    sameSound = (sound == layer->sound);
1268
                    layer->sound = sound;
1269
                    tuning = sound->tuning;
1270
                } else {
1271
                    layer->sound = NULL;
1272
                    tuning = 1.0f;
1273
                }
1274

1275
                temp_f2 = gNoteFrequencies[cmd] * tuning;
1276
                temp_f12 = gNoteFrequencies[layer->portamentoTargetNote] * tuning;
1277

1278
                portamento = &layer->portamento;
1279
                switch (PORTAMENTO_MODE(layer->portamento)) {
1280
                    case PORTAMENTO_MODE_1:
1281
                    case PORTAMENTO_MODE_3:
1282
                    case PORTAMENTO_MODE_5:
1283
                        sp24 = temp_f2;
1284
                        freqScale = temp_f12;
1285
                        break;
1286

1287
                    case PORTAMENTO_MODE_2:
1288
                    case PORTAMENTO_MODE_4:
1289
                        freqScale = temp_f2;
1290
                        sp24 = temp_f12;
1291
                        break;
1292

1293
                    default:
1294
                        freqScale = temp_f2;
1295
                        sp24 = temp_f2;
1296
                        break;
1297
                }
1298

1299
                portamento->extent = sp24 / freqScale - 1.0f;
1300

1301
                if (PORTAMENTO_IS_SPECIAL(layer->portamento)) {
1302
                    portamento->speed = US_FLOAT(32512.0) * FLOAT_CAST(seqPlayer->tempo)
1303
                                        / ((f32) layer->delay * (f32) gTempoInternalToExternal
1304
                                            * FLOAT_CAST(layer->portamentoTime));
1305
                } else {
1306
                    portamento->speed = US_FLOAT(127.0) / FLOAT_CAST(layer->portamentoTime);
1307
                }
1308
                portamento->cur = 0.0f;
1309
                layer->freqScale = freqScale;
1310
                if (PORTAMENTO_MODE(layer->portamento) == PORTAMENTO_MODE_5) {
1311
                    layer->portamentoTargetNote = cmd;
1312
                }
1313
            } else if (instrument != NULL) {
1314
                sound = instrument_get_audio_bank_sound(instrument, cmd);
1315
                sameSound = (sound == layer->sound);
1316
                layer->sound = sound;
1317
                layer->freqScale = gNoteFrequencies[cmd] * sound->tuning;
1318
            } else {
1319
                layer->sound = NULL;
1320
                layer->freqScale = gNoteFrequencies[cmd];
1321
            }
1322
        }
1323
    }
1324
    layer->delayUnused = layer->delay;
1325
    layer->freqScale *= layer->freqScaleMultiplier;
1326
    return sameSound;
1327
}
1328

1329
s32 seq_channel_layer_process_script_part3(struct SequenceChannelLayer *layer, s32 cmd) {
1330
    struct M64ScriptState *state = &layer->scriptState;
1331
    u16 sp3A;
1332
    s32 vel;
1333
    struct SequenceChannel *seqChannel = layer->seqChannel;
1334
    struct SequencePlayer *seqPlayer = seqChannel->seqPlayer;
1335

1336
    if (cmd == 0xc0) { // layer_delay
1337
        layer->delay = m64_read_compressed_u16(state);
1338
        layer->stopSomething = TRUE;
1339
        return -1;
1340
    }
1341

1342
    layer->stopSomething = FALSE;
1343

1344
    if (seqChannel->largeNotes == TRUE) {
1345
        switch (cmd & 0xc0) {
1346
            case 0x00: // layer_note0 (play percentage, velocity, duration)
1347
                sp3A = m64_read_compressed_u16(state);
1348
                vel = *(state->pc++);
1349
                layer->noteDuration = *(state->pc++);
1350
                layer->playPercentage = sp3A;
1351
                break;
1352

1353
            case 0x40: // layer_note1 (play percentage, velocity)
1354
                sp3A = m64_read_compressed_u16(state);
1355
                vel = *(state->pc++);
1356
                layer->noteDuration = 0;
1357
                layer->playPercentage = sp3A;
1358
                break;
1359

1360
            case 0x80: // layer_note2 (velocity, duration; uses last play percentage)
1361
                sp3A = layer->playPercentage;
1362
                vel = *(state->pc++);
1363
                layer->noteDuration = *(state->pc++);
1364
                break;
1365
        }
1366
        if (vel >= 0x80 || vel < 0) {
1367
            vel = 0x7f;
1368
        }
1369
        layer->velocitySquare = ((f32) vel * (f32) vel) / (f32) (0x7f * 0x7f);
1370
        // the remaining bits are used for the semitone
1371
        cmd -= (cmd & 0xc0);
1372
    } else {
1373
        switch (cmd & 0xc0) {
1374
            case 0x00: // play note, type 0 (play percentage)
1375
                sp3A = m64_read_compressed_u16(state);
1376
                layer->playPercentage = sp3A;
1377
                break;
1378

1379
            case 0x40: // play note, type 1 (uses default play percentage)
1380
                sp3A = layer->shortNoteDefaultPlayPercentage;
1381
                break;
1382

1383
            case 0x80: // play note, type 2 (uses last play percentage)
1384
                sp3A = layer->playPercentage;
1385
                break;
1386
        }
1387

1388
        // the remaining bits are used for the semitone
1389
        cmd -= cmd & 0xc0;
1390
    }
1391

1392
    layer->delay = sp3A;
1393
    layer->duration = layer->noteDuration * sp3A >> 8;
1394
    if ((seqPlayer->muted && (seqChannel->muteBehavior & 0x50) != 0)
1395
        || seqChannel->stopSomething2)
1396
    {
1397
        layer->stopSomething = TRUE;
1398
        return -1;
1399
    }
1400

1401
    return cmd;
1402
}
1403
#endif
1404

1405
u8 get_instrument(struct SequenceChannel *seqChannel, u8 instId, struct Instrument **instOut, struct AdsrSettings *adsr) {
1406
    struct Instrument *inst;
1407
#if defined(VERSION_EU) || defined(VERSION_SH)
1408
    inst = get_instrument_inner(seqChannel->bankId, instId);
1409
    if (inst == NULL)
1410
    {
1411
        *instOut = NULL;
1412
        return 0;
1413
    }
1414
    adsr->envelope = inst->envelope;
1415
    adsr->releaseRate = inst->releaseRate;
1416
    *instOut = inst;
1417
    instId++;
1418
    return instId;
1419
#else
1420
    UNUSED u32 pad;
1421

1422
    if (instId >= gCtlEntries[seqChannel->bankId].numInstruments) {
1423
        instId = gCtlEntries[seqChannel->bankId].numInstruments;
1424
        if (instId == 0) {
1425
            return 0;
1426
        }
1427
        instId--;
1428
    }
1429

1430
    inst = gCtlEntries[seqChannel->bankId].instruments[instId];
1431
    if (inst == NULL) {
1432
        struct SequenceChannel seqChannelCpy = *seqChannel;
1433

1434
        while (instId != 0xff) {
1435
            inst = gCtlEntries[seqChannelCpy.bankId].instruments[instId];
1436
            if (inst != NULL) {
1437
                break;
1438
            }
1439
            instId--;
1440
        }
1441
    }
1442

1443
    if (((uintptr_t) gBankLoadedPool.persistent.pool.start <= (uintptr_t) inst
1444
         && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.persistent.pool.start
1445
                    + gBankLoadedPool.persistent.pool.size))
1446
        || ((uintptr_t) gBankLoadedPool.temporary.pool.start <= (uintptr_t) inst
1447
            && (uintptr_t) inst <= (uintptr_t)(gBankLoadedPool.temporary.pool.start
1448
                                   + gBankLoadedPool.temporary.pool.size))) {
1449
        adsr->envelope = inst->envelope;
1450
        adsr->releaseRate = inst->releaseRate;
1451
        *instOut = inst;
1452
        instId++;
1453
        return instId;
1454
    }
1455

1456
    gAudioErrorFlags = instId + 0x20000;
1457
    *instOut = NULL;
1458
    return 0;
1459
#endif
1460
}
1461

1462
void set_instrument(struct SequenceChannel *seqChannel, u8 instId) {
1463
    if (instId >= 0x80) {
1464
        seqChannel->instOrWave = instId;
1465
        seqChannel->instrument = NULL;
1466
    } else if (instId == 0x7f) {
1467
        seqChannel->instOrWave = 0;
1468
        seqChannel->instrument = (struct Instrument *) 1;
1469
    } else {
1470
#if defined(VERSION_EU) || defined(VERSION_SH)
1471
        if ((seqChannel->instOrWave =
1472
            get_instrument(seqChannel, instId, &seqChannel->instrument, &seqChannel->adsr)) == 0)
1473
#else
1474
        seqChannel->instOrWave =
1475
            get_instrument(seqChannel, instId, &seqChannel->instrument, &seqChannel->adsr);
1476
        if (seqChannel->instOrWave == 0)
1477
#endif
1478
        {
1479
            seqChannel->hasInstrument = FALSE;
1480
            return;
1481
        }
1482
    }
1483
    seqChannel->hasInstrument = TRUE;
1484
}
1485

1486
void sequence_channel_set_volume(struct SequenceChannel *seqChannel, u8 volume) {
1487
    seqChannel->volume = FLOAT_CAST(volume) / US_FLOAT(127.0);
1488
}
1489

1490
void sequence_channel_process_script(struct SequenceChannel *seqChannel) {
1491
    struct M64ScriptState *state;
1492
    struct SequencePlayer *seqPlayer;
1493
    u8 cmd;
1494
    s8 temp;
1495
    u8 loBits;
1496
    u16 sp5A;
1497
    s32 sp38;
1498
    s8 value;
1499
    s32 i;
1500
    u8 *seqData;
1501

1502
    if (!seqChannel->enabled) {
1503
        return;
1504
    }
1505

1506
    if (seqChannel->stopScript) {
1507
        for (i = 0; i < LAYERS_MAX; i++) {
1508
            if (seqChannel->layers[i] != NULL) {
1509
                seq_channel_layer_process_script(seqChannel->layers[i]);
1510
            }
1511
        }
1512
        return;
1513
    }
1514

1515
    seqPlayer = seqChannel->seqPlayer;
1516
    if (seqPlayer->muted && (seqChannel->muteBehavior & MUTE_BEHAVIOR_STOP_SCRIPT) != 0) {
1517
        return;
1518
    }
1519

1520
    if (seqChannel->delay != 0) {
1521
        seqChannel->delay--;
1522
    }
1523

1524
    state = &seqChannel->scriptState;
1525
    if (seqChannel->delay == 0) {
1526
        for (;;) {
1527
            cmd = m64_read_u8(state);
1528
#if !defined(VERSION_EU) && !defined(VERSION_SH)
1529
            if (cmd == 0xff) // chan_end
1530
            {
1531
                if (state->depth == 0) {
1532
                    sequence_channel_disable(seqChannel);
1533
                    break;
1534
                }
1535
                state->depth--, state->pc = state->stack[state->depth];
1536
            }
1537
            if (cmd == 0xfe) // chan_delay1
1538
            {
1539
                break;
1540
            }
1541
            if (cmd == 0xfd) // chan_delay
1542
            {
1543
                seqChannel->delay = m64_read_compressed_u16(state);
1544
                break;
1545
            }
1546
            if (cmd == 0xf3) // chan_hang
1547
            {
1548
                seqChannel->stopScript = TRUE;
1549
                break;
1550
            }
1551
#endif
1552

1553
#ifdef VERSION_SH
1554
            if (cmd >= 0xb0)
1555
#else
1556
            if (cmd > 0xc0)
1557
#endif
1558
            {
1559
                switch (cmd) {
1560
                    case 0xff: // chan_end
1561
#if defined(VERSION_EU) || defined(VERSION_SH)
1562
                        if (state->depth == 0) {
1563
                            sequence_channel_disable(seqChannel);
1564
                            goto out;
1565
                        } else {
1566
                            state->pc = state->stack[--state->depth];
1567
                        }
1568
#endif
1569
                        break;
1570

1571
#if defined(VERSION_EU) || defined(VERSION_SH)
1572
                    case 0xfe: // chan_delay1
1573
                        goto out;
1574

1575
                    case 0xfd: // chan_delay
1576
                        seqChannel->delay = m64_read_compressed_u16(state);
1577
                        goto out;
1578

1579
                    case 0xea:
1580
                        seqChannel->stopScript = TRUE;
1581
                        goto out;
1582
#endif
1583
                    case 0xfc: // chan_call
1584
                        if (0 && state->depth >= 4) {
1585
                            eu_stubbed_printf_0("Audio:Track :Call Macro Level Over Error!\n");
1586
                        }
1587
                        sp5A = m64_read_s16(state);
1588
#if defined(VERSION_EU) || defined(VERSION_SH)
1589
                        state->stack[state->depth++] = state->pc;
1590
#else
1591
                        state->depth++, state->stack[state->depth - 1] = state->pc;
1592
#endif
1593
                        state->pc = seqPlayer->seqData + sp5A;
1594
                        break;
1595

1596
                    case 0xf8: // chan_loop; loop start, N iterations (or 256 if N = 0)
1597
                        if (0 && state->depth >= 4) {
1598
                            eu_stubbed_printf_0("Audio:Track :Loops Macro Level Over Error!\n");
1599
                        }
1600
                        state->remLoopIters[state->depth] = m64_read_u8(state);
1601
#if defined(VERSION_EU) || defined(VERSION_SH)
1602
                        state->stack[state->depth++] = state->pc;
1603
#else
1604
                        state->depth++, state->stack[state->depth - 1] = state->pc;
1605
#endif
1606
                        break;
1607

1608
                    case 0xf7: // chan_loopend
1609
                        state->remLoopIters[state->depth - 1]--;
1610
                        if (state->remLoopIters[state->depth - 1] != 0) {
1611
                            state->pc = state->stack[state->depth - 1];
1612
                        } else {
1613
                            state->depth--;
1614
                        }
1615
                        break;
1616

1617
                    case 0xf6: // chan_break; break loop, if combined with jump
1618
                        state->depth--;
1619
                        break;
1620

1621
                    case 0xfb: // chan_jump
1622
                    case 0xfa: // chan_beqz
1623
                    case 0xf9: // chan_bltz
1624
                    case 0xf5: // chan_bgez
1625
                        sp5A = m64_read_s16(state);
1626
                        if (cmd == 0xfa && value != 0)
1627
                            break;
1628
                        if (cmd == 0xf9 && value >= 0)
1629
                            break;
1630
                        if (cmd == 0xf5 && value < 0)
1631
                            break;
1632
                        state->pc = seqPlayer->seqData + sp5A;
1633
                        break;
1634

1635
#if defined(VERSION_EU) || defined(VERSION_SH)
1636
                    case 0xf4: // chan_jump_rel
1637
                    case 0xf3: // chan_beqz_rel
1638
                    case 0xf2: // chan_bltz_rel
1639
                        temp = m64_read_u8(state);
1640
                        if (cmd == 0xf3 && value != 0)
1641
                            break;
1642
                        if (cmd == 0xf2 && value >= 0)
1643
                            break;
1644
                        state->pc += temp;
1645
                        break;
1646
#endif
1647

1648
#if defined(VERSION_EU) || defined(VERSION_SH)
1649
                    case 0xf1: // chan_reservenotes
1650
#else
1651
                    case 0xf2: // chan_reservenotes
1652
#endif
1653
                        note_pool_clear(&seqChannel->notePool);
1654
                        note_pool_fill(&seqChannel->notePool, m64_read_u8(state));
1655
                        break;
1656

1657
#if defined(VERSION_EU) || defined(VERSION_SH)
1658
                    case 0xf0: // chan_unreservenotes
1659
#else
1660
                    case 0xf1: // chan_unreservenotes
1661
#endif
1662
                        note_pool_clear(&seqChannel->notePool);
1663
                        break;
1664

1665
                    case 0xc2: // chan_setdyntable
1666
                        sp5A = m64_read_s16(state);
1667
                        seqChannel->dynTable = (void *) (seqPlayer->seqData + sp5A);
1668
                        break;
1669

1670
                    case 0xc5: // chan_dynsetdyntable
1671
                        if (value != -1) {
1672
#if defined(VERSION_EU) || defined(VERSION_SH)
1673
                            seqData = (*seqChannel->dynTable)[value];
1674
                            sp38 = (u16)((seqData[0] << 8) + seqData[1]);
1675
                            seqChannel->dynTable = (void *) (seqPlayer->seqData + sp38);
1676
#else
1677
                            sp5A = (u16)((((*seqChannel->dynTable)[value])[0] << 8) + (((*seqChannel->dynTable)[value])[1]));
1678
                            seqChannel->dynTable = (void *) (seqPlayer->seqData + sp5A);
1679
#endif
1680
                        }
1681
                        break;
1682

1683
#if defined(VERSION_EU) || defined(VERSION_SH)
1684
                    case 0xeb: // chan_setbankandinstr
1685
                        cmd = m64_read_u8(state);
1686
                        // Switch to the cmd's (0-indexed) bank in this sequence's
1687
                        // bank set. Note that in the binary format (not in the JSON!)
1688
                        // the banks are listed backwards, so we counts from the back.
1689
                        // (gAlBankSets[offset] is number of banks)
1690
                        sp38 = ((u16 *) gAlBankSets)[seqPlayer->seqId];
1691
                        loBits = *(sp38 + gAlBankSets);
1692
                        cmd = gAlBankSets[(s32)sp38 + loBits - cmd];
1693

1694
#ifdef VERSION_SH
1695
                        if (get_bank_or_seq(1, 2, cmd) != NULL)
1696
#else
1697
                        if (get_bank_or_seq(&gBankLoadedPool, 2, cmd) != NULL)
1698
#endif
1699
                        {
1700
                            seqChannel->bankId = cmd;
1701
                        } else {
1702
                            eu_stubbed_printf_1("SUB:ERR:BANK %d NOT CACHED.\n", cmd);
1703
                        }
1704
                        // fallthrough
1705
#endif
1706

1707
                    case 0xc1: // chan_setinstr ("set program"?)
1708
                        set_instrument(seqChannel, m64_read_u8(state));
1709
                        break;
1710

1711
                    case 0xc3: // chan_largenotesoff
1712
                        seqChannel->largeNotes = FALSE;
1713
                        break;
1714

1715
                    case 0xc4: // chan_largenoteson
1716
                        seqChannel->largeNotes = TRUE;
1717
                        break;
1718

1719
                    case 0xdf: // chan_setvol
1720
                        sequence_channel_set_volume(seqChannel, m64_read_u8(state));
1721
#if defined(VERSION_EU) || defined(VERSION_SH)
1722
                        seqChannel->changes.as_bitfields.volume = TRUE;
1723
#endif
1724
                        break;
1725

1726
                    case 0xe0: // chan_setvolscale
1727
                        seqChannel->volumeScale = FLOAT_CAST(m64_read_u8(state)) / US_FLOAT(128.0);
1728
#if defined(VERSION_EU) || defined(VERSION_SH)
1729
                        seqChannel->changes.as_bitfields.volume = TRUE;
1730
#endif
1731
                        break;
1732

1733
                    case 0xde: // chan_freqscale; pitch bend using raw frequency multiplier N/2^15 (N is u16)
1734
                        sp5A = m64_read_s16(state);
1735
                        seqChannel->freqScale = FLOAT_CAST(sp5A) / US_FLOAT(32768.0);
1736
#if defined(VERSION_EU) || defined(VERSION_SH)
1737
                        seqChannel->changes.as_bitfields.freqScale = TRUE;
1738
#endif
1739
                        break;
1740

1741
                    case 0xd3: // chan_pitchbend; pitch bend by <= 1 octave in either direction (-127..127)
1742
                        // (m64_read_u8(state) is really s8 here)
1743
#ifdef VERSION_SH
1744
                        cmd = m64_read_u8(state) + 128;
1745
#else
1746
                        cmd = m64_read_u8(state) + 127;
1747
#endif
1748
                        seqChannel->freqScale = gPitchBendFrequencyScale[cmd];
1749
#if defined(VERSION_EU) || defined(VERSION_SH)
1750
                        seqChannel->changes.as_bitfields.freqScale = TRUE;
1751
#endif
1752
                        break;
1753

1754
#ifdef VERSION_SH
1755
                    case 0xee:
1756
                        cmd = m64_read_u8(state) + 0x80;
1757
                        seqChannel->freqScale = unk_sh_data_1[cmd];
1758
                        seqChannel->changes.as_bitfields.freqScale = TRUE;
1759
                        break;
1760
#endif
1761

1762
                    case 0xdd: // chan_setpan
1763
#if defined(VERSION_EU) || defined(VERSION_SH)
1764
                        seqChannel->newPan = m64_read_u8(state);
1765
                        seqChannel->changes.as_bitfields.pan = TRUE;
1766
#else
1767
                        seqChannel->pan = FLOAT_CAST(m64_read_u8(state)) / US_FLOAT(128.0);
1768
#endif
1769
                        break;
1770

1771
                    case 0xdc: // chan_setpanmix; set proportion of pan to come from channel (0..128)
1772
#if defined(VERSION_EU) || defined(VERSION_SH)
1773
                        seqChannel->panChannelWeight = m64_read_u8(state);
1774
                        seqChannel->changes.as_bitfields.pan = TRUE;
1775
#else
1776
                        seqChannel->panChannelWeight = FLOAT_CAST(m64_read_u8(state)) / US_FLOAT(128.0);
1777
#endif
1778
                        break;
1779

1780
                    case 0xdb: // chan_transpose; set transposition in semitones
1781
                        temp = *state->pc++;
1782
                        seqChannel->transposition = temp;
1783
                        break;
1784

1785
                    case 0xda: // chan_setenvelope
1786
                        sp5A = m64_read_s16(state);
1787
                        seqChannel->adsr.envelope = (struct AdsrEnvelope *) (seqPlayer->seqData + sp5A);
1788
                        break;
1789

1790
                    case 0xd9: // chan_setdecayrelease
1791
                        seqChannel->adsr.releaseRate = m64_read_u8(state);
1792
                        break;
1793

1794
                    case 0xd8: // chan_setvibratoextent
1795
                        seqChannel->vibratoExtentTarget = m64_read_u8(state) * 8;
1796
                        seqChannel->vibratoExtentStart = 0;
1797
                        seqChannel->vibratoExtentChangeDelay = 0;
1798
                        break;
1799

1800
                    case 0xd7: // chan_setvibratorate
1801
                        seqChannel->vibratoRateStart = seqChannel->vibratoRateTarget =
1802
                            m64_read_u8(state) * 32;
1803
                        seqChannel->vibratoRateChangeDelay = 0;
1804
                        break;
1805

1806
                    case 0xe2: // chan_setvibratoextentlinear
1807
                        seqChannel->vibratoExtentStart = m64_read_u8(state) * 8;
1808
                        seqChannel->vibratoExtentTarget = m64_read_u8(state) * 8;
1809
                        seqChannel->vibratoExtentChangeDelay = m64_read_u8(state) * 16;
1810
                        break;
1811

1812
                    case 0xe1: // chan_setvibratoratelinear
1813
                        seqChannel->vibratoRateStart = m64_read_u8(state) * 32;
1814
                        seqChannel->vibratoRateTarget = m64_read_u8(state) * 32;
1815
                        seqChannel->vibratoRateChangeDelay = m64_read_u8(state) * 16;
1816
                        break;
1817

1818
                    case 0xe3: // chan_setvibratodelay
1819
                        seqChannel->vibratoDelay = m64_read_u8(state) * 16;
1820
                        break;
1821

1822
#if defined(VERSION_JP) || defined(VERSION_US)
1823
                    case 0xd6: // chan_setupdatesperframe_unimplemented
1824
                        cmd = m64_read_u8(state);
1825
                        if (cmd == 0) {
1826
                            cmd = gAudioUpdatesPerFrame;
1827
                        }
1828
                        seqChannel->updatesPerFrameUnused = cmd;
1829
                        break;
1830
#endif
1831

1832
                    case 0xd4: // chan_setreverb
1833
                        seqChannel->reverbVol = m64_read_u8(state);
1834
                        break;
1835

1836
                    case 0xc6: // chan_setbank; switch bank within set
1837
                        cmd = m64_read_u8(state);
1838
                        // Switch to the temp's (0-indexed) bank in this sequence's
1839
                        // bank set. Note that in the binary format (not in the JSON!)
1840
                        // the banks are listed backwards, so we counts from the back.
1841
                        // (gAlBankSets[offset] is number of banks)
1842
#if defined(VERSION_EU) || defined(VERSION_SH)
1843
                        sp38 = ((u16 *) gAlBankSets)[seqPlayer->seqId];
1844
                        loBits = *(sp38 + gAlBankSets);
1845
                        cmd = gAlBankSets[(s32)sp38 + loBits - cmd];
1846
#else
1847
                        sp5A = ((u16 *) gAlBankSets)[seqPlayer->seqId];
1848
                        loBits = *(sp5A + gAlBankSets);
1849
                        cmd = gAlBankSets[sp5A + loBits - cmd];
1850
#endif
1851
#ifdef VERSION_SH
1852
                        if (get_bank_or_seq(1, 2, cmd) != NULL)
1853
#else
1854
                        if (get_bank_or_seq(&gBankLoadedPool, 2, cmd) != NULL)
1855
#endif
1856
                        {
1857
                            seqChannel->bankId = cmd;
1858
                        } else {
1859
                            eu_stubbed_printf_1("SUB:ERR:BANK %d NOT CACHED.\n", cmd);
1860
                        }
1861
                        break;
1862

1863
                    case 0xc7: // chan_writeseq; write to sequence data (!)
1864
                        {
1865
#if !defined(VERSION_EU) && !defined(VERSION_SH)
1866
                            u8 *seqData;
1867
#endif
1868
                            cmd = m64_read_u8(state);
1869
                            sp5A = m64_read_s16(state);
1870
                            seqData = seqPlayer->seqData + sp5A;
1871
                            *seqData = (u8)value + cmd;
1872
                        }
1873
                        break;
1874

1875
                    case 0xc8: // chan_subtract
1876
                    case 0xc9: // chan_bitand
1877
                    case 0xcc: // chan_setval
1878
                        temp = m64_read_u8(state);
1879
                        if (cmd == 0xc8) {
1880
                            value -= temp;
1881
                        } else if (cmd == 0xcc) {
1882
                            value = temp;
1883
                        } else {
1884
                            value &= temp;
1885
                        }
1886
                        break;
1887

1888
#ifdef VERSION_SH
1889
                    case 0xcd:
1890
                        sequence_channel_disable(seqPlayer->channels[m64_read_u8(state)]);
1891
                        break;
1892
#endif
1893

1894
                    case 0xca: // chan_setmutebhv
1895
                        seqChannel->muteBehavior = m64_read_u8(state);
1896
#ifdef VERSION_SH
1897
                        seqChannel->changes.as_bitfields.volume = TRUE;
1898
#endif
1899
                        break;
1900

1901
                    case 0xcb: // chan_readseq
1902
                        sp38 = (u16)m64_read_s16(state) + value;
1903
                        value = seqPlayer->seqData[sp38];
1904
                        break;
1905

1906
#ifdef VERSION_SH
1907
                    case 0xce:
1908
                        seqChannel->unkC8 = m64_read_s16(state);
1909
                        break;
1910

1911
                    case 0xcf:
1912
                        sp5A = m64_read_s16(state);
1913
                        seqData = seqPlayer->seqData + sp5A;
1914
                        seqData[0] = (seqChannel->unkC8 >> 8) & 0xffff;
1915
                        seqData[1] = (seqChannel->unkC8) & 0xffff;
1916
                        break;
1917
#endif
1918

1919
                    case 0xd0: // chan_stereoheadseteffects
1920
                        seqChannel->stereoHeadsetEffects = m64_read_u8(state);
1921
                        break;
1922

1923
                    case 0xd1: // chan_setnoteallocationpolicy
1924
                        seqChannel->noteAllocPolicy = m64_read_u8(state);
1925
                        break;
1926

1927
                    case 0xd2: // chan_setsustain
1928
#if defined(VERSION_EU) || defined(VERSION_SH)
1929
                        seqChannel->adsr.sustain = m64_read_u8(state);
1930
#else
1931
                        seqChannel->adsr.sustain = m64_read_u8(state) << 8;
1932
#endif
1933
                        break;
1934
#if defined(VERSION_EU) || defined(VERSION_SH)
1935
                    case 0xe5:
1936
                        seqChannel->reverbIndex = m64_read_u8(state);
1937
                        break;
1938
#endif
1939
                    case 0xe4: // chan_dyncall
1940
                        if (value != -1) {
1941
#if defined(VERSION_EU) || defined(VERSION_SH)
1942
                            if (state->depth >= 4) {
1943
                                eu_stubbed_printf_0("Audio:Track: CTBLCALL Macro Level Over Error!\n");
1944
                            }
1945
#endif
1946
                            seqData = (*seqChannel->dynTable)[value];
1947
#if defined(VERSION_EU) || defined(VERSION_SH)
1948
                            state->stack[state->depth++] = state->pc;
1949
                            sp38 = (u16)((seqData[0] << 8) + seqData[1]);
1950
                            state->pc = seqPlayer->seqData + sp38;
1951

1952
                            if (0 && sp38 >= gSeqFileHeader->seqArray[seqPlayer->seqId].len) {
1953
                                eu_stubbed_printf_3("Err :Sub %x ,address %x:Undefined SubTrack Function %x", seqChannel, state->pc, sp38);
1954
                            }
1955
#else
1956
                            state->depth++, state->stack[state->depth - 1] = state->pc;
1957
                            sp5A = ((seqData[0] << 8) + seqData[1]);
1958
                            state->pc = seqPlayer->seqData + sp5A;
1959
#endif
1960
                        }
1961
                        break;
1962

1963
#if defined(VERSION_EU) || defined(VERSION_SH)
1964
                    case 0xe6:
1965
                        seqChannel->bookOffset = m64_read_u8(state);
1966
                        break;
1967

1968
                    case 0xe7:
1969
                        sp5A = m64_read_s16(state);
1970
                        seqData = seqPlayer->seqData + sp5A;
1971
                        seqChannel->muteBehavior = *seqData++;
1972
                        seqChannel->noteAllocPolicy = *seqData++;
1973
                        seqChannel->notePriority = *seqData++;
1974
                        seqChannel->transposition = (s8) *seqData++;
1975
                        seqChannel->newPan = *seqData++;
1976
                        seqChannel->panChannelWeight = *seqData++;
1977
                        seqChannel->reverbVol = *seqData++;
1978
                        seqChannel->reverbIndex = *seqData++;
1979
                        seqChannel->changes.as_bitfields.pan = TRUE;
1980
                        break;
1981

1982
                    case 0xe8:
1983
                        seqChannel->muteBehavior = m64_read_u8(state);
1984
                        seqChannel->noteAllocPolicy = m64_read_u8(state);
1985
                        seqChannel->notePriority = m64_read_u8(state);
1986
                        seqChannel->transposition = (s8) m64_read_u8(state);
1987
                        seqChannel->newPan = m64_read_u8(state);
1988
                        seqChannel->panChannelWeight = m64_read_u8(state);
1989
                        seqChannel->reverbVol = m64_read_u8(state);
1990
                        seqChannel->reverbIndex = m64_read_u8(state);
1991
                        seqChannel->changes.as_bitfields.pan = TRUE;
1992
                        break;
1993

1994
                    case 0xec:
1995
                        seqChannel->vibratoExtentTarget = 0;
1996
                        seqChannel->vibratoExtentStart = 0;
1997
                        seqChannel->vibratoExtentChangeDelay = 0;
1998
                        seqChannel->vibratoRateTarget = 0;
1999
                        seqChannel->vibratoRateStart = 0;
2000
                        seqChannel->vibratoRateChangeDelay = 0;
2001
                        seqChannel->freqScale = 1.0f;
2002
                        break;
2003

2004
                    case 0xe9: // chan_setnotepriority
2005
#ifdef VERSION_SH
2006
                        cmd = m64_read_u8(state);
2007
                        if ((cmd & 0xf) != 0) {
2008
                            seqChannel->notePriority = cmd & 0xf;
2009
                        }
2010
                        cmd = cmd >> 4;
2011
                        if (cmd != 0) {
2012
                            seqChannel->unkSH06 = cmd;
2013
                        }
2014
#else
2015
                        seqChannel->notePriority = m64_read_u8(state);
2016
#endif
2017
                        break;
2018
#endif
2019
#ifdef VERSION_SH
2020
                    case 0xed:
2021
                        seqChannel->synthesisVolume = m64_read_u8(state);
2022
                        break;
2023

2024
                    case 0xef:
2025
                        m64_read_s16(state);
2026
                        m64_read_u8(state);
2027
                        break;
2028

2029
                    case 0xb0:
2030
                        sp5A = m64_read_s16(state);
2031
                        seqData = seqPlayer->seqData + sp5A;
2032
                        seqChannel->filter = (s16 *) (seqData);
2033
                        break;
2034

2035
                    case 0xb1:
2036
                        seqChannel->filter = NULL;
2037
                        break;
2038

2039
                    case 0xb3:
2040
                        if (seqChannel->filter != NULL) {
2041
                            cmd = m64_read_u8(state);
2042
                            if (cmd == 0) {
2043
                                seqChannel->filter = NULL;
2044
                            } else {
2045
                                loBits = (cmd >> 4) & 0xf;
2046
                                cmd &= 0xf;
2047
                                fill_filter(seqChannel->filter, loBits, cmd);
2048
                            }
2049
                        }
2050
                        break;
2051

2052
                    case 0xb2:
2053
                        i = (value * 2);
2054
                        sp5A = m64_read_s16(state);
2055
                        sp38 = sp5A + i;
2056
                        seqChannel->unkC8 = *(u16 *) (seqPlayer->seqData + sp38);
2057
                        break;
2058

2059
                    case 0xb4:
2060
                        seqChannel->dynTable = (void *) (seqPlayer->seqData + seqChannel->unkC8);
2061
                        break;
2062

2063
                    case 0xb5:
2064
                        seqChannel->unkC8 = *(u16 *) (*seqChannel->dynTable)[value];
2065
                        break;
2066

2067
                    case 0xb6:
2068
                        value = (*seqChannel->dynTable)[0][value];
2069
                        break;
2070
#endif
2071
                }
2072
            } else {
2073
#ifdef VERSION_SH
2074
                if (cmd >= 0x80) {
2075
                    loBits = cmd & 7;
2076
                    switch (cmd & 0xf8) {
2077
                        case 0x80:
2078
                            if (seqChannel->layers[loBits] != NULL) {
2079
                                value = seqChannel->layers[loBits]->finished;
2080
                            } else {
2081
                                value = -1;
2082
                            }
2083
                            break;
2084

2085
                        case 0x88:
2086
                            sp5A = m64_read_s16(state);
2087
                            if (seq_channel_set_layer(seqChannel, loBits) == 0) {
2088
                                if (1) {}
2089
                                seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A;
2090
                            }
2091
                            break;
2092

2093
                        case 0x90:
2094
                            seq_channel_layer_free(seqChannel, loBits);
2095
                            break;
2096

2097
                        case 0x98:
2098
                            if (value != -1 && seq_channel_set_layer(seqChannel, loBits) != -1) {
2099
                                seqData = (*seqChannel->dynTable)[value];
2100
                                sp5A = ((seqData[0] << 8) + seqData[1]);
2101
                                seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A;
2102
                            }
2103
                            break;
2104
                    }
2105
                } else {
2106
#endif
2107
                loBits = cmd & 0xf;
2108

2109
                switch (cmd & 0xf0) {
2110
#ifdef VERSION_SH
2111
                    case 0x00:
2112
                        seqChannel->delay = loBits;
2113
                        goto out;
2114

2115
                    case 0x10:
2116
                        seqChannel->soundScriptIO[loBits] = -1;
2117
                        if (func_sh_802f47c8(seqChannel->bankId, (u8)value, &seqChannel->soundScriptIO[loBits]) == -1) {
2118
                        }
2119
                        break;
2120
#else
2121
                    case 0x00: // chan_testlayerfinished
2122
                        if (seqChannel->layers[loBits] != NULL) {
2123
                            value = seqChannel->layers[loBits]->finished;
2124
                        }
2125
#ifdef VERSION_EU
2126
                        else {
2127
                            value = -1;
2128
                        }
2129
#endif
2130
                        break;
2131
#endif
2132

2133
                    // sh: 0x70
2134
                    case 0x70: // chan_iowriteval; write data back to audio lib
2135
                        seqChannel->soundScriptIO[loBits] = value;
2136
                        break;
2137

2138
#ifdef VERSION_SH
2139
                    case 0x60:
2140
#else
2141
                    case 0x80: // chan_ioreadval; read data from audio lib
2142
#endif
2143
                        value = seqChannel->soundScriptIO[loBits];
2144
                        if (loBits < 4) {
2145
                            seqChannel->soundScriptIO[loBits] = -1;
2146
                        }
2147
                        break;
2148

2149
                    // sh: 0x50
2150
                    case 0x50: // chan_ioreadvalsub; subtract with read data from audio lib
2151
                        value -= seqChannel->soundScriptIO[loBits];
2152
                        break;
2153

2154
#ifndef VERSION_SH
2155
#ifdef VERSION_EU
2156
                    // sh: 0x00
2157
                    case 0x60: // chan_delayshort
2158
                        seqChannel->delay = loBits;
2159
                        goto out;
2160
#endif
2161

2162
                    case 0x90: // chan_setlayer
2163
                        sp5A = m64_read_s16(state);
2164
                        if (seq_channel_set_layer(seqChannel, loBits) == 0) {
2165
#ifdef VERSION_EU
2166
                            if (1) {}
2167
#endif
2168
                            seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A;
2169
                        }
2170
                        break;
2171

2172
                    case 0xa0: // chan_freelayer
2173
                        seq_channel_layer_free(seqChannel, loBits);
2174
                        break;
2175

2176
                    case 0xb0: // chan_dynsetlayer
2177
                        if (value != -1 && seq_channel_set_layer(seqChannel, loBits) != -1) {
2178
                            seqData = (*seqChannel->dynTable)[value];
2179
                            sp5A = ((seqData[0] << 8) + seqData[1]);
2180
                            seqChannel->layers[loBits]->scriptState.pc = seqPlayer->seqData + sp5A;
2181
                        }
2182
                        break;
2183

2184
#ifndef VERSION_EU
2185
                    case 0x60: // chan_setnotepriority (arg must be >= 2)
2186
                        seqChannel->notePriority = loBits;
2187
                        break;
2188
#endif
2189
#endif
2190

2191
#ifdef VERSION_SH
2192
                    case 0x20:
2193
#else
2194
                    case 0x10: // chan_startchannel
2195
#endif
2196
                        sp5A = m64_read_s16(state);
2197
                        sequence_channel_enable(seqPlayer, loBits, seqPlayer->seqData + sp5A);
2198
                        break;
2199

2200
#ifndef VERSION_SH
2201
                    case 0x20: // chan_disablechannel
2202
                        sequence_channel_disable(seqPlayer->channels[loBits]);
2203
                        break;
2204
#endif
2205

2206
                    case 0x30: // chan_iowriteval2; write data back to audio lib for another channel
2207
                        cmd = m64_read_u8(state);
2208
                        seqPlayer->channels[loBits]->soundScriptIO[cmd] = value;
2209
                        break;
2210

2211
                    case 0x40: // chan_ioreadval2; read data from audio lib from another channel
2212
                        cmd = m64_read_u8(state);
2213
                        value = seqPlayer->channels[loBits]->soundScriptIO[cmd];
2214
                        break;
2215
                }
2216
#ifdef VERSION_SH
2217
                }
2218
#endif
2219
            }
2220
        }
2221
    }
2222
#if defined(VERSION_EU) || defined(VERSION_SH)
2223
    out:
2224
#endif
2225

2226
    for (i = 0; i < LAYERS_MAX; i++) {
2227
        if (seqChannel->layers[i] != 0) {
2228
            seq_channel_layer_process_script(seqChannel->layers[i]);
2229
        }
2230
    }
2231
}
2232

2233
void sequence_player_process_sequence(struct SequencePlayer *seqPlayer, float seqVol) {
2234
    u8 cmd;
2235
#ifdef VERSION_SH
2236
    UNUSED u32 pad;
2237
#endif
2238
    u8 loBits;
2239
    u8 temp;
2240
    s32 value;
2241
    s32 i;
2242
    u16 u16v;
2243
    u8 *seqData;
2244
    struct M64ScriptState *state;
2245
#if defined(VERSION_EU) || defined(VERSION_SH)
2246
    s32 temp32;
2247
#endif
2248

2249
    if (seqPlayer->enabled == FALSE) {
2250
        return;
2251
    }
2252

2253
#ifndef VERSION_SH
2254
    if (seqPlayer->bankDmaInProgress == TRUE) {
2255
#ifdef VERSION_EU
2256
        if (osRecvMesg(&seqPlayer->bankDmaMesgQueue, NULL, 0) == -1) {
2257
            return;
2258
        }
2259
        if (seqPlayer->bankDmaRemaining == 0) {
2260
            seqPlayer->bankDmaInProgress = FALSE;
2261
            patch_audio_bank(
2262
                (struct AudioBank *) (gCtlEntries[seqPlayer->loadingBankId].instruments - 1),
2263
                gAlTbl->seqArray[seqPlayer->loadingBankId].offset,
2264
                gCtlEntries[seqPlayer->loadingBankId].numInstruments,
2265
                gCtlEntries[seqPlayer->loadingBankId].numDrums);
2266
            gCtlEntries[seqPlayer->loadingBankId].drums =
2267
                ((struct AudioBank *) (gCtlEntries[seqPlayer->loadingBankId].instruments - 1))->drums;
2268
            gBankLoadStatus[seqPlayer->loadingBankId] = SOUND_LOAD_STATUS_COMPLETE;
2269
        } else {
2270
            audio_dma_partial_copy_async(&seqPlayer->bankDmaCurrDevAddr, &seqPlayer->bankDmaCurrMemAddr,
2271
                                         &seqPlayer->bankDmaRemaining, &seqPlayer->bankDmaMesgQueue,
2272
                                         &seqPlayer->bankDmaIoMesg);
2273
        }
2274
#else
2275
        if (seqPlayer->bankDmaMesg == NULL) {
2276
            return;
2277
        }
2278
        if (seqPlayer->bankDmaRemaining == 0) {
2279
            seqPlayer->bankDmaInProgress = FALSE;
2280
            patch_audio_bank(seqPlayer->loadingBank, gAlTbl->seqArray[seqPlayer->loadingBankId].offset,
2281
                             seqPlayer->loadingBankNumInstruments, seqPlayer->loadingBankNumDrums);
2282
            gCtlEntries[seqPlayer->loadingBankId].numInstruments = seqPlayer->loadingBankNumInstruments;
2283
            gCtlEntries[seqPlayer->loadingBankId].numDrums = seqPlayer->loadingBankNumDrums;
2284
            gCtlEntries[seqPlayer->loadingBankId].instruments = seqPlayer->loadingBank->instruments;
2285
            gCtlEntries[seqPlayer->loadingBankId].drums = seqPlayer->loadingBank->drums;
2286
            gBankLoadStatus[seqPlayer->loadingBankId] = SOUND_LOAD_STATUS_COMPLETE;
2287
        } else {
2288
            osCreateMesgQueue(&seqPlayer->bankDmaMesgQueue, &seqPlayer->bankDmaMesg, 1);
2289
            seqPlayer->bankDmaMesg = NULL;
2290
            audio_dma_partial_copy_async(&seqPlayer->bankDmaCurrDevAddr, &seqPlayer->bankDmaCurrMemAddr,
2291
                                         &seqPlayer->bankDmaRemaining, &seqPlayer->bankDmaMesgQueue,
2292
                                         &seqPlayer->bankDmaIoMesg);
2293
        }
2294
#endif
2295
        return;
2296
    }
2297

2298
    if (seqPlayer->seqDmaInProgress == TRUE) {
2299
#ifdef VERSION_EU
2300
        if (osRecvMesg(&seqPlayer->seqDmaMesgQueue, NULL, 0) == -1) {
2301
            return;
2302
        }
2303
#ifndef AVOID_UB
2304
        if (temp) {
2305
        }
2306
#endif
2307
#else
2308
        if (seqPlayer->seqDmaMesg == NULL) {
2309
            return;
2310
        }
2311
#endif
2312
        seqPlayer->seqDmaInProgress = FALSE;
2313
        gSeqLoadStatus[seqPlayer->seqId] = SOUND_LOAD_STATUS_COMPLETE;
2314
    }
2315
#endif
2316

2317
    // If discarded, bail out.
2318
    if (IS_SEQ_LOAD_COMPLETE(seqPlayer->seqId) == FALSE
2319
        || (
2320
#ifdef VERSION_SH
2321
        seqPlayer->defaultBank[0] != 0xff &&
2322
#endif
2323
        IS_BANK_LOAD_COMPLETE(seqPlayer->defaultBank[0]) == FALSE)) {
2324
        eu_stubbed_printf_1("Disappear Sequence or Bank %d\n", seqPlayer->seqId);
2325
        sequence_player_disable(seqPlayer);
2326
        return;
2327
    }
2328

2329
    // Remove possible SOUND_LOAD_STATUS_DISCARDABLE marks.
2330
#ifdef VERSION_SH
2331
    if (gSeqLoadStatus[seqPlayer->seqId] != 5)
2332
#endif
2333
        gSeqLoadStatus[seqPlayer->seqId] = SOUND_LOAD_STATUS_COMPLETE;
2334

2335
#ifdef VERSION_SH
2336
    if (gBankLoadStatus[seqPlayer->defaultBank[0]] != 5)
2337
#endif
2338
        gBankLoadStatus[seqPlayer->defaultBank[0]] = SOUND_LOAD_STATUS_COMPLETE;
2339

2340
    if (seqPlayer->muted && (seqPlayer->muteBehavior & MUTE_BEHAVIOR_STOP_SCRIPT) != 0) {
2341
        return;
2342
    }
2343

2344
    // Check if we surpass the number of ticks needed for a tatum, else stop.
2345
    seqPlayer->tempoAcc += seqPlayer->tempo;
2346
#ifdef VERSION_SH
2347
    seqPlayer->tempoAcc += seqPlayer->tempoAdd;
2348
#endif
2349
    if (seqPlayer->tempoAcc < gTempoInternalToExternal) {
2350
        return;
2351
    }
2352
    seqPlayer->tempoAcc -= (u16) gTempoInternalToExternal;
2353

2354
    state = &seqPlayer->scriptState;
2355
    if (seqPlayer->delay > 1) {
2356
#ifndef AVOID_UB
2357
        if (temp) {
2358
        }
2359
#endif
2360
        seqPlayer->delay--;
2361
    } else {
2362
#if defined(VERSION_EU) || defined(VERSION_SH)
2363
        seqPlayer->recalculateVolume = 1;
2364
#endif
2365
        for (;;) {
2366
            cmd = m64_read_u8(state);
2367
            if (cmd == 0xff) // seq_end
2368
            {
2369
                if (state->depth == 0) {
2370
                    sequence_player_disable(seqPlayer);
2371
                    break;
2372
                }
2373
#if defined(VERSION_EU) || defined(VERSION_SH)
2374
                state->pc = state->stack[--state->depth];
2375
#else
2376
                state->depth--, state->pc = state->stack[state->depth];
2377
#endif
2378
            }
2379

2380
            if (cmd == 0xfd) // seq_delay
2381
            {
2382
                seqPlayer->delay = m64_read_compressed_u16(state);
2383
                break;
2384
            }
2385

2386
            if (cmd == 0xfe) // seq_delay1
2387
            {
2388
                seqPlayer->delay = 1;
2389
                break;
2390
            }
2391

2392
            if (cmd >= 0xc0) {
2393
                switch (cmd) {
2394
                    case 0xff: // seq_end
2395
                        break;
2396

2397
                    case 0xfc: // seq_call
2398
                        u16v = m64_read_s16(state);
2399
                        if (0 && state->depth >= 4) {
2400
                            eu_stubbed_printf_0("Macro Level Over Error!\n");
2401
                        }
2402
#if defined(VERSION_EU) || defined(VERSION_SH)
2403
                        state->stack[state->depth++] = state->pc;
2404
#else
2405
                        state->depth++, state->stack[state->depth - 1] = state->pc;
2406
#endif
2407
                        state->pc = seqPlayer->seqData + u16v;
2408
                        break;
2409

2410
                    case 0xf8: // seq_loop; loop start, N iterations (or 256 if N = 0)
2411
                        if (0 && state->depth >= 4) {
2412
                            eu_stubbed_printf_0("Macro Level Over Error!\n");
2413
                        }
2414
                        state->remLoopIters[state->depth] = m64_read_u8(state);
2415
#if defined(VERSION_EU) || defined(VERSION_SH)
2416
                        state->stack[state->depth++] = state->pc;
2417
#else
2418
                        state->depth++, state->stack[state->depth - 1] = state->pc;
2419
#endif
2420
                        break;
2421

2422
                    case 0xf7: // seq_loopend
2423
                        state->remLoopIters[state->depth - 1]--;
2424
                        if (state->remLoopIters[state->depth - 1] != 0) {
2425
                            state->pc = state->stack[state->depth - 1];
2426
                        } else {
2427
                            state->depth--;
2428
                        }
2429
                        break;
2430

2431
                    case 0xfb: // seq_jump
2432
                    case 0xfa: // seq_beqz; jump if == 0
2433
                    case 0xf9: // seq_bltz; jump if < 0
2434
                    case 0xf5: // seq_bgez; jump if >= 0
2435
                        u16v = m64_read_s16(state);
2436
                        if (cmd == 0xfa && value != 0) {
2437
                            break;
2438
                        }
2439
                        if (cmd == 0xf9 && value >= 0) {
2440
                            break;
2441
                        }
2442
                        if (cmd == 0xf5 && value < 0) {
2443
                            break;
2444
                        }
2445
                        state->pc = seqPlayer->seqData + u16v;
2446
                        break;
2447

2448
#if defined(VERSION_EU) || defined(VERSION_SH)
2449
                    case 0xf4:
2450
                    case 0xf3:
2451
                    case 0xf2:
2452
                        temp = m64_read_u8(state);
2453
                        if (cmd == 0xf3 && value != 0) {
2454
                            break;
2455
                        }
2456
                        if (cmd == 0xf2 && value >= 0) {
2457
                            break;
2458
                        }
2459
                        state->pc += (s8) temp;
2460
                        break;
2461
#endif
2462

2463
#if defined(VERSION_EU) || defined(VERSION_SH)
2464
                    case 0xf1: // seq_reservenotes
2465
#else
2466
                    case 0xf2: // seq_reservenotes
2467
#endif
2468
                        note_pool_clear(&seqPlayer->notePool);
2469
                        note_pool_fill(&seqPlayer->notePool, m64_read_u8(state));
2470
                        break;
2471

2472
#if defined(VERSION_EU) || defined(VERSION_SH)
2473
                    case 0xf0: // seq_unreservenotes
2474
#else
2475
                    case 0xf1: // seq_unreservenotes
2476
#endif
2477
                        note_pool_clear(&seqPlayer->notePool);
2478
                        break;
2479

2480
                    case 0xdf: // seq_transpose; set transposition in semitones
2481
                        seqPlayer->transposition = 0;
2482
                        // fallthrough
2483

2484
                    case 0xde: // seq_transposerel; add transposition
2485
                        seqPlayer->transposition += (s8) m64_read_u8(state);
2486
                        break;
2487

2488
                    case 0xdd: // seq_settempo (bpm)
2489
#ifndef VERSION_SH
2490
                    case 0xdc: // seq_addtempo (bpm)
2491
#endif
2492
#ifdef VERSION_SH
2493
                        seqPlayer->tempo = m64_read_u8(state) * TEMPO_SCALE;
2494
#else
2495
                        temp = m64_read_u8(state);
2496
                        if (cmd == 0xdd) {
2497
                            seqPlayer->tempo = temp * TEMPO_SCALE;
2498
                        } else {
2499
                            seqPlayer->tempo += (s8) temp * TEMPO_SCALE;
2500
                        }
2501
#endif
2502

2503
                        if (seqPlayer->tempo > gTempoInternalToExternal) {
2504
                            seqPlayer->tempo = gTempoInternalToExternal;
2505
                        }
2506

2507
                        //if (cmd){}
2508

2509
                        if ((s16) seqPlayer->tempo <= 0) {
2510
                            seqPlayer->tempo = 1;
2511
                        }
2512
                        break;
2513

2514
#ifdef VERSION_SH
2515
                    case 0xdc: // seq_addtempo (bpm)
2516
                        seqPlayer->tempoAdd = (s8) m64_read_u8(state) * TEMPO_SCALE;
2517
                        break;
2518
#endif
2519

2520
#if defined(VERSION_EU) || defined(VERSION_SH)
2521
                    case 0xda:
2522
                        cmd = m64_read_u8(state);
2523
                        u16v = m64_read_s16(state);
2524
                        switch (cmd) {
2525
                            case SEQUENCE_PLAYER_STATE_0:
2526
                            case SEQUENCE_PLAYER_STATE_FADE_OUT:
2527
                                if (seqPlayer->state != SEQUENCE_PLAYER_STATE_2) {
2528
                                    seqPlayer->fadeTimerUnkEu = u16v;
2529
                                    seqPlayer->state = cmd;
2530
                                }
2531
                                break;
2532
                            case SEQUENCE_PLAYER_STATE_2:
2533
                                seqPlayer->fadeRemainingFrames = u16v;
2534
                                seqPlayer->state = cmd;
2535
                                seqPlayer->fadeVelocity =
2536
                                    (0.0f - seqPlayer->fadeVolume) / (s32)(u16v & 0xFFFFu);
2537
                                break;
2538
                        }
2539
                        break;
2540

2541
                    case 0xdb:
2542
                        temp32 = m64_read_u8(state);
2543
                        switch (seqPlayer->state) {
2544
                            case SEQUENCE_PLAYER_STATE_2:
2545
                                break;
2546
                            case SEQUENCE_PLAYER_STATE_FADE_OUT:
2547
                                seqPlayer->state = SEQUENCE_PLAYER_STATE_0;
2548
                                seqPlayer->fadeVolume = 0.0f;
2549
                                // fallthrough
2550
                            case SEQUENCE_PLAYER_STATE_0:
2551
                                seqPlayer->fadeRemainingFrames = seqPlayer->fadeTimerUnkEu;
2552
                                if (seqPlayer->fadeTimerUnkEu != 0) {
2553
                                    seqPlayer->fadeVelocity = (temp32 / 127.0f - seqPlayer->fadeVolume * seqVol) / FLOAT_CAST(seqPlayer->fadeRemainingFrames);
2554
                                } else {
2555
                                    seqPlayer->fadeVolume = temp32 / 127.0f * seqVol;
2556
                                }
2557
                        }
2558
                        break;
2559
#else
2560
                    case 0xdb: // seq_setvol
2561
                        cmd = m64_read_u8(state);
2562
                        switch (seqPlayer->state) {
2563
                            case SEQUENCE_PLAYER_STATE_2:
2564
                                if (seqPlayer->fadeRemainingFrames != 0) {
2565
                                    f32 targetVolume = FLOAT_CAST(cmd) / US_FLOAT(127.0) * seqVol;
2566
                                    seqPlayer->fadeVelocity = (targetVolume - seqPlayer->fadeVolume * seqVol)
2567
                                                              / FLOAT_CAST(seqPlayer->fadeRemainingFrames);
2568
                                    break;
2569
                                }
2570
                                // fallthrough
2571
                            case SEQUENCE_PLAYER_STATE_0:
2572
                                seqPlayer->fadeVolume = FLOAT_CAST(cmd) / US_FLOAT(127.0) * seqVol;
2573
                                break;
2574
                            case SEQUENCE_PLAYER_STATE_FADE_OUT:
2575
                            case SEQUENCE_PLAYER_STATE_4:
2576
                                seqPlayer->volume = FLOAT_CAST(cmd) / US_FLOAT(127.0) * seqVol;
2577
                                break;
2578
                        }
2579
                        break;
2580

2581
                    case 0xda: // seq_changevol
2582
                        temp = m64_read_u8(state);
2583
                        seqPlayer->fadeVolume =
2584
                            seqPlayer->fadeVolume + (f32)(s8) temp / US_FLOAT(127.0) * seqVol;
2585
                        break;
2586
#endif
2587

2588
#if defined(VERSION_EU) || defined(VERSION_SH)
2589
                    case 0xd9:
2590
                        temp = m64_read_u8(state);
2591
                        seqPlayer->fadeVolumeScale = (s8) temp / 127.0f;
2592
                        break;
2593
#endif
2594

2595
                    case 0xd7: // seq_initchannels
2596
                        u16v = m64_read_s16(state);
2597
                        sequence_player_init_channels(seqPlayer, u16v);
2598
                        break;
2599

2600
                    case 0xd6: // seq_disablechannels
2601
                        u16v = m64_read_s16(state);
2602
                        sequence_player_disable_channels(seqPlayer, u16v);
2603
                        break;
2604

2605
                    case 0xd5: // seq_setmutescale
2606
                        temp = m64_read_u8(state);
2607
                        seqPlayer->muteVolumeScale = (f32)(s8) temp / US_FLOAT(127.0);
2608
                        break;
2609

2610
                    case 0xd4: // seq_mute
2611
                        seqPlayer->muted = TRUE;
2612
                        break;
2613

2614
                    case 0xd3: // seq_setmutebhv
2615
                        seqPlayer->muteBehavior = m64_read_u8(state);
2616
                        break;
2617

2618
                    case 0xd2: // seq_setshortnotevelocitytable
2619
                    case 0xd1: // seq_setshortnotedurationtable
2620
                        u16v = m64_read_s16(state);
2621
                        seqData = seqPlayer->seqData + u16v;
2622
                        if (cmd == 0xd2) {
2623
                            seqPlayer->shortNoteVelocityTable = seqData;
2624
                        } else {
2625
                            seqPlayer->shortNoteDurationTable = seqData;
2626
                        }
2627
                        break;
2628

2629
                    case 0xd0: // seq_setnoteallocationpolicy
2630
                        seqPlayer->noteAllocPolicy = m64_read_u8(state);
2631
                        break;
2632

2633
                    case 0xcc: // seq_setval
2634
                        value = m64_read_u8(state);
2635
                        break;
2636

2637
                    case 0xc9: // seq_bitand
2638
#if defined(VERSION_EU) || defined(VERSION_SH)
2639
                        value &= m64_read_u8(state);
2640
#else
2641
                        value = m64_read_u8(state) & value;
2642
#endif
2643
                        break;
2644

2645
                    case 0xc8: // seq_subtract
2646
                        value = value - m64_read_u8(state);
2647
                        break;
2648

2649
#ifdef VERSION_SH
2650
                    case 0xc7:
2651
                        cmd = m64_read_u8(state);
2652
                        u16v = m64_read_s16(state);
2653
                        seqData = seqPlayer->seqData + u16v;
2654
                        *seqData = (u8)value + cmd;
2655
                        break;
2656

2657
                    case 0xc6:
2658
                        seqPlayer->unkSh = TRUE;
2659
                        return;
2660
#endif
2661

2662
                    default:
2663
                        eu_stubbed_printf_1("Group:Undefine upper C0h command (%x)\n", cmd);
2664
                        break;
2665
                }
2666
            } else {
2667
                loBits = cmd & 0xf;
2668
                switch (cmd & 0xf0) {
2669
                    case 0x00: // seq_testchdisabled
2670
#if defined(VERSION_EU) || defined(VERSION_SH)
2671
                        value = seqPlayer->channels[loBits]->finished;
2672
#else
2673
                        if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[loBits]) == TRUE) {
2674
                            value = seqPlayer->channels[loBits]->finished;
2675
                        }
2676
#endif
2677
                        break;
2678
                    case 0x10:
2679
                        break;
2680
                    case 0x20:
2681
                        break;
2682
                    case 0x40:
2683
                        break;
2684
                    case 0x50: // seq_subvariation
2685
#if defined(VERSION_EU) || defined(VERSION_SH)
2686
                        value -= seqPlayer->seqVariationEu[0];
2687
#else
2688
                        value -= seqPlayer->seqVariation;
2689
#endif
2690
                        break;
2691
                    case 0x60:
2692
                        break;
2693
                    case 0x70: // seq_setvariation
2694
#if defined(VERSION_EU) || defined(VERSION_SH)
2695
                        seqPlayer->seqVariationEu[0] = value;
2696
#else
2697
                        seqPlayer->seqVariation = value;
2698
#endif
2699
                        break;
2700
                    case 0x80: // seq_getvariation
2701
#if defined(VERSION_EU) || defined(VERSION_SH)
2702
                        value = seqPlayer->seqVariationEu[0];
2703
#else
2704
                        value = seqPlayer->seqVariation;
2705
#endif
2706
                        break;
2707
                    case 0x90: // seq_startchannel
2708
                        u16v = m64_read_s16(state);
2709
                        sequence_channel_enable(seqPlayer, loBits, seqPlayer->seqData + u16v);
2710
                        break;
2711
                    case 0xa0:
2712
                        break;
2713
#if !defined(VERSION_EU) && !defined(VERSION_SH)
2714
                    case 0xd8: // (this makes no sense)
2715
                        break;
2716
                    case 0xd9:
2717
                        break;
2718
#endif
2719

2720
                    default:
2721
                        eu_stubbed_printf_0("Group:Undefined Command\n");
2722
                        break;
2723
                }
2724
            }
2725
        }
2726
    }
2727

2728
    for (i = 0; i < CHANNELS_MAX; i++) {
2729
#if defined(VERSION_EU) || defined(VERSION_SH)
2730
        if (IS_SEQUENCE_CHANNEL_VALID(seqPlayer->channels[i]) == TRUE) {
2731
            sequence_channel_process_script(seqPlayer->channels[i]);
2732
        }
2733
#else
2734
        if (seqPlayer->channels[i] != &gSequenceChannelNone) {
2735
            sequence_channel_process_script(seqPlayer->channels[i]);
2736
        }
2737
#endif
2738
    }
2739
}
2740

2741
// This runs 240 times per second.
2742
void process_sequences(UNUSED s32 iterationsRemaining) {
2743
    s32 i;
2744
    for (i = 0; i < SEQUENCE_PLAYERS; i++) {
2745
        if (gSequencePlayers[i].enabled == TRUE) {
2746
#if defined(VERSION_EU) || defined(VERSION_SH)
2747
            sequence_player_process_sequence(&gSequencePlayers[i], configSeqVolume[i]);
2748
            sequence_player_process_sound(&gSequencePlayers[i], configSeqVolume[i]);
2749
#else
2750
            sequence_player_process_sequence(gSequencePlayers + i, configSeqVolume[i]);
2751
            sequence_player_process_sound(gSequencePlayers + i, configSeqVolume[i]);
2752
#endif
2753
        }
2754
    }
2755
#if defined(VERSION_JP) || defined(VERSION_US)
2756
    reclaim_notes();
2757
#endif
2758
    process_notes();
2759
}
2760

2761
void init_sequence_player(u32 player) {
2762
    struct SequencePlayer *seqPlayer = &gSequencePlayers[player];
2763
#if defined(VERSION_EU) || defined(VERSION_SH)
2764
    sequence_player_disable(seqPlayer);
2765
#endif
2766
#ifdef VERSION_SH
2767
    seqPlayer->unkSh = FALSE;
2768
#else
2769
    seqPlayer->muted = FALSE;
2770
#endif
2771
    seqPlayer->delay = 0;
2772
#if defined(VERSION_EU) || defined(VERSION_SH)
2773
    seqPlayer->state = 1;
2774
#else
2775
    seqPlayer->state = SEQUENCE_PLAYER_STATE_0;
2776
#endif
2777
    seqPlayer->fadeRemainingFrames = 0;
2778
#if defined(VERSION_EU) || defined(VERSION_SH)
2779
    seqPlayer->fadeTimerUnkEu = 0;
2780
#endif
2781
    seqPlayer->tempoAcc = 0;
2782
    seqPlayer->tempo = 120 * TEMPO_SCALE; // 120 BPM
2783
#ifdef VERSION_SH
2784
    seqPlayer->tempoAdd = 0;
2785
#endif
2786
    seqPlayer->transposition = 0;
2787
#ifndef VERSION_SH
2788
    seqPlayer->muteBehavior = MUTE_BEHAVIOR_STOP_SCRIPT | MUTE_BEHAVIOR_STOP_NOTES | MUTE_BEHAVIOR_SOFTEN;
2789
#endif
2790
    seqPlayer->noteAllocPolicy = 0;
2791
    seqPlayer->shortNoteVelocityTable = gDefaultShortNoteVelocityTable;
2792
    seqPlayer->shortNoteDurationTable = gDefaultShortNoteDurationTable;
2793
    seqPlayer->fadeVolume = 1.0f;
2794
#if defined(VERSION_EU) || defined(VERSION_SH)
2795
    seqPlayer->fadeVolumeScale = 1.0f;
2796
#endif
2797
    seqPlayer->fadeVelocity = 0.0f;
2798
    seqPlayer->volume = 0.0f;
2799
    seqPlayer->muteVolumeScale = 0.5f;
2800
}
2801

2802
void init_sequence_players(void) {
2803
    // Initialization function, called from audio_init
2804
    s32 i, j;
2805

2806
    for (i = 0; i < ARRAY_COUNT(gSequenceChannels); i++) {
2807
        gSequenceChannels[i].seqPlayer = NULL;
2808
        gSequenceChannels[i].enabled = FALSE;
2809
#if defined(VERSION_JP) || defined(VERSION_US)
2810
    }
2811

2812
    for (i = 0; i < ARRAY_COUNT(gSequenceChannels); i++) {
2813
#endif
2814
        // @bug Size of wrong array. Zeroes out second half of gSequenceChannels[0],
2815
        // all of gSequenceChannels[1..31], and part of gSequenceLayers[0].
2816
        // However, this is only called at startup, so it's harmless.
2817
#ifdef AVOID_UB
2818
#define LAYERS_SIZE LAYERS_MAX
2819
#else
2820
#define LAYERS_SIZE ARRAY_COUNT(gSequenceLayers)
2821
#endif
2822
        for (j = 0; j < LAYERS_SIZE; j++) {
2823
            gSequenceChannels[i].layers[j] = NULL;
2824
        }
2825
    }
2826

2827
    init_layer_freelist();
2828

2829
    for (i = 0; i < ARRAY_COUNT(gSequenceLayers); i++) {
2830
        gSequenceLayers[i].seqChannel = NULL;
2831
        gSequenceLayers[i].enabled = FALSE;
2832
    }
2833

2834
    for (i = 0; i < SEQUENCE_PLAYERS; i++) {
2835
        for (j = 0; j < CHANNELS_MAX; j++) {
2836
            gSequencePlayers[i].channels[j] = &gSequenceChannelNone;
2837
        }
2838

2839
#if defined(VERSION_EU) || defined(VERSION_SH)
2840
        gSequencePlayers[i].seqVariationEu[0] = -1;
2841
#else
2842
        gSequencePlayers[i].seqVariation = -1;
2843
#endif
2844
#ifdef VERSION_SH
2845
        gSequencePlayers[i].muteBehavior = MUTE_BEHAVIOR_STOP_SCRIPT | MUTE_BEHAVIOR_STOP_NOTES | MUTE_BEHAVIOR_SOFTEN;
2846
        gSequencePlayers[i].enabled = FALSE;
2847
        gSequencePlayers[i].muted = FALSE;
2848
#endif
2849
        gSequencePlayers[i].bankDmaInProgress = FALSE;
2850
        gSequencePlayers[i].seqDmaInProgress = FALSE;
2851
        init_note_lists(&gSequencePlayers[i].notePool);
2852
        init_sequence_player(i);
2853
    }
2854
}
2855

2856

2857
Product

Resources

Company
