Replaced snprintf and vnsprintf calls by dpsnprintf and dpvsnprintf calls, to ensure...
[xonotic/darkplaces.git] / snd_mem.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20
21
22 #include "quakedef.h"
23
24 #include "snd_main.h"
25 #include "snd_ogg.h"
26 #include "snd_wav.h"
27
28
29 /*
30 ================
31 ResampleSfx
32 ================
33 */
34 size_t ResampleSfx (const qbyte *in_data, size_t in_length, const snd_format_t* in_format, qbyte *out_data, const char* sfxname)
35 {
36         size_t srclength, outcount, i;
37
38         srclength = in_length * in_format->channels;
39         outcount = (double)in_length * shm->format.speed / in_format->speed;
40
41         //Con_DPrintf("ResampleSfx(%s): %d samples @ %dHz -> %d samples @ %dHz\n",
42         //                      sfxname, in_length, in_format->speed, outcount, shm->format.speed);
43
44         // Trivial case (direct transfer)
45         if (in_format->speed == shm->format.speed)
46         {
47                 if (in_format->width == 1)
48                 {
49                         for (i = 0; i < srclength; i++)
50                                 ((signed char*)out_data)[i] = in_data[i] - 128;
51                 }
52                 else  // if (in_format->width == 2)
53                         memcpy (out_data, in_data, srclength * in_format->width);
54         }
55
56         // General case (linear interpolation with a fixed-point fractional
57         // step, 18-bit integer part and 14-bit fractional part)
58         // Can handle up to 2^18 (262144) samples per second (> 96KHz stereo)
59         #define FRACTIONAL_BITS 14
60         #define FRACTIONAL_MASK ((1 << FRACTIONAL_BITS) - 1)
61         #define INTEGER_BITS (sizeof(samplefrac)*8 - FRACTIONAL_BITS)
62         else
63         {
64                 const unsigned int fracstep = (double)in_format->speed / shm->format.speed * (1 << FRACTIONAL_BITS);
65                 size_t remain_in = srclength, total_out = 0;
66                 unsigned int samplefrac;
67                 const qbyte *in_ptr = in_data;
68                 qbyte *out_ptr = out_data;
69
70                 // Check that we can handle one second of that sound
71                 if (in_format->speed * in_format->channels > (1 << INTEGER_BITS))
72                         Sys_Error ("ResampleSfx: sound quality too high for resampling (%uHz, %u channel(s))",
73                                            in_format->speed, in_format->channels);
74
75                 // We work 1 sec at a time to make sure we don't accumulate any
76                 // significant error when adding "fracstep" over several seconds, and
77                 // also to be able to handle very long sounds.
78                 while (total_out < outcount)
79                 {
80                         size_t tmpcount;
81
82                         samplefrac = 0;
83
84                         // If more than 1 sec of sound remains to be converted
85                         if (outcount - total_out > shm->format.speed)
86                                 tmpcount = shm->format.speed;
87                         else
88                                 tmpcount = outcount - total_out;
89
90                         // Convert up to 1 sec of sound
91                         for (i = 0; i < tmpcount; i++)
92                         {
93                                 unsigned int j = 0;
94                                 unsigned int srcsample = (samplefrac >> FRACTIONAL_BITS) * in_format->channels;
95                                 int a, b;
96
97                                 // 16 bit samples
98                                 if (in_format->width == 2)
99                                 {
100                                         for (j = 0; j < in_format->channels; j++, srcsample++)
101                                         {
102                                                 // No value to interpolate with?
103                                                 if (srcsample + in_format->channels < remain_in)
104                                                 {
105                                                         a = ((const short*)in_ptr)[srcsample];
106                                                         b = ((const short*)in_ptr)[srcsample + in_format->channels];
107                                                         *((short*)out_ptr) = (((b - a) * (samplefrac & FRACTIONAL_MASK)) >> FRACTIONAL_BITS) + a;
108                                                 }
109                                                 else
110                                                         *((short*)out_ptr) = ((const short*)in_ptr)[srcsample];
111
112                                                 out_ptr += sizeof (short);
113                                         }
114                                 }
115                                 // 8 bit samples
116                                 else  // if (in_format->width == 1)
117                                 {
118                                         for (j = 0; j < in_format->channels; j++, srcsample++)
119                                         {
120                                                 // No more value to interpolate with?
121                                                 if (srcsample + in_format->channels < remain_in)
122                                                 {
123                                                         a = ((const qbyte*)in_ptr)[srcsample] - 128;
124                                                         b = ((const qbyte*)in_ptr)[srcsample + in_format->channels] - 128;
125                                                         *((signed char*)out_ptr) = (((b - a) * (samplefrac & FRACTIONAL_MASK)) >> FRACTIONAL_BITS) + a;
126                                                 }
127                                                 else
128                                                         *((signed char*)out_ptr) = ((const qbyte*)in_ptr)[srcsample] - 128;
129
130                                                 out_ptr += sizeof (signed char);
131                                         }
132                                 }
133
134                                 samplefrac += fracstep;
135                         }
136
137                         // Update the counters and the buffer position
138                         remain_in -= in_format->speed * in_format->channels;
139                         in_ptr += in_format->speed * in_format->channels * in_format->width;
140                         total_out += tmpcount;
141                 }
142         }
143
144         return outcount;
145 }
146
147 //=============================================================================
148
149 /*
150 ==============
151 S_LoadSound
152 ==============
153 */
154 qboolean S_LoadSound (sfx_t *s, qboolean complain)
155 {
156         char namebuffer[MAX_QPATH + 16];
157         size_t len;
158
159         if (!shm || !shm->format.speed)
160                 return false;
161
162         // If we weren't able to load it previously, no need to retry
163         if (s->flags & SFXFLAG_FILEMISSING)
164                 return false;
165
166         // See if in memory
167         if (s->fetcher != NULL)
168         {
169                 if (s->format.speed != shm->format.speed)
170                         Sys_Error ("S_LoadSound: sound %s hasn't been resampled (%uHz instead of %uHz)", s->name);
171                 return true;
172         }
173
174         // LordHavoc: if the sound filename does not begin with sound/, try adding it
175         if (strncasecmp(s->name, "sound/", 6))
176         {
177                 len = dpsnprintf (namebuffer, sizeof(namebuffer), "sound/%s", s->name);
178                 if (len < 0)
179                 {
180                         // name too long
181                         Con_Printf("S_LoadSound: name \"%s\" is too long\n", s->name);
182                         return false;
183                 }
184                 if (S_LoadWavFile (namebuffer, s))
185                         return true;
186                 if (len >= 4 && !strcasecmp (namebuffer + len - 4, ".wav"))
187                         strcpy (namebuffer + len - 3, "ogg");
188                 if (OGG_LoadVorbisFile (namebuffer, s))
189                         return true;
190         }
191
192         // LordHavoc: then try without the added sound/ as wav and ogg
193         len = dpsnprintf (namebuffer, sizeof(namebuffer), "%s", s->name);
194         if (len < 0)
195         {
196                 // name too long
197                 Con_Printf("S_LoadSound: name \"%s\" is too long\n", s->name);
198                 return false;
199         }
200         if (S_LoadWavFile (namebuffer, s))
201                 return true;
202         if (len >= 4 && !strcasecmp (namebuffer + len - 4, ".wav"))
203                 strcpy (namebuffer + len - 3, "ogg");
204         if (OGG_LoadVorbisFile (namebuffer, s))
205                 return true;
206
207         // Can't load the sound!
208         s->flags |= SFXFLAG_FILEMISSING;
209         if (complain)
210                 Con_Printf("S_LoadSound: Couldn't load \"%s\"\n", s->name);
211         return false;
212 }
213
214 void S_UnloadSound (sfx_t *s)
215 {
216         if (s->fetcher != NULL)
217         {
218                 unsigned int i;
219
220                 // Stop all channels that use this sound
221                 for (i = 0; i < total_channels ; i++)
222                         if (channels[i].sfx == s)
223                                 S_StopChannel (i);
224
225                 s->fetcher = NULL;
226                 s->fetcher_data = NULL;
227                 Mem_FreePool(&s->mempool);
228         }
229 }