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