-
Notifications
You must be signed in to change notification settings - Fork 44
/
Copy pathsnd_main.c
2249 lines (1947 loc) · 75 KB
/
snd_main.c
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
/*
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
// snd_main.c -- main control for any streaming sound output device
#include "quakedef.h"
#include "snd_main.h"
#include "snd_ogg.h"
#ifdef USEXMP
#include "snd_xmp.h"
#endif
#include "csprogs.h"
#include "cl_collision.h"
#include "cdaudio.h"
#define SND_MIN_SPEED 8000
#define SND_MAX_SPEED 192000
#define SND_MIN_WIDTH 1
#define SND_MAX_WIDTH 2
#define SND_MIN_CHANNELS 1
#define SND_MAX_CHANNELS 8
#if SND_LISTENERS != 8
# error this data only supports up to 8 channel, update it!
#endif
speakerlayout_t snd_speakerlayout;
// Our speaker layouts are based on ALSA. They differ from those
// Win32 and Mac OS X APIs use when there's more than 4 channels.
// (rear left + rear right, and front center + LFE are swapped).
#define SND_SPEAKERLAYOUTS (sizeof(snd_speakerlayouts) / sizeof(snd_speakerlayouts[0]))
static const speakerlayout_t snd_speakerlayouts[] =
{
{
"surround71", 8,
{
{0, 45, 0.2f, 0.2f, 0.5f}, // front left
{1, 315, 0.2f, 0.2f, 0.5f}, // front right
{2, 135, 0.2f, 0.2f, 0.5f}, // rear left
{3, 225, 0.2f, 0.2f, 0.5f}, // rear right
{4, 0, 0.2f, 0.2f, 0.5f}, // front center
{5, 0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so... no lfe)
{6, 90, 0.2f, 0.2f, 0.5f}, // side left
{7, 180, 0.2f, 0.2f, 0.5f}, // side right
}
},
{
"surround51", 6,
{
{0, 45, 0.2f, 0.2f, 0.5f}, // front left
{1, 315, 0.2f, 0.2f, 0.5f}, // front right
{2, 135, 0.2f, 0.2f, 0.5f}, // rear left
{3, 225, 0.2f, 0.2f, 0.5f}, // rear right
{4, 0, 0.2f, 0.2f, 0.5f}, // front center
{5, 0, 0, 0, 0}, // lfe (we don't have any good lfe sound sources and it would take some filtering work to generate them (and they'd probably still be wrong), so... no lfe)
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
}
},
{
// these systems sometimes have a subwoofer as well, but it has no
// channel of its own
"surround40", 4,
{
{0, 45, 0.3f, 0.3f, 0.8f}, // front left
{1, 315, 0.3f, 0.3f, 0.8f}, // front right
{2, 135, 0.3f, 0.3f, 0.8f}, // rear left
{3, 225, 0.3f, 0.3f, 0.8f}, // rear right
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
}
},
{
// these systems sometimes have a subwoofer as well, but it has no
// channel of its own
"stereo", 2,
{
{0, 90, 0.5f, 0.5f, 1}, // side left
{1, 270, 0.5f, 0.5f, 1}, // side right
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
}
},
{
"mono", 1,
{
{0, 0, 0, 1, 1}, // center
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
}
}
};
// =======================================================================
// Internal sound data & structures
// =======================================================================
channel_t channels[MAX_CHANNELS];
unsigned int total_channels;
snd_ringbuffer_t *snd_renderbuffer = NULL;
static unsigned int soundtime = 0;
static unsigned int oldpaintedtime = 0;
static unsigned int extrasoundtime = 0;
static double snd_starttime = 0.0;
qbool snd_threaded = false;
qbool snd_usethreadedmixing = false;
vec3_t listener_origin;
matrix4x4_t listener_basematrix;
static unsigned char *listener_pvs = NULL;
static int listener_pvsbytes = 0;
matrix4x4_t listener_matrix[SND_LISTENERS];
mempool_t *snd_mempool;
// Linked list of known sfx
static sfx_t *known_sfx = NULL;
qbool simsound = false;
#ifdef CONFIG_VIDEO_CAPTURE
static qbool recording_sound = false;
#endif
bool snd_blocked = false;
static bool current_swapstereo = false;
static int current_channellayout = SND_CHANNELLAYOUT_AUTO;
static int current_channellayout_used = SND_CHANNELLAYOUT_AUTO;
static float spatialpower, spatialmin, spatialdiff, spatialoffset, spatialfactor;
typedef enum { SPATIAL_NONE, SPATIAL_LOG, SPATIAL_POW, SPATIAL_THRESH } spatialmethod_t;
spatialmethod_t spatialmethod;
// Cvars declared in sound.h (part of the sound API)
cvar_t bgmvolume = {CF_CLIENT | CF_ARCHIVE, "bgmvolume", "1", "volume of background music (such as CD music or replacement files such as sound/cdtracks/track002.ogg)"};
cvar_t volume = {CF_CLIENT | CF_ARCHIVE, "volume", "0.7", "volume of sound effects"};
cvar_t snd_initialized = {CF_CLIENT | CF_READONLY, "snd_initialized", "0", "indicates the sound subsystem is active"};
// Cvars declared in snd_main.h (shared with other snd_*.c files)
cvar_t snd_channellayout = {CF_CLIENT, "snd_channellayout", "0", "channel layout. Can be 0 (auto - snd_restart needed), 1 (standard layout), or 2 (ALSA layout)"};
cvar_t snd_streaming = {CF_CLIENT | CF_ARCHIVE, "snd_streaming", "1", "enables keeping compressed ogg sound files compressed, decompressing them only as needed, otherwise they will be decompressed completely at load (may use a lot of memory); when set to 2, streaming is performed even if this would waste memory"};
cvar_t snd_streaming_length = {CF_CLIENT | CF_ARCHIVE, "snd_streaming_length", "1", "decompress sounds completely if they are less than this play time when snd_streaming is 1"};
cvar_t snd_waterfx = {CF_CLIENT | CF_ARCHIVE, "snd_waterfx", "1", "underwater sound filter strength"};
// Local cvars
cvar_t mastervolume = {CF_CLIENT | CF_ARCHIVE, "mastervolume", "0.7", "master volume"};
cvar_t snd_staticvolume = {CF_CLIENT | CF_ARCHIVE, "snd_staticvolume", "1", "volume of ambient sound effects (such as swampy sounds at the start of e1m2)"};
cvar_t snd_soundradius = {CF_CLIENT | CF_ARCHIVE, "snd_soundradius", "1200", "radius of weapon sounds and other standard sound effects (monster idle noises are half this radius and flickering light noises are one third of this radius)"};
cvar_t snd_attenuation_exponent = {CF_CLIENT | CF_ARCHIVE, "snd_attenuation_exponent", "1", "Exponent of (1-radius) in sound attenuation formula"};
cvar_t snd_attenuation_decibel = {CF_CLIENT | CF_ARCHIVE, "snd_attenuation_decibel", "0", "Decibel sound attenuation per sound radius distance"};
cvar_t snd_spatialization_min_radius = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min_radius", "10000", "use minimum spatialization above to this radius"};
cvar_t snd_spatialization_max_radius = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max_radius", "100", "use maximum spatialization below this radius"};
cvar_t snd_spatialization_min = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_min", "0.70", "minimum spatializazion of sounds"};
cvar_t snd_spatialization_max = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_max", "0.95", "maximum spatialization of sounds"};
cvar_t snd_spatialization_power = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_power", "0", "exponent of the spatialization falloff curve (0: logarithmic)"};
cvar_t snd_spatialization_control = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_control", "0", "enable spatialization control (headphone friendly mode)"};
cvar_t snd_spatialization_prologic = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic", "0", "use dolby prologic (I, II or IIx) encoding (snd_channels must be 2)"};
cvar_t snd_spatialization_prologic_frontangle = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_prologic_frontangle", "30", "the angle between the front speakers and the center speaker"};
cvar_t snd_spatialization_occlusion = {CF_CLIENT | CF_ARCHIVE, "snd_spatialization_occlusion", "1", "enable occlusion testing on spatialized sounds, which simply quiets sounds that are blocked by the world; 1 enables PVS method, 2 enables LineOfSight method, 3 enables both"};
cvar_t _snd_mixahead = {CF_CLIENT | CF_ARCHIVE, "_snd_mixahead", "0.15", "how much sound to mix ahead of time"};
cvar_t snd_swapstereo = {CF_CLIENT | CF_ARCHIVE, "snd_swapstereo", "0", "swaps left/right speakers for old ISA soundblaster cards"};
cvar_t snd_maxchannelvolume = {CF_CLIENT | CF_ARCHIVE, "snd_maxchannelvolume", "10", "maximum volume of a single sound"};
cvar_t snd_mutewhenidle = {CF_CLIENT | CF_ARCHIVE, "snd_mutewhenidle", "1", "1 disables sound output when game window is inactive, 2 disables it only when the window is minimised"};
cvar_t snd_softclip = {CF_CLIENT | CF_ARCHIVE, "snd_softclip", "0", "Use soft-clipping. Soft-clipping can make the sound more smooth if very high volume levels are used. Enable this option if the dynamic range of the loudspeakers is very low. WARNING: This feature creates distortion and should be considered a last resort."};
//cvar_t snd_softclip = {CF_CLIENT | CF_ARCHIVE, "snd_softclip", "0", "Use soft-clipping (when set to 2, use it even if output is floating point). Soft-clipping can make the sound more smooth if very high volume levels are used. Enable this option if the dynamic range of the loudspeakers is very low. WARNING: This feature creates distortion and should be considered a last resort."};
cvar_t snd_entchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel1volume", "1", "volume multiplier of the 1st entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel2volume", "1", "volume multiplier of the 2nd entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel3volume", "1", "volume multiplier of the 3rd entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel4volume", "1", "volume multiplier of the 4th entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel5volume", "1", "volume multiplier of the 5th entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel6volume", "1", "volume multiplier of the 6th entity channel of regular entities (DEPRECATED)"};
cvar_t snd_entchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_entchannel7volume", "1", "volume multiplier of the 7th entity channel of regular entities (DEPRECATED)"};
cvar_t snd_playerchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel1volume", "1", "volume multiplier of the 1st entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel2volume", "1", "volume multiplier of the 2nd entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel3volume", "1", "volume multiplier of the 3rd entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel4volume", "1", "volume multiplier of the 4th entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel5volume", "1", "volume multiplier of the 5th entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel6volume", "1", "volume multiplier of the 6th entity channel of player entities (DEPRECATED)"};
cvar_t snd_playerchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_playerchannel7volume", "1", "volume multiplier of the 7th entity channel of player entities (DEPRECATED)"};
cvar_t snd_worldchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel0volume", "1", "volume multiplier of the auto-allocate entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel1volume", "1", "volume multiplier of the 1st entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel2volume", "1", "volume multiplier of the 2nd entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel3volume", "1", "volume multiplier of the 3rd entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel4volume", "1", "volume multiplier of the 4th entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel5volume", "1", "volume multiplier of the 5th entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel6volume", "1", "volume multiplier of the 6th entity channel of the world entity (DEPRECATED)"};
cvar_t snd_worldchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_worldchannel7volume", "1", "volume multiplier of the 7th entity channel of the world entity (DEPRECATED)"};
cvar_t snd_csqcchannel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel0volume", "1", "volume multiplier of the auto-allocate entity channel CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel1volume", "1", "volume multiplier of the 1st entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel2volume", "1", "volume multiplier of the 2nd entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel3volume", "1", "volume multiplier of the 3rd entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel4volume", "1", "volume multiplier of the 4th entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel5volume", "1", "volume multiplier of the 5th entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel6volume", "1", "volume multiplier of the 6th entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_csqcchannel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_csqcchannel7volume", "1", "volume multiplier of the 7th entity channel of CSQC entities (DEPRECATED)"};
cvar_t snd_channel0volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel0volume", "1", "volume multiplier of the auto-allocate entity channel"};
cvar_t snd_channel1volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel1volume", "1", "volume multiplier of the 1st entity channel"};
cvar_t snd_channel2volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel2volume", "1", "volume multiplier of the 2nd entity channel"};
cvar_t snd_channel3volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel3volume", "1", "volume multiplier of the 3rd entity channel"};
cvar_t snd_channel4volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel4volume", "1", "volume multiplier of the 4th entity channel"};
cvar_t snd_channel5volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel5volume", "1", "volume multiplier of the 5th entity channel"};
cvar_t snd_channel6volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel6volume", "1", "volume multiplier of the 6th entity channel"};
cvar_t snd_channel7volume = {CF_CLIENT | CF_ARCHIVE, "snd_channel7volume", "1", "volume multiplier of the 7th entity channel"};
static cvar_t nosound = {CF_CLIENT, "nosound", "0", "disables sound"};
static cvar_t snd_precache = {CF_CLIENT, "snd_precache", "1", "loads sounds before they are used"};
static cvar_t ambient_level = {CF_CLIENT, "ambient_level", "0.3", "volume of environment noises (water and wind)"};
static cvar_t ambient_fade = {CF_CLIENT, "ambient_fade", "100", "rate of volume fading when moving from one environment to another"};
static cvar_t snd_show = {CF_CLIENT, "snd_show", "0", "shows some statistics about sound mixing"};
// Default sound format is 48KHz, 32bit float, stereo
// (48KHz because a lot of onboard sound cards sucks at any other speed)
static cvar_t snd_speed = {CF_CLIENT | CF_ARCHIVE, "snd_speed", "48000", "sound output frequency, in hertz"};
static cvar_t snd_width = {CF_CLIENT | CF_ARCHIVE, "snd_width", "4", "sound output precision, in bytes - 1 = 8bit, 2 = 16bit, 4 = 32bit float"};
static cvar_t snd_channels = {CF_CLIENT | CF_ARCHIVE, "snd_channels", "2", "number of channels for the sound output (2 for stereo; up to 8 supported for 3D sound)"};
cvar_t snd_bufferlength = {CF_CLIENT | CF_ARCHIVE, "snd_bufferlength", "20", "Desired length of the SDL2 audio buffer in milliseconds, smaller values reduce latency but can lead to underflow if the system is heavily loaded. Affects only how many sample frames are requested (which will be a power of 2 between 512 and 8192 inclusive)"};
static cvar_t snd_startloopingsounds = {CF_CLIENT, "snd_startloopingsounds", "1", "whether to start sounds that would loop (you want this to be 1); existing sounds are not affected"};
static cvar_t snd_startnonloopingsounds = {CF_CLIENT, "snd_startnonloopingsounds", "1", "whether to start sounds that would not loop (you want this to be 1); existing sounds are not affected"};
// randomization
static cvar_t snd_identicalsoundrandomization_time = {CF_CLIENT, "snd_identicalsoundrandomization_time", "0.1", "how much seconds to randomly skip (positive) or delay (negative) sounds when multiple identical sounds are started on the same frame"};
static cvar_t snd_identicalsoundrandomization_tics = {CF_CLIENT, "snd_identicalsoundrandomization_tics", "0", "if nonzero, how many tics to limit sound randomization as defined by snd_identicalsoundrandomization_time"};
// Ambient sounds
static sfx_t* ambient_sfxs [2] = { NULL, NULL };
static const char* ambient_names [2] = { "sound/ambience/water1.wav", "sound/ambience/wind2.wav" };
extern cvar_t v_flipped;
// ====================================================================
// Functions
// ====================================================================
void S_FreeSfx (sfx_t *sfx, qbool force);
static void S_Play_Common (cmd_state_t *cmd, float fvol, float attenuation)
{
int i, ch_ind;
char name [MAX_QPATH];
sfx_t *sfx;
i = 1;
while (i < Cmd_Argc (cmd))
{
// Get the name, and appends ".wav" as an extension if there's none
dp_strlcpy (name, Cmd_Argv(cmd, i), sizeof (name));
if (!strrchr (name, '.'))
dp_strlcat (name, ".wav", sizeof (name));
i++;
// If we need to get the volume from the command line
if (fvol == -1.0f)
{
fvol = atof (Cmd_Argv(cmd, i));
i++;
}
sfx = S_PrecacheSound (name, true, true);
if (sfx)
{
ch_ind = S_StartSound (-1, 0, sfx, listener_origin, fvol, attenuation);
// Free the sfx if the file didn't exist
if (!sfx->fetcher)
S_FreeSfx (sfx, false);
else
channels[ch_ind].flags |= CHANNELFLAG_LOCALSOUND;
}
}
}
static void S_Play_f(cmd_state_t *cmd)
{
S_Play_Common(cmd, 1.0f, 1.0f);
}
static void S_Play2_f(cmd_state_t *cmd)
{
S_Play_Common(cmd, 1.0f, 0.0f);
}
static void S_PlayVol_f(cmd_state_t *cmd)
{
S_Play_Common(cmd, -1.0f, 0.0f);
}
static void S_SoundList_f(cmd_state_t *cmd)
{
unsigned int i;
sfx_t *sfx;
unsigned int total;
total = 0;
for (sfx = known_sfx, i = 0; sfx != NULL; sfx = sfx->next, i++)
{
if (sfx->fetcher != NULL)
{
unsigned int size;
size = (unsigned int)sfx->memsize;
Con_Printf ("%c%c%c(%5iHz %2db %6s) %8i : %s\n",
(sfx->loopstart < sfx->total_length) ? 'L' : ' ',
(sfx->flags & SFXFLAG_STREAMED) ? 'S' : ' ',
(sfx->flags & SFXFLAG_MENUSOUND) ? 'P' : ' ',
sfx->format.speed,
sfx->format.width * 8,
(sfx->format.channels == 1) ? "mono" : "stereo",
size,
sfx->name);
total += size;
}
else
Con_Printf (" ( unknown ) unloaded : %s\n", sfx->name);
}
Con_Printf("Total resident: %i\n", total);
}
static void S_SoundInfo_f(cmd_state_t *cmd)
{
if (snd_renderbuffer == NULL)
{
Con_Print("sound system not started\n");
return;
}
Con_Printf("%5d speakers\n", snd_renderbuffer->format.channels);
Con_Printf("%5d frames\n", snd_renderbuffer->maxframes);
Con_Printf("%5d samplebits\n", snd_renderbuffer->format.width * 8);
Con_Printf("%5d speed\n", snd_renderbuffer->format.speed);
Con_Printf("%5u total_channels\n", total_channels);
}
static void S_PauseSound_f(cmd_state_t *cmd)
{
if( Cmd_Argc(cmd) != 2 ) {
Con_Print("pausesound <pause>\n");
return;
}
S_PauseGameSounds(atoi( Cmd_Argv(cmd, 1 ) ) != 0);
}
int S_GetSoundRate(void)
{
return snd_renderbuffer ? snd_renderbuffer->format.speed : 0;
}
int S_GetSoundChannels(void)
{
return snd_renderbuffer ? snd_renderbuffer->format.channels : 0;
}
int S_GetSoundWidth(void)
{
return snd_renderbuffer ? snd_renderbuffer->format.width : 0;
}
#define SWAP_LISTENERS(l1, l2, tmpl) { tmpl = (l1); (l1) = (l2); (l2) = tmpl; }
static void S_SetChannelLayout (void)
{
unsigned int i;
listener_t swaplistener;
listener_t *listeners;
int layout;
for (i = 0; i < SND_SPEAKERLAYOUTS; i++)
if (snd_speakerlayouts[i].channels == snd_renderbuffer->format.channels)
break;
if (i >= SND_SPEAKERLAYOUTS)
{
Con_Printf("S_SetChannelLayout: can't find the speaker layout for %hu channels. Defaulting to mono output\n",
snd_renderbuffer->format.channels);
i = SND_SPEAKERLAYOUTS - 1;
}
snd_speakerlayout = snd_speakerlayouts[i];
listeners = snd_speakerlayout.listeners;
// Swap the left and right channels if snd_swapstereo is set
if (boolxor(snd_swapstereo.integer, v_flipped.integer))
{
switch (snd_speakerlayout.channels)
{
case 8:
SWAP_LISTENERS(listeners[6], listeners[7], swaplistener);
// no break
case 4:
case 6:
SWAP_LISTENERS(listeners[2], listeners[3], swaplistener);
// no break
case 2:
SWAP_LISTENERS(listeners[0], listeners[1], swaplistener);
break;
default:
case 1:
// Nothing to do
break;
}
}
// Sanity check
if (snd_channellayout.integer < SND_CHANNELLAYOUT_AUTO ||
snd_channellayout.integer > SND_CHANNELLAYOUT_ALSA)
Cvar_SetValueQuick (&snd_channellayout, SND_CHANNELLAYOUT_STANDARD);
if (snd_channellayout.integer == SND_CHANNELLAYOUT_AUTO)
{
// If we're in the sound engine initialization
if (current_channellayout_used == SND_CHANNELLAYOUT_AUTO)
{
layout = SND_CHANNELLAYOUT_STANDARD;
Cvar_SetValueQuick (&snd_channellayout, layout);
}
else
layout = current_channellayout_used;
}
else
layout = snd_channellayout.integer;
// Convert our layout (= ALSA) to the standard layout if necessary
if (snd_speakerlayout.channels == 6 || snd_speakerlayout.channels == 8)
{
if (layout == SND_CHANNELLAYOUT_STANDARD)
{
SWAP_LISTENERS(listeners[2], listeners[4], swaplistener);
SWAP_LISTENERS(listeners[3], listeners[5], swaplistener);
}
Con_Printf("S_SetChannelLayout: using %s speaker layout for 3D sound\n",
(layout == SND_CHANNELLAYOUT_ALSA) ? "ALSA" : "standard");
}
current_swapstereo = boolxor(snd_swapstereo.integer, v_flipped.integer);
current_channellayout = snd_channellayout.integer;
current_channellayout_used = layout;
}
void S_Startup (void)
{
snd_format_t chosen_fmt;
static snd_format_t prev_render_format = {0, 0, 0};
char* env;
#if _MSC_VER >= 1400
size_t envlen;
#endif
int i;
if (!snd_initialized.integer)
return;
// Get the starting sound format from the cvars
chosen_fmt.speed = snd_speed.integer;
chosen_fmt.width = snd_width.integer;
chosen_fmt.channels = snd_channels.integer;
// Check the environment variables to see if the player wants a particular sound format
#if _MSC_VER >= 1400
_dupenv_s(&env, &envlen, "QUAKE_SOUND_CHANNELS");
#else
env = getenv("QUAKE_SOUND_CHANNELS");
#endif
if (env != NULL)
{
chosen_fmt.channels = atoi (env);
#if _MSC_VER >= 1400
free(env);
#endif
}
#if _MSC_VER >= 1400
_dupenv_s(&env, &envlen, "QUAKE_SOUND_SPEED");
#else
env = getenv("QUAKE_SOUND_SPEED");
#endif
if (env != NULL)
{
chosen_fmt.speed = atoi (env);
#if _MSC_VER >= 1400
free(env);
#endif
}
#if _MSC_VER >= 1400
_dupenv_s(&env, &envlen, "QUAKE_SOUND_SAMPLEBITS");
#else
env = getenv("QUAKE_SOUND_SAMPLEBITS");
#endif
if (env != NULL)
{
chosen_fmt.width = atoi (env) / 8;
#if _MSC_VER >= 1400
free(env);
#endif
}
// Parse the command line to see if the player wants a particular sound format
// COMMANDLINEOPTION: Sound: -sndquad sets sound output to 4 channel surround
if (Sys_CheckParm ("-sndquad") != 0)
{
chosen_fmt.channels = 4;
}
// COMMANDLINEOPTION: Sound: -sndstereo sets sound output to stereo
else if (Sys_CheckParm ("-sndstereo") != 0)
{
chosen_fmt.channels = 2;
}
// COMMANDLINEOPTION: Sound: -sndmono sets sound output to mono
else if (Sys_CheckParm ("-sndmono") != 0)
{
chosen_fmt.channels = 1;
}
// COMMANDLINEOPTION: Sound: -sndspeed <hz> chooses sound output rate (supported values are 48000, 44100, 32000, 24000, 22050, 16000, 11025 (quake), 8000)
i = Sys_CheckParm ("-sndspeed");
if (0 < i && i < sys.argc - 1)
{
chosen_fmt.speed = atoi (sys.argv[i + 1]);
}
// COMMANDLINEOPTION: Sound: -sndbits <bits> chooses 8 bit or 16 bit or 32bit float sound output
i = Sys_CheckParm ("-sndbits");
if (0 < i && i < sys.argc - 1)
{
chosen_fmt.width = atoi (sys.argv[i + 1]) / 8;
}
#if 0
// LadyHavoc: now you can with the resampler...
// You can't change sound speed after start time (not yet supported)
if (prev_render_format.speed != 0)
{
if (chosen_fmt.speed != prev_render_format.speed)
{
Con_Printf("S_Startup: sound speed has changed! This is NOT supported yet. Falling back to previous speed (%u Hz)\n",
prev_render_format.speed);
chosen_fmt.speed = prev_render_format.speed;
}
}
#endif
// Sanity checks
if (chosen_fmt.speed < SND_MIN_SPEED)
{
chosen_fmt.speed = SND_MIN_SPEED;
}
else if (chosen_fmt.speed > SND_MAX_SPEED)
{
chosen_fmt.speed = SND_MAX_SPEED;
}
if (chosen_fmt.width < SND_MIN_WIDTH)
{
chosen_fmt.width = SND_MIN_WIDTH;
}
else if (chosen_fmt.width == 3)
{
chosen_fmt.width = 4;
}
else if (chosen_fmt.width > SND_MAX_WIDTH)
{
chosen_fmt.width = SND_MAX_WIDTH;
}
if (chosen_fmt.channels < SND_MIN_CHANNELS)
{
chosen_fmt.channels = SND_MIN_CHANNELS;
}
else if (chosen_fmt.channels > SND_MAX_CHANNELS)
{
chosen_fmt.channels = SND_MAX_CHANNELS;
}
// create the sound buffer used for sumitting the samples to the plaform-dependent module
if (!simsound)
{
Con_Printf("S_Startup: initializing sound output format: %dHz, %d bit, %d channels...\n",
chosen_fmt.speed,
chosen_fmt.width,
chosen_fmt.channels);
if (!SndSys_Init(&chosen_fmt))
{
Con_Print("S_Startup: SndSys_Init failed.\n");
return;
}
}
else
{
snd_renderbuffer = Snd_CreateRingBuffer(&chosen_fmt, 0, NULL);
Con_Print ("S_Startup: simulating sound output\n");
}
memcpy(&prev_render_format, &snd_renderbuffer->format, sizeof(prev_render_format));
Con_Printf("Sound format: %dHz, %d channels, %d bits per sample\n",
chosen_fmt.speed, chosen_fmt.channels, chosen_fmt.width * 8);
// Update the cvars
if (snd_speed.integer != (int)chosen_fmt.speed)
Cvar_SetValueQuick(&snd_speed, chosen_fmt.speed);
if (snd_width.integer != chosen_fmt.width)
Cvar_SetValueQuick(&snd_width, chosen_fmt.width);
if (snd_channels.integer != chosen_fmt.channels)
Cvar_SetValueQuick(&snd_channels, chosen_fmt.channels);
current_channellayout_used = SND_CHANNELLAYOUT_AUTO;
S_SetChannelLayout();
snd_starttime = host.realtime;
// If the sound module has already run, add an extra time to make sure
// the sound time doesn't decrease, to not confuse playing SFXs
if (oldpaintedtime != 0)
{
// The extra time must be a multiple of the render buffer size
// to avoid modifying the current position in the buffer,
// some modules write directly to a shared (DMA) buffer
extrasoundtime = oldpaintedtime + snd_renderbuffer->maxframes - 1;
extrasoundtime -= extrasoundtime % snd_renderbuffer->maxframes;
Con_Printf("S_Startup: extra sound time = %u\n", extrasoundtime);
soundtime = extrasoundtime;
}
else
extrasoundtime = 0;
snd_renderbuffer->startframe = soundtime;
snd_renderbuffer->endframe = soundtime;
#ifdef CONFIG_VIDEO_CAPTURE
recording_sound = false;
#endif
CDAudio_Startup();
}
void S_Shutdown(void)
{
if (snd_renderbuffer == NULL)
return;
CDAudio_Shutdown();
oldpaintedtime = snd_renderbuffer->endframe;
if (simsound)
{
Mem_Free(snd_renderbuffer->ring);
Mem_Free(snd_renderbuffer);
snd_renderbuffer = NULL;
}
else
SndSys_Shutdown();
}
static void S_Restart_f(cmd_state_t *cmd)
{
// NOTE: we can't free all sounds if we are running a map (this frees sfx_t that are still referenced by precaches)
// So, refuse to do this if we are connected.
if(cls.state == ca_connected)
{
Con_Printf("snd_restart would wreak havoc if you do that while connected!\n");
return;
}
S_Shutdown();
S_Startup();
}
/*
================
S_Init
================
*/
void S_Init(void)
{
Cvar_RegisterVariable(&volume);
Cvar_RegisterVariable(&bgmvolume);
Cvar_RegisterVariable(&mastervolume);
Cvar_RegisterVariable(&snd_staticvolume);
Cvar_RegisterVariable(&snd_entchannel0volume);
Cvar_RegisterVariable(&snd_entchannel1volume);
Cvar_RegisterVariable(&snd_entchannel2volume);
Cvar_RegisterVariable(&snd_entchannel3volume);
Cvar_RegisterVariable(&snd_entchannel4volume);
Cvar_RegisterVariable(&snd_entchannel5volume);
Cvar_RegisterVariable(&snd_entchannel6volume);
Cvar_RegisterVariable(&snd_entchannel7volume);
Cvar_RegisterVariable(&snd_worldchannel0volume);
Cvar_RegisterVariable(&snd_worldchannel1volume);
Cvar_RegisterVariable(&snd_worldchannel2volume);
Cvar_RegisterVariable(&snd_worldchannel3volume);
Cvar_RegisterVariable(&snd_worldchannel4volume);
Cvar_RegisterVariable(&snd_worldchannel5volume);
Cvar_RegisterVariable(&snd_worldchannel6volume);
Cvar_RegisterVariable(&snd_worldchannel7volume);
Cvar_RegisterVariable(&snd_playerchannel0volume);
Cvar_RegisterVariable(&snd_playerchannel1volume);
Cvar_RegisterVariable(&snd_playerchannel2volume);
Cvar_RegisterVariable(&snd_playerchannel3volume);
Cvar_RegisterVariable(&snd_playerchannel4volume);
Cvar_RegisterVariable(&snd_playerchannel5volume);
Cvar_RegisterVariable(&snd_playerchannel6volume);
Cvar_RegisterVariable(&snd_playerchannel7volume);
Cvar_RegisterVariable(&snd_csqcchannel0volume);
Cvar_RegisterVariable(&snd_csqcchannel1volume);
Cvar_RegisterVariable(&snd_csqcchannel2volume);
Cvar_RegisterVariable(&snd_csqcchannel3volume);
Cvar_RegisterVariable(&snd_csqcchannel4volume);
Cvar_RegisterVariable(&snd_csqcchannel5volume);
Cvar_RegisterVariable(&snd_csqcchannel6volume);
Cvar_RegisterVariable(&snd_csqcchannel7volume);
Cvar_RegisterVariable(&snd_channel0volume);
Cvar_RegisterVariable(&snd_channel1volume);
Cvar_RegisterVariable(&snd_channel2volume);
Cvar_RegisterVariable(&snd_channel3volume);
Cvar_RegisterVariable(&snd_channel4volume);
Cvar_RegisterVariable(&snd_channel5volume);
Cvar_RegisterVariable(&snd_channel6volume);
Cvar_RegisterVariable(&snd_channel7volume);
Cvar_RegisterVariable(&snd_attenuation_exponent);
Cvar_RegisterVariable(&snd_attenuation_decibel);
Cvar_RegisterVariable(&snd_spatialization_min_radius);
Cvar_RegisterVariable(&snd_spatialization_max_radius);
Cvar_RegisterVariable(&snd_spatialization_min);
Cvar_RegisterVariable(&snd_spatialization_max);
Cvar_RegisterVariable(&snd_spatialization_power);
Cvar_RegisterVariable(&snd_spatialization_control);
Cvar_RegisterVariable(&snd_spatialization_occlusion);
Cvar_RegisterVariable(&snd_spatialization_prologic);
Cvar_RegisterVariable(&snd_spatialization_prologic_frontangle);
Cvar_RegisterVariable(&snd_speed);
Cvar_RegisterVariable(&snd_width);
Cvar_RegisterVariable(&snd_channels);
Cvar_RegisterVariable(&snd_bufferlength);
Cvar_RegisterVariable(&snd_mutewhenidle);
Cvar_RegisterVariable(&snd_maxchannelvolume);
Cvar_RegisterVariable(&snd_softclip);
Cvar_RegisterVariable(&snd_startloopingsounds);
Cvar_RegisterVariable(&snd_startnonloopingsounds);
Cvar_RegisterVariable(&snd_identicalsoundrandomization_time);
Cvar_RegisterVariable(&snd_identicalsoundrandomization_tics);
// COMMANDLINEOPTION: Sound: -nosound disables sound (including CD audio)
if (Sys_CheckParm("-nosound"))
{
// dummy out Play and Play2 because mods stuffcmd that
Cmd_AddCommand(CF_CLIENT, "play", Cmd_NoOperation_f, "does nothing because -nosound was specified");
Cmd_AddCommand(CF_CLIENT, "play2", Cmd_NoOperation_f, "does nothing because -nosound was specified");
return;
}
snd_mempool = Mem_AllocPool("sound", 0, NULL);
// COMMANDLINEOPTION: Sound: -simsound runs sound mixing but with no output
if (Sys_CheckParm("-simsound"))
simsound = true;
Cmd_AddCommand(CF_CLIENT, "play", S_Play_f, "play a sound at your current location (not heard by anyone else)");
Cmd_AddCommand(CF_CLIENT, "play2", S_Play2_f, "play a sound globally throughout the level (not heard by anyone else)");
Cmd_AddCommand(CF_CLIENT, "playvol", S_PlayVol_f, "play a sound at the specified volume level at your current location (not heard by anyone else)");
Cmd_AddCommand(CF_CLIENT, "stopsound", S_StopAllSounds_f, "silence");
Cmd_AddCommand(CF_CLIENT, "pausesound", S_PauseSound_f, "temporary silence");
Cmd_AddCommand(CF_CLIENT, "soundlist", S_SoundList_f, "list loaded sounds");
Cmd_AddCommand(CF_CLIENT, "soundinfo", S_SoundInfo_f, "print sound system information (such as channels and speed)");
Cmd_AddCommand(CF_CLIENT, "snd_restart", S_Restart_f, "restart sound system");
Cmd_AddCommand(CF_CLIENT, "snd_unloadallsounds", S_UnloadAllSounds_f, "unload all sound files");
Cvar_RegisterVariable(&nosound);
Cvar_RegisterVariable(&snd_precache);
Cvar_RegisterVariable(&snd_initialized);
Cvar_RegisterVariable(&snd_streaming);
Cvar_RegisterVariable(&snd_streaming_length);
Cvar_RegisterVariable(&ambient_level);
Cvar_RegisterVariable(&ambient_fade);
Cvar_RegisterVariable(&snd_show);
Cvar_RegisterVariable(&snd_waterfx);
Cvar_RegisterVariable(&_snd_mixahead);
Cvar_RegisterVariable(&snd_swapstereo); // for people with backwards sound wiring
Cvar_RegisterVariable(&snd_channellayout);
Cvar_RegisterVariable(&snd_soundradius);
Cvar_SetValueQuick(&snd_initialized, true);
known_sfx = NULL;
total_channels = MAX_DYNAMIC_CHANNELS + NUM_AMBIENTS; // no statics
memset(channels, 0, MAX_CHANNELS * sizeof(channel_t));
OGG_OpenLibrary ();
#ifdef USEXMP
XMP_OpenLibrary ();
#endif
CDAudio_Init();
}
/*
================
S_Terminate
Shutdown and free all resources
================
*/
void S_Terminate (void)
{
S_Shutdown ();
#ifdef USEXMP
XMP_CloseLibrary ();
#endif
OGG_CloseLibrary ();
// Free all SFXs
while (known_sfx != NULL)
S_FreeSfx (known_sfx, true);
Cvar_SetValueQuick (&snd_initialized, false);
Mem_FreePool (&snd_mempool);
}
/*
==================
S_UnloadAllSounds_f
==================
*/
void S_UnloadAllSounds_f(cmd_state_t *cmd)
{
int i;
// NOTE: we can't free all sounds if we are running a map (this frees sfx_t that are still referenced by precaches)
// So, refuse to do this if we are connected.
if(cls.state == ca_connected)
{
Con_Printf("snd_unloadallsounds would wreak havoc if you do that while connected!\n");
return;
}
// stop any active sounds
S_StopAllSounds();
// because the ambient sounds will be freed, clear the pointers
for (i = 0;i < (int)sizeof (ambient_sfxs) / (int)sizeof (ambient_sfxs[0]);i++)
ambient_sfxs[i] = NULL;
// now free all sounds
while (known_sfx != NULL)
S_FreeSfx (known_sfx, true);
}
/*
==================
S_FindName
==================
*/
sfx_t changevolume_sfx = {""};
sfx_t *S_FindName (const char *name)
{
sfx_t *sfx;
if (!snd_initialized.integer)
return NULL;
if(!strcmp(name, changevolume_sfx.name))
return &changevolume_sfx;
if (strlen (name) >= sizeof (sfx->name))
{
Con_Printf ("S_FindName: sound name too long (%s)\n", name);
return NULL;
}
// Look for this sound in the list of known sfx
// TODO: hash table search?
for (sfx = known_sfx; sfx != NULL; sfx = sfx->next)
if(!strcmp (sfx->name, name))
return sfx;
// check for # in the beginning, try lookup by soundindex
if (name[0] == '#' && name[1])
{
int soundindex = atoi(name + 1);
if (soundindex > 0 && soundindex < MAX_SOUNDS)
if (cl.sound_precache[soundindex]->name[0])
return cl.sound_precache[soundindex];
}
// Add a sfx_t struct for this sound
sfx = (sfx_t *)Mem_Alloc (snd_mempool, sizeof (*sfx));
memset (sfx, 0, sizeof(*sfx));
dp_strlcpy (sfx->name, name, sizeof (sfx->name));
sfx->memsize = sizeof(*sfx);
sfx->next = known_sfx;
known_sfx = sfx;
return sfx;
}
/*
==================
S_FreeSfx
==================
*/
void S_FreeSfx (sfx_t *sfx, qbool force)
{
unsigned int i;
// Do not free a precached sound during purge
if (!force && (sfx->flags & (SFXFLAG_LEVELSOUND | SFXFLAG_MENUSOUND)))
return;
if (developer_loading.integer)
Con_Printf ("unloading sound %s\n", sfx->name);
// Remove it from the list of known sfx
if (sfx == known_sfx)
known_sfx = known_sfx->next;
else
{
sfx_t *prev_sfx;
for (prev_sfx = known_sfx; prev_sfx != NULL; prev_sfx = prev_sfx->next)
if (prev_sfx->next == sfx)
{
prev_sfx->next = sfx->next;
break;
}
if (prev_sfx == NULL)
{
Con_Printf ("S_FreeSfx: Can't find SFX %s in the list!\n", sfx->name);
return;
}
}
// Stop all channels using this sfx
for (i = 0; i < total_channels; i++)
{
if (channels[i].sfx == sfx)
{
Con_Printf("S_FreeSfx: stopping channel %i for sfx \"%s\"\n", i, sfx->name);
S_StopChannel (i, true, false);
}
}
// Free it
if (sfx->fetcher != NULL && sfx->fetcher->freesfx != NULL)
sfx->fetcher->freesfx(sfx);
Mem_Free (sfx);
}
/*
==================
S_ClearUsed
==================
*/
void S_ClearUsed (void)
{
sfx_t *sfx;
// sfx_t *sfxnext;
unsigned int i;