ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removed unnecessary code from mupen64plus-audio-bkm. Improved lagspikes quite significantly.

This commit is contained in:
null_ptr 2014-01-20 15:33:58 +00:00
parent 83591cda67
commit edee798341
4 changed files with 105 additions and 473 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

574
libmupen64plus/mupen64plus-audio-bkm/main.c
View File

@ -1,6 +1,7 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Mupen64plus-sdl-audio - main.c *
* Mupen64plus-bkm-audio - main.c *
* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
* Editet 2013 null_ptr Completely rewritten to suit custom needs *
* Copyright (C) 2007-2009 Richard Goedeken *
* Copyright (C) 2007-2008 Ebenblues *
* Copyright (C) 2003 JttL *
@ -26,13 +27,6 @@
#include <stdlib.h>
#include <string.h>
#ifdef USE_SRC
#include <samplerate.h>
#endif
#ifdef USE_SPEEX
#include <speex/speex_resampler.h>
#endif
#define M64P_PLUGIN_PROTOTYPES 1
#include "m64p_types.h"
#include "m64p_plugin.h"
@ -42,96 +36,34 @@
#include "main.h"
#include "osal_dynamiclib.h"
/* Default start-time size of primary buffer (in equivalent output samples).
This is the buffer where audio is loaded after it's extracted from n64's memory.
This value must be larger than PRIMARY_BUFFER_TARGET */
#define PRIMARY_BUFFER_SIZE 16384
/* this is the buffer fullness level (in equivalent output samples) which is targeted
for the primary audio buffer (by inserting delays) each time data is received from
the running N64 program. This value must be larger than the SECONDARY_BUFFER_SIZE.
Decreasing this value will reduce audio latency but requires a faster PC to avoid
choppiness. Increasing this will increase audio latency but reduce the chance of
drop-outs. The default value 10240 gives a 232ms maximum A/V delay at 44.1khz */
#define PRIMARY_BUFFER_TARGET 10240
/* Size of secondary buffer, in output samples. This is the requested size of SDL's
hardware buffer, and the size of the mix buffer for doing SDL volume control. The
SDL documentation states that this should be a power of two between 512 and 8192. */
#define SECONDARY_BUFFER_SIZE 2048
/* This sets default frequency what is used if rom doesn't want to change it.
Probably only game that needs this is Zelda: Ocarina Of Time Master Quest
*NOTICE* We should try to find out why Demos' frequencies are always wrong
They tend to rely on a default frequency, apparently, never the same one ;)*/
#define DEFAULT_FREQUENCY 33600
#define DEFAULT_BUFFER_SIZE 12480
/* number of bytes per sample */
#define N64_SAMPLE_BYTES 4
#define SDL_SAMPLE_BYTES 4
/* volume mixer types */
#define VOLUME_TYPE_SDL 1
#define VOLUME_TYPE_OSS 2
/* local variables */
static void (*l_DebugCallback)(void *, int, const char *) = NULL;
static void *l_DebugCallContext = NULL;
static int l_PluginInit = 0;
static m64p_handle l_ConfigAudio;
enum resampler_type {
RESAMPLER_TRIVIAL,
#ifdef USE_SRC
RESAMPLER_SRC,
#endif
#ifdef USE_SPEEX
RESAMPLER_SPEEX,
#endif
};
/* Read header for type definition */
static AUDIO_INFO AudioInfo;
/* Pointer to the primary audio buffer */
static unsigned char *primaryBuffer = NULL;
static unsigned char *mixBuffer = NULL;
static unsigned int primaryBufferBytes = 0;
/* Position in buffer array where next audio chunk should be placed */
static unsigned int buffer_pos = 0;
/* Audio frequency, this is usually obtained from the game, but for compatibility we set default value */
static int GameFreq = DEFAULT_FREQUENCY;
/* timestamp for the last time that our audio callback was called */
static unsigned int last_callback_ticks = 0;
/* SpeedFactor is used to increase/decrease game playback speed */
static unsigned int speed_factor = 100;
// If this is true then left and right channels are swapped */
static int SwapChannels = 0;
// Size of Primary audio buffer in equivalent output samples
static unsigned int PrimaryBufferSize = PRIMARY_BUFFER_SIZE;
// Fullness level target for Primary audio buffer, in equivalent output samples
static unsigned int PrimaryBufferTarget = PRIMARY_BUFFER_TARGET;
// Size of Secondary audio buffer in output samples
static unsigned int SecondaryBufferSize = SECONDARY_BUFFER_SIZE;
// Resample type
static enum resampler_type Resample = RESAMPLER_TRIVIAL;
// Resampler specific quality
static int ResampleQuality = 3;
// volume to scale the audio by, range of 0..100
// if muted, this holds the volume when not muted
static int VolPercent = 80;
// how much percent to increment/decrement volume by
static int VolDelta = 5;
// Muted or not
static int VolIsMuted = 0;
//which type of volume control to use
static int VolumeControlType = VOLUME_TYPE_SDL;
static int OutputFreq;
/* Audio buffer */
static char* audioBuffer = NULL;
static size_t bufferBack = 0;
static size_t bufferSize = 0;
// Prototype of local functions
static void InitializeAudio(int freq);
static void ReadConfig(void);
static void InitializeSDL(void);
static void SetSamplingRate(int freq);
static void SetBufferSize(size_t size);
static int critical_failure = 0;
@ -168,14 +100,14 @@ static void DebugMessage(int level, const char *message, ...)
va_end(args);
}
#pragma region (De-)Initialization
/* Mupen64Plus plugin functions */
EXPORT m64p_error CALL PluginStartup(m64p_dynlib_handle CoreLibHandle, void *Context,
void (*DebugCallback)(void *, int, const char *))
{
ptr_CoreGetAPIVersions CoreAPIVersionFunc;
int ConfigAPIVersion, DebugAPIVersion, VidextAPIVersion, bSaveConfig;
float fConfigParamsVersion = 0.0f;
int ConfigAPIVersion, DebugAPIVersion, VidextAPIVersion;
if (l_PluginInit)
return M64ERR_ALREADY_INIT;
@ -224,53 +156,6 @@ EXPORT m64p_error CALL PluginStartup(m64p_dynlib_handle CoreLibHandle, void *Con
if (ConfigAPIVersion >= 0x020100 && !ConfigSaveSection)
return M64ERR_INCOMPATIBLE;
/* get a configuration section handle */
if (ConfigOpenSection("Audio-SDL", &l_ConfigAudio) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "Couldn't open config section 'Audio-SDL'");
return M64ERR_INPUT_NOT_FOUND;
}
/* check the section version number */
bSaveConfig = 0;
if (ConfigGetParameter(l_ConfigAudio, "Version", M64TYPE_FLOAT, &fConfigParamsVersion, sizeof(float)) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "No version number in 'Audio-SDL' config section. Setting defaults.");
ConfigDeleteSection("Audio-SDL");
ConfigOpenSection("Audio-SDL", &l_ConfigAudio);
bSaveConfig = 1;
}
else if (((int) fConfigParamsVersion) != ((int) CONFIG_PARAM_VERSION))
{
DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in 'Audio-SDL' config section: current is %.2f. Setting defaults.", fConfigParamsVersion, (float) CONFIG_PARAM_VERSION);
ConfigDeleteSection("Audio-SDL");
ConfigOpenSection("Audio-SDL", &l_ConfigAudio);
bSaveConfig = 1;
}
else if ((CONFIG_PARAM_VERSION - fConfigParamsVersion) >= 0.0001f)
{
/* handle upgrades */
float fVersion = CONFIG_PARAM_VERSION;
ConfigSetParameter(l_ConfigAudio, "Version", M64TYPE_FLOAT, &fVersion);
DebugMessage(M64MSG_INFO, "Updating parameter set version in 'Audio-SDL' config section to %.2f", fVersion);
bSaveConfig = 1;
}
/* set the default values for this plugin */
ConfigSetDefaultFloat(l_ConfigAudio, "Version", CONFIG_PARAM_VERSION, "Mupen64Plus SDL Audio Plugin config parameter version number");
ConfigSetDefaultInt(l_ConfigAudio, "DEFAULT_FREQUENCY", DEFAULT_FREQUENCY, "Frequency which is used if rom doesn't want to change it");
ConfigSetDefaultBool(l_ConfigAudio, "SWAP_CHANNELS", 0, "Swaps left and right channels");
ConfigSetDefaultInt(l_ConfigAudio, "PRIMARY_BUFFER_SIZE", PRIMARY_BUFFER_SIZE, "Size of primary buffer in output samples. This is where audio is loaded after it's extracted from n64's memory.");
ConfigSetDefaultInt(l_ConfigAudio, "PRIMARY_BUFFER_TARGET", PRIMARY_BUFFER_TARGET, "Fullness level target for Primary audio buffer, in equivalent output samples");
ConfigSetDefaultInt(l_ConfigAudio, "SECONDARY_BUFFER_SIZE", SECONDARY_BUFFER_SIZE, "Size of secondary buffer in output samples. This is SDL's hardware buffer.");
ConfigSetDefaultString(l_ConfigAudio, "RESAMPLE", "trivial", "Audio resampling algorithm. src-sinc-best-quality, src-sinc-medium-quality, src-sinc-fastest, src-zero-order-hold, src-linear, speex-fixed-{10-0}, trivial");
ConfigSetDefaultInt(l_ConfigAudio, "VOLUME_CONTROL_TYPE", VOLUME_TYPE_SDL, "Volume control type: 1 = SDL (only affects Mupen64Plus output) 2 = OSS mixer (adjusts master PC volume)");
ConfigSetDefaultInt(l_ConfigAudio, "VOLUME_ADJUST", 5, "Percentage change each time the volume is increased or decreased");
ConfigSetDefaultInt(l_ConfigAudio, "VOLUME_DEFAULT", 80, "Default volume when a game is started. Only used if VOLUME_CONTROL_TYPE is 1");
if (bSaveConfig && ConfigAPIVersion >= 0x020100)
ConfigSaveSection("Audio-SDL");
l_PluginInit = 1;
return M64ERR_SUCCESS;
}
@ -288,6 +173,57 @@ EXPORT m64p_error CALL PluginShutdown(void)
return M64ERR_SUCCESS;
}
EXPORT int CALL RomOpen(void)
{
if (!l_PluginInit)
return 0;
SetSamplingRate(GameFreq);
SetBufferSize(DEFAULT_BUFFER_SIZE);
return 1;
}
EXPORT void CALL RomClosed( void )
{
if (!l_PluginInit)
return;
if (critical_failure == 1)
return;
// Delete the buffer, as we are done producing sound
if (audioBuffer != NULL)
{
bufferSize = 0;
bufferBack = 0;
free(audioBuffer);
audioBuffer = NULL;
}
}
EXPORT int CALL InitiateAudio( AUDIO_INFO Audio_Info )
{
if (!l_PluginInit)
return 0;
AudioInfo = Audio_Info;
return 1;
}
static void SetBufferSize(size_t size)
{
char* oldBuffer = audioBuffer;
audioBuffer = (char*)malloc(size);
if(audioBuffer != NULL)
{
memcpy(audioBuffer, oldBuffer, min(size, bufferBack));
free(oldBuffer);
}
bufferSize = size;
bufferBack = min(size, bufferBack);
}
#pragma endregion
#pragma region Pluginversion
EXPORT m64p_error CALL PluginGetVersion(m64p_plugin_type *PluginType, int *PluginVersion, int *APIVersion, const char **PluginNamePtr, int *Capabilities)
{
/* set version info */
@ -295,23 +231,25 @@ EXPORT m64p_error CALL PluginGetVersion(m64p_plugin_type *PluginType, int *Plugi
*PluginType = M64PLUGIN_AUDIO;
if (PluginVersion != NULL)
*PluginVersion = SDL_AUDIO_PLUGIN_VERSION;
*PluginVersion = BKM_AUDIO_PLUGIN_VERSION;
if (APIVersion != NULL)
*APIVersion = AUDIO_PLUGIN_API_VERSION;
if (PluginNamePtr != NULL)
*PluginNamePtr = "Mupen64Plus SDL Audio Plugin";
*PluginNamePtr = "Mupen64Plus BKM Audio Plugin for Bizhawk";
if (Capabilities != NULL)
{
*Capabilities = 0;
}
return M64ERR_SUCCESS;
}
#pragma endregion
/* ----------- Audio Functions ------------- */
#pragma region Handle audio
/* --- Called when sampling rate changes --- */
EXPORT void CALL AiDacrateChanged( int SystemType )
{
int f = GameFreq;
@ -338,10 +276,11 @@ EXPORT void CALL AiDacrateChanged( int SystemType )
break;
}
}
InitializeAudio(f);
SetSamplingRate(f);
}
/* --- Called when length of n64 audio buffer changes --- */
/* --- i.e. new audio data in buffer --- */
EXPORT void CALL AiLenChanged( void )
{
unsigned int LenReg;
@ -355,33 +294,22 @@ EXPORT void CALL AiLenChanged( void )
LenReg = *AudioInfo.AI_LEN_REG;
p = AudioInfo.RDRAM + (*AudioInfo.AI_DRAM_ADDR_REG & 0xFFFFFF);
if (buffer_pos + LenReg < primaryBufferBytes)
if (bufferBack + LenReg < bufferSize)
{
unsigned int i;
for ( i = 0 ; i < LenReg ; i += 4 )
{
// Left channel
audioBuffer[ bufferBack + i ] = p[ i + 2 ];
audioBuffer[ bufferBack + i + 1 ] = p[ i + 3 ];
if(SwapChannels == 0)
{
// Left channel
primaryBuffer[ buffer_pos + i ] = p[ i + 2 ];
primaryBuffer[ buffer_pos + i + 1 ] = p[ i + 3 ];
// Right channel
primaryBuffer[ buffer_pos + i + 2 ] = p[ i ];
primaryBuffer[ buffer_pos + i + 3 ] = p[ i + 1 ];
} else {
// Left channel
primaryBuffer[ buffer_pos + i ] = p[ i ];
primaryBuffer[ buffer_pos + i + 1 ] = p[ i + 1 ];
// Right channel
primaryBuffer[ buffer_pos + i + 2 ] = p[ i + 2];
primaryBuffer[ buffer_pos + i + 3 ] = p[ i + 3 ];
}
// Right channel
audioBuffer[ bufferBack + i + 2 ] = p[ i ];
audioBuffer[ bufferBack + i + 3 ] = p[ i + 1 ];
}
buffer_pos += i;
bufferBack += i;
}
else
{
@ -389,372 +317,76 @@ EXPORT void CALL AiLenChanged( void )
}
}
EXPORT int CALL InitiateAudio( AUDIO_INFO Audio_Info )
{
if (!l_PluginInit)
return 0;
AudioInfo = Audio_Info;
return 1;
}
static int underrun_count = 0;
#ifdef USE_SRC
static float *_src = NULL;
static unsigned int _src_len = 0;
static float *_dest = NULL;
static unsigned int _dest_len = 0;
static int error;
static SRC_STATE *src_state;
static SRC_DATA src_data;
#endif
#ifdef USE_SPEEX
SpeexResamplerState* spx_state = NULL;
static int error;
#endif
EXPORT int CALL RomOpen(void)
{
if (!l_PluginInit)
return 0;
ReadConfig();
InitializeAudio(GameFreq);
return 1;
}
static void CreatePrimaryBuffer(void)
{
unsigned int newPrimaryBytes = (unsigned int) ((long long) PrimaryBufferSize * GameFreq * speed_factor /
(OutputFreq * 100)) * N64_SAMPLE_BYTES;
if (primaryBuffer == NULL)
{
DebugMessage(M64MSG_VERBOSE, "Allocating memory for audio buffer: %i bytes.", newPrimaryBytes);
primaryBuffer = (unsigned char*) malloc(newPrimaryBytes);
memset(primaryBuffer, 0, newPrimaryBytes);
primaryBufferBytes = newPrimaryBytes;
}
else if (newPrimaryBytes > primaryBufferBytes) /* primary buffer only grows; there's no point in shrinking it */
{
unsigned char *newPrimaryBuffer = (unsigned char*) malloc(newPrimaryBytes);
unsigned char *oldPrimaryBuffer = primaryBuffer;
memcpy(newPrimaryBuffer, oldPrimaryBuffer, primaryBufferBytes);
memset(newPrimaryBuffer + primaryBufferBytes, 0, newPrimaryBytes - primaryBufferBytes);
primaryBuffer = newPrimaryBuffer;
primaryBufferBytes = newPrimaryBytes;
free(oldPrimaryBuffer);
}
}
static void InitializeAudio(int freq)
static void SetSamplingRate(int freq)
{
GameFreq = freq; // This is important for the sync
if(freq < 11025) OutputFreq = 11025;
else if(freq < 22050) OutputFreq = 22050;
else OutputFreq = 44100;
OutputFreq = 11025;
/* reload these because they gets re-assigned from SDL data below, and InitializeAudio can be called more than once */
PrimaryBufferSize = ConfigGetParamInt(l_ConfigAudio, "PRIMARY_BUFFER_SIZE");
PrimaryBufferTarget = ConfigGetParamInt(l_ConfigAudio, "PRIMARY_BUFFER_TARGET");
SecondaryBufferSize = ConfigGetParamInt(l_ConfigAudio, "SECONDARY_BUFFER_SIZE");
if (PrimaryBufferTarget < SecondaryBufferSize)
PrimaryBufferTarget = SecondaryBufferSize;
if (PrimaryBufferSize < PrimaryBufferTarget)
PrimaryBufferSize = PrimaryBufferTarget;
if (PrimaryBufferSize < SecondaryBufferSize * 2)
PrimaryBufferSize = SecondaryBufferSize * 2;
CreatePrimaryBuffer();
if (mixBuffer != NULL)
free(mixBuffer);
mixBuffer = (unsigned char*) malloc(SecondaryBufferSize * SDL_SAMPLE_BYTES);
}
EXPORT void CALL RomClosed( void )
{
if (!l_PluginInit)
return;
if (critical_failure == 1)
return;
// Delete the buffer, as we are done producing sound
if (primaryBuffer != NULL)
{
primaryBufferBytes = 0;
free(primaryBuffer);
primaryBuffer = NULL;
}
}
#pragma endregion
#pragma region Unused methods
/* ----------------------------------------------------------------------
* ------------ STUBS. WE DO NOT USE THESE API FUNCTIONS ---------------
* -------- MUPEN EXPECTS THEM AND FAILS IF THEY DON'T EXIST ------------
* ---------------------------------------------------------------------- */
EXPORT void CALL ProcessAList(void)
{
}
EXPORT void CALL SetSpeedFactor(int percentage)
{
if (!l_PluginInit)
return;
if (percentage >= 10 && percentage <= 300)
speed_factor = percentage;
// we need a different size primary buffer to store the N64 samples when the speed changes
CreatePrimaryBuffer();
}
static void ReadConfig(void)
{
const char *resampler_id;
/* read the configuration values into our static variables */
GameFreq = ConfigGetParamInt(l_ConfigAudio, "DEFAULT_FREQUENCY");
SwapChannels = ConfigGetParamBool(l_ConfigAudio, "SWAP_CHANNELS");
PrimaryBufferSize = ConfigGetParamInt(l_ConfigAudio, "PRIMARY_BUFFER_SIZE");
PrimaryBufferTarget = ConfigGetParamInt(l_ConfigAudio, "PRIMARY_BUFFER_TARGET");
SecondaryBufferSize = ConfigGetParamInt(l_ConfigAudio, "SECONDARY_BUFFER_SIZE");
resampler_id = ConfigGetParamString(l_ConfigAudio, "RESAMPLE");
VolumeControlType = ConfigGetParamInt(l_ConfigAudio, "VOLUME_CONTROL_TYPE");
VolDelta = ConfigGetParamInt(l_ConfigAudio, "VOLUME_ADJUST");
VolPercent = ConfigGetParamInt(l_ConfigAudio, "VOLUME_DEFAULT");
if (!resampler_id) {
Resample = RESAMPLER_TRIVIAL;
DebugMessage(M64MSG_WARNING, "Could not find RESAMPLE configuration; use trivial resampler");
return;
}
if (strcmp(resampler_id, "trivial") == 0) {
Resample = RESAMPLER_TRIVIAL;
return;
}
#ifdef USE_SPEEX
if (strncmp(resampler_id, "speex-fixed-", strlen("speex-fixed-")) == 0) {
int i;
static const char *speex_quality[] = {
"speex-fixed-0",
"speex-fixed-1",
"speex-fixed-2",
"speex-fixed-3",
"speex-fixed-4",
"speex-fixed-5",
"speex-fixed-6",
"speex-fixed-7",
"speex-fixed-8",
"speex-fixed-9",
"speex-fixed-10",
};
Resample = RESAMPLER_SPEEX;
for (i = 0; i < sizeof(speex_quality) / sizeof(*speex_quality); i++) {
if (strcmp(speex_quality[i], resampler_id) == 0) {
ResampleQuality = i;
return;
}
}
DebugMessage(M64MSG_WARNING, "Unknown RESAMPLE configuration %s; use speex-fixed-4 resampler", resampler_id);
ResampleQuality = 4;
return;
}
#endif
#ifdef USE_SRC
if (strncmp(resampler_id, "src-", strlen("src-")) == 0) {
Resample = RESAMPLER_SRC;
if (strcmp(resampler_id, "src-sinc-best-quality") == 0) {
ResampleQuality = SRC_SINC_BEST_QUALITY;
return;
}
if (strcmp(resampler_id, "src-sinc-medium-quality") == 0) {
ResampleQuality = SRC_SINC_MEDIUM_QUALITY;
return;
}
if (strcmp(resampler_id, "src-sinc-fastest") == 0) {
ResampleQuality = SRC_SINC_FASTEST;
return;
}
if (strcmp(resampler_id, "src-zero-order-hold") == 0) {
ResampleQuality = SRC_ZERO_ORDER_HOLD;
return;
}
if (strcmp(resampler_id, "src-linear") == 0) {
ResampleQuality = SRC_LINEAR;
return;
}
DebugMessage(M64MSG_WARNING, "Unknown RESAMPLE configuration %s; use src-sinc-medium-quality resampler", resampler_id);
ResampleQuality = SRC_SINC_MEDIUM_QUALITY;
return;
}
#endif
DebugMessage(M64MSG_WARNING, "Unknown RESAMPLE configuration %s; use trivial resampler", resampler_id);
Resample = RESAMPLER_TRIVIAL;
}
// Returns the most recent ummuted volume level.
static int VolumeGetUnmutedLevel(void)
{
#if defined(HAS_OSS_SUPPORT)
// reload volume if we're using OSS
if (!VolIsMuted && VolumeControlType == VOLUME_TYPE_OSS)
{
return volGet();
}
#endif
return VolPercent;
return 100;
}
EXPORT void CALL VolumeMute(void)
{
if (!l_PluginInit)
return;
// Store the volume level in order to restore it later
if (!VolIsMuted)
VolPercent = VolumeGetUnmutedLevel();
// Toogle mute
VolIsMuted = !VolIsMuted;
}
EXPORT void CALL VolumeUp(void)
{
if (!l_PluginInit)
return;
VolumeSetLevel(VolumeGetUnmutedLevel() + VolDelta);
}
EXPORT void CALL VolumeDown(void)
{
if (!l_PluginInit)
return;
VolumeSetLevel(VolumeGetUnmutedLevel() - VolDelta);
}
EXPORT int CALL VolumeGetLevel(void)
{
return VolIsMuted ? 0 : VolumeGetUnmutedLevel();
return 100;
}
EXPORT void CALL VolumeSetLevel(int level)
{
if (!l_PluginInit)
return;
//if muted, unmute first
VolIsMuted = 0;
// adjust volume
VolPercent = level;
if (VolPercent < 0)
VolPercent = 0;
else if (VolPercent > 100)
VolPercent = 100;
}
EXPORT const char * CALL VolumeGetString(void)
{
static char VolumeString[32];
if (VolIsMuted)
{
strcpy(VolumeString, "Mute");
}
else
{
sprintf(VolumeString, "%i%%", VolPercent);
}
return VolumeString;
}
static int resample(unsigned char *input, int input_avail, int oldsamplerate, unsigned char *output, int output_needed, int newsamplerate)
{
int *psrc = (int*)input;
int *pdest = (int*)output;
int i = 0, j = 0;
// RESAMPLE == TRIVIAL
if (newsamplerate >= oldsamplerate)
{
int sldf = oldsamplerate;
int const2 = 2*sldf;
int dldf = newsamplerate;
int const1 = const2 - 2*dldf;
int criteria = const2 - dldf;
for (i = 0; i < output_needed/4; i++)
{
pdest[i] = psrc[j];
if(criteria >= 0)
{
++j;
criteria += const1;
}
else criteria += const2;
}
return j * 4; //number of bytes consumed
}
// newsamplerate < oldsamplerate, this only happens when speed_factor > 1
for (i = 0; i < output_needed/4; i++)
{
j = i * oldsamplerate / newsamplerate;
pdest[i] = psrc[j];
}
return j * 4; //number of bytes consumed
}
EXPORT void CALL my_audio_callback(unsigned char *stream, int len)
{
int oldsamplerate, newsamplerate;
if (!l_PluginInit)
return;
newsamplerate = OutputFreq * 100 / speed_factor;
oldsamplerate = GameFreq;
if (buffer_pos > (unsigned int) (len * oldsamplerate) / newsamplerate)
{
int input_used;
{
input_used = resample(primaryBuffer, buffer_pos, oldsamplerate, stream, len, newsamplerate);
}
memmove(primaryBuffer, &primaryBuffer[input_used], buffer_pos - input_used);
buffer_pos -= input_used;
DebugMessage(M64MSG_VERBOSE, "my_audio_callback: used %i samples",
len / 4);
}
else
{
unsigned int SamplesNeeded = (len * oldsamplerate) / (newsamplerate * 4);
unsigned int SamplesPresent = buffer_pos / N64_SAMPLE_BYTES;
underrun_count++;
DebugMessage(M64MSG_VERBOSE, "Buffer underflow (%i). %i samples present, %i needed",
underrun_count, SamplesPresent, SamplesNeeded);
memset(stream , 0, len);
}
return "100%";
}
/* ----------------------------------------------------------------------
* --------------------------- STUBS END --------------------------------
* ---------------------------------------------------------------------- */
#pragma endregion
#pragma region Buffer export
/* --- Moves content of audio buffer to destination --- */
EXPORT void CALL ReadAudioBuffer(short* dest)
{
int i;
short * src = (short*)primaryBuffer;
for (i = 0; i < buffer_pos/2; i++)
{
dest[i] = src[i];
}
buffer_pos = 0;
memcpy(dest, audioBuffer, bufferBack);
bufferBack = 0;
}
/* --- Returns number of shorts of internal data --- */
EXPORT int CALL GetBufferSize()
{
return buffer_pos/2;
return max(bufferBack/2, 0);
}
/* --- Returns current sampling rate --- */
EXPORT int CALL GetAudioRate()
{
return GameFreq;
}
}
#pragma endregion

2
libmupen64plus/mupen64plus-audio-bkm/main.h
View File

@ -20,7 +20,7 @@
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* version info */
#define SDL_AUDIO_PLUGIN_VERSION 0x016305
#define BKM_AUDIO_PLUGIN_VERSION 0x016305
#define AUDIO_PLUGIN_API_VERSION 0x020000
#define CONFIG_API_VERSION 0x020100
#define CONFIG_PARAM_VERSION 1.00

2
libmupen64plus/mupen64plus-audio-bkm/mupen64plus-audio-bkm/mupen64plus-audio-bkm.vcxproj
View File

@ -71,7 +71,7 @@
<OptimizeReferences>true</OptimizeReferences>
</Link>
<PostBuildEvent>
<Command>xcopy /y $(OutDir)$(TargetName)$(TargetExt) $(TargetDir)..\..\..\..\..\output\dll\</Command>
<Command>xcopy /y "$(OutDir)$(TargetName)$(TargetExt)" "$(TargetDir)..\..\..\..\..\output\dll\"</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemGroup>

BIN
output/dll/mupen64plus-audio-bkm.dll
View File

Binary file not shown.