llvm_dsp_factory* FaustgenFactory::createFactoryFromSourceCode(FaustAudioPluginInstance* instance)
{
defaultCompileOptions();
// Prepare compile options
std::string error;
const char* argv[32];
memset(argv, 0, 32 * sizeof(char*));
jassert(fCompileOptions.size() < 32);
for (int opt = 0; opt < fCompileOptions.size(); opt++)
{
argv[opt] = (char*) fCompileOptions.getReference(opt).toRawUTF8();
}
llvm_dsp_factory* factory = createDSPFactoryFromString(getTMPName().toStdString(), fSourceCode.toStdString(), fCompileOptions.size(), argv, getTarget(), error, LLVM_OPTIMIZATION);
if (factory)
{
return factory;
}
else
{
if (fUpdateInstance == instance)
{
instance->highlightON(error);
}
LOG("Invalid Faust code or compile options:" + error);
return 0;
}
}
// Create DSP Factory
bool Server::compile_Data(connection_info_struct* con_info){
if(con_info->fSHAKey != ""){
// Sort out compilation options
int argc = con_info->fCompilationOptions.size();
const char* argv[argc];
for(int i=0; i<argc; i++){
argv[i] = (con_info->fCompilationOptions[i]).c_str();
}
string error("");
con_info->fLLVMFactory = createDSPFactoryFromString(con_info->fNameApp, con_info->fFaustCode, argc, argv, "", error, atoi(con_info->fOptLevel.c_str()));
if(con_info->fLLVMFactory){
fAvailableFactories[con_info->fSHAKey] = make_pair(con_info->fNameApp, con_info->fLLVMFactory);
// Once the factory is compiled, the json is stored as answerstring
con_info->fAnswerstring = getJson(con_info);
return true;
}
}
con_info->fAnswerstring = "Impossible to generate SHA1 key";
return false;
}
int init_faustcompile(CSOUND *csound, faustcompile *p) {
faustobj **pffactory, *ffactory;
llvm_dsp_factory *factory;
int argc = 0;
std::string err_msg;
char *cmd = (char *) malloc(p->args->size + 8);
strcpy(cmd, p->args->data);
#ifdef USE_DOUBLE
strcat(cmd, " -double");
#endif
const char **argv = (const char **) parse_cmd(cmd, &argc);
const char* varname = "::factory";
factory = createDSPFactoryFromString("faustop", (const char *) p->code->data, argc, argv, "", err_msg, 3);
if(factory == NULL) {
free(argv);
free(cmd);
return csound->InitError(csound,
Str("Faust compilation problem: %s\n"), err_msg.c_str());
}
pffactory = (faustobj **) csound->QueryGlobalVariable(csound,varname);
if(pffactory == NULL) {
csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *));
pffactory = (faustobj **) csound->QueryGlobalVariable(csound,varname);
ffactory = (faustobj *) csound->Calloc(csound, sizeof(faustobj));
ffactory->obj = factory;
ffactory->nxt = NULL;
ffactory->cnt = 0;
*pffactory = ffactory;
}
else {
ffactory = *pffactory;
while(ffactory->nxt){
ffactory = ffactory->nxt;
}
ffactory->nxt = (faustobj *) csound->Calloc(csound, sizeof(faustobj));
ffactory->nxt->cnt = ffactory->cnt+1;
ffactory = ffactory->nxt;
ffactory->obj = factory;
}
p->factory = factory;
*p->hptr = (MYFLT) ffactory->cnt;
csound->RegisterResetCallback(csound, p, delete_faustcompile);
free(argv);
free(cmd);
return OK;
}
//-------------------------------------------------------------------------
// MAIN
//-------------------------------------------------------------------------
int main(int argc, char *argv[])
{
char jackname[256];
snprintf(jackname, 256, "%s", basename(argv[0]));
std::string error_msg;
if (argc < 2) {
printf("faust-llvm 'foo.dsp'\n");
exit(-1);
}
// Error check to add....
// llvm_dsp_factory* factory = createDSPFactoryFromFile(argv[1], argc-2, (const char**)&argv[2], "", error_msg, -1);
// Another possibility by directly giving the Faust program as a string
// Additional parameters given to the compiler
int argc1 = 3;
const char* argv1[argc];
argv1[0] = "-vec";
argv1[1] = "-lv";
argv1[2] = " 1";
// Faust program
std::string faust_program = "process = 1;";
llvm_dsp_factory* factory = createDSPFactoryFromString("test", faust_program, argc1, argv1, "", error_msg, -1);
dsp* DSP = createDSPInstance(factory);
PrintUI interface;
DSP->buildUserInterface(&interface);
dummyaudio audio(BUFFER_TO_RENDER);
audio.init(jackname, DSP);
audio.start();
// Render BUFFER_TO_RENDER buffers...
audio.stop();
return 0;
}
// Create DSP Factory
llvm_dsp_factory* dsp_server_connection_info::createFactory(DSPServer* server, string& error)
{
// Sort out compilation options
int argc = fCompilationOptions.size();
const char* argv[argc];
for (int i = 0; i < argc; i++) {
argv[i] = fCompilationOptions[i].c_str();
}
llvm_dsp_factory* factory = NULL;
if (isopt(argc, argv, "-lm")) {
// Machine code
factory = readDSPFactoryFromMachine(fFaustCode, loptions(argv, "-lm", ""));
//factory = readCDSPFactoryFromMachine(fFaustCode.c_str(), loptions(argv, "-lm", ""));
} else {
// DSP code
string error1;
factory = createDSPFactoryFromString(fNameApp,
fFaustCode,
argc, argv, "",
error, atoi(fOptLevel.c_str()));
/*
char error1[256];
factory = createCDSPFactoryFromString(fNameApp.c_str(),
fFaustCode.c_str(),
argc, argv, "",
error1, atoi(fOptLevel.c_str()));
*/
error = error1;
}
if (factory && server->fCreateDSPFactoryCb) {
// Possibly call callback
server->fCreateDSPFactoryCb(factory, server->fCreateDSPFactoryCb_arg);
}
return factory;
}
Block::Block(
const QString& script,
AudioEngine& params):
AudioBlock{params}
{
std::string target;
m_faustFactory = createDSPFactoryFromString(
"name",
"phasor(f) = f/48000 : (+,1.0:fmod) ~ _ ; "
"process = phasor(220) * 6.28 : sin;",//script.toStdString(),
0, nullptr, "", target);
if(m_faustFactory)
{
m_faustPlug = createDSPInstance(m_faustFactory);
}
for(auto& vec : in_vec_cnt)
vec.resize(parameters().bufferSize);
for(auto& vec : out_vec_cnt)
vec.resize(parameters().bufferSize);
}
// Create DSP Factory
llvm_dsp_factory* dsp_server_connection_info::crossCompileFactory(DSPServer* server, string& error)
{
llvm_dsp_factory* factory;
// Already in the cache...
if ((factory = getDSPFactoryFromSHAKey(fSHAKey))) {
// if ((factory = getCDSPFactoryFromSHAKey(fSHAKey.c_str()))) {
return factory;
} else {
// Sort out compilation options
int argc = fCompilationOptions.size();
const char* argv[argc];
for (int i = 0; i < argc; i++) {
argv[i] = fCompilationOptions[i].c_str();
}
/*
char error1[256];
factory = createCDSPFactoryFromString(fNameApp.c_str(),
fFaustCode.c_str(),
argc, argv, fTarget.c_str(),
error1, atoi(fOptLevel.c_str()));
*/
string error1;
factory = createDSPFactoryFromString(fNameApp,
fFaustCode,
argc, argv, fTarget,
error1, atoi(fOptLevel.c_str()));
error = error1;
if (factory && server->fCreateDSPFactoryCb) {
// Possibly call callback
server->fCreateDSPFactoryCb(factory, server->fCreateDSPFactoryCb_arg);
}
return factory;
}
}
dsp* FaustgenFactory::createDSPAux(FaustAudioPluginInstance* instance)
{
dsp* dsp = nullptr;
std::string error;
String logStr;
// Factory already allocated
if (fDSPfactory)
{
dsp = fDSPfactory->createDSPInstance();
logStr << "Factory already allocated, " << dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
goto end;
}
// Tries to create from bitcode
if (fBitCode.length() > 0)
{
fDSPfactory = createFactoryFromBitcode();
if (fDSPfactory)
{
dsp = fDSPfactory->createDSPInstance();
logStr << "Compilation from bitcode succeeded, " << dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
goto end;
}
}
// Otherwise tries to create from source code
if (fSourceCode.length() > 0)
{
fDSPfactory = createFactoryFromSourceCode(instance);
if (fDSPfactory)
{
dsp = fDSPfactory->createDSPInstance();
logStr << "Compilation from source code succeeded, " << dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
goto end;
}
}
// Otherwise creates default DSP keeping the same input/output number
fDSPfactory = createDSPFactoryFromString("default", DEFAULT_CODE, 0, 0, getTarget(), error, LLVM_OPTIMIZATION);
jassert(fDSPfactory);
if (fDSPfactory)
{
dsp = fDSPfactory->createDSPInstance();
logStr << "Allocation of default DSP succeeded, " << dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
}
end:
LOG(logStr);
jassert(dsp);
// Prepare JSON
JSONUI builder(dsp->getNumInputs(), dsp->getNumOutputs());
dsp->metadata(&builder);
dsp->buildUserInterface(&builder);
fJSON = String(builder.JSON());
//LOG(fJSON);
return dsp;
}
// Create DSP Factory
dsp_factory* dsp_server_connection_info::crossCompileFactory(DSPServer* server, string& error)
{
dsp_factory* factory;
// Already in the cache...
#ifdef LLVM_DSP_FACTORY
if ((factory = getDSPFactoryFromSHAKey(fSHAKey))) {
#else
if ((factory = getInterpreterDSPFactoryFromSHAKey(fSHAKey))) {
#endif
return factory;
} else {
// Sort out compilation options
int argc = int(fCompilationOptions.size());
const char* argv[argc];
for (int i = 0; i < argc; i++) {
argv[i] = fCompilationOptions[i].c_str();
}
string error1;
#ifdef LLVM_DSP_FACTORY
factory = createDSPFactoryFromString(fNameApp, fFaustCode, argc, argv, fTarget, error1, atoi(fOptLevel.c_str()));
#else
factory = createInterpreterDSPFactoryFromString(fNameApp, fFaustCode, argc, argv, error1);
#endif
error = error1;
if (factory && server->fCreateDSPFactoryCb) {
// Possibly call callback
server->fCreateDSPFactoryCb(factory, server->fCreateDSPFactoryCb_arg);
}
return factory;
}
}
// Create DSP Factory
dsp_factory* dsp_server_connection_info::createFactory(DSPServer* server, string& error)
{
// Sort out compilation options
int argc = fCompilationOptions.size();
const char* argv[argc];
for (int i = 0; i < argc; i++) {
argv[i] = fCompilationOptions[i].c_str();
}
dsp_factory* factory = NULL;
if (isopt(argc, argv, "-lm")) {
// Machine code
#ifdef LLVM_DSP_FACTORY
factory = readDSPFactoryFromMachine(fFaustCode, loptions(argv, "-lm", ""));
#else
factory = readInterpreterDSPFactoryFromMachine(fFaustCode);
#endif
} else {
// DSP code
string error1;
#ifdef LLVM_DSP_FACTORY
factory = createDSPFactoryFromString(fNameApp,fFaustCode, argc, argv, "", error, atoi(fOptLevel.c_str()));
#else
factory = createInterpreterDSPFactoryFromString(fNameApp, fFaustCode, argc, argv, error);
#endif
error = error1;
}
if (factory && server->fCreateDSPFactoryCb) {
// Possibly call callback
server->fCreateDSPFactoryCb(factory, server->fCreateDSPFactoryCb_arg);
}
return factory;
}
int init_faustgen(CSOUND *csound, faustgen *p){
OPARMS parms;
std::string err_msg;
int size;
int argc = 3;
const char* argv[argc];
faustobj **pfdsp, *fdsp;
llvm_dsp *dsp;
controls *ctls = new controls();
const char *varname = "::dsp";
argv[0] = "-vec";
argv[1] = "-lv";
argv[2] = " 1";
#ifdef USE_DOUBLE
argv[3] = "-double";
argc += 1;
#endif
p->factory = createDSPFactoryFromString("faustop", (const char *) p->code->data, argc, argv, "", err_msg, 3);
if(p->factory == NULL)
return csound->InitError(csound,
Str("Faust compilation problem: %s\n"), err_msg.c_str());
dsp = createDSPInstance(p->factory);
if(dsp == NULL)
return csound->InitError(csound, Str("Faust instantiation problem \n"));
dsp->buildUserInterface(ctls);
pfdsp = (faustobj **) csound->QueryGlobalVariable(csound,varname);
if(pfdsp == NULL) {
csound->CreateGlobalVariable(csound, varname, sizeof(faustobj *));
pfdsp = (faustobj **) csound->QueryGlobalVariable(csound,varname);
fdsp = (faustobj *) csound->Calloc(csound, sizeof(faustobj));
fdsp->obj = dsp;
fdsp->ctls = ctls;
fdsp->nxt = NULL;
fdsp->cnt = 0;
*pfdsp = fdsp;
}
else {
fdsp = *pfdsp;
while(fdsp->nxt){
fdsp = fdsp->nxt;
}
fdsp->nxt = (faustobj *) csound->Calloc(csound, sizeof(faustobj));
fdsp->nxt->cnt = fdsp->cnt++;
fdsp = fdsp->nxt;
fdsp->obj = dsp;
fdsp->ctls = ctls;
}
p->engine = dsp;
dsp->buildUserInterface(ctls);
dsp->init(csound->GetSr(csound));
if(p->engine->getNumInputs() != p->INCOUNT-1) {
deleteDSPInstance(p->engine);
deleteDSPFactory(p->factory);
return csound->InitError(csound, Str("wrong number of input args\n"));
}
if(p->engine->getNumOutputs() != p->OUTCOUNT-1){
deleteDSPInstance(p->engine);
deleteDSPFactory(p->factory);
return csound->InitError(csound, Str("wrong number of output args\n"));
}
/* memory for sampAccurate offsets */
csound->GetOParms(csound, &parms);
if(parms.sampleAccurate){
int size;
size = p->engine->getNumInputs()*sizeof(MYFLT *);
if(p->memin.auxp == NULL ||
p->memin.size < size)
csound->AuxAlloc(csound, size, &p->memin);
size = p->engine->getNumOutputs()*sizeof(MYFLT *);
if(p->memout.auxp == NULL ||
p->memout.size < size)
csound->AuxAlloc(csound, size, &p->memout);
}
p->ctls = ctls;
*p->ohptr = (MYFLT) fdsp->cnt;
csound->RegisterDeinitCallback(csound, p, delete_faustgen);
return OK;
}
