lcoogan
/
flucoma-sc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updates to wrapper for HPSS freq-amp pairs parameter, improved kontrol input handling. Updated object stubs

Browse Source 
include/FluidSCWrapper.hpp
src/FluidBufHPSS/FluidBufHPSS.cpp
src/FluidBufNoveltySlice/FluidBufNoveltySlice.cpp
src/FluidHPSS/FluidHPSS.cpp
nix
Owen Green 7 years ago
parent 4ee4d8edfa
commit 5496a72a18
4 changed files with 73 additions and 293 deletions
Show Stats Download Patch File Download Diff File

64
include/FluidSCWrapper.hpp
Unescape Escape View File

@ -19,6 +19,7 @@ namespace client {
template <typename Client> class FluidSCWrapper;
namespace impl {
template <typename Client, typename T, size_t N> struct Setter;
template <size_t N, typename T> struct ArgumentGetter;
template <size_t N, typename T> struct ControlGetter;
@ -33,11 +34,33 @@ template <size_t N, typename T, msg_iter_method<T> Method> struct GetArgument
}
};
template <size_t N, typename T> struct GetControl
struct FloatControlsIter
{
T operator()(World*, float **controls) { return *controls[N]; }
FloatControlsIter(float** vals, size_t N):mValues(vals), mSize(N) {}
float next()
{
assert(mCount + 1 < mSize);
return *mValues[mCount++];
}
void reset(float** vals)
{
mValues = vals;
mCount = 0;
}
private:
float** mValues;
size_t mSize;
size_t mCount{0};
};
template <size_t N, typename T> struct GetControl
{
T operator()(World*, FloatControlsIter& controls) { return controls.next(); }
};
template <size_t N> struct ArgumentGetter<N, FloatT> : public GetArgument<N, float, &sc_msg_iter::getf>
{};
@ -59,9 +82,38 @@ template <size_t N> struct ArgumentGetter<N, BufferT>
}
};
template <size_t N> struct ArgumentGetter<N, FloatPairsArrayT>
{
typename FloatPairsArrayT::type operator()(World* w, sc_msg_iter *args)
{
return {{args->getf(),args->getf()},{args->getf(),args->getf()}};
}
};
template <size_t N, typename T> struct ControlGetter : public GetControl<N, typename T::type>
{};
template <size_t N> struct ControlGetter<N, BufferT>
{
auto operator()(World* w, FloatControlsIter& iter)
{
long bufnum = iter.next();
return std::unique_ptr<BufferAdaptor>(new SCBufferAdaptor(bufnum,w));
}
};
template<size_t N>
struct ControlGetter<N,FloatPairsArrayT>
{
typename FloatPairsArrayT::type operator()(World*, FloatControlsIter& iter)
{
return {{iter.next(),iter.next()},{iter.next(),iter.next()}};
}
};
//template <size_t N, typename
template <class Wrapper> class RealTime : public SCUnit
@ -72,7 +124,7 @@ template <class Wrapper> class RealTime : public SCUnit
public:
static void setup(InterfaceTable *ft, const char *name) { registerUnit<Wrapper>(ft, name); }
RealTime() {}
RealTime():mControlsIterator{nullptr,0} {}
void init()
{
@ -105,7 +157,8 @@ public:
{
Wrapper *w = static_cast<Wrapper *>(this);
auto &client = w->client();
w->setParams( mWorld->mVerbosity > 0, mWorld,mInBuf + client.audioChannelsIn()); // forward on inputs N + audio inputs as params
mControlsIterator.reset(mInBuf + client.audioChannelsIn());
w->setParams( mWorld->mVerbosity > 0, mWorld,mControlsIterator); // forward on inputs N + audio inputs as params
const Unit *unit = this;
for (int i = 0; i < client.audioChannelsIn(); ++i)
{
@ -123,6 +176,7 @@ private:
std::vector<bool> mOutputConnections;
std::vector<HostVector> mAudioInputs;
std::vector<HostVector> mAudioOutputs;
FloatControlsIter mControlsIterator;
};
template <class Wrapper> class NonRealTime
@ -292,7 +346,7 @@ public:
impl::FluidSCWrapperBase<Client>::setup(ft, name);
}
auto setParams(bool verbose, World* world, float **inputs)
auto setParams(bool verbose, World* world, impl::FloatControlsIter& inputs)
{
return mClient.template setParameterValues<impl::ControlGetter>(verbose, world, inputs);
}

97
src/FluidBufHPSS/FluidBufHPSS.cpp
Unescape Escape View File

@ -1,101 +1,14 @@
// FD_BufHPSS, an NRT buffer HPSS Processor
// A tool from the FluCoMa project, funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899)
#include "fdNRTBase.hpp"
#include "algorithms/STFT.hpp"
#include "data/FluidTensor.hpp"
#include "clients/nrt/HPSS.hpp"
#include "clients/common/FluidParams.hpp"
#include "SC_PlugIn.h"
#include <unordered_set>
#include <vector>
#include <clients/rt/HPSSClient.hpp>
#include <clients/nrt/FluidNRTClientWrapper.hpp>
#include <FluidSCWrapper.hpp>
static InterfaceTable *ft;
//Using statements for fluidtensor
using fluid::FluidTensor;
using fluid::FluidTensorView;
namespace fluid {
namespace wrapper{
class BufHPSS: public NRTCommandBase
{
/*
- srcbuf num
– src start frame
- src numframes
– src start chan
– src num chans
– harms dst
– perc dst
– window size
– hop size
– fft size
*/
public:
using client_type = client::HPSSClient;
using NRTCommandBase::NRTCommandBase;
~BufHPSS() {}
void runCommand(World* world, void* replyAddr, char* completionMsgData, size_t completionMsgSize)
{
cmd<BufHPSS, &BufHPSS::process, &BufHPSS::postProcess, &BufHPSS::postComplete>(world, "/BufHPSS", replyAddr, completionMsgData, completionMsgSize);
}
bool process(World* world)
{
//sanity check the parameters
bool parametersOk;
client::HPSSClient::ProcessModel processModel;
std::string whatHappened;//this will give us a message to pass back if param check fails
std::tie(parametersOk,whatHappened,processModel) = processor.sanityCheck();
if(!parametersOk)
{
Print("fdHPSS: %s \n", whatHappened.c_str());
return false;
}
//Now, we can proceed
processor.process(processModel);
mModel = processModel;
return true;
}
bool postProcess(World* world)
{
static_cast<SCBufferView*>(mModel.harm)->assignToRT(world);
static_cast<SCBufferView*>(mModel.perc)->assignToRT(world);
if(mModel.res)
static_cast<SCBufferView*>(mModel.res)->assignToRT(world);
return true;
}
bool postComplete(World*) {
static_cast<SCBufferView*>(mModel.harm)->cleanUp();
static_cast<SCBufferView*>(mModel.perc)->cleanUp();
if(mModel.res)
static_cast<SCBufferView*>(mModel.res)->cleanUp();
return true;
}
std::vector<client::Instance>& parameters()
{
return processor.getParams();
}
private:
client::HPSSClient processor;
client::HPSSClient::ProcessModel mModel;
};//class
} //namespace wrapper
}//namespace fluid
PluginLoad(OfflineFluidDecompositionUGens) {
ft = inTable;
registerCommand<fluid::wrapper::BufHPSS,fluid::client::HPSSClient>(ft, "BufHPSS");
fluid::wrapper::printCmd<fluid::client::HPSSClient>(ft,"BufHPSS","FDHPSS");
using namespace fluid::client;
makeSCWrapper<NRTStreamAdaptor<HPSSClient<double,float>>>(ft, "BufHPSS");
}

71
src/FluidBufNoveltySlice/FluidBufNoveltySlice.cpp
Unescape Escape View File

@ -2,74 +2,13 @@
// A tool from the FluCoMa project, funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899)
#include "clients/nrt/NoveltyClient.hpp"
#include "fdNRTBase.hpp"
#include "data/FluidTensor.hpp"
#include "clients/common/FluidParams.hpp"
//#include "SC_PlugIn.h"
//#include <unordered_set>
//#include <vector>
static InterfaceTable *ft;
namespace fluid {
namespace wrapper{
class BufNoveltySlice: public NRTCommandBase
{
public:
using client_type = client::NoveltyClient;
using NRTCommandBase::NRTCommandBase;
~BufNoveltySlice() {}
void runCommand(World* world, void* replyAddr, char* completionMsgData, size_t completionMsgSize)
{
cmd<BufNoveltySlice, &BufNoveltySlice::process, &BufNoveltySlice::postProcess, &BufNoveltySlice::postComplete>(world, "/BufNoveltySlice", replyAddr, completionMsgData, completionMsgSize);
}
bool process(World* world)
{
//sanity check the parameters
bool parametersOk;
client_type::ProcessModel processModel;
std::string whatHappened;//this will give us a message to pass back if param check fails
std::tie(parametersOk,whatHappened,processModel) = trans.sanityCheck();
if(!parametersOk)
{
Print("FluidBufNovletySlice: %s \n", whatHappened.c_str());
return false;
}
trans.process(processModel);
mModel = processModel;
return true;
}
bool postProcess(World* world)
{
static_cast<SCBufferView*>(mModel.indices)->assignToRT(world);
return true;
}
bool postComplete(World*) {
static_cast<SCBufferView*>(mModel.indices)->cleanUp();
return true;
}
std::vector<client::Instance>& parameters()
{
return trans.getParams();
}
private:
client_type trans;
client_type::ProcessModel mModel;
};//class
} //namespace wrapper
}//namespace fluid
#include <clients/nrt/NoveltyClient.hpp>
#include <FluidSCWrapper.hpp>
static InterfaceTable* ft;
PluginLoad(OfflineFluidDecompositionUGens) {
ft = inTable;
registerCommand<fluid::wrapper::BufNoveltySlice,fluid::client::NoveltyClient>(ft, "BufNoveltySlice");
fluid::wrapper::printCmd<fluid::client::NoveltyClient>(ft,"BufNoveltySlice","FluidBufNoveltySlice");
using namespace fluid::client;
makeSCWrapper<NoveltyClient>(ft, "BufNoveltySlice");
}

134
src/FluidHPSS/FluidHPSS.cpp
Unescape Escape View File

@ -1,140 +1,14 @@
// A tool from the FluCoMa project, funded by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 725899)
#include "SC_PlugIn.hpp"
#include "data/FluidTensor.hpp"
#include "clients/rt/HPSSClient.hpp"
#include <clients/rt/HPSSClient.hpp>
#include <FluidSCWrapper.hpp>
static InterfaceTable *ft;
namespace fluid {
namespace wrapper{
class FDRTHPSS: public SCUnit
{
using AudioSignalWrapper = client::HPSSClient<double, float>::AudioSignal;
using SignalWrapper = client::HPSSClient<double, float>::Signal<float>;
using SignalPointer = std::unique_ptr<SignalWrapper>;
using ClientPointer = std::unique_ptr<client::HPSSClient<double,float>>;
template <size_t N>
using SignalArray = std::array<SignalPointer,N>;
public:
FDRTHPSS()
{
//Order of args
//psize hszie pthresh hthresh Window size, Hop size, FFT Size
//Oh NO! Heap allocation! Make client object
mClient = ClientPointer(new client::HPSSClient<double,float>(65536));
setParams(true);
bool isOK;
std::string feedback;
std::tie(isOK, feedback) = mClient->sanityCheck();
if(!isOK)
{
Print("fdRTHPSS Error: %s",feedback.c_str());
return;
}
mClient->setHostBufferSize(bufferSize());
mClient->reset();
//Work out what signals we need. For now keep it simple:
inputSignals[0] = SignalPointer(new AudioSignalWrapper());
outputSignals[0] = SignalPointer(new AudioSignalWrapper());
outputSignals[1] = SignalPointer(new AudioSignalWrapper());
outputSignals[2] = SignalPointer(new AudioSignalWrapper());
mCalcFunc = make_calc_function<FDRTHPSS,&FDRTHPSS::next>();
Unit* unit = this;
ClearUnitOutputs(unit,1);
}
~FDRTHPSS() {}
private:
void setParams(bool instantiation)
{
assert(mClient);
for(size_t i = 0; i < mClient->getParams().size(); ++i)
{
client::Instance& p = mClient->getParams()[i];
if(!instantiation && p.getDescriptor().instantiation())
continue;
switch(p.getDescriptor().getType())
{
case client::Type::kLong:
p.setLong(in0(i + 1));
p.checkRange();
break;
case client::Type::kFloat: {
// We need to constrain threshold (normalised) frequency pairs at
// runtime.
std::string attrname = p.getDescriptor().getName();
auto constraint = paramConstraints.find(attrname);
if (constraint != paramConstraints.end()) {
double limit = client::lookupParam(constraint->second.param,
mClient->getParams())
.getFloat();
if (!constraint->second.condition(in0(i + 1), limit)) {
return;
}
}
p.setFloat(in0(i + 1));
p.checkRange();
}
break;
case client::Type::kBuffer:
// p.setBuffer( in0(i+1));
break;
default:
break;
}
}
}
void next(int numsamples)
{
setParams(false);
const float* input = in(0);
const float inscalar = in0(0);
inputSignals[0]->set(const_cast<float*>(input), inscalar);
outputSignals[0]->set(out(0), out0(0));
outputSignals[1]->set(out(1), out0(1));
outputSignals[2]->set(out(2), out0(2));
mClient->doProcess(std::begin(inputSignals),std::end(inputSignals),std::begin(outputSignals), std::end(outputSignals),numsamples,1,3);
}
struct Constraint{
std::string param;
std::function<bool(double, double)> condition;
};
std::map<std::string, Constraint> paramConstraints{
{"ptf1",{"ptf2", std::less<double>()}},
{"htf1",{"htf2", std::less<double>()}},
{"ptf2",{"ptf1", std::greater<double>()}},
{"htf2",{"htf1", std::greater<double>()}}
};
ClientPointer mClient;
SignalArray<1> inputSignals;
SignalArray<3> outputSignals;
};
}
}
PluginLoad(FluidSTFTUGen) {
ft = inTable;
registerUnit<fluid::wrapper::FDRTHPSS>(ft, "FluidHPSS");
using namespace fluid::client;
makeSCWrapper<HPSSClient<double,float>>(ft, "FluidHPSS");
}

Write Preview
Loading…
Cancel
Save