-
Notifications
You must be signed in to change notification settings - Fork 6
/
m4a_hq_mixer.s
1192 lines (1071 loc) · 38.9 KB
/
m4a_hq_mixer.s
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* HQ-Mixer rev 4.0 created by ipatix (c) 2021
* licensed under GPLv3, see LICENSE.txt for details */
/**********************
* CONFIGURATION AREA *
**********************/
.equ hq_buffer_ptr, SoundMainRAM_MixBuffer @ <-- set this to an IWRAM address where you want your high quality mix buffer to be
.equ POKE_CHN_INIT, 1 @ <-- set to '1' for pokemon games, '0' for other games
.equ ENABLE_STEREO, 1 @ <-- TODO actually implement, not functional yet
.equ ENABLE_REVERB, 0 @ <-- if you want faster code or don't like reverb, set this to '0', set to '1' otherwise
.equ ENABLE_DMA, 1 @ <-- Using DMA produces smaller code and has better performance. Disable it if your case does not allow to use DMA.
/*****************
* END OF CONFIG *
*****************/
/* NO USER SERVICABLE CODE BELOW HERE! YOU HAVE BEEN WARNED */
.syntax unified
.cpu arm7tdmi
/* globals */
.global SoundMainRAM
.equ DMA_BUFFER_SIZE, 0x630
.equ FRAME_LENGTH_5734, 0x60
.equ FRAME_LENGTH_7884, 0x84 @ THIS MODE IS NOT SUPPORTED BY THIS ENGINE BECAUSE IT DOESN'T USE AN 8 ALIGNED BUFFER LENGTH
.equ FRAME_LENGTH_10512, 0xB0
.equ FRAME_LENGTH_13379, 0xE0 @ DEFAULT
.equ FRAME_LENGTH_15768, 0x108
.equ FRAME_LENGTH_18157, 0x130
.equ FRAME_LENGTH_21024, 0x160
.equ FRAME_LENGTH_26758, 0x1C0
.equ FRAME_LENGTH_31536, 0x210
.equ FRAME_LENGTH_36314, 0x260
.equ FRAME_LENGTH_40137, 0x2A0
.equ FRAME_LENGTH_42048, 0x2C0
/* stack variables */
.equ ARG_FRAME_LENGTH, 0x0 @ Number of samples per frame/buffer
.equ ARG_REMAIN_CHN, 0x4 @ temporary to count down the channels to process
.equ ARG_BUFFER_POS, 0x8 @ stores the current output buffer pointer
.equ ARG_LOOP_START_POS, 0xC @ stores wave loop start position in channel loop
.equ ARG_LOOP_LENGTH, 0x10 @ '' '' '' end position
.equ ARG_BUFFER_POS_INDEX_HINT, 0x14 @ if this value is == 2, then this is the last buffer before wraparound
.equ ARG_PCM_STRUCT, 0x18 @ pointer to engine the main work area
/* channel struct */
.equ CHN_STATUS, 0x0 @ [byte] channel status bitfield
.equ CHN_MODE, 0x1 @ [byte] channel mode bitfield
.equ CHN_VOL_1, 0x2 @ [byte] volume right
.equ CHN_VOL_2, 0x3 @ [byte] volume left
.equ CHN_ATTACK, 0x4 @ [byte] wave attack summand
.equ CHN_DECAY, 0x5 @ [byte] wave decay factor
.equ CHN_SUSTAIN, 0x6 @ [byte] wave sustain level
.equ CHN_RELEASE, 0x7 @ [byte] wave release factor
.equ CHN_ADSR_LEVEL, 0x9 @ [byte] current envelope level
.equ CHN_FINAL_VOL_1, 0xA @ [byte] not used anymore!
.equ CHN_FINAL_VOL_2, 0xB @ [byte] not used anymore!
.equ CHN_ECHO_VOL, 0xC @ [byte] pseudo echo volume
.equ CHN_ECHO_REMAIN, 0xD @ [byte] pseudo echo length
.equ CHN_SAMPLE_COUNTDOWN, 0x18 @ [word] sample countdown in mixing loop
.equ CHN_FINE_POSITION, 0x1C @ [word] inter sample position (23 bits)
.equ CHN_FREQUENCY, 0x20 @ [word] sample rate (in Hz)
.equ CHN_WAVE_OFFSET, 0x24 @ [word] wave header pointer
.equ CHN_POSITION_ABS, 0x28 @ [word] points to the current position in the wave data (relative offset for compressed samples)
.equ CHN_SAMPLE_STOR, 0x3F @ [byte] contains the previously loaded sample from the linear interpolation
/* wave header struct */
.equ WAVE_TYPE, 0x0 @ [byte] 0x0 = 8 bit pcm, 0x1 = pokemon dpcm
.equ WAVE_LOOP_FLAG, 0x3 @ [byte] 0x0 = oneshot; 0x40 = looped
.equ WAVE_FREQ, 0x4 @ [word] pitch adjustment value = mid-C samplerate * 1024
.equ WAVE_LOOP_START, 0x8 @ [word] loop start position
.equ WAVE_LENGTH, 0xC @ [word] loop end / wave end position
.equ WAVE_DATA, 0x10 @ [byte array] actual wave data
/* pulse wave synth configuration offset */
.equ SYNTH_TYPE, 0x1 @ [byte]
.equ SYNTH_BASE_WAVE_DUTY, 0x2 @ [byte]
.equ SYNTH_WIDTH_CHANGE_1, 0x3 @ [byte]
.equ SYNTH_MOD_AMOUNT, 0x4 @ [byte]
.equ SYNTH_WIDTH_CHANGE_2, 0x5 @ [byte]
/* CHN_STATUS flags - 0x0 = OFF */
.equ FLAG_CHN_INIT, 0x80 @ [bit] write this value to init a channel
.equ FLAG_CHN_RELEASE, 0x40 @ [bit] write this value to release (fade out) the channel
.equ FLAG_CHN_LOOP, 0x10 @ [bit] loop (yes/no)
.equ FLAG_CHN_ECHO, 0x4 @ [bit] echo phase
.equ FLAG_CHN_ATTACK, 0x3 @ [bit] attack phase
.equ FLAG_CHN_DECAY, 0x2 @ [bit] decay phase
.equ FLAG_CHN_SUSTAIN, 0x1 @ [bit] sustain phase
/* CHN_MODE flags */
.equ MODE_FIXED_FREQ, 0x8 @ [bit] set to disable resampling (i.e. playback with output rate)
.equ MODE_REVERSE, 0x10 @ [bit] set to reverse sample playback
.equ MODE_COMP, 0x20 @ [bit] is wave being played compressed
.equ MODE_SYNTH, 0x40 @ [bit] channel is a synth channel
.equ MODE_FLGSH_SIGN_REVERSE, 27 @ shift by n bits to get the reverse flag into SIGN
/* variables of the engine work area */
.equ VAR_REVERB, 0x5 @ [byte] 0-127 = reverb level
.equ VAR_MAX_CHN, 0x6 @ [byte] maximum channels to process
.equ VAR_MASTER_VOL, 0x7 @ [byte] PCM master volume
.equ VAR_EXT_NOISE_SHAPE_LEFT, 0xE @ [byte] normally unused, used here for noise shaping
.equ VAR_EXT_NOISE_SHAPE_RIGHT, 0xF @ [byte] normally unused, used here for noise shaping
.equ VAR_DEF_PITCH_FAC, 0x18 @ [word] this value get's multiplied with the samplerate for the inter sample distance
.equ VAR_FIRST_CHN, 0x50 @ [CHN struct] relative offset to channel array
.equ VAR_PCM_BUFFER, 0x350
/* just some more defines */
.equ REG_DMA3_SRC, 0x040000D4
.equ ARM_OP_LEN, 0x4
/* extensions */
.equ BDPCM_BLK_STRIDE, 0x21
.equ BDPCM_BLK_SIZE, 0x40
.equ BDPCM_BLK_SIZE_MASK, 0x3F
.equ BDPCM_BLK_SIZE_SHIFT, 0x6
.thumb
.thumb_func
.align 2
SoundMainRAM:
/* load Reverb level and check if we need to apply it */
STR R4, [SP, #ARG_BUFFER_POS_INDEX_HINT]
/*
* okay, before the actual mixing starts
* the volume and envelope calculation takes place
*/
MOV R4, R8 @ R4 = buffer length
/*
* this stores the buffer length to a backup location
*/
STR R4, [SP, #ARG_FRAME_LENGTH]
/* init channel loop */
LDR R4, [SP, #ARG_PCM_STRUCT] @ R4 = main work area pointer
LDR R0, [R4, #VAR_DEF_PITCH_FAC] @ R0 = samplingrate pitch factor
MOV R12, R0
LDRB R0, [R4, #VAR_MAX_CHN]
ADDS R4, #VAR_FIRST_CHN @ R4 = Base channel Offset (Channel #0)
C_channel_state_loop:
/* this is the main channel processing loop */
STR R0, [SP, #ARG_REMAIN_CHN]
LDR R3, [R4, #CHN_WAVE_OFFSET]
LDRB R6, [R4, #CHN_STATUS] @ R6 will hold the channel status
MOVS R0, #0xC7 @ check if any of the channel status flags is set
TST R0, R6 @ check if none of the flags is set
BEQ C_skip_channel
/* check channel flags */
LSLS R0, R6, #25 @ shift over the FLAG_CHN_INIT to CARRY
BCC C_adsr_echo_check @ continue with normal channel procedure
/* check leftmost bit */
BMI C_stop_channel @ FLAG_CHN_INIT | FLAG_CHN_RELEASE -> stop directly
/* channel init procedure */
MOVS R6, #FLAG_CHN_ATTACK
/* enabled compression if sample flag is set */
MOVS R0, R3 @ R0 = CHN_WAVE_OFFSET
ADDS R0, #WAVE_DATA @ R0 = wave data offset
LDR R2, [R3, #WAVE_LENGTH]
CMP R2, #0
BEQ C_channel_init_synth
LDRB R5, [R3, #WAVE_TYPE]
LSLS R5, R5, #31
LDRB R5, [R4, #CHN_MODE]
BMI C_channel_init_comp
LSLS R5, R5, #27 @ shift MODE_REVERSE flag to SIGN
BMI C_channel_init_noncomp_reverse
/* Pokemon games seem to init channels differently than other m4a games */
C_channel_init_noncomp_forward:
.if POKE_CHN_INIT==0
.else
LDR R1, [R4, #CHN_SAMPLE_COUNTDOWN]
ADDS R0, R1
SUBS R2, R1
.endif
B C_channel_init_check_loop
C_channel_init_synth:
MOVS R5, #MODE_SYNTH
STRB R5, [R4, #CHN_MODE]
LDRB R1, [R3, #(WAVE_DATA + SYNTH_TYPE)]
CMP R1, #2
BNE C_channel_init_check_loop
/* start triangular synth wave at 90 degree phase
* to avoid a pop sound at the start of the wave */
MOVS R5, #0x40
LSLS R5, #24
STR R5, [R4, #CHN_FINE_POSITION]
MOVS R5, #0
B C_channel_init_check_loop_no_fine_pos
C_channel_init_noncomp_reverse:
.if POKE_CHN_INIT==0
ADDS R0, R2
.else
ADDS R0, R2
LDR R1, [R4, #CHN_SAMPLE_COUNTDOWN]
SUBS R0, R1
SUBS R2, R1
.endif
B C_channel_init_check_loop
C_channel_init_comp:
MOVS R0, #MODE_COMP
ORRS R5, R0
STRB R5, [R4, #CHN_MODE]
LSLS R5, R5, #27 @ shift MODE_REVERSE flag to SIGN
BMI C_channel_init_comp_reverse
C_channel_init_comp_forward:
.if POKE_CHN_INIT==0
MOVS R0, #0
.else
LDR R0, [R4, #CHN_SAMPLE_COUNTDOWN]
SUBS R2, R0
.endif
B C_channel_init_check_loop
C_channel_init_comp_reverse:
.if POKE_CHN_INIT==0
MOVS R0, R2
.else
LDR R1, [R4, #CHN_SAMPLE_COUNTDOWN]
SUBS R2, R1
MOVS R0, R2
.endif
C_channel_init_check_loop:
MOVS R5, #0 @ initial envelope = #0
STR R5, [R4, #CHN_FINE_POSITION]
C_channel_init_check_loop_no_fine_pos:
STR R0, [R4, #CHN_POSITION_ABS]
STR R2, [R4, #CHN_SAMPLE_COUNTDOWN]
STRB R5, [R4, #CHN_ADSR_LEVEL]
MOVS R2, #CHN_SAMPLE_STOR @ offset is too large to be used in one instruction
STRB R5, [R4, R2]
/* enabled loop if required */
LDRB R2, [R3, #WAVE_LOOP_FLAG]
LSRS R0, R2, #6
BEQ C_adsr_attack
/* loop enabled here */
ADDS R6, #FLAG_CHN_LOOP
B C_adsr_attack
C_adsr_echo_check:
/* this is the normal ADSR procedure without init */
LDRB R5, [R4, #CHN_ADSR_LEVEL]
LSLS R0, R6, #29 @ FLAG_CHN_ECHO --> bit 31 (sign bit)
BPL C_adsr_release_check
/* pseudo echo handler */
LDRB R0, [R4, #CHN_ECHO_REMAIN]
SUBS R0, #1
STRB R0, [R4, #CHN_ECHO_REMAIN]
BHI C_channel_vol_calc @ continue normal if channel is still on
C_stop_channel:
MOVS R0, #0
STRB R0, [R4, #CHN_STATUS]
C_skip_channel:
/* go to end of the channel loop */
B C_end_channel_state_loop
C_adsr_release_check:
LSLS R0, R6, #25 @ FLAG_CHN_RELEASE --> bit 31 (sign bit)
BPL C_adsr_decay_check
/* release handler */
LDRB R0, [R4, #CHN_RELEASE]
MULS R5, R5, R0
LSRS R5, #8
BLE C_adsr_released
/* pseudo echo init handler */
LDRB R0, [R4, #CHN_ECHO_VOL]
CMP R5, R0
BHI C_channel_vol_calc
C_adsr_released:
/* if volume released to #0 */
LDRB R5, [R4, #CHN_ECHO_VOL]
CMP R5, #0
BEQ C_stop_channel
/* pseudo echo volume handler */
MOVS R0, #FLAG_CHN_ECHO
ORRS R6, R0 @ set the echo flag
B C_adsr_save_and_finalize
C_adsr_decay_check:
/* check if decay is active */
MOVS R2, #(FLAG_CHN_DECAY+FLAG_CHN_SUSTAIN)
ANDS R2, R6
CMP R2, #FLAG_CHN_DECAY
BNE C_adsr_attack_check @ decay not active yet
/* decay handler */
LDRB R0, [R4, #CHN_DECAY]
MULS R5, R5, R0
LSRS R5, R5, #8
LDRB R0, [R4, #CHN_SUSTAIN]
CMP R5, R0
BHI C_channel_vol_calc @ sample didn't decay yet
/* sustain handler */
MOVS R5, R0 @ current level = sustain level
BEQ C_adsr_released @ sustain level #0 --> branch
/* step to next phase otherweise */
B C_adsr_next_state
C_adsr_attack_check:
/* attack handler */
CMP R2, #FLAG_CHN_ATTACK
BNE C_channel_vol_calc @ if it isn't in attack attack phase, it has to be in sustain (keep vol) --> branch
C_adsr_attack:
/* apply attack summand */
LDRB R0, [R4, #CHN_ATTACK]
ADDS R5, R0
CMP R5, #0xFF
BLO C_adsr_save_and_finalize
/* cap attack at 0xFF */
MOVS R5, #0xFF
C_adsr_next_state:
/* switch to next adsr phase */
SUBS R6, #1
C_adsr_save_and_finalize:
/* store channel status */
STRB R6, [R4, #CHN_STATUS]
C_channel_vol_calc:
/* store the calculated ADSR level */
STRB R5, [R4, #CHN_ADSR_LEVEL]
/* apply master volume */
LDR R0, [SP, #ARG_PCM_STRUCT]
LDRB R0, [R0, #VAR_MASTER_VOL]
ADDS R0, #1
MULS R5, R0
/* left side volume */
LDRB R0, [R4, #CHN_VOL_2]
MULS R0, R5
LSRS R0, #13
MOV R10, R0 @ R10 = left volume
/* right side volume */
LDRB R0, [R4, #CHN_VOL_1]
MULS R0, R5
LSRS R0, #13
MOV R11, R0 @ R11 = right volume
/*
* Now we get closer to actual mixing:
* For looped samples some additional operations are required
*/
MOVS R0, #FLAG_CHN_LOOP
ANDS R0, R6
BEQ C_sample_loop_setup_skip
/* loop setup handler */
ADDS R3, #WAVE_LOOP_START
LDMIA R3!, {R0, R1} @ R0 = loop start, R1 = loop end
LDRB R2, [R4, #CHN_MODE]
LSLS R2, R2, #MODE_FLGSH_SIGN_REVERSE
BCS C_sample_loop_setup_comp
ADDS R3, R0 @ R3 = loop start position (absolute)
B C_sample_loop_setup_finish
C_sample_loop_setup_comp:
MOVS R3, R0
C_sample_loop_setup_finish:
STR R3, [SP, #ARG_LOOP_START_POS]
SUBS R0, R1, R0
C_sample_loop_setup_skip:
/* do the rest of the setup */
STR R0, [SP, #ARG_LOOP_LENGTH] @ if loop is off --> R0 = 0x0
LDR R5, hq_buffer_literal
LDR R2, [R4, #CHN_SAMPLE_COUNTDOWN]
LDR R3, [R4, #CHN_POSITION_ABS]
LDRB R0, [R4, #CHN_MODE]
/* switch to arm */
ADR R1, C_mixing_setup
BX R1
.align 2
hq_buffer_literal:
.word hq_buffer_ptr
.arm
.align 2
/* register usage:
* R0: scratch
* R1: scratch
* R2: sample countdown
* R3: sample pointer
* R4: sample step
* R5: mixing buffer
* R6: sampleval base
* R7: sample interpos
* R8: frame count
* R9: scratch
* R10: scratch
* R11: volume
* R12: sampval diff
* LR: scratch */
C_mixing_setup:
/* frequency and mixing loading routine */
LDRSB R6, [R4, #CHN_SAMPLE_STOR]
LDR R8, [SP, #ARG_FRAME_LENGTH]
ORRS R11, R11, R10, LSL#16 @ R11 = 00LL00RR
BEQ C_mixing_epilogue @ volume #0 --> branch and skip channel processing
/* normal processing otherwise */
TST R0, #(MODE_COMP|MODE_REVERSE)
BNE C_mixing_setup_comp_rev
TST R0, #MODE_FIXED_FREQ
BNE C_setup_fixed_freq_mixing
C_mixing_setup_comp_rev:
PUSH {R4, R9, R12}
ADD R4, R4, #CHN_FINE_POSITION
LDMIA R4, {R7, LR} @ R7 = Fine Position, LR = Frequency
MUL R4, LR, R12 @ R4 = inter sample steps = output rate factor * samplerate
TST R0, #MODE_SYNTH
BNE C_setup_synth
/*
* Mixing goes with volume ranges 0-127
* They come in 0-255 --> divide by 2 (rounding up)
*/
MOVS R11, R11, LSR#1
ADC R11, R11, #0x8000
BIC R11, R11, #0x8000
MOV R1, R7 @ R1 = inter sample position
/*
* There is 2 different mixing codepaths for uncompressed data
* path 1: fast mixing, but doesn't supports loop or stop
* path 2: not so fast but supports sample loops / stop
* This checks if there is enough samples aviable for path 1.
* important: R0 is expected to be #0
*/
SUB R10, SP, #0x8
TST R0, #MODE_FIXED_FREQ
MOVNE R4, #0x800000
MOVS R0, R0, LSL#(MODE_FLGSH_SIGN_REVERSE)
UMLAL R1, R0, R4, R8
MOV R1, R1, LSR#23
ORR R0, R1, R0, LSL#9
BCS C_data_load_comp
BMI C_data_load_uncomp_rev
B C_data_load_uncomp_for
/* registers:
* R9: src address (relative to start address)
* R0: dst address (on stack)
* R12: delta_lookup_table */
F_decode_compressed:
PUSH {R3, LR}
MOV LR, #BDPCM_BLK_SIZE
LDRB R2, [R9], #1
LDRB R3, [R9], #1
B C_bdpcm_decoder_loop_entry
C_bdpcm_decoder_loop:
LDRB R3, [R9], #1
LDRB R2, [R12, R3, LSR#4]
ADD R2, R1, R2
AND R3, R3, #0xF
C_bdpcm_decoder_loop_entry:
LDRB R1, [R12, R3]
ADD R1, R1, R2
bdpcm_instructions:
NOP
NOP
SUBS LR, #2
BGT C_bdpcm_decoder_loop
POP {R3, PC}
bdpcm_instruction_resource_for:
STRB R2, [R0], #1
STRB R1, [R0], #1
bdpcm_instruction_resource_rev:
STRB R2, [R0, #-1]!
STRB R1, [R0, #-1]!
delta_lookup_table:
.byte 0, 1, 4, 9, 16, 25, 36, 49, -64, -49, -36, -25, -16, -9, -4, -1
stack_boundary_literal:
.word 0x03007900
C_data_load_comp:
ADRPL R9, bdpcm_instruction_resource_for
ADRMI R9, bdpcm_instruction_resource_rev
LDMIA R9, {R12, LR}
ADR R9, bdpcm_instructions
STMIA R9, {R12, LR}
ADR R12, delta_lookup_table
BMI C_data_load_comp_rev
C_data_load_comp_for:
/* TODO having loop support for forward samples would be nice */
/* LR = end_of_last_block */
ADD LR, R3, R0
ADD LR, #(1+(BDPCM_BLK_SIZE-1)) @ -1 for alignment, +1 because we need an extra sample for interpolation
BIC LR, #BDPCM_BLK_SIZE_MASK
/* R9 = start_of_first_block >> 6 */
MOV R9, R3, LSR#BDPCM_BLK_SIZE_SHIFT
/* R8 = num_samples */
SUB R8, LR, R9, LSL#BDPCM_BLK_SIZE_SHIFT
/* check if stack would overflow */
LDR R1, stack_boundary_literal
ADD R1, R8
CMP R1, SP
BHS C_end_mixing
/* --- */
ADD R1, R3, R0
SUBS R0, R2, R0
PUSH {R0, R1}
SUB SP, R8
BGT C_data_load_comp_for_calc_pos
/* locate end of sample data block */
ADD R1, R3, R2
/* ugly workaround for unaligned samples */
ADD R1, R1, #BDPCM_BLK_SIZE_MASK
BIC R1, R1, #BDPCM_BLK_SIZE_MASK
SUB R1, LR, R1
SUB R8, R1
ADD R0, SP, R8
BL F_clear_mem
C_data_load_comp_for_calc_pos:
AND R3, R3, #BDPCM_BLK_SIZE_MASK
MOV R0, SP
C_data_load_comp_decode:
LDR R2, [R10, #8] @ load chn_ptr from previous STMFD
@ zero flag should be only set when leaving from F_clear_mem (R1 = 0)
STRBEQ R1, [R2, #CHN_STATUS]
LDR R2, [R2, #CHN_WAVE_OFFSET]
ADD R2, #WAVE_DATA
MOV R1, #BDPCM_BLK_STRIDE
MLA R9, R1, R9, R2
C_data_load_comp_loop:
BL F_decode_compressed
SUBS R8, #BDPCM_BLK_SIZE
BGT C_data_load_comp_loop
B C_select_highspeed_codepath_vla_r3
C_data_load_comp_rev:
/* LR = end_of_last_block */
ADD LR, R3, #BDPCM_BLK_SIZE_MASK
BIC LR, LR, #BDPCM_BLK_SIZE_MASK
/* R9 = start_of_first_block >> 6 */
SUB R9, R3, R0
SUB R9, #1 @ one extra sample for LERP
MOV R9, R9, LSR#BDPCM_BLK_SIZE_SHIFT
/* R8 = num_samples */
SUB R8, LR, R9, LSL#BDPCM_BLK_SIZE_SHIFT
/* check if stack would overflow */
LDR LR, stack_boundary_literal
ADD LR, R8
CMP LR, SP
BHS C_end_mixing
/* --- */
SUB LR, R3, R0
SUBS R0, R2, R0
PUSH {R0, LR}
MOV R0, SP
SUB SP, R8
BGT C_data_load_comp_rev_calc_pos
SUB R1, R3, R2
SUB R1, R1, R9, LSL#BDPCM_BLK_SIZE_SHIFT
SUB R8, R1
ADD R0, SP, R8
BL F_clear_mem
C_data_load_comp_rev_calc_pos:
NEG R3, R3
AND R3, R3, #BDPCM_BLK_SIZE_MASK
B C_data_load_comp_decode
C_data_load_uncomp_rev:
/* LR = end_of_last_block */
ADD LR, R3, #0x3
BIC LR, #0x3
/* R9 = start_of_first_block */
SUB R9, R3, R0
SUB R9, #1
BIC R9, #0x3
/* R8 = num_samples */
SUB R8, LR, R9
/* check if stack would overflow */
LDR R1, stack_boundary_literal
ADD R1, R8
CMP R1, SP
BHS C_end_mixing
/* --- */
SUB R1, R3, R0
SUBS R0, R2, R0
PUSH {R0, R1}
MOV R0, SP
SUB SP, R8
BGT C_data_load_uncomp_rev_loop
SUB R1, R3, R2
SUB R1, R9
SUB R8, R1
ADD R0, SP, R8
BL F_clear_mem
LDR R2, [R10, #8] @ load chn_ptr from previous STMFD
@ R1 should be zero here
STRB R1, [R2, #CHN_STATUS]
C_data_load_uncomp_rev_loop:
LDMIA R9!, {R1}
@ Byteswap
EOR R2, R1, R1, ROR#16
MOV R2, R2, LSR#8
BIC R2, R2, #0xFF00
EOR R1, R2, R1, ROR#8
STMDB R0!, {R1}
SUBS R8, #4
BGT C_data_load_uncomp_rev_loop
NEG R3, R3
B C_select_highspeed_codepath_vla_r3_and3
C_data_load_uncomp_for:
CMP R2, R0 @ actual comparison
BLE C_unbuffered_mixing @ if not enough samples are available for path 1 --> branch
/*
* This is the mixer path 1.
* The interesting thing here is that the code will
* buffer enough samples on stack if enough space
* on stack is available (or goes over the limit of 0x400 bytes)
*/
SUB R2, R2, R0
LDR R9, stack_boundary_literal
ADD R9, R0
CMP R9, SP
ADD R9, R3, R0
/*
* R2 = remaining samples after processing
* R9 = final sample position
* SP = original stack location
* These values will get reloaded after channel processing
* due to the lack of registers.
*/
PUSH {R2, R9}
CMPLO R0, #0x400 @ > 0x400 bytes --> read directly from ROM rather than buffered
BHS C_select_highspeed_codepath
BIC R1, R3, #3
ADD R0, R0, #7
.if ENABLE_DMA==1
/*
* The code below inits the DMA to read word aligned
* samples from ROM to stack
*/
MOV R9, #REG_DMA3_SRC & 0xFF000000
ADD R9, #REG_DMA3_SRC & 0x000000FF
MOV R0, R0, LSR#2
SUB SP, SP, R0, LSL#2
ORR LR, R0, #0x84000000 @ DMA enable, 32-bit transfer type
STMIA R9, {R1, SP, LR} @ actually starts the DMA
.else
/*
* This alternative path doesn't use DMA but copies with CPU instead
*/
BIC R0, R0, #0x3
SUB SP, SP, R0
MOV LR, SP
PUSH {R3-R10}
ANDS R10, R0, #0xE0
RSB R10, R10, #0xF0
ADD PC, PC, R10, LSR#2
C_copy_loop:
.rept 8 @ duff's device 8 times
LDMIA R1!, {R3-R10}
STMIA LR!, {R3-R10}
.endr
SUBS R0, #0x100
BPL C_copy_loop
ANDS R0, R0, #0x1C
BEQ C_copy_end
C_copy_loop_rest:
LDMIA R1!, {R3}
STMIA LR!, {R3}
SUBS R0, #0x4
BGT C_copy_loop_rest
C_copy_end:
POP {R3-R10}
.endif
C_select_highspeed_codepath_vla_r3_and3:
AND R3, R3, #3
C_select_highspeed_codepath_vla_r3:
ADD R3, R3, SP
C_select_highspeed_codepath:
PUSH {R10} @ save original SP for VLA
/*
* This code decides which piece of code to load
* depending on playback-rate / default-rate ratio.
* Modes > 1.0 run with different volume levels.
* R4 = inter sample step
*/
ADR R0, high_speed_code_resource @ loads the base pointer of the code
SUBS R4, R4, #0x800000
MOVPL R11, R11, LSL#1 @ if >= 1.0* 0-127 --> 0-254 volume level
ADDPL R0, R0, #(ARM_OP_LEN*6) @ 6 instructions further
SUBSPL R4, R4, #0x800000 @ if >= 2.0*
ADDPL R0, R0, #(ARM_OP_LEN*6)
ADDPL R4, R4, #0x800000
LDR R2, previous_fast_code
CMP R0, R2 @ code doesn't need to be reloaded if it's already in place
BEQ C_skip_fast_mixing_creation
/* This loads the needed code to RAM */
STR R0, previous_fast_code
LDMIA R0, {R0-R2, R8-R10} @ load 6 opcodes
ADR LR, fast_mixing_instructions+(ARM_OP_LEN*2) @ first NOP
C_fast_mixing_creation_loop:
/* paste code to destination, see below for patterns */
STMIA LR, {R0, R1}
ADD LR, LR, #(ARM_OP_LEN*38)
STMIA LR, {R0, R1}
SUB LR, LR, #(ARM_OP_LEN*35)
STMIA LR, {R2, R8-R10}
ADD LR, LR, #(ARM_OP_LEN*38)
STMIA LR, {R2, R8-R10}
SUB LR, LR, #(ARM_OP_LEN*32)
ADDS R5, R5, #0x40000000 @ do that for 4 blocks (unused pointer bits)
BCC C_fast_mixing_creation_loop
C_skip_fast_mixing_creation:
LDR R8, [SP] @ restore R8 with the frame length
LDR R8, [R8, #(ARG_FRAME_LENGTH + 0x8 + 0xC)]
MOVS R2, #0xFF000000 @ load the fine position overflow bitmask, set NE
LDRSB R12, [R3]
SUB R12, R12, R6
C_fast_mixing_loop:
/* This is the actual processing and interpolation code loop; NOPs will be replaced by the code above */
fast_mixing_instructions:
/* Mix the first 4 stereo samples, then the next 4. */
.rept 2
LDMIA R5, {R0, R1, R10, LR} @ load 4 stereo samples to Registers
.irp REG, R0, R1, R10, LR @ 4 blocks
MULNE R9, R7, R12
NOP
NOP
MLANE \REG, R11, R9, \REG
NOP
NOP
NOP
NOP
BIC R7, R7, R2, ASR#1
.endr
STMIA R5!, {R0, R1, R10, LR} @ write 4 stereo samples
.endr
SUBS R8, R8, #8
BGT C_fast_mixing_loop
/* restore previously saved values */
LDR SP, [SP] @ reload original stack pointer from VLA
C_skip_fast_mixing:
POP {R2, R3}
B C_end_mixing
/* Various variables for the cached mixer */
.align 2
previous_fast_code:
.word 0x0 /* mark as invalid initially */
/* Those instructions below are used by the high speed loop self modifying code */
high_speed_code_resource:
/* Block for Mix Freq < 1.0 * Output Frequency */
MOV R9, R9, ASR#22
ADDS R9, R9, R6, LSL#1
ADDS R7, R7, R4
ADDPL R6, R12, R6
LDRSBPL R12, [R3, #1]!
SUBSPL R12, R12, R6
/* Block for Mix Freq > 1.0 AND < 2.0 * Output Frequency */
ADDS R9, R6, R9, ASR#23
ADD R6, R12, R6
ADDS R7, R7, R4
LDRSBPL R6, [R3, #1]!
LDRSB R12, [R3, #1]!
SUBS R12, R12, R6
/* Block for Mix Freq > 2.0 * Output Frequency */
ADDS R9, R6, R9, ASR#23
ADD R7, R7, R4
ADD R3, R3, R7, LSR#23
LDRSB R6, [R3]
LDRSB R12, [R3, #1]!
SUBS R12, R12, R6
/* incase a loop or end occurs during mixing, this code is used */
C_unbuffered_mixing:
LDRSB R12, [R3]
SUB R12, R12, R6
ADD R5, R5, R8, LSL#2 @ R5 = End of HQ buffer
/* This below is the unbuffered mixing loop. R6 = base sample, R12 diff to next */
C_unbuffered_mixing_loop:
MUL R9, R7, R12
MOV R9, R9, ASR#22
ADDS R9, R9, R6, LSL#1
LDRNE R0, [R5, -R8, LSL#2]
MLANE R0, R11, R9, R0
STRNE R0, [R5, -R8, LSL#2]
ADD R7, R7, R4
MOVS R9, R7, LSR#23
BEQ C_unbuffered_mixing_skip_load @ skip the mixing load if it isn't required
SUBS R2, R2, R9
BLE C_unbuffered_mixing_loop_or_end
C_unbuffered_mixing_loop_continue:
SUBS R9, R9, #1
ADDEQ R6, R12, R6
LDRSBNE R6, [R3, R9]!
LDRSB R12, [R3, #1]!
SUB R12, R12, R6
BIC R7, R7, #0x3F800000
C_unbuffered_mixing_skip_load:
SUBS R8, R8, #1 @ reduce the sample count for the buffer by #1
BGT C_unbuffered_mixing_loop
C_end_mixing:
POP {R4, R9, R12}
STR R7, [R4, #CHN_FINE_POSITION]
STRB R6, [R4, #CHN_SAMPLE_STOR]
B C_mixing_end_store
C_unbuffered_mixing_loop_or_end:
/* XXX: R0 or R6? */
/* This loads the loop information end loops incase it should */
LDR R0, [SP, #(ARG_LOOP_LENGTH+0xC)]
CMP R0, #0 @ check if loop is enabled; if Loop is enabled R6 is != 0
SUBNE R3, R3, R0
ADDNE R2, R2, R0
BNE C_unbuffered_mixing_loop_continue
POP {R4, R9, R12}
B C_mixing_end_and_stop_channel @ R0 == 0 (if this branches)
C_fixed_mixing_loop_or_end:
LDR R2, [SP, #ARG_LOOP_LENGTH+0x8]
MOVS R0, R2 @ copy it to R6 and check whether loop is disabled
LDRNE R3, [SP, #ARG_LOOP_START_POS+0x8]
BNE C_fixed_mixing_loop_continue
POP {R4, R9}
C_mixing_end_and_stop_channel:
STRB R0, [R4] @ update channel flag with chn halt
B C_mixing_epilogue
/* These are used for the fixed freq mixer */
fixed_mixing_code_resource:
MOVS R6, R10, LSL#24
MOVS R6, R6, ASR#24
MOVS R6, R10, LSL#16
MOVS R6, R6, ASR#24
MOVS R6, R10, LSL#8
MOVS R6, R6, ASR#24
MOVS R6, R10, ASR#24
LDMIA R3!, {R10} @ load chunk of samples
MOVS R6, R10, LSL#24
MOVS R6, R6, ASR#24
MOVS R6, R10, LSL#16
MOVS R6, R6, ASR#24
MOVS R6, R10, LSL#8
MOVS R6, R6, ASR#24
C_setup_fixed_freq_mixing:
STMFD SP!, {R4, R9}
C_fixed_mixing_length_check:
CMP R2, R8 @ min(buffer_size, sample_countdown) - 1
SUBGT LR, R8, #1
SUBLE LR, R2, #1
MOVS LR, LR, LSR#2
BEQ C_fixed_mixing_process_rest @ <= 3 samples to process
SUB R8, R8, LR, LSL#2 @ subtract the amount of samples we need to process from the buffer length
SUB R2, R2, LR, LSL#2 @ subtract the amount of samples we need to process from the remaining samples
ADR R1, fixed_mixing_instructions
ADR R0, fixed_mixing_code_resource
MOV R9, R3, LSL#30
ADD R0, R0, R9, LSR#27 @ alignment * 8 + resource offset = new resource offset
LDMIA R0!, {R6, R7, R9, R10} @ load and write instructions
STMIA R1, {R6, R7}
ADD R1, R1, #0xC
STMIA R1, {R9, R10}
ADD R1, R1, #0xC
LDMIA R0, {R6, R7, R9, R10}
STMIA R1, {R6, R7}
ADD R1, R1, #0xC
STMIA R1, {R9, R10}
LDMIA R3!, {R10} @ load 4 samples from ROM
C_fixed_mixing_loop:
LDMIA R5, {R0, R1, R7, R9} @ load 4 samples from hq buffer
fixed_mixing_instructions:
.irp REG, R0, R1, R7, R9
NOP
NOP
MLANE \REG, R11, R6, \REG @ add new sample if neccessary
.endr
STMIA R5!, {R0, R1, R7, R9} @ write samples to the mixing buffer
SUBS LR, LR, #1
BNE C_fixed_mixing_loop
SUB R3, R3, #4 @ we'll need to load this block again, so rewind a bit
C_fixed_mixing_process_rest:
MOV R1, #4 @ repeat the loop #4 times to completely get rid of alignment errors
C_fixed_mixing_unaligned_loop:
LDR R0, [R5]
LDRSB R6, [R3], #1
MLA R0, R11, R6, R0
STR R0, [R5], #4
SUBS R2, R2, #1
BEQ C_fixed_mixing_loop_or_end
C_fixed_mixing_loop_continue:
SUBS R1, R1, #1
BGT C_fixed_mixing_unaligned_loop
SUBS R8, R8, #4
BGT C_fixed_mixing_length_check @ repeat the mixing procedure until the buffer is filled
POP {R4, R9}
C_mixing_end_store:
STR R2, [R4, #CHN_SAMPLE_COUNTDOWN]
STR R3, [R4, #CHN_POSITION_ABS]
C_mixing_epilogue:
/* Switch to Thumb */
ADR R0, (C_end_channel_state_loop+1)
BX R0
.thumb
.thumb_func
C_end_channel_state_loop:
LDR R0, [SP, #ARG_REMAIN_CHN]
SUBS R0, #1
BLE C_main_mixer_return
ADDS R4, #0x40
B C_channel_state_loop
C_main_mixer_return:
LDR R3, [SP, #ARG_PCM_STRUCT]
LDRB R4, [R3, #VAR_EXT_NOISE_SHAPE_LEFT]
LSLS R4, R4, #16
LDRB R5, [R3, #VAR_EXT_NOISE_SHAPE_RIGHT]
LSLS R5, R5, #16
.if ENABLE_REVERB==1
LDRB R2, [R3, #VAR_REVERB]
LSRS R2, R2, #2
LDR R1, [SP, #ARG_BUFFER_POS_INDEX_HINT]
CMP R1, #2
.else
MOVS R2, #0
MOVS R3, #0
.endif
/* Switch to ARM */
ADR R0, C_downsampler
BX R0
.arm
.align 2
C_downsampler:
LDR R8, [SP, #ARG_FRAME_LENGTH]
LDR R9, [SP, #ARG_BUFFER_POS]
.if ENABLE_REVERB==1
ORR R2, R2, R2, LSL#16
MOVNE R3, R8
ADDEQ R3, R3, #VAR_PCM_BUFFER
SUBEQ R3, R3, R9
.endif
LDR R10, hq_buffer_literal
MOV R11, #0xFF00
MOV LR, #0xC0000000
C_downsampler_loop:
LDMIA R10, {R0, R1}
ADD R12, R4, R0 @ left sample #1
ADDS R4, R12, R12
EORVS R12, LR, R4, ASR#31
AND R4, R12, #0x007F0000
AND R6, R11, R12, LSR#15
ADD R12, R5, R0, LSL#16 @ right sample #1
ADDS R5, R12, R12
EORVS R12, LR, R5, ASR#31
AND R5, R12, #0x007F0000
AND R7, R11, R12, LSR#15
ADD R12, R4, R1 @ left sample #2
ADDS R4, R12, R12
EORVS R12, LR, R4, ASR#31
AND R4, R12, #0x007F0000
AND R12, R11, R12, LSR#15
ORR R6, R12, R6, LSR#8
ADD R12, R5, R1, LSL#16 @ right sample #2
ADDS R5, R12, R12