#include <windows.h>
#include "miniaudio/dr_flac.h"
#include "miniaudio/dr_mp3.h"
#include "miniaudio/dr_wav.h"
#include "miniaudio/stb_vorbis.c"
#include "miniaudio.h"
#include "../client/client.h"

Macros
#define	DR_FLAC_IMPLEMENTATION

#define	DR_MP3_IMPLEMENTATION

#define	DR_WAV_IMPLEMENTATION

#define	MINIAUDIO_IMPLEMENTATION

Functions
static void	data_callback (ma_device pDevice, void pOutput, const void *pInput, ma_uint32 frameCount)

static void	Miniaudio_Pause (void)

static void	Miniaudio_Resume (void)

static void	Miniaudio_f (void)

void	Miniaudio_Init (void)

static ma_result	LoadTrack (const char *gamedir, int track)

void	Miniaudio_Play (int track, qboolean looping)

void	Miniaudio_Stop (void)

void	Miniaudio_Update (void)

void	Miniaudio_Shutdown (void)

Variables
static ma_decoder	decoder

static ma_device	device

static int	loopcounter

static int	playTrack = 0

static qboolean	enabled = true

static qboolean	paused = false

static qboolean	playLooping = false

static qboolean	trackFinished = false

static cvar_t *	cd_nocd

static cvar_t *	cd_loopcount

static cvar_t *	cd_looptrack

Macro Definition Documentation

◆ DR_FLAC_IMPLEMENTATION

#define DR_FLAC_IMPLEMENTATION

Definition at line 32 of file snd_miniaudio.c.

◆ DR_MP3_IMPLEMENTATION

#define DR_MP3_IMPLEMENTATION

Definition at line 34 of file snd_miniaudio.c.

◆ DR_WAV_IMPLEMENTATION

#define DR_WAV_IMPLEMENTATION

Definition at line 36 of file snd_miniaudio.c.

◆ MINIAUDIO_IMPLEMENTATION

#define MINIAUDIO_IMPLEMENTATION

Definition at line 41 of file snd_miniaudio.c.

Function Documentation

◆ data_callback()

static void data_callback	(	ma_device *	pDevice,
		void *	pOutput,
		const void *	pInput,
		ma_uint32	frameCount
	)

static

Definition at line 91 of file snd_miniaudio.c.

 {
     ma_decoder* pDecoder = (ma_decoder*)pDevice->pUserData;
     if (pDecoder == NULL) {
         return;
     }
  
     // playback completed
     if (!ma_decoder_read_pcm_frames(pDecoder, pOutput, frameCount))
     {
         trackFinished = true;
     }
  
     (void)pInput;
 }

Referenced by Miniaudio_Play().

◆ LoadTrack()

static ma_result LoadTrack	(	const char *	gamedir,
		int	track
	)

static

Definition at line 209 of file snd_miniaudio.c.

 {
     ma_result result;
     int trackExtIdx = 0;
     static char *trackExts[] = { "ogg", "flac", "mp3", "wav" };
  
     do
     {
         char trackPath[64];
         Com_sprintf(trackPath, sizeof(trackPath), "%s/music/track%s%i.%s", gamedir, track < 10 ? "0" : "", track, trackExts[trackExtIdx]);
         result = ma_decoder_init_file(trackPath, NULL, &decoder);
     } while (result != MA_SUCCESS && ++trackExtIdx < 4);
  
     return result;
 }

Referenced by Miniaudio_Play().

◆ Miniaudio_f()

static void Miniaudio_f ( void )

static

Definition at line 125 of file snd_miniaudio.c.

 {
     char    *command;
  
     if (Cmd_Argc() < 2)
         return;
  
     command = Cmd_Argv(1);
  
     if (Q_strcasecmp(command, "on") == 0)
     {
         enabled = true;
         return;
     }
  
     if (Q_strcasecmp(command, "off") == 0)
     {
         Miniaudio_Stop();
         enabled = false;
         return;
     }
  
     if (Q_strcasecmp(command, "play") == 0)
     {
         Miniaudio_Play(atoi(Cmd_Argv(2)), false);
         return;
     }
  
     if (Q_strcasecmp(command, "loop") == 0)
     {
         Miniaudio_Play(atoi(Cmd_Argv(2)), true);
         return;
     }
  
     if (Q_strcasecmp(command, "stop") == 0)
     {
         Miniaudio_Stop();
         return;
     }
  
     if (Q_strcasecmp(command, "pause") == 0)
     {
         Miniaudio_Pause();
         return;
     }
  
     if (Q_strcasecmp(command, "resume") == 0)
     {
         Miniaudio_Resume();
         return;
     }
  
     if (Q_strcasecmp(command, "info") == 0)
     {
         if (device.pContext)
             Com_Printf("Using %s backend. ", ma_get_backend_name(device.pContext->backend));
         else
             Com_Printf("No audio backend enabled. ");
  
         if (ma_device_is_started(&device))
             Com_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
         else if (paused)
             Com_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
         else
             Com_Printf("No music is playing.\n");
         return;
     }
 }

Referenced by Miniaudio_Init().

◆ Miniaudio_Init()

void Miniaudio_Init ( void )

Definition at line 195 of file snd_miniaudio.c.

 {
     cd_nocd = Cvar_Get("cd_nocd", "0", CVAR_ARCHIVE);
     cd_loopcount = Cvar_Get("cd_loopcount", "4", 0);
     cd_looptrack = Cvar_Get("cd_looptrack", "11", 0);
     enabled = true;
     paused = false;
  
 #ifdef __APPLE__
     bufferSizeInFrames = Cvar_VariableValue("s_chunksize") * sizeof(float) / GetBytesPerSampleFrame();
 #endif
     Cmd_AddCommand("miniaudio", Miniaudio_f);
 }

Referenced by CL_Init().

◆ Miniaudio_Pause()

static void Miniaudio_Pause ( void )

static

Definition at line 107 of file snd_miniaudio.c.

 {
     if (!enabled || !ma_device_is_started(&device) || paused)
         return;
  
     ma_device_stop(&device);
     paused = true;
 }

Referenced by Miniaudio_f(), Miniaudio_Play(), and Miniaudio_Update().

◆ Miniaudio_Play()

void Miniaudio_Play	(	int	track,
		qboolean	looping
	)

Definition at line 225 of file snd_miniaudio.c.

 {
     ma_result result;
     ma_device_config deviceConfig;
  
     if (!enabled || playTrack == track)
         return;
  
     Miniaudio_Stop();
  
     // ignore invalid tracks
     if (track < 1)
         return;
  
     result = LoadTrack(FS_Gamedir(), track);
  
     // try the baseq2 folder if loading the track from a custom gamedir failed
     if (result != MA_SUCCESS && Q_stricmp(FS_Gamedir(), "./"BASEDIRNAME) != 0)
     {
         result = LoadTrack(BASEDIRNAME, track);
     }
  
     if (result != MA_SUCCESS)
     {
         Com_Printf("Failed to open %s/music/track%s%i.[ogg/flac/mp3/wav]: error %i\n", FS_Gamedir(), track < 10 ? "0" : "", track, result);
         return;
     }
  
     deviceConfig = ma_device_config_init(ma_device_type_playback);
     deviceConfig.playback.format = decoder.outputFormat;
     deviceConfig.playback.channels = decoder.outputChannels;
     deviceConfig.sampleRate = decoder.outputSampleRate;
     deviceConfig.dataCallback = data_callback;
     deviceConfig.pUserData = &decoder;
 #ifdef __APPLE__
     deviceConfig.bufferSizeInFrames = bufferSizeInFrames;
     deviceConfig.periods = 1;
 #endif
  
     if (ma_device_init(NULL, &deviceConfig, &device) != MA_SUCCESS) {
         Com_Printf("Failed to open playback device: error %i\n", result);
         ma_decoder_uninit(&decoder);
         return;
     }
  
     if (ma_device_start(&device) != MA_SUCCESS) {
         Com_Printf("Failed to start playback device: error %i\n", result);
         ma_device_uninit(&device);
         ma_decoder_uninit(&decoder);
         return;
     }
  
     loopcounter = 0;
     playTrack = track;
     playLooping = looping;
     paused = false;
     trackFinished = false;
  
     if (Cvar_VariableValue("cd_nocd"))
         Miniaudio_Pause();
 }

Referenced by CL_ParseConfigString(), CL_PrepRefresh(), Miniaudio_f(), and Miniaudio_Update().

◆ Miniaudio_Resume()

static void Miniaudio_Resume ( void )

static

Definition at line 116 of file snd_miniaudio.c.

 {
     if (!enabled || !paused)
         return;
  
     ma_device_start(&device);
     paused = false;
 }

Referenced by Miniaudio_f(), and Miniaudio_Update().

◆ Miniaudio_Shutdown()

void Miniaudio_Shutdown ( void )

Definition at line 352 of file snd_miniaudio.c.

 {
     Miniaudio_Stop();
     Cmd_RemoveCommand("miniaudio");
 }

Referenced by CL_Shutdown().

◆ Miniaudio_Stop()

void Miniaudio_Stop ( void )

Definition at line 287 of file snd_miniaudio.c.

 {
     if (!enabled || !ma_device_is_started(&device))
         return;
  
     paused = false;
     playTrack = 0;
  
     ma_device_uninit(&device);
     ma_decoder_uninit(&decoder);
 }

Referenced by Miniaudio_f(), Miniaudio_Play(), Miniaudio_Shutdown(), Miniaudio_Update(), SCR_BeginLoadingPlaque(), and SCR_PlayCinematic().

◆ Miniaudio_Update()

void Miniaudio_Update ( void )

Definition at line 299 of file snd_miniaudio.c.

 {
     if (cd_nocd->value != !enabled)
     {
         if (cd_nocd->value)
         {
             Miniaudio_Pause();
             enabled = false;
         }
         else
         {
             enabled = true;
             int track = atoi(cl.configstrings[CS_CDTRACK]);
             if (!paused || playTrack != track)
             {
                 if ((playTrack == 0 && !playLooping) || (playTrack > 0 && playTrack != track))
                     Miniaudio_Play(track, true);
                 else
                     Miniaudio_Play(playTrack, playLooping);
             }
             else
                 Miniaudio_Resume();
         }
     }
  
     if (enabled && ma_device_is_started(&device) && trackFinished)
     {
         trackFinished = false;
         if (playLooping)
         {
             // if the track has played the given number of times,
             // go to the ambient track
             if (++loopcounter >= cd_loopcount->value)
             {
                 // ambient track will be played for the first time, so we need to load it
                 if (loopcounter == cd_loopcount->value)
                 {
                     Miniaudio_Stop();
                     Miniaudio_Play(cd_looptrack->value, true);
                 }
                 else
                 {
                     ma_decoder_seek_to_pcm_frame(&decoder, 0);
                 }
             }
             else
             {
                 ma_decoder_seek_to_pcm_frame(&decoder, 0);
             }
         }
     }
 }