mirror of
https://github.com/libretro/bsnes-libretro.git
synced 2024-11-23 08:59:40 +00:00
fdc41611cf
byuu says:
Changelog:
- improved attenuation of biquad filter by computing butterworth Q
coefficients correctly (instead of using the same constant)
- adding 1e-25 to each input sample into the biquad filters to try and
prevent denormalization
- updated normalization from [0.0 to 1.0] to [-1.0 to +1.0]; volume/reverb
happen in floating-point mode now
- good amount of work to make the base Emulator::Audio support any number
of output channels
- so that we don't have to do separate work on left/right channels;
and can instead share the code for each channel
- Emulator::Interface::audioSample(int16 left, int16 right); changed to:
- Emulator::Interface::audioSample(double* samples, uint channels);
- samples are normalized [-1.0 to +1.0]
- for now at least, channels will be the value given to
Emulator::Audio::reset()
- fixed GUI crash on startup when audio driver is set to None
I'm probably going to be updating ruby to accept normalized doubles as
well; but I'm not sure if I will try and support anything other 2-channel
audio output. It'll depend on how easy it is to do so; perhaps it'll be
a per-driver setting.
The denormalization thing is fierce. If that happens, it drops the
emulator framerate from 220fps to about 20fps for Game Boy emulation. And
that happens basically whenever audio output is silent. I'm probably
also going to make a nall/denormal.hpp file at some point with
platform-specific functionality to set the CPU state to "denormals as
zero" where applicable. I'll still add the 1e-25 offset (inaudible)
as another fallback.
57 lines
1.7 KiB
C++
57 lines
1.7 KiB
C++
#pragma once
|
|
|
|
namespace nall {
|
|
|
|
struct Interpolation {
|
|
static inline auto Nearest(double mu, double a, double b, double c, double d) -> double {
|
|
return (mu <= 0.5 ? b : c);
|
|
}
|
|
|
|
static inline auto Sublinear(double mu, double a, double b, double c, double d) -> double {
|
|
mu = ((mu - 0.5) * 2.0) + 0.5;
|
|
if(mu < 0) mu = 0;
|
|
if(mu > 1) mu = 1;
|
|
return b * (1.0 - mu) + c * mu;
|
|
}
|
|
|
|
static inline auto Linear(double mu, double a, double b, double c, double d) -> double {
|
|
return b * (1.0 - mu) + c * mu;
|
|
}
|
|
|
|
static inline auto Cosine(double mu, double a, double b, double c, double d) -> double {
|
|
mu = (1.0 - cos(mu * Math::Pi)) / 2.0;
|
|
return b * (1.0 - mu) + c * mu;
|
|
}
|
|
|
|
static inline auto Cubic(double mu, double a, double b, double c, double d) -> double {
|
|
double A = d - c - a + b;
|
|
double B = a - b - A;
|
|
double C = c - a;
|
|
double D = b;
|
|
return A * (mu * mu * mu) + B * (mu * mu) + C * mu + D;
|
|
}
|
|
|
|
static inline auto Hermite(double mu1, double a, double b, double c, double d) -> double {
|
|
const double tension = 0.0; //-1 = low, 0 = normal, +1 = high
|
|
const double bias = 0.0; //-1 = left, 0 = even, +1 = right
|
|
double mu2, mu3, m0, m1, a0, a1, a2, a3;
|
|
|
|
mu2 = mu1 * mu1;
|
|
mu3 = mu2 * mu1;
|
|
|
|
m0 = (b - a) * (1.0 + bias) * (1.0 - tension) / 2.0;
|
|
m0 += (c - b) * (1.0 - bias) * (1.0 - tension) / 2.0;
|
|
m1 = (c - b) * (1.0 + bias) * (1.0 - tension) / 2.0;
|
|
m1 += (d - c) * (1.0 - bias) * (1.0 - tension) / 2.0;
|
|
|
|
a0 = +2 * mu3 - 3 * mu2 + 1;
|
|
a1 = mu3 - 2 * mu2 + mu1;
|
|
a2 = mu3 - mu2;
|
|
a3 = -2 * mu3 + 3 * mu2;
|
|
|
|
return (a0 * b) + (a1 * m0) + (a2 * m1) + (a3 * c);
|
|
}
|
|
};
|
|
|
|
}
|