mod_q3bsp_nolightmaps: do not load lightmaps, use the bad q3map2-written vertex light...
[divverent/darkplaces.git] / snd_modplug.c
1 /*
2         Copyright (C) 2003-2005  Mathieu Olivier
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:
17
18                 Free Software Foundation, Inc.
19                 59 Temple Place - Suite 330
20                 Boston, MA  02111-1307, USA
21
22 */
23
24
25 #include "quakedef.h"
26 #include "snd_main.h"
27 #include "snd_modplug.h"
28
29 #ifdef SND_MODPLUG_STATIC
30
31 #include <libmodplug/modplug.h>
32 qboolean ModPlug_OpenLibrary (void)
33 {
34         return true; // statically linked
35 }
36 void ModPlug_CloseLibrary (void)
37 {
38 }
39 #define modplug_dll 1
40
41 #else
42 // BEGIN SECTION FROM modplug.h
43
44         /*
45          * This source code is public domain.
46          *
47          * Authors: Kenton Varda <temporal@gauge3d.org> (C interface wrapper)
48          */
49
50         enum _ModPlug_Flags
51         {
52                         MODPLUG_ENABLE_OVERSAMPLING     = 1 << 0,  /* Enable oversampling (*highly* recommended) */
53                         MODPLUG_ENABLE_NOISE_REDUCTION  = 1 << 1,  /* Enable noise reduction */
54                         MODPLUG_ENABLE_REVERB           = 1 << 2,  /* Enable reverb */
55                         MODPLUG_ENABLE_MEGABASS         = 1 << 3,  /* Enable megabass */
56                         MODPLUG_ENABLE_SURROUND         = 1 << 4   /* Enable surround sound. */
57         };
58
59         enum _ModPlug_ResamplingMode
60         {
61                         MODPLUG_RESAMPLE_NEAREST = 0,  /* No interpolation (very fast, extremely bad sound quality) */
62                         MODPLUG_RESAMPLE_LINEAR  = 1,  /* Linear interpolation (fast, good quality) */
63                         MODPLUG_RESAMPLE_SPLINE  = 2,  /* Cubic spline interpolation (high quality) */
64                         MODPLUG_RESAMPLE_FIR     = 3   /* 8-tap fir filter (extremely high quality) */
65         };
66
67         typedef struct _ModPlug_Settings
68         {
69                         int mFlags;  /* One or more of the MODPLUG_ENABLE_* flags above, bitwise-OR'ed */
70                         
71                         /* Note that ModPlug always decodes sound at 44100kHz, 32 bit, stereo and then
72                          * down-mixes to the settings you choose. */
73                         int mChannels;       /* Number of channels - 1 for mono or 2 for stereo */
74                         int mBits;           /* Bits per sample - 8, 16, or 32 */
75                         int mFrequency;      /* Sampling rate - 11025, 22050, or 44100 */
76                         int mResamplingMode; /* One of MODPLUG_RESAMPLE_*, above */
77                         
78                         int mReverbDepth;    /* Reverb level 0(quiet)-100(loud)      */
79                         int mReverbDelay;    /* Reverb delay in ms, usually 40-200ms */
80                         int mBassAmount;     /* XBass level 0(quiet)-100(loud)       */
81                         int mBassRange;      /* XBass cutoff in Hz 10-100            */
82                         int mSurroundDepth;  /* Surround level 0(quiet)-100(heavy)   */
83                         int mSurroundDelay;  /* Surround delay in ms, usually 5-40ms */
84                         int mLoopCount;      /* Number of times to loop.  Zero prevents looping.
85                                                                         -1 loops forever. */
86         } ModPlug_Settings;
87
88         struct _ModPlugFile;
89         typedef struct _ModPlugFile ModPlugFile;
90
91 // END SECTION FROM modplug.h
92
93 static ModPlugFile* (*ModPlug_Load) (const void* data, int size);
94 static void (*ModPlug_Unload) (ModPlugFile* file);
95 static int (*ModPlug_Read) (ModPlugFile* file, void* buffer, int size);
96 static void (*ModPlug_Seek) (ModPlugFile* file, int millisecond);
97 static void (*ModPlug_GetSettings) (ModPlug_Settings* settings);
98 static void (*ModPlug_SetSettings) (const ModPlug_Settings* settings);
99 static void (*ModPlug_SetMasterVolume) (ModPlugFile* file,unsigned int cvol) ;
100
101
102 static dllfunction_t modplugfuncs[] =
103 {
104         {"ModPlug_Load",                        (void **) &ModPlug_Load},
105         {"ModPlug_Unload",                      (void **) &ModPlug_Unload},
106         {"ModPlug_Read",                        (void **) &ModPlug_Read},
107         {"ModPlug_Seek",                        (void **) &ModPlug_Seek},
108         {"ModPlug_GetSettings",         (void **) &ModPlug_GetSettings},
109         {"ModPlug_SetSettings",         (void **) &ModPlug_SetSettings},
110         {NULL, NULL}
111 };
112
113 // Handles for the modplug and modplugfile DLLs
114 static dllhandle_t modplug_dll = NULL;
115
116 /*
117 =================================================================
118
119   DLL load & unload
120
121 =================================================================
122 */
123
124 /*
125 ====================
126 ModPlug_OpenLibrary
127
128 Try to load the modplugFile DLL
129 ====================
130 */
131 qboolean ModPlug_OpenLibrary (void)
132 {
133         const char* dllnames_modplug [] =
134         {
135 #if defined(WIN64)
136                 "libmodplug64.dll",
137 #elif defined(WIN32)
138                 "libmodplug-0.dll",
139                 "modplug.dll",
140 #elif defined(MACOSX)
141                 "libmodplug.dylib",
142 #else
143                 "libmodplug.so.0",
144                 "libmodplug.so",
145 #endif
146                 NULL
147         };
148
149         // Already loaded?
150         if (modplug_dll)
151                 return true;
152
153 // COMMANDLINEOPTION: Sound: -nomodplug disables modplug sound support
154         if (COM_CheckParm("-nomodplug"))
155                 return false;
156
157         // Load the DLLs
158         // We need to load both by hand because some OSes seem to not load
159         // the modplug DLL automatically when loading the modplugFile DLL
160         if(Sys_LoadLibrary (dllnames_modplug, &modplug_dll, modplugfuncs))
161         {
162                 ModPlug_SetMasterVolume = Sys_GetProcAddress(modplug_dll, "ModPlug_SetMasterVolume");
163                 if(!ModPlug_SetMasterVolume)
164                         Con_Print("Warning: modplug volume control not supported. Try getting a newer version of libmodplug.\n");
165                 return true;
166         }
167         else
168                 return false;
169 }
170
171
172 /*
173 ====================
174 ModPlug_CloseLibrary
175
176 Unload the modplugFile DLL
177 ====================
178 */
179 void ModPlug_CloseLibrary (void)
180 {
181         Sys_UnloadLibrary (&modplug_dll);
182 }
183 #endif
184
185
186 /*
187 =================================================================
188
189         modplug decoding
190
191 =================================================================
192 */
193
194 #define STREAM_BUFFER_DURATION 1.5f     // 1.5 sec
195 #define STREAM_BUFFER_SIZE(format_ptr) ((int)(ceil (STREAM_BUFFER_DURATION * ((format_ptr)->speed * (format_ptr)->width * (format_ptr)->channels))))
196 // We work with 1 sec sequences, so this buffer must be able to contain
197 // 1 sec of sound of the highest quality (48 KHz, 16 bit samples, stereo)
198 static unsigned char resampling_buffer [48000 * 2 * 2];
199
200
201 // Per-sfx data structure
202 typedef struct
203 {
204         unsigned char   *file;
205         size_t                  filesize;
206         snd_format_t    format;
207         unsigned int    total_length;
208         char                    name[128];
209         sfx_t           *sfx;
210 } modplug_stream_persfx_t;
211
212 // Per-channel data structure
213 typedef struct
214 {
215         ModPlugFile     *mf;
216         unsigned int    sb_offset;
217         int                             bs;
218         snd_buffer_t    sb;             // must be at the end due to its dynamically allocated size
219 } modplug_stream_perchannel_t;
220
221
222 /*
223 ====================
224 ModPlug_FetchSound
225 ====================
226 */
227 static const snd_buffer_t* ModPlug_FetchSound (void *sfxfetcher, void **chfetcherpointer, unsigned int *start, unsigned int nbsampleframes)
228 {
229         modplug_stream_perchannel_t* per_ch = (modplug_stream_perchannel_t *)*chfetcherpointer;
230         modplug_stream_persfx_t* per_sfx = (modplug_stream_persfx_t *)sfxfetcher;
231         snd_buffer_t* sb;
232         int newlength, done, ret;
233         unsigned int real_start;
234         unsigned int factor;
235
236         // If there's no fetcher structure attached to the channel yet
237         if (per_ch == NULL)
238         {
239                 size_t buff_len, memsize;
240                 snd_format_t sb_format;
241
242                 sb_format.speed = snd_renderbuffer->format.speed;
243                 sb_format.width = per_sfx->format.width;
244                 sb_format.channels = per_sfx->format.channels;
245
246                 buff_len = STREAM_BUFFER_SIZE(&sb_format);
247                 memsize = sizeof (*per_ch) - sizeof (per_ch->sb.samples) + buff_len;
248                 per_ch = (modplug_stream_perchannel_t *)Mem_Alloc (snd_mempool, memsize);
249
250                 // Open it with the modplugFile API
251                 per_ch->mf = ModPlug_Load(per_sfx->file, per_sfx->filesize);
252                 if (!per_ch->mf)
253                 {
254                         Con_Printf("error while reading ModPlug stream \"%s\"\n", per_sfx->name);
255                         Mem_Free (per_ch);
256                         return NULL;
257                 }
258
259                 if(ModPlug_SetMasterVolume)
260                         ModPlug_SetMasterVolume(per_ch->mf, 512); // max volume, DP scales down!
261
262                 per_ch->bs = 0;
263
264                 per_ch->sb_offset = 0;
265                 per_ch->sb.format = sb_format;
266                 per_ch->sb.nbframes = 0;
267                 per_ch->sb.maxframes = buff_len / (per_ch->sb.format.channels * per_ch->sb.format.width);
268
269                 *chfetcherpointer = per_ch;
270         }
271
272         real_start = *start;
273
274         sb = &per_ch->sb;
275         factor = per_sfx->format.width * per_sfx->format.channels;
276
277         // If the stream buffer can't contain that much samples anyway
278         if (nbsampleframes > sb->maxframes)
279         {
280                 Con_Printf ("ModPlug_FetchSound: stream buffer too small (%u sample frames required)\n", nbsampleframes);
281                 return NULL;
282         }
283
284         // If the data we need has already been decompressed in the sfxbuffer, just return it
285         if (per_ch->sb_offset <= real_start && per_ch->sb_offset + sb->nbframes >= real_start + nbsampleframes)
286         {
287                 *start = per_ch->sb_offset;
288                 return sb;
289         }
290
291         newlength = (int)(per_ch->sb_offset + sb->nbframes) - real_start;
292
293         // If we need to skip some data before decompressing the rest, or if the stream has looped
294         if (newlength < 0 || per_ch->sb_offset > real_start)
295         {
296                 unsigned int time_start;
297                 unsigned int modplug_start;
298
299                 /*
300                 MODs loop on their own, so any position is valid!
301                 if (real_start > (unsigned int)per_sfx->total_length)
302                 {
303                         Con_Printf ("ModPlug_FetchSound: asked for a start position after the end of the sfx! (%u > %u)\n",
304                                                 real_start, per_sfx->total_length);
305                         return NULL;
306                 }
307                 */
308
309                 // We work with 200ms (1/5 sec) steps to avoid rounding errors
310                 time_start = real_start * 5 / snd_renderbuffer->format.speed;
311                 modplug_start = time_start * (1000 / 5);
312
313                 Con_DPrintf("warning: mod file needed to seek (to %d)\n", modplug_start);
314
315                 ModPlug_Seek(per_ch->mf, modplug_start);
316                 sb->nbframes = 0;
317
318                 real_start = (float)modplug_start / 1000 * snd_renderbuffer->format.speed;
319                 if (*start - real_start + nbsampleframes > sb->maxframes)
320                 {
321                         Con_Printf ("ModPlug_FetchSound: stream buffer too small after seek (%u sample frames required)\n",
322                                                 *start - real_start + nbsampleframes);
323                         per_ch->sb_offset = real_start;
324                         return NULL;
325                 }
326         }
327         // Else, move forward the samples we need to keep in the sound buffer
328         else
329         {
330                 memmove (sb->samples, sb->samples + (real_start - per_ch->sb_offset) * factor, newlength * factor);
331                 sb->nbframes = newlength;
332         }
333
334         per_ch->sb_offset = real_start;
335
336         // We add exactly 1 sec of sound to the buffer:
337         // 1- to ensure we won't lose any sample during the resampling process
338         // 2- to force one call to ModPlug_FetchSound per second to regulate the workload
339         if (sb->format.speed + sb->nbframes > sb->maxframes)
340         {
341                 Con_Printf ("ModPlug_FetchSound: stream buffer overflow (%u sample frames / %u)\n",
342                                         sb->format.speed + sb->nbframes, sb->maxframes);
343                 return NULL;
344         }
345         newlength = per_sfx->format.speed * factor;  // -> 1 sec of sound before resampling
346         if(newlength > (int)sizeof(resampling_buffer))
347                 newlength = sizeof(resampling_buffer);
348
349         // Decompress in the resampling_buffer
350         done = 0;
351         while ((ret = ModPlug_Read (per_ch->mf, (char *)&resampling_buffer[done], (int)(newlength - done))) > 0)
352                 done += ret;
353         if(done < newlength)
354         {
355                 // Argh. We didn't get as many samples as we wanted. Probably
356                 // libmodplug forgot what mLoopCount==-1 means... basically, this means
357                 // we can't loop like this. Try to let DP fix it later...
358                 per_sfx->sfx->total_length = (real_start + ((size_t)done / (size_t)factor));
359                 per_sfx->sfx->loopstart = 0;
360
361                 if(newlength != done)
362                         Con_DPrintf("ModPlug_Fetch: wanted: %d, got: %d\n", newlength, done);
363         }
364
365         Snd_AppendToSndBuffer (sb, resampling_buffer, (size_t)done / (size_t)factor, &per_sfx->format);
366
367         *start = per_ch->sb_offset;
368         return sb;
369 }
370
371
372 /*
373 ====================
374 ModPlug_FetchEnd
375 ====================
376 */
377 static void ModPlug_FetchEnd (void *chfetcherdata)
378 {
379         modplug_stream_perchannel_t* per_ch = (modplug_stream_perchannel_t *)chfetcherdata;
380
381         if (per_ch != NULL)
382         {
383                 // Free the modplug decoder
384                 ModPlug_Unload (per_ch->mf);
385
386                 Mem_Free (per_ch);
387         }
388 }
389
390
391 /*
392 ====================
393 ModPlug_FreeSfx
394 ====================
395 */
396 static void ModPlug_FreeSfx (void *sfxfetcherdata)
397 {
398         modplug_stream_persfx_t* per_sfx = (modplug_stream_persfx_t *)sfxfetcherdata;
399
400         // Free the modplug file
401         Mem_Free(per_sfx->file);
402
403         // Free the stream structure
404         Mem_Free(per_sfx);
405 }
406
407
408 /*
409 ====================
410 ModPlug_GetFormat
411 ====================
412 */
413 static const snd_format_t* ModPlug_GetFormat (sfx_t* sfx)
414 {
415         modplug_stream_persfx_t* per_sfx = (modplug_stream_persfx_t *)sfx->fetcher_data;
416         return &per_sfx->format;
417 }
418
419 static const snd_fetcher_t modplug_fetcher = { ModPlug_FetchSound, ModPlug_FetchEnd, ModPlug_FreeSfx, ModPlug_GetFormat };
420
421
422 /*
423 ====================
424 ModPlug_LoadmodplugFile
425
426 Load an modplug file into memory
427 ====================
428 */
429 qboolean ModPlug_LoadModPlugFile (const char *filename, sfx_t *sfx)
430 {
431         unsigned char *data;
432         fs_offset_t filesize;
433         ModPlugFile *mf;
434         modplug_stream_persfx_t* per_sfx;
435         ModPlug_Settings s;
436
437         if (!modplug_dll)
438                 return false;
439
440         // Already loaded?
441         if (sfx->fetcher != NULL)
442                 return true;
443
444         // Load the file
445         data = FS_LoadFile (filename, snd_mempool, false, &filesize);
446         if (data == NULL)
447                 return false;
448
449         if (developer_loading.integer >= 2)
450                 Con_Printf ("Loading ModPlug file \"%s\"\n", filename);
451
452         ModPlug_GetSettings(&s);
453         s.mFlags = MODPLUG_ENABLE_OVERSAMPLING | MODPLUG_ENABLE_NOISE_REDUCTION | MODPLUG_ENABLE_REVERB;
454         s.mChannels = 2;
455         s.mBits = 16;
456         s.mFrequency = 44100;
457         s.mResamplingMode = MODPLUG_RESAMPLE_SPLINE;
458         s.mLoopCount = -1;
459         ModPlug_SetSettings(&s);
460
461         // Open it with the modplugFile API
462         if (!(mf = ModPlug_Load (data, filesize)))
463         {
464                 Con_Printf ("error while opening ModPlug file \"%s\"\n", filename);
465                 Mem_Free(data);
466                 return false;
467         }
468
469         if(ModPlug_SetMasterVolume)
470                 ModPlug_SetMasterVolume(mf, 512); // max volume, DP scales down!
471
472         if (developer_loading.integer >= 2)
473                 Con_Printf ("\"%s\" will be streamed\n", filename);
474         per_sfx = (modplug_stream_persfx_t *)Mem_Alloc (snd_mempool, sizeof (*per_sfx));
475         strlcpy(per_sfx->name, sfx->name, sizeof(per_sfx->name));
476         sfx->memsize += sizeof (*per_sfx);
477         per_sfx->file = data;
478         per_sfx->filesize = filesize;
479         sfx->memsize += filesize;
480
481         per_sfx->format.speed = 44100; // modplug always works at that rate
482         per_sfx->format.width = 2;  // We always work with 16 bits samples
483         per_sfx->format.channels = 2; // stereo rulez ;) (MAYBE default to mono because Amiga MODs sound better then?)
484         per_sfx->sfx = sfx;
485
486         sfx->fetcher_data = per_sfx;
487         sfx->fetcher = &modplug_fetcher;
488         sfx->flags |= SFXFLAG_STREAMED;
489         sfx->total_length = 2147384647; // they always loop
490         sfx->loopstart = sfx->total_length; // modplug does it
491
492         return true;
493 }