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

Formatting

Browse Source 
include/FluidSCWrapper.hpp
include/SCBufferAdaptor.hpp
nix
Owen Green 7 years ago
parent 337b3e6e25
commit 6d19889ba5
2 changed files with 188 additions and 260 deletions
Show Stats Download Patch File Download Diff File

315
include/FluidSCWrapper.hpp
Unescape Escape View File

@ -1,4 +1,4 @@
#pragma once #pragma once
#include "SCBufferAdaptor.hpp" #include "SCBufferAdaptor.hpp"
#include <clients/common/FluidBaseClient.hpp> #include <clients/common/FluidBaseClient.hpp>
@ -16,27 +16,32 @@
namespace fluid { namespace fluid {
namespace client { namespace client {
template <typename Client, typename Params> class FluidSCWrapper; template <typename Client, typename Params>
class FluidSCWrapper;
namespace impl { namespace impl {
template <typename Client, typename T, size_t N> struct Setter; template <typename Client, typename T, size_t N>
template <size_t N, typename T> struct ArgumentGetter; struct Setter;
template <size_t N, typename T> struct ControlGetter; template <size_t N, typename T>
template <typename T> using msg_iter_method = T (sc_msg_iter::*)(T); struct ArgumentGetter;
template <size_t N, typename T>
struct ControlGetter;
template <typename T>
using msg_iter_method = T (sc_msg_iter::*)(T);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Iterate over kr/ir inputs via callbacks from params object // Iterate over kr/ir inputs via callbacks from params object
struct FloatControlsIter struct FloatControlsIter
{ {
FloatControlsIter(float** vals, size_t N):mValues(vals), mSize(N) {} FloatControlsIter(float **vals, size_t N)
: mValues(vals)
, mSize(N)
{}
float next() float next() { return mCount >= mSize ? 0 : *mValues[mCount++]; }
{
return mCount >= mSize ? 0 : *mValues[mCount++];
}
void reset(float** vals) void reset(float **vals)
{ {
mValues = vals; mValues = vals;
mCount = 0; mCount = 0;
@ -44,102 +49,109 @@ struct FloatControlsIter
size_t size() const noexcept { return mSize; } size_t size() const noexcept { return mSize; }
private: private:
float** mValues; float **mValues;
size_t mSize; size_t mSize;
size_t mCount{0}; size_t mCount{0};
}; };
//General case // General case
template <size_t N, typename T> struct GetControl template <size_t N, typename T>
struct GetControl
{ {
T operator()(World*, FloatControlsIter& controls) { return controls.next(); } T operator()(World *, FloatControlsIter &controls) { return controls.next(); }
}; };
template <size_t N, typename T> struct ControlGetter : public GetControl<N, typename T::type> template <size_t N, typename T>
struct ControlGetter : public GetControl<N, typename T::type>
{}; {};
//Specializations // Specializations
template <size_t N> struct ControlGetter<N, BufferT> template <size_t N>
struct ControlGetter<N, BufferT>
{ {
auto operator() (World* w, FloatControlsIter& iter) auto operator()(World *w, FloatControlsIter &iter)
{ {
typename LongT::type bufnum = iter.next(); typename LongT::type bufnum = iter.next();
return std::unique_ptr<BufferAdaptor>(bufnum >= 0 ? new SCBufferAdaptor(bufnum,w): nullptr); return std::unique_ptr<BufferAdaptor>(bufnum >= 0 ? new SCBufferAdaptor(bufnum, w) : nullptr);
} }
}; };
template<size_t N> template <size_t N>
struct ControlGetter<N,FloatPairsArrayT> struct ControlGetter<N, FloatPairsArrayT>
{ {
typename FloatPairsArrayT::type operator()(World*, FloatControlsIter& iter) typename FloatPairsArrayT::type operator()(World *, FloatControlsIter &iter)
{ {
return {{iter.next(),iter.next()},{iter.next(),iter.next()}}; return {{iter.next(), iter.next()}, {iter.next(), iter.next()}};
} }
}; };
template<size_t N> template <size_t N>
struct ControlGetter<N,FFTParamsT> struct ControlGetter<N, FFTParamsT>
{ {
typename FFTParamsT::type operator()(World*, FloatControlsIter& iter) typename FFTParamsT::type operator()(World *, FloatControlsIter &iter)
{ {
return {static_cast<long>(iter.next()),static_cast<long>(iter.next()),static_cast<long>(iter.next())}; return {static_cast<long>(iter.next()), static_cast<long>(iter.next()), static_cast<long>(iter.next())};
} }
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Iterate over arguments in sc_msg_iter, via callbacks from params object /// Iterate over arguments in sc_msg_iter, via callbacks from params object
template <size_t N, typename T, msg_iter_method<T> Method> struct GetArgument template <size_t N, typename T, msg_iter_method<T> Method>
struct GetArgument
{ {
T operator()(World* w, sc_msg_iter *args) T operator()(World *w, sc_msg_iter *args)
{ {
T r = (args->*Method)(T{0}); T r = (args->*Method)(T{0});
return r; return r;
} }
}; };
//General cases // General cases
template <size_t N> struct ArgumentGetter<N, FloatT> : public GetArgument<N, float, &sc_msg_iter::getf> template <size_t N>
struct ArgumentGetter<N, FloatT> : public GetArgument<N, float, &sc_msg_iter::getf>
{}; {};
template <size_t N> struct ArgumentGetter<N, LongT> : public GetArgument<N, int32, &sc_msg_iter::geti> template <size_t N>
struct ArgumentGetter<N, LongT> : public GetArgument<N, int32, &sc_msg_iter::geti>
{}; {};
template <size_t N> struct ArgumentGetter<N, EnumT> : public GetArgument<N, int32, &sc_msg_iter::geti> template <size_t N>
struct ArgumentGetter<N, EnumT> : public GetArgument<N, int32, &sc_msg_iter::geti>
{}; {};
//Specializations // Specializations
template <size_t N> struct ArgumentGetter<N, BufferT> template <size_t N>
struct ArgumentGetter<N, BufferT>
{ {
auto operator() (World* w, sc_msg_iter *args) auto operator()(World *w, sc_msg_iter *args)
{ {
typename LongT::type bufnum = args->geti(-1); typename LongT::type bufnum = args->geti(-1);
return std::unique_ptr<BufferAdaptor>(bufnum >= 0 ? new SCBufferAdaptor(bufnum,w) : nullptr); return std::unique_ptr<BufferAdaptor>(bufnum >= 0 ? new SCBufferAdaptor(bufnum, w) : nullptr);
} }
}; };
template <size_t N> struct ArgumentGetter<N, FloatPairsArrayT> template <size_t N>
struct ArgumentGetter<N, FloatPairsArrayT>
{ {
typename FloatPairsArrayT::type operator()(World* w, sc_msg_iter *args) typename FloatPairsArrayT::type operator()(World *w, sc_msg_iter *args)
{ {
return {{args->getf(),args->getf()},{args->getf(),args->getf()}}; return {{args->getf(), args->getf()}, {args->getf(), args->getf()}};
} }
}; };
template <size_t N> struct ArgumentGetter<N, FFTParamsT> template <size_t N>
struct ArgumentGetter<N, FFTParamsT>
{ {
typename FFTParamsT::type operator()(World* w, sc_msg_iter *args) typename FFTParamsT::type operator()(World *w, sc_msg_iter *args) { return {args->geti(), args->geti(), args->geti()}; }
{
return {args->geti(),args->geti(),args->geti()};
}
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Real Time Processor // Real Time Processor
template <typename Client,class Wrapper, class Params> class RealTime : public SCUnit template <typename Client, class Wrapper, class Params>
class RealTime : public SCUnit
{ {
using HostVector = FluidTensorView<float, 1>; using HostVector = FluidTensorView<float, 1>;
// using Client = typename Wrapper::ClientType; // using Client = typename Wrapper::ClientType;
@ -148,45 +160,46 @@ public:
static void setup(InterfaceTable *ft, const char *name) static void setup(InterfaceTable *ft, const char *name)
{ {
registerUnit<Wrapper>(ft, name); registerUnit<Wrapper>(ft, name);
ft->fDefineUnitCmd(name,"latency",doLatency); ft->fDefineUnitCmd(name, "latency", doLatency);
} }
static void doLatency(Unit *unit, sc_msg_iter *args) static void doLatency(Unit *unit, sc_msg_iter *args)
{ {
float l[] {static_cast<float>(static_cast<Wrapper*>(unit)->mClient.latency())}; float l[]{static_cast<float>(static_cast<Wrapper *>(unit)->mClient.latency())};
auto ft = Wrapper::getInterfaceTable(); auto ft = Wrapper::getInterfaceTable();
std::stringstream ss; std::stringstream ss;
ss << '/' << Wrapper::getName() << "_latency"; ss << '/' << Wrapper::getName() << "_latency";
std::cout << ss.str() << '\n'; std::cout << ss.str() << '\n';
ft->fSendNodeReply(&unit->mParent->mNode,-1,ss.str().c_str() , 1, l); ft->fSendNodeReply(&unit->mParent->mNode, -1, ss.str().c_str(), 1, l);
} }
RealTime(): RealTime()
mControlsIterator{mInBuf + mSpecialIndex + 1,mNumInputs - mSpecialIndex - 1}, : mControlsIterator{mInBuf + mSpecialIndex + 1, mNumInputs - mSpecialIndex - 1}
mParams{*Wrapper::getParamDescriptors()}, , mParams{*Wrapper::getParamDescriptors()}
mClient{Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld, mControlsIterator)} , mClient{Wrapper::setParams(mParams, mWorld->mVerbosity > 0, mWorld, mControlsIterator)}
{} {}
void init() void init()
{ {
assert(!(mClient.audioChannelsOut() > 0 && mClient.controlChannelsOut() > 0) && "Client can't have both audio and control outputs"); assert(!(mClient.audioChannelsOut() > 0 && mClient.controlChannelsOut() > 0) &&
"Client can't have both audio and control outputs");
//If we don't the number of arguments we expect, the language side code is probably the wrong version // If we don't the number of arguments we expect, the language side code is probably the wrong version
//set plugin to no-op, squawk, and bail; // set plugin to no-op, squawk, and bail;
if(mControlsIterator.size() != Wrapper::getParamDescriptors()->count()) if (mControlsIterator.size() != Wrapper::getParamDescriptors()->count())
{ {
mCalcFunc = Wrapper::getInterfaceTable()->fClearUnitOutputs; mCalcFunc = Wrapper::getInterfaceTable()->fClearUnitOutputs;
std::cout << "ERROR: " << Wrapper::getName() << std::cout << "ERROR: " << Wrapper::getName() << " wrong number of arguments. Expected "
" wrong number of arguments. Expected " << Wrapper::getParamDescriptors()->count() << << Wrapper::getParamDescriptors()->count() << ", got " << mControlsIterator.size()
", got " << mControlsIterator.size() << ". Your .sc file and binary plugin might be different versions." << std::endl; << ". Your .sc file and binary plugin might be different versions." << std::endl;
return; return;
} }
mInputConnections.reserve(mClient.audioChannelsIn()); mInputConnections.reserve(mClient.audioChannelsIn());
mOutputConnections.reserve(mClient.audioChannelsOut()); mOutputConnections.reserve(mClient.audioChannelsOut());
mAudioInputs.reserve(mClient.audioChannelsIn()); mAudioInputs.reserve(mClient.audioChannelsIn());
mOutputs.reserve(std::max(mClient.audioChannelsOut(),mClient.controlChannelsOut())); mOutputs.reserve(std::max(mClient.audioChannelsOut(), mClient.controlChannelsOut()));
for (int i = 0; i < mClient.audioChannelsIn(); ++i) for (int i = 0; i < mClient.audioChannelsIn(); ++i)
{ {
@ -200,10 +213,7 @@ public:
mOutputs.emplace_back(nullptr, 0, 0); mOutputs.emplace_back(nullptr, 0, 0);
} }
for (int i = 0; i < mClient.controlChannelsOut(); ++i) for (int i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs.emplace_back(nullptr, 0, 0); }
{
mOutputs.emplace_back(nullptr, 0, 0);
}
set_calc_function<RealTime, &RealTime::next>(); set_calc_function<RealTime, &RealTime::next>();
Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1); Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
@ -211,8 +221,9 @@ public:
void next(int n) void next(int n)
{ {
mControlsIterator.reset(mInBuf + 1); //mClient.audioChannelsIn()); mControlsIterator.reset(mInBuf + 1); // mClient.audioChannelsIn());
Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld,mControlsIterator); // forward on inputs N + audio inputs as params Wrapper::setParams(mParams, mWorld->mVerbosity > 0, mWorld,
mControlsIterator); // forward on inputs N + audio inputs as params
const Unit *unit = this; const Unit *unit = this;
for (int i = 0; i < mClient.audioChannelsIn(); ++i) for (int i = 0; i < mClient.audioChannelsIn(); ++i)
{ {
@ -222,18 +233,17 @@ public:
{ {
if (mOutputConnections[i]) mOutputs[i].reset(out(i), 0, fullBufferSize()); if (mOutputConnections[i]) mOutputs[i].reset(out(i), 0, fullBufferSize());
} }
for(int i = 0; i < mClient.controlChannelsOut();++i) for (int i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs[i].reset(out(i), 0, 1); }
{
mOutputs[i].reset(out(i),0,1);
}
mClient.process(mAudioInputs, mOutputs); mClient.process(mAudioInputs, mOutputs);
} }
private: private:
std::vector<bool> mInputConnections; std::vector<bool> mInputConnections;
std::vector<bool> mOutputConnections; std::vector<bool> mOutputConnections;
std::vector<HostVector> mAudioInputs; std::vector<HostVector> mAudioInputs;
std::vector<HostVector> mOutputs; std::vector<HostVector> mOutputs;
FloatControlsIter mControlsIterator; FloatControlsIter mControlsIterator;
protected: protected:
ParameterSet<Params> mParams; ParameterSet<Params> mParams;
Client mClient; Client mClient;
@ -241,14 +251,15 @@ protected:
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Non Real Time Processor /// Non Real Time Processor
template <typename Client, typename Wrapper, typename Params> class NonRealTime template <typename Client, typename Wrapper, typename Params>
class NonRealTime
{ {
public: public:
static void setup(InterfaceTable *ft, const char *name) { DefinePlugInCmd(name, launch, nullptr); } static void setup(InterfaceTable *ft, const char *name) { DefinePlugInCmd(name, launch, nullptr); }
NonRealTime(World *world,sc_msg_iter *args): NonRealTime(World *world, sc_msg_iter *args)
mParams{*Wrapper::getParamDescriptors()}, : mParams{*Wrapper::getParamDescriptors()}
mClient{mParams} , mClient{mParams}
{} {}
void init(){}; void init(){};
@ -256,16 +267,16 @@ public:
static void launch(World *world, void *inUserData, struct sc_msg_iter *args, void *replyAddr) static void launch(World *world, void *inUserData, struct sc_msg_iter *args, void *replyAddr)
{ {
if (args->tags && ((std::string{args->tags}.size() - 1) != Wrapper::getParamDescriptors()->count()))
if(args->tags && ((std::string{args->tags}.size() - 1) != Wrapper::getParamDescriptors()->count()))
{ {
std::cout << "ERROR: " << Wrapper::getName() << std::cout << "ERROR: " << Wrapper::getName() << " wrong number of arguments. Expected "
" wrong number of arguments. Expected " << Wrapper::getParamDescriptors()->count() << << Wrapper::getParamDescriptors()->count() << ", got " << (std::string{args->tags}.size() - 1)
", got " << (std::string{args->tags}.size() - 1) << ". Your .sc file and binary plugin might be different versions." << std::endl; << ". Your .sc file and binary plugin might be different versions." << std::endl;
return; return;
} }
Wrapper *w = new Wrapper(world,args); //this has to be on the heap, because it doesn't get destoryed until the async command is done Wrapper *w = new Wrapper(
world, args); // this has to be on the heap, because it doesn't get destoryed until the async command is done
int argsPosition = args->count; int argsPosition = args->count;
auto argsRdPos = args->rdpos; auto argsRdPos = args->rdpos;
@ -278,35 +289,28 @@ public:
} }
args->count = argsPosition; args->count = argsPosition;
args->rdpos = argsRdPos; args->rdpos = argsRdPos;
Wrapper::setParams(w->mParams,false, world, args); Wrapper::setParams(w->mParams, false, world, args);
size_t msgSize = args->getbsize(); size_t msgSize = args->getbsize();
std::vector<char> completionMessage(msgSize); std::vector<char> completionMessage(msgSize);
// char * completionMsgData = 0; // char * completionMsgData = 0;
if (msgSize) if (msgSize) { args->getb(completionMessage.data(), msgSize); }
{
args->getb(completionMessage.data(), msgSize);
}
world->ft->fDoAsynchronousCommand(world, replyAddr, Wrapper::getName(), w, process, exchangeBuffers, tidyUp, destroy,msgSize, completionMessage.data()); world->ft->fDoAsynchronousCommand(world, replyAddr, Wrapper::getName(), w, process, exchangeBuffers, tidyUp, destroy,
msgSize, completionMessage.data());
} }
static bool process(World *world, void *data) { return static_cast<Wrapper *>(data)->process(world); } static bool process(World *world, void *data) { return static_cast<Wrapper *>(data)->process(world); }
static bool exchangeBuffers(World *world, void *data) { return static_cast<Wrapper *>(data)->exchangeBuffers(world); } static bool exchangeBuffers(World *world, void *data) { return static_cast<Wrapper *>(data)->exchangeBuffers(world); }
static bool tidyUp(World *world, void *data) { return static_cast<Wrapper *>(data)->tidyUp(world); } static bool tidyUp(World *world, void *data) { return static_cast<Wrapper *>(data)->tidyUp(world); }
static void destroy(World *world, void *data) static void destroy(World *world, void *data) { delete static_cast<Wrapper *>(data); }
{
// void* c = static_cast<Wrapper *>(data)->mCompletionMessage;
// if(c) world->ft->fRTFree(world,c);
delete static_cast<Wrapper *>(data);
}
protected: protected:
ParameterSet<Params> mParams; ParameterSet<Params> mParams;
Client mClient; Client mClient;
private: private:
static Result validateParameters(NonRealTime *w, World* world, sc_msg_iter *args) static Result validateParameters(NonRealTime *w, World *world, sc_msg_iter *args)
{ {
auto results = w->mParams.template checkParameterValues<ArgumentGetter>(world, args); auto results = w->mParams.template checkParameterValues<ArgumentGetter>(world, args);
for (auto &r : results) for (auto &r : results)
@ -318,9 +322,9 @@ private:
bool process(World *world) bool process(World *world)
{ {
Result r = mClient.process();///mInputs, mOutputs); Result r = mClient.process();
if(!r.ok()) if (!r.ok())
{ {
std::cout << "ERROR: " << Wrapper::getName() << ": " << r.message().c_str(); std::cout << "ERROR: " << Wrapper::getName() << ": " << r.message().c_str();
return false; return false;
@ -331,95 +335,98 @@ private:
bool exchangeBuffers(World *world) bool exchangeBuffers(World *world)
{ {
mParams.template forEachParamType<BufferT,AssignBuffer>(world); mParams.template forEachParamType<BufferT, AssignBuffer>(world);
// for (auto &b : mBuffersOut) b.assignToRT(world);
return true; return true;
} }
bool tidyUp(World *world) bool tidyUp(World *world)
{ {
// for (auto &b : mBuffersIn) b.cleanUp(); mParams.template forEachParamType<BufferT, CleanUpBuffer>();
// for (auto &b : mBuffersOut) b.cleanUp()
mParams.template forEachParamType<BufferT,CleanUpBuffer>();
return true; return true;
} }
template<size_t N,typename T> template <size_t N, typename T>
struct AssignBuffer struct AssignBuffer
{ {
void operator()(typename BufferT::type& p, World* w) void operator()(typename BufferT::type &p, World *w)
{ {
if(auto b = static_cast<SCBufferAdaptor*>(p.get())) if (auto b = static_cast<SCBufferAdaptor *>(p.get())) b->assignToRT(w);
b->assignToRT(w);
} }
}; };
template<size_t N,typename T> template <size_t N, typename T>
struct CleanUpBuffer struct CleanUpBuffer
{ {
void operator()(typename BufferT::type& p) void operator()(typename BufferT::type &p)
{ {
if(auto b = static_cast<SCBufferAdaptor*>(p.get())) if (auto b = static_cast<SCBufferAdaptor *>(p.get())) b->cleanUp();
b->cleanUp();
} }
}; };
// std::vector<SCBufferAdaptor> mBuffersIn;
// std::vector<SCBufferAdaptor> mBuffersOut;
// std::vector<BufferProcessSpec> mInputs;
// std::vector<BufferProcessSpec> mOutputs;
char * mCompletionMessage = nullptr; char * mCompletionMessage = nullptr;
void * mReplyAddr = nullptr; void * mReplyAddr = nullptr;
const char * mName = nullptr; const char *mName = nullptr;
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// An impossible monstrosty /// An impossible monstrosty
template <typename Client, typename Wrapper, typename Params> class NonRealTimeAndRealTime : public RealTime<Client,Wrapper, Params>, public NonRealTime<Client,Wrapper, Params> template <typename Client, typename Wrapper, typename Params>
class NonRealTimeAndRealTime : public RealTime<Client, Wrapper, Params>, public NonRealTime<Client, Wrapper, Params>
{ {
static void setup(InterfaceTable *ft, const char *name) static void setup(InterfaceTable *ft, const char *name)
{ {
RealTime<Client,Wrapper,Params >::setup(ft, name); RealTime<Client, Wrapper, Params>::setup(ft, name);
NonRealTime<Client,Wrapper, Params>::setup(ft, name); NonRealTime<Client, Wrapper, Params>::setup(ft, name);
} }
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Template Specialisations for NRT/RT // Template Specialisations for NRT/RT
template <typename Client, typename Wrapper, typename Params, typename NRT, typename RT> class FluidSCWrapperImpl; template <typename Client, typename Wrapper, typename Params, typename NRT, typename RT>
class FluidSCWrapperImpl;
template <typename Client, typename Wrapper, typename Params> class FluidSCWrapperImpl<Client, Wrapper, Params, std::true_type, std::false_type> : public NonRealTime<Client, Wrapper, Params> template <typename Client, typename Wrapper, typename Params>
class FluidSCWrapperImpl<Client, Wrapper, Params, std::true_type, std::false_type>
: public NonRealTime<Client, Wrapper, Params>
{ {
public: public:
FluidSCWrapperImpl(World* w, sc_msg_iter *args): NonRealTime<Client, Wrapper, Params>(w,args){}; FluidSCWrapperImpl(World *w, sc_msg_iter *args)
: NonRealTime<Client, Wrapper, Params>(w, args){};
}; };
template <typename Client, typename Wrapper, typename Params> class FluidSCWrapperImpl<Client, Wrapper,Params, std::false_type, std::true_type> : public RealTime<Client, Wrapper, Params> template <typename Client, typename Wrapper, typename Params>
class FluidSCWrapperImpl<Client, Wrapper, Params, std::false_type, std::true_type> : public RealTime<Client, Wrapper, Params>
{}; {};
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Make base class(es), full of CRTP mixin goodness // Make base class(es), full of CRTP mixin goodness
template <typename Client,typename Params> template <typename Client, typename Params>
using FluidSCWrapperBase = FluidSCWrapperImpl<Client, FluidSCWrapper<Client, Params>,Params, isNonRealTime<Client>, isRealTime<Client>>; using FluidSCWrapperBase =
FluidSCWrapperImpl<Client, FluidSCWrapper<Client, Params>, Params, isNonRealTime<Client>, isRealTime<Client>>;
} // namespace impl } // namespace impl
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///The main wrapper /// The main wrapper
template <typename C, typename P> class FluidSCWrapper : public impl::FluidSCWrapperBase<C,P> template <typename C, typename P>
class FluidSCWrapper : public impl::FluidSCWrapperBase<C, P>
{ {
public: public:
using Client = C; using Client = C;
using Params = P; using Params = P;
FluidSCWrapper() //mParams{*getParamDescriptors()}, //impl::FluidSCWrapperBase<Client,Params>() FluidSCWrapper() // mParams{*getParamDescriptors()}, //impl::FluidSCWrapperBase<Client,Params>()
{ impl::FluidSCWrapperBase<Client,Params>::init(); } {
impl::FluidSCWrapperBase<Client, Params>::init();
FluidSCWrapper(World* w, sc_msg_iter *args): impl::FluidSCWrapperBase<Client, Params>(w,args) }
{ impl::FluidSCWrapperBase<Client, Params>::init(); }
FluidSCWrapper(World *w, sc_msg_iter *args)
: impl::FluidSCWrapperBase<Client, Params>(w, args)
{
impl::FluidSCWrapperBase<Client, Params>::init();
}
static const char *getName(const char *setName = nullptr) static const char *getName(const char *setName = nullptr)
{ {
@ -429,7 +436,7 @@ public:
static Params *getParamDescriptors(Params *setParams = nullptr) static Params *getParamDescriptors(Params *setParams = nullptr)
{ {
static Params* descriptors = nullptr; static Params *descriptors = nullptr;
return (descriptors = setParams ? setParams : descriptors); return (descriptors = setParams ? setParams : descriptors);
} }
@ -439,7 +446,7 @@ public:
return (ft = setTable ? setTable : ft); return (ft = setTable ? setTable : ft);
} }
static void setup(Params& p, InterfaceTable *ft, const char *name) static void setup(Params &p, InterfaceTable *ft, const char *name)
{ {
getName(name); getName(name);
getInterfaceTable(ft); getInterfaceTable(ft);
@ -447,35 +454,29 @@ public:
impl::FluidSCWrapperBase<Client, Params>::setup(ft, name); impl::FluidSCWrapperBase<Client, Params>::setup(ft, name);
} }
template<typename ParameterSet> template <typename ParameterSet>
static auto& setParams(ParameterSet& p, bool verbose, World* world, impl::FloatControlsIter& inputs) static auto &setParams(ParameterSet &p, bool verbose, World *world, impl::FloatControlsIter &inputs)
{ {
//We won't even try and set params if the arguments don't match // We won't even try and set params if the arguments don't match
if(inputs.size() == getParamDescriptors()->count()) if (inputs.size() == getParamDescriptors()->count())
p.template setParameterValues<impl::ControlGetter>(verbose, world, inputs); p.template setParameterValues<impl::ControlGetter>(verbose, world, inputs);
return p; return p;
} }
template<typename ParameterSet> template <typename ParameterSet>
static auto& setParams(ParameterSet& p, bool verbose, World* world, sc_msg_iter *args) static auto &setParams(ParameterSet &p, bool verbose, World *world, sc_msg_iter *args)
{ {
p.template setParameterValues<impl::ArgumentGetter>(verbose,world, args); p.template setParameterValues<impl::ArgumentGetter>(verbose, world, args);
return p; return p;
} }
// impl::ParameterSet<Params> mParams;
// Client &client() { return mClient; }
//
//private:
// Client mClient;
}; };
template <template <typename...> class Client,typename...Rest,typename Params> template <template <typename...> class Client, typename... Rest, typename Params>
void makeSCWrapper(const char *name, Params& params, InterfaceTable *ft) void makeSCWrapper(const char *name, Params &params, InterfaceTable *ft)
{ {
FluidSCWrapper<Client<ParameterSet<Params>,Rest...>, Params>::setup(params, ft, name); FluidSCWrapper<Client<ParameterSet<Params>, Rest...>, Params>::setup(params, ft, name);
} }
} // namespace client } // namespace client
} // namespace fluid } // namespace fluid

73
include/SCBufferAdaptor.hpp
Unescape Escape View File

@ -3,7 +3,6 @@
#include <SC_PlugIn.h> #include <SC_PlugIn.h>
#include <boost/align/aligned_alloc.hpp> #include <boost/align/aligned_alloc.hpp>
#include <cctype> #include <cctype>
//#include <clients/common/FluidParams.hpp>
#include <data/FluidTensor.hpp> #include <data/FluidTensor.hpp>
#include <clients/common/BufferAdaptor.hpp> #include <clients/common/BufferAdaptor.hpp>
#include <fstream> #include <fstream>
@ -12,7 +11,6 @@
#include <string> #include <string>
#include <vector> #include <vector>
// static InterfaceTable *ft;
namespace fluid namespace fluid
{ {
@ -169,77 +167,6 @@ protected:
size_t mRank{1}; size_t mRank{1};
}; };
class RTBufferView : public client::BufferAdaptor
{
public:
RTBufferView(World *world, int bufnum)
: mWorld(world)
, mBufnum(bufnum)
{
}
void acquire() override { mBuffer = World_GetBuf(mWorld, mBufnum); }
void release() override {}
// Validity is based on whether this buffer is within the range the server
// knows about
bool valid() const override
{
return (mBuffer && mBufnum >= 0 && mBufnum < mWorld->mNumSndBufs);
}
FluidTensorView<float, 1> samps(size_t channel, size_t rankIdx = 0) override
{
FluidTensorView<float, 2> v{mBuffer->data, 0,
static_cast<size_t>(mBuffer->frames),
static_cast<size_t>(mBuffer->channels)};
return v.col(rankIdx + channel * mRank);
}
FluidTensorView<float, 1> samps(size_t offset, size_t nframes,
size_t chanoffset) override
{
FluidTensorView<float, 2> v{mBuffer->data, 0,
static_cast<size_t>(mBuffer->frames),
static_cast<size_t>(mBuffer->channels)};
return v(fluid::Slice(offset, nframes), fluid::Slice(chanoffset, 1)).col(0);
}
size_t numFrames() const override
{
return valid() ? this->mBuffer->frames : 0;
}
size_t numChans() const override
{
return valid() ? this->mBuffer->channels / mRank : 0;
}
size_t rank() const override { return valid() ? mRank : 0; }
void resize(size_t frames, size_t channels, size_t rank) override
{
assert(false && "Don't try and resize real-time buffers");
}
int bufnum() { return mBufnum; }
private:
bool equal(BufferAdaptor *rhs) const override
{
RTBufferView *x = dynamic_cast<RTBufferView *>(rhs);
if (x) { return mBufnum == x->mBufnum; }
return false;
}
size_t mRank = 1;
World * mWorld;
int mBufnum = -1;
SndBuf *mBuffer = nullptr;
};
std::ostream& operator <<(std::ostream& os, SCBufferAdaptor& b) std::ostream& operator <<(std::ostream& os, SCBufferAdaptor& b)
{ {
return os << b.bufnum(); return os << b.bufnum();

Write Preview
Loading…
Cancel
Save