shawn/op-pedal
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP Sync

Browse Source
This commit is contained in:
Robin E.R. Davies
2026-01-27 23:45:13 -05:00
parent 96cb9967aa
commit 6c441ecfee
28 changed files with 480 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/AlsaDriverTest.cpp
+109 -94
View File
@@ -1,18 +1,18 @@
/*
* MIT License
*
*
* Copyright (c) 2022 Robin E. R. Davies
*
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is furnished to do
* so, subject to the following conditions:
*
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -27,28 +27,34 @@
#include <cmath>
#include <mutex>
#include <iostream>
#include <algorithm>
#include "AlsaDriver.hpp"
#include "JackDriver.hpp"
#include "ChannelRouterSettings.hpp"
using namespace pipedal;
using namespace std;
class AlsaTester: private AudioDriverHost {
class AlsaTester : private AudioDriverHost
{
public:
enum class TestType { Oscillator, LatencyMonitor, NullTest};
enum class TestType
{
Oscillator,
LatencyMonitor,
NullTest
};
private:
AudioDriver *audioDriver = nullptr;
TestType testType;
public:
AlsaTester(TestType testType)
: testType(testType)
: testType(testType)
{
// audioDriver = CreateAlsaDriver(this);
// audioDriver = CreateJackDriver(this);
}
~AlsaTester()
{
@@ -57,47 +63,47 @@ public:
delete[] outputBuffers;
}
bool useJack = false;
void initializeChannelSelection(JackConfiguration &jackConfiguration, ChannelSelection &channelSelection)
{
size_t nInputs = std::max(jackConfiguration.inputAudioPorts().size(),size_t(2));
size_t nOutputs = std::max(jackConfiguration.outputAudioPorts().size(),size_t(2));
auto &inputSelections = channelSelection.mainInputChannels();
auto &outputSelections = channelSelection.mainOutputChannels();
inputSelections.resize(nInputs);
for (size_t i = 0; i < nInputs; ++i)
{
inputSelections[i] = i;
}
outputSelections.resize(nOutputs);
for (size_t i = 0; i < nOutputs; ++i)
{
outputSelections[i] = i;
}
}
void Test()
{
AlsaFormatEncodeDecodeTest(this);
JackServerSettings serverSettings("hw:M2","hw:M2",48000,32,3);
JackServerSettings serverSettings("hw:M2", "hw:M2", 48000, 32, 3);
JackConfiguration jackConfiguration;
if (useJack)
{
jackConfiguration.JackInitialize();
} else {
jackConfiguration.AlsaInitialize(serverSettings);
}
jackConfiguration.AlsaInitialize(serverSettings);
JackChannelSelection channelSelection(
jackConfiguration.inputAudioPorts(),
jackConfiguration.outputAudioPorts(),
jackConfiguration.inputMidiDevices());
ChannelSelection channelSelection;
#if JACK_HOST
if (useJack)
{
audioDriver = CreateJackDriver(this);
} else {
audioDriver = CreateAlsaDriver(this);
}
#else
audioDriver = CreateAlsaDriver(this);
#endif
initializeChannelSelection(jackConfiguration, channelSelection);
oscillator.Init(440,jackConfiguration.sampleRate());
oscillator.Init(440, jackConfiguration.sampleRate());
latencyMonitor.Init(jackConfiguration.sampleRate());
audioDriver->Open(serverSettings,channelSelection);
audioDriver->Open(serverSettings, channelSelection);
inputBuffers = new float*[channelSelection.GetInputAudioPorts().size()];
outputBuffers = new float*[channelSelection.GetOutputAudioPorts().size()];
inputBuffers = new float *[channelSelection.mainInputChannels().size()];
outputBuffers = new float *[channelSelection.mainOutputChannels().size()];
audioDriver->Activate();
@@ -107,7 +113,7 @@ public:
if (testType == TestType::LatencyMonitor)
{
auto latency = this->latencyMonitor.GetLatency();
double ms = 1000.0*latency/jackConfiguration.sampleRate();
double ms = 1000.0 * latency / jackConfiguration.sampleRate();
cout << "Latency: " << latency << " samples " << ms << "ms" << " xruns: " << GetXruns() << " Cpu: " << audioDriver->CpuUse() << "%" << endl;
}
@@ -115,37 +121,40 @@ public:
audioDriver->Deactivate();
audioDriver->Close();
}
float**inputBuffers = nullptr;
float**outputBuffers = nullptr;
float **inputBuffers = nullptr;
float **outputBuffers = nullptr;
class Oscillator {
class Oscillator
{
private:
double dx = 0;
double x = 0;
double dx2 = 0;
double x2 = 0;
public:
public:
void Init(float frequency, size_t sampleRate)
{
dx = frequency*3.141592736*2/sampleRate;
dx2 = 0.5*3.141592736*2/sampleRate;
dx = frequency * 3.141592736 * 2 / sampleRate;
dx2 = 0.5 * 3.141592736 * 2 / sampleRate;
}
float Next() {
float Next()
{
float result = (float)std::cos(x);
float env = (float)std::cos(x2);
x += dx;
x2 += dx2;
return result*env;
return result * env;
}
};
class LatencyMonitor {
enum class State {
class LatencyMonitor
{
enum class State
{
Idle,
Waiting,
};
@@ -156,67 +165,74 @@ public:
size_t current_latency = 0;
size_t latency = 0;
std::mutex sync;
public:
void Init(uint64_t sampleRate)
{
idle_samples = (uint64_t)sampleRate*2;
waiting_samples = (uint64_t)sampleRate*2;
idle_samples = (uint64_t)sampleRate * 2;
waiting_samples = (uint64_t)sampleRate * 2;
state = State::Idle;
t = idle_samples;
latency = 0;
}
size_t GetLatency() {
std::lock_guard lock { sync};
size_t GetLatency()
{
std::lock_guard lock{sync};
return latency;
}
float Next(float input)
{
switch(state)
switch (state)
{
default:
case State::Idle:
default:
case State::Idle:
{
if (t-- == 0)
{
if (t-- == 0) {
state = State::Waiting;
current_latency = 0;
}
return 0.01;
state = State::Waiting;
current_latency = 0;
}
break;
case State::Waiting:
return 0.01;
}
break;
case State::Waiting:
{
if (std::abs(input) > 0.1 || current_latency > 500)
{
if (std::abs(input) > 0.1 || current_latency > 500) {
{
std::lock_guard lock { sync};
latency = current_latency;
}
state = State::Idle;
t = idle_samples;
} else {
++current_latency;
{
std::lock_guard lock{sync};
latency = current_latency;
}
return current_latency < 100 ? 0.25 : 0.0;
state = State::Idle;
t = idle_samples;
}
break;
else
{
++current_latency;
}
return current_latency < 100 ? 0.25 : 0.0;
}
break;
}
}
};
Oscillator oscillator;
LatencyMonitor latencyMonitor;
virtual void OnAudioTerminated() {
virtual void OnAudioTerminated()
{
}
virtual void OnAlsaDriverStopped() {
virtual void OnAlsaDriverStopped()
{
}
virtual void OnProcess(size_t nFrames) {
if (testType == TestType::NullTest) return;
virtual void OnProcess(size_t nFrames)
{
if (testType == TestType::NullTest)
return;
size_t inputs = audioDriver->MainInputBufferCount();
size_t outputs = audioDriver->MainOutputBufferCount();
@@ -233,14 +249,15 @@ public:
{
for (size_t i = 0; i < nFrames; ++i)
{
float v = oscillator.Next()*0.25f;
float v = oscillator.Next() * 0.25f;
for (size_t c = 0; c < outputs; ++c)
{
outputBuffers[c][i] = v;
}
}
}
else {
else
{
for (size_t i = 0; i < nFrames; ++i)
{
float v = latencyMonitor.Next(inputBuffers[0][i]);
@@ -249,36 +266,34 @@ public:
outputBuffers[c][i] = v;
}
}
}
}
std::mutex sync;
uint64_t xruns;
uint64_t GetXruns() {
lock_guard lock { sync};
uint64_t GetXruns()
{
lock_guard lock{sync};
return xruns;
}
virtual void OnUnderrun() {
lock_guard lock { sync };
virtual void OnUnderrun()
{
lock_guard lock{sync};
++xruns;
}
};
TEST_CASE("alsa_test", "[alsa_test]")
{
TEST_CASE( "alsa_test", "[alsa_test]" ) {
AlsaTester alsaDriver(AlsaTester::TestType::Oscillator);
alsaDriver.Test();
}
TEST_CASE( "alsa_midi_test", "[alsa_midi_test]" ) {
TEST_CASE("alsa_midi_test", "[alsa_midi_test]")
{
AlsaTester alsaDriver(AlsaTester::TestType::Oscillator);
MidiDecoderTest();
}