Ok, good to know.  2 is the frontrunner solution for now then.  I'll
take a look at faust-stk though - I've only looked at the examples in
the folder above that so far. 

My app would be osc controlled, no GUI.  I envision faust providing
interesting synthesis patches in addition to the samples, as well as
pitch shifting the samples to provide arbitrary scales, as well as
looping and effects.  The platform is linux, running on a bananapi or
raspberry pi 2. 

I'm interested in rust right now, so I might look at a way to use the
faust code from rust, perhaps building a library with a C interface for
rust to use.  I have some existing code that uses haskell to control
supercollider, and I may end up reusing some of that, perhaps just to
send OSC messages to the rust server.  Or, I may port that code to rust. 

Ben

On 09/07/2015 02:58 AM, Hermann Meyer wrote:
> Option 2 is what we do in Guitarix.
>
> For option 1, you may have a look at the faust-stk, in special in
> instrument.h / instrument.lib and it's use.
> Maybe you didn't need a external program to get the samples into faust.
>
> regards
> hermann
>
> Am 07.09.2015 um 10:45 schrieb Stéphane Letz:
>> I would go for 2), but maybe you could describer first a bit more
>> what you are trying to develop :
>>
>> - on which platform?
>>
>> - what would be the role of Faust processing into your application?
>>
>> - would you application need a complete  UI or would it be only
>> remotely controlled? (like with OSC..)
>>
>> Stéphane
>>
>>
>> Le 7 sept. 2015 à 02:59, Ben Burdette <[email protected]> a écrit :
>>
>>> Hey all;
>>>
>>> I'm interesting in writing a program which can load multiple banks of
>>> sound samples based on a configuration file.  For a given config file
>>> there might be 10 or 15 banks, and (probably) 24 samples per bank.
>>>
>>> Faust, by design, doesn't have any provisions for this sort of thing as
>>> far as I can tell.  So I'll need to do my sample loading outside of
>>> faust.
>>>
>>> What would be a recommended architecture for such a program?  I can
>>> think of a couple of possibilities:
>>>
>>> 1) write a faust program with 24 slots for sounds.  Have an external
>>> program put the sounds into faust via osc, perhaps (is this possible?).
>>> Each time the sample bank is changed, load new sounds into faust,
>>> replacing the old.
>>>
>>> 2) write a program which uses the faust-generated C++ code as a module.
>>> This program would load the samples into its memory, and handle
>>> streaming them (and perhaps external sound sources) into the faust
>>> code,
>>> and then routing the faust code results to an audio device.
>>>
>>> 3) ??
>>>
>>> Option 2 certainly involves more responsibility, what with dealing with
>>> audio devices and so forth.  Option 1 seems easier, but perhaps a
>>> little
>>> kludgy - switching from one sound bank to another would be
>>> comparatively
>>> slow.
>>>
>>> Anyway, any input would be appreciated!
>>>
>>> - Ben
>>>
>>> ------------------------------------------------------------------------------
>>>
>>> _______________________________________________
>>> Faudiostream-users mailing list
>>> [email protected]
>>> https://lists.sourceforge.net/lists/listinfo/faudiostream-users
>>
>> ------------------------------------------------------------------------------
>>
>> _______________________________________________
>> Faudiostream-users mailing list
>> [email protected]
>> https://lists.sourceforge.net/lists/listinfo/faudiostream-users
>


------------------------------------------------------------------------------
_______________________________________________
Faudiostream-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/faudiostream-users

Reply via email to