changed most Sys_Error calls to Con_Printf with appropriate error returns
[divverent/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                 {
73                         Con_Printf ("ResampleSfx: sound quality too high for resampling (%uHz, %u channel(s))",
74                                            in_format->speed, in_format->channels);
75                         return 0;
76                 }
77
78                 // We work 1 sec at a time to make sure we don't accumulate any
79                 // significant error when adding "fracstep" over several seconds, and
80                 // also to be able to handle very long sounds.
81                 while (total_out < outcount)
82                 {
83                         size_t tmpcount;
84
85                         samplefrac = 0;
86
87                         // If more than 1 sec of sound remains to be converted
88                         if (outcount - total_out > shm->format.speed)
89                                 tmpcount = shm->format.speed;
90                         else
91                                 tmpcount = outcount - total_out;
92
93                         // Convert up to 1 sec of sound
94                         for (i = 0; i < tmpcount; i++)
95                         {
96                                 unsigned int j = 0;
97                                 unsigned int srcsample = (samplefrac >> FRACTIONAL_BITS) * in_format->channels;
98                                 int a, b;
99
100                                 // 16 bit samples
101                                 if (in_format->width == 2)
102                                 {
103                                         for (j = 0; j < in_format->channels; j++, srcsample++)
104                                         {
105                                                 // No value to interpolate with?
106                                                 if (srcsample + in_format->channels < remain_in)
107                                                 {
108                                                         a = ((const short*)in_ptr)[srcsample];
109                                                         b = ((const short*)in_ptr)[srcsample + in_format->channels];
110                                                         *((short*)out_ptr) = (((b - a) * (samplefrac & FRACTIONAL_MASK)) >> FRACTIONAL_BITS) + a;
111                                                 }
112                                                 else
113                                                         *((short*)out_ptr) = ((const short*)in_ptr)[srcsample];
114
115                                                 out_ptr += sizeof (short);
116                                         }
117                                 }
118                                 // 8 bit samples
119                                 else  // if (in_format->width == 1)
120                                 {
121                                         for (j = 0; j < in_format->channels; j++, srcsample++)
122                                         {
123                                                 // No more value to interpolate with?
124                                                 if (srcsample + in_format->channels < remain_in)
125                                                 {
126                                                         a = ((const qbyte*)in_ptr)[srcsample] - 128;
127                                                         b = ((const qbyte*)in_ptr)[srcsample + in_format->channels] - 128;
128                                                         *((signed char*)out_ptr) = (((b - a) * (samplefrac & FRACTIONAL_MASK)) >> FRACTIONAL_BITS) + a;
129                                                 }
130                                                 else
131                                                         *((signed char*)out_ptr) = ((const qbyte*)in_ptr)[srcsample] - 128;
132
133                                                 out_ptr += sizeof (signed char);
134                                         }
135                                 }
136
137                                 samplefrac += fracstep;
138                         }
139
140                         // Update the counters and the buffer position
141                         remain_in -= in_format->speed * in_format->channels;
142                         in_ptr += in_format->speed * in_format->channels * in_format->width;
143                         total_out += tmpcount;
144                 }
145         }
146
147         return outcount;
148 }
149
150 //=============================================================================
151
152 /*
153 ==============
154 S_LoadSound
155 ==============
156 */
157 qboolean S_LoadSound (sfx_t *s, qboolean complain)
158 {
159         char namebuffer[MAX_QPATH + 16];
160         size_t len;
161
162         if (!shm || !shm->format.speed)
163                 return false;
164
165         // If we weren't able to load it previously, no need to retry
166         if (s->flags & SFXFLAG_FILEMISSING)
167                 return false;
168
169         // See if in memory
170         if (s->fetcher != NULL)
171         {
172                 if (s->format.speed != shm->format.speed)
173                         Con_Printf ("S_LoadSound: sound %s hasn't been resampled (%uHz instead of %uHz)", s->name);
174                 return true;
175         }
176
177         // LordHavoc: if the sound filename does not begin with sound/, try adding it
178         if (strncasecmp(s->name, "sound/", 6))
179         {
180                 len = dpsnprintf (namebuffer, sizeof(namebuffer), "sound/%s", s->name);
181                 if (len < 0)
182                 {
183                         // name too long
184                         Con_Printf("S_LoadSound: name \"%s\" is too long\n", s->name);
185                         return false;
186                 }
187                 if (S_LoadWavFile (namebuffer, s))
188                         return true;
189                 if (len >= 4 && !strcasecmp (namebuffer + len - 4, ".wav"))
190                         strcpy (namebuffer + len - 3, "ogg");
191                 if (OGG_LoadVorbisFile (namebuffer, s))
192                         return true;
193         }
194
195         // LordHavoc: then try without the added sound/ as wav and ogg
196         len = dpsnprintf (namebuffer, sizeof(namebuffer), "%s", s->name);
197         if (len < 0)
198         {
199                 // name too long
200                 Con_Printf("S_LoadSound: name \"%s\" is too long\n", s->name);
201                 return false;
202         }
203         if (S_LoadWavFile (namebuffer, s))
204                 return true;
205         if (len >= 4 && !strcasecmp (namebuffer + len - 4, ".wav"))
206                 strcpy (namebuffer + len - 3, "ogg");
207         if (OGG_LoadVorbisFile (namebuffer, s))
208                 return true;
209
210         // Can't load the sound!
211         s->flags |= SFXFLAG_FILEMISSING;
212         if (complain)
213                 Con_Printf("S_LoadSound: Couldn't load \"%s\"\n", s->name);
214         return false;
215 }
216
217 void S_UnloadSound (sfx_t *s)
218 {
219         if (s->fetcher != NULL)
220         {
221                 unsigned int i;
222
223                 // Stop all channels that use this sound
224                 for (i = 0; i < total_channels ; i++)
225                         if (channels[i].sfx == s)
226                                 S_StopChannel (i);
227
228                 s->fetcher = NULL;
229                 s->fetcher_data = NULL;
230                 Mem_FreePool(&s->mempool);
231         }
232 }