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

signed indices in SC wrapper

Browse Source
nix
Owen Green 6 years ago
parent 8d73df1c03
commit c6dd99ec81
2 changed files with 60 additions and 52 deletions
Show Stats Download Patch File Download Diff File

60
include/FluidSCWrapper.hpp
Unescape Escape View File

@ -26,7 +26,7 @@ namespace impl {
// 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) FloatControlsIter(float **vals, index N)
: mValues(vals) : mValues(vals)
, mSize(N) , mSize(N)
{} {}
@ -39,12 +39,12 @@ struct FloatControlsIter
mCount = 0; mCount = 0;
} }
size_t size() const noexcept { return mSize; } index size() const noexcept { return mSize; }
private: private:
float **mValues; float **mValues;
size_t mSize; index mSize;
size_t mCount{0}; index mCount{0};
}; };
//////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -78,7 +78,7 @@ public:
} }
RealTime() RealTime()
: mControlsIterator{mInBuf + mSpecialIndex + 1,static_cast<size_t>(static_cast<ptrdiff_t>(mNumInputs) - mSpecialIndex - 1)} : mControlsIterator{mInBuf + mSpecialIndex + 1,static_cast<index>(mNumInputs) - mSpecialIndex - 1}
, mParams{Wrapper::Client::getParameterDescriptors()} , mParams{Wrapper::Client::getParameterDescriptors()}
, mClient{Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld, mControlsIterator,true)} , mClient{Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld, mControlsIterator,true)}
{} {}
@ -100,24 +100,24 @@ public:
} }
mClient.sampleRate(fullSampleRate()); mClient.sampleRate(fullSampleRate());
mInputConnections.reserve(mClient.audioChannelsIn()); mInputConnections.reserve(asUnsigned(mClient.audioChannelsIn()));
mOutputConnections.reserve(mClient.audioChannelsOut()); mOutputConnections.reserve(asUnsigned(mClient.audioChannelsOut()));
mAudioInputs.reserve(mClient.audioChannelsIn()); mAudioInputs.reserve(asUnsigned(mClient.audioChannelsIn()));
mOutputs.reserve(std::max(mClient.audioChannelsOut(), mClient.controlChannelsOut())); mOutputs.reserve(asUnsigned(std::max(mClient.audioChannelsOut(), mClient.controlChannelsOut())));
for (int i = 0; i < static_cast<int>(mClient.audioChannelsIn()); ++i) for (index i = 0; i < mClient.audioChannelsIn(); ++i)
{ {
mInputConnections.emplace_back(isAudioRateIn(i)); mInputConnections.emplace_back(isAudioRateIn(static_cast<int>(i)));
mAudioInputs.emplace_back(nullptr, 0, 0); mAudioInputs.emplace_back(nullptr, 0, 0);
} }
for (int i = 0; i < static_cast<int>(mClient.audioChannelsOut()); ++i) for (index i = 0; i < mClient.audioChannelsOut(); ++i)
{ {
mOutputConnections.emplace_back(true); mOutputConnections.emplace_back(true);
mOutputs.emplace_back(nullptr, 0, 0); mOutputs.emplace_back(nullptr, 0, 0);
} }
for (int i = 0; i < static_cast<int>(mClient.controlChannelsOut()); ++i) { mOutputs.emplace_back(nullptr, 0, 0); } for (index i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs.emplace_back(nullptr, 0, 0); }
mCalcFunc = make_calc_function<RealTime, &RealTime::next>(); mCalcFunc = make_calc_function<RealTime, &RealTime::next>();
Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1); Wrapper::getInterfaceTable()->fClearUnitOutputs(this, 1);
@ -129,15 +129,23 @@ public:
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
mParams.constrainParameterValues(); mParams.constrainParameterValues();
const Unit *unit = this; const Unit *unit = this;
for (size_t i = 0; i < mClient.audioChannelsIn(); ++i) for (index i = 0; i < mClient.audioChannelsIn(); ++i)
{ {
if (mInputConnections[i]) mAudioInputs[i].reset(IN(i), 0, fullBufferSize()); if (mInputConnections[asUnsigned(i)])
{
mAudioInputs[asUnsigned(i)].reset(IN(i), 0, fullBufferSize());
}
}
for (index i = 0; i < mClient.audioChannelsOut(); ++i)
{
assert(i <= std::numeric_limits<int>::max());
if (mOutputConnections[asUnsigned(i)]) mOutputs[asUnsigned(i)].reset(out(static_cast<int>(i)), 0, fullBufferSize());
} }
for (size_t i = 0; i < mClient.audioChannelsOut(); ++i) for (index i = 0; i < mClient.controlChannelsOut(); ++i)
{ {
if (mOutputConnections[i]) mOutputs[i].reset(out(static_cast<int>(i)), 0, fullBufferSize()); assert(i <= std::numeric_limits<int>::max());
mOutputs[asUnsigned(i)].reset(out(static_cast<int>(i)), 0, 1);
} }
for (size_t i = 0; i < mClient.controlChannelsOut(); ++i) { mOutputs[i].reset(out(static_cast<int>(i)), 0, 1); }
mClient.process(mAudioInputs, mOutputs,mContext); mClient.process(mAudioInputs, mOutputs,mContext);
} }
@ -196,10 +204,10 @@ public:
/// Penultimate input is the doneAction, final is blocking mode. Neither are params, so we skip them in the controlsIterator /// Penultimate input is the doneAction, final is blocking mode. Neither are params, so we skip them in the controlsIterator
NonRealTime() : NonRealTime() :
mControlsIterator{mInBuf,static_cast<size_t>(static_cast<ptrdiff_t>(mNumInputs) - mSpecialIndex - 2)} mControlsIterator{mInBuf,index(mNumInputs) - mSpecialIndex - 2}
, mParams{Wrapper::Client::getParameterDescriptors()} , mParams{Wrapper::Client::getParameterDescriptors()}
, mClient{Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld, mControlsIterator,true)} , mClient{Wrapper::setParams(mParams,mWorld->mVerbosity > 0, mWorld, mControlsIterator,true)}
, mSynchronous{mNumInputs > 2 ? (in0(static_cast<int>(mNumInputs - 1)) > 0) : false} , mSynchronous{mNumInputs > 2 ? (in0(int(mNumInputs) - 1) > 0) : false}
{} {}
~NonRealTime() ~NonRealTime()
@ -220,7 +228,7 @@ public:
mFifoMsg.Set(mWorld, initNRTJob, nullptr, this); mFifoMsg.Set(mWorld, initNRTJob, nullptr, this);
mWorld->ft->fSendMsgFromRT(mWorld,mFifoMsg); mWorld->ft->fSendMsgFromRT(mWorld,mFifoMsg);
//we want to poll thread roughly every 20ms //we want to poll thread roughly every 20ms
checkThreadInterval = static_cast<size_t>(0.02 / controlDur()); checkThreadInterval = static_cast<index>(0.02 / controlDur());
set_calc_function<NonRealTime, &NonRealTime::poll>(); set_calc_function<NonRealTime, &NonRealTime::poll>();
}; };
@ -301,7 +309,7 @@ public:
auto w = static_cast<Wrapper*>(data); auto w = static_cast<Wrapper*>(data);
if(w->mDone && w->mNumInputs > 2) //don't check for doneAction if UGen has no ins (there should be 3 minimum -> sig, doneAction, blocking mode) if(w->mDone && w->mNumInputs > 2) //don't check for doneAction if UGen has no ins (there should be 3 minimum -> sig, doneAction, blocking mode)
{ {
int doneAction = static_cast<int>(w->in0(static_cast<int>(w->mNumInputs - 2))); //doneAction is penultimate input; THIS IS THE LAW int doneAction = static_cast<int>(w->in0(int(w->mNumInputs) - 2)); //doneAction is penultimate input; THIS IS THE LAW
world->ft->fDoneAction(doneAction,w); world->ft->fDoneAction(doneAction,w);
return; return;
} }
@ -363,8 +371,8 @@ private:
char* mCompletionMessage = nullptr; char* mCompletionMessage = nullptr;
void* mReplyAddr = nullptr; void* mReplyAddr = nullptr;
const char *mName = nullptr; const char *mName = nullptr;
size_t checkThreadInterval; index checkThreadInterval;
size_t pollCounter{0}; index pollCounter{0};
protected: protected:
ParamSetType mParams; ParamSetType mParams;
Client mClient; Client mClient;
@ -427,7 +435,7 @@ class FluidSCWrapper : public impl::FluidSCWrapperBase<C>
template <typename ArgType, size_t N, typename T> template <typename ArgType, size_t N, typename T>
struct Setter struct Setter
{ {
static constexpr size_t argSize = C::getParameterDescriptors().template get<N>().fixedSize; static constexpr index argSize = C::getParameterDescriptors().template get<N>().fixedSize;
auto fromArgs(World *, FloatControlsIter& args, LongT::type, int) { return args.next(); } auto fromArgs(World *, FloatControlsIter& args, LongT::type, int) { return args.next(); }
auto fromArgs(World *, FloatControlsIter& args, FloatT::type, int) { return args.next(); } auto fromArgs(World *, FloatControlsIter& args, FloatT::type, int) { return args.next(); }
@ -449,7 +457,7 @@ class FluidSCWrapper : public impl::FluidSCWrapperBase<C>
ParamLiteralConvertor<T, argSize> a; ParamLiteralConvertor<T, argSize> a;
using LiteralType = typename ParamLiteralConvertor<T, argSize>::LiteralType; using LiteralType = typename ParamLiteralConvertor<T, argSize>::LiteralType;
for (size_t i = 0; i < argSize; i++) for (index i = 0; i < argSize; i++)
a[i] = static_cast<LiteralType>(fromArgs(w, args, a[0], 0)); a[i] = static_cast<LiteralType>(fromArgs(w, args, a[0], 0));
return a.value(); return a.value();

52
include/SCBufferAdaptor.hpp
Unescape Escape View File

@ -26,9 +26,9 @@ struct NRTBuf {
: mBuffer(b) : mBuffer(b)
{ {
} }
NRTBuf(World *world, uint32 bufnum, bool rt = false) NRTBuf(World *world, index bufnum, bool rt = false)
: NRTBuf(rt ? World_GetBuf(world, bufnum) : NRTBuf(rt ? World_GetBuf(world, static_cast<uint32>(bufnum))
: World_GetNRTBuf(world, bufnum)) : World_GetNRTBuf(world, static_cast<uint32>(bufnum)))
{ {
if (mBuffer && !static_cast<bool>(mBuffer->samplerate)) if (mBuffer && !static_cast<bool>(mBuffer->samplerate))
mBuffer->samplerate = world->mFullRate.mSampleRate; mBuffer->samplerate = world->mFullRate.mSampleRate;
@ -65,8 +65,8 @@ public:
SCBufferAdaptor& operator=(SCBufferAdaptor&&) = default; SCBufferAdaptor& operator=(SCBufferAdaptor&&) = default;
SCBufferAdaptor(intptr_t bufnum,World *world, bool rt = false) SCBufferAdaptor(index bufnum,World *world, bool rt = false)
: NRTBuf(world, static_cast<uint32>(bufnum), rt) : NRTBuf(world, bufnum, rt)
, mBufnum(bufnum) , mBufnum(bufnum)
, mWorld(world) , mWorld(world)
{ {
@ -109,60 +109,60 @@ public:
return true; return true;
} }
FluidTensorView<float, 1> samps(size_t channel) override FluidTensorView<float, 1> samps(index channel) override
{ {
FluidTensorView<float, 2> v{mBuffer->data, 0, FluidTensorView<float, 2> v{mBuffer->data, 0,
static_cast<size_t>(mBuffer->frames), mBuffer->frames,
static_cast<size_t>(mBuffer->channels)}; mBuffer->channels};
return v.col(channel); return v.col(channel);
} }
FluidTensorView<float, 1> samps(size_t offset, size_t nframes, FluidTensorView<float, 1> samps(index offset, index nframes,
size_t chanoffset) override index chanoffset) override
{ {
FluidTensorView<float, 2> v{mBuffer->data, 0, FluidTensorView<float, 2> v{mBuffer->data, 0,
static_cast<size_t>(mBuffer->frames), mBuffer->frames,
static_cast<size_t>(mBuffer->channels)}; mBuffer->channels};
return v(fluid::Slice(offset, nframes), fluid::Slice(chanoffset, 1)).col(0); return v(fluid::Slice(offset, nframes), fluid::Slice(chanoffset, 1)).col(0);
} }
FluidTensorView<const float, 1> samps(size_t channel) const override FluidTensorView<const float, 1> samps(index channel) const override
{ {
FluidTensorView<const float, 2> v{mBuffer->data, 0, FluidTensorView<const float, 2> v{mBuffer->data, 0,
static_cast<size_t>(mBuffer->frames), mBuffer->frames,
static_cast<size_t>(mBuffer->channels)}; mBuffer->channels};
return v.col(channel); return v.col(channel);
} }
FluidTensorView<const float, 1> samps(size_t offset, size_t nframes, FluidTensorView<const float, 1> samps(index offset, index nframes,
size_t chanoffset) const override index chanoffset) const override
{ {
FluidTensorView<const float, 2> v{mBuffer->data, 0, FluidTensorView<const float, 2> v{mBuffer->data, 0,
static_cast<size_t>(mBuffer->frames), mBuffer->frames,
static_cast<size_t>(mBuffer->channels)}; mBuffer->channels};
return v(fluid::Slice(offset, nframes), fluid::Slice(chanoffset, 1)).col(0); return v(fluid::Slice(offset, nframes), fluid::Slice(chanoffset, 1)).col(0);
} }
size_t numFrames() const override index numFrames() const override
{ {
return valid() ? static_cast<size_t>(this->mBuffer->frames) : 0u; return valid() ? this->mBuffer->frames : 0;
} }
size_t numChans() const override index numChans() const override
{ {
return valid() ? static_cast<size_t>(this->mBuffer->channels) : 0u; return valid() ? this->mBuffer->channels : 0;
} }
double sampleRate() const override { return valid() ? mBuffer->samplerate : 0; } double sampleRate() const override { return valid() ? mBuffer->samplerate : 0; }
std::string asString() const override { return std::to_string(bufnum()); } std::string asString() const override { return std::to_string(bufnum()); }
const Result resize(size_t frames, size_t channels, double sampleRate) override const Result resize(index frames, index channels, double sampleRate) override
{ {
SndBuf *thisThing = mBuffer; SndBuf *thisThing = mBuffer;
mOldData = thisThing->data; mOldData = thisThing->data;
@ -178,14 +178,14 @@ public:
return r; return r;
} }
intptr_t bufnum() const { return mBufnum; } index bufnum() const { return mBufnum; }
void realTime(bool rt) { mRealTime = rt; } void realTime(bool rt) { mRealTime = rt; }
protected: protected:
bool mRealTime{false}; bool mRealTime{false};
float *mOldData{0}; float *mOldData{0};
intptr_t mBufnum; index mBufnum;
World *mWorld; World *mWorld;
}; };

Write Preview
Loading…
Cancel
Save