void gBrowser::init(const char *init_path) {
gLog("[gBrowser] init path = '%s'\n", init_path);
if (init_path == NULL || !gIsDir(init_path)) {
#if defined(__linux__) || defined(__APPLE__)
path_obj->value("/home");
#elif defined(_WIN32)
/* SHGetFolderPath is deprecated. We should use SHGetKnownFolderPath
* but that would break compatibility with XP. On Vista, GetFolderPath
* is a wrapper of GetKnownFolderPath, so no problem. */
char winRoot[1024];
SHGetFolderPath(NULL, CSIDL_COMMON_DESKTOPDIRECTORY, NULL, 0, winRoot); // si parte dal Desktop
path_obj->value(winRoot);
#endif
gLog("[gBrowser] init_path null or invalid, using default\n");
}
else
path_obj->value(init_path);
refresh();
sort();
}
int Wave::resample(int quality, int newRate)
{
float ratio = newRate / (float) inHeader.samplerate;
int newSize = ceil(size * ratio);
if (newSize % 2 != 0) // libsndfile goes crazy with odd size in case of saving
newSize++;
float *tmp = (float *) malloc(newSize * sizeof(float));
if (!tmp) {
gLog("[wave] unable to allocate memory for resampling\n");
return -1;
}
SRC_DATA src_data;
src_data.data_in = data;
src_data.input_frames = size/2; // in frames, i.e. /2 (stereo)
src_data.data_out = tmp;
src_data.output_frames = newSize/2; // in frames, i.e. /2 (stereo)
src_data.src_ratio = ratio;
gLog("[wave] resampling: new size=%d (%d frames)\n", newSize, newSize/2);
int ret = src_simple(&src_data, quality, 2);
if (ret != 0) {
gLog("[wave] resampling error: %s\n", src_strerror(ret));
return 0;
}
free(data);
data = tmp;
size = newSize;
inHeader.samplerate = newRate;
return 1;
}
int Plugin::unload() {
if (module == NULL)
return 1;
#if defined(_WIN32)
FreeLibrary((HMODULE)module); // FIXME - error checking
return 1;
#elif defined(__linux__)
return dlclose(module) == 0 ? 1 : 0;
#elif defined(__APPLE__)
/* we must unload bundles but because bundles may be in use for other
plug-in types it is important (and mandatory on certain plug-ins,
e.g. Korg) to do a check on the retain count. */
CFIndex retainCount = CFGetRetainCount(module);
if (retainCount == 1) {
gLog("[plugin] retainCount == 1, can unload dlyb\n");
CFBundleUnloadExecutable(module);
CFRelease(module);
}
else
gLog("[plugin] retainCount > 1 (%d), leave dlyb alone\n", (int) retainCount);
return 1;
#endif
}
int Wave::writeData(const char *f)
{
/* prepare the header for output file */
outHeader.samplerate = inHeader.samplerate;
outHeader.channels = inHeader.channels;
outHeader.format = inHeader.format;
fileOut = sf_open(f, SFM_WRITE, &outHeader);
if (fileOut == NULL) {
gLog("[wave] unable to open %s for exporting\n", f);
return 0;
}
int out = sf_write_float(fileOut, data, size);
if (out != (int) size) {
gLog("[wave] error while exporting %s! %s\n", f, sf_strerror(fileOut));
return 0;
}
isLogical = false;
isEdited = false;
sf_close(fileOut);
return 1;
}
void PluginHost::freePlugin(int id, int stackType, Channel *ch) {
gVector <Plugin *> *pStack;
pStack = getStack(stackType, ch);
/* try to delete the plugin until succeed. G_Mixer has priority. */
for (unsigned i=0; i<pStack->size; i++)
if (pStack->at(i)->getId() == id) {
if (pStack->at(i)->status == 0) { // no frills if plugin is missing
delete pStack->at(i);
pStack->del(i);
return;
}
else {
int lockStatus;
while (true) {
lockStatus = pthread_mutex_trylock(&G_Mixer.mutex_plugins);
if (lockStatus == 0) {
pStack->at(i)->suspend();
pStack->at(i)->close();
delete pStack->at(i);
pStack->del(i);
pthread_mutex_unlock(&G_Mixer.mutex_plugins);
gLog("[pluginHost] plugin id=%d removed\n", id);
return;
}
//else
//gLog("[pluginHost] waiting for mutex...\n");
}
}
}
gLog("[pluginHost] plugin id=%d not found\n", id);
}
int wfx_trim(Wave *w, int a, int b) {
a = a * 2;
b = b * 2;
if (a < 0) a = 0;
if (b > w->size) b = w->size;
int newSize = b - a;
float *temp = (float *) malloc(newSize * sizeof(float));
if (temp == NULL) {
gLog("[wfx] unable to allocate memory for trimming\n");
return 0;
}
gLog("[wfx] trimming from %d to %d (area = %d)\n", a, b, b-a);
for (int i=a, k=0; i<b; i++, k++)
temp[k] = w->data[i];
free(w->data);
w->data = temp;
w->size = newSize;
//w->inHeader.frames = b-a;
w->frames(b - a);
w->isEdited = true;
return 1;
}
void updateSamplerate(int systemRate, int patchRate)
{
/* diff ratio: systemRate / patchRate
* e.g. 44100 / 96000 = 0.4... */
if (systemRate == patchRate)
return;
gLog("[REC] systemRate (%d) != patchRate (%d), converting...\n", systemRate, patchRate);
float ratio = systemRate / (float) patchRate;
for (unsigned i=0; i<frames.size; i++) {
gLog("[REC] oldFrame = %d", frames.at(i));
float newFrame = frames.at(i);
newFrame = floorf(newFrame * ratio);
frames.at(i) = (int) newFrame;
if (frames.at(i) % 2 != 0)
frames.at(i)++;
gLog(", newFrame = %d\n", frames.at(i));
}
/* update structs */
for (unsigned i=0; i<frames.size; i++) {
for (unsigned j=0; j<global.at(i).size; j++) {
action *a = global.at(i).at(j);
a->frame = frames.at(i);
}
}
}
void AppidManager::UpdateAppidMeta(const Config& config) {
int ret = 0;
unsigned int appid = 0;
std::string interval_value; //60, 3600, 86400
unsigned char new_index = (index_ + 1) % 2;
AppidMapVecAppidMeta& tmp_appid = appid_map_[new_index];
tmp_appid.clear();
std::vector<std::string> keys;
config.GetKeysBySection("appid", keys);
for (std::vector<std::string>::iterator it = keys.begin();
it != keys.end(); ++it) {
appid = atoi(it->c_str());
ret = config.ReadItem("appid", *it, "", interval_value);
if (ret != 0 || appid == 0) {
gLog("[%s][%d]: read %s appid %d failed %d\n", __FILE__, __LINE__,
it->c_str(), appid, ret);
continue;
}
int32_t min = 0, mid = 0, max = 0;
char *save_ptr = NULL;
char *p = NULL;
char buf[128];
snprintf(buf, sizeof(buf), "%s", interval_value.c_str());
p = strtok_r(buf, ",", &save_ptr);
if (p != NULL) {
min = atoi(p);
if (min > 0 && min <= 86400) {
tmp_appid[appid].set_min_interval(min);
}
}
p = strtok_r(NULL, ",", &save_ptr);
if (p != NULL) {
mid = atoi(p);
if (mid > 0 && mid <= 86400) {
tmp_appid[appid].set_mid_interval(mid);
}
}
p = strtok_r(NULL, ",", &save_ptr);
if (p != NULL) {
max = atoi(p);
if (max > 0 && max <= 86400) {
tmp_appid[appid].set_max_interval(max);
}
}
}
index_ = new_index;
gLog("[%s][%d]: index = %d\n", __FILE__, __LINE__, index_);
for (AppidMapVecAppidMeta::iterator it = appid_map_[index_].begin();
it != appid_map_[index_].end(); ++it) {
gLog("[%s][%d]: appid = %u, meta = %s\n", __FILE__, __LINE__,
it->first, it->second.DebugString().c_str());
}
}
int jackSyncCb(jack_transport_state_t state, jack_position_t *pos,
void *arg)
{
switch (state) {
case JackTransportStopped:
gLog("[KA] Jack transport stopped, frame=%d\n", pos->frame);
glue_stopSeq(false); // false = not from GUI
if (pos->frame == 0)
glue_rewindSeq();
break;
case JackTransportRolling:
gLog("[KA] Jack transport rolling\n");
break;
case JackTransportStarting:
gLog("[KA] Jack transport starting, frame=%d\n", pos->frame);
glue_startSeq(false); // false = not from GUI
if (pos->frame == 0)
glue_rewindSeq();
break;
default:
gLog("[KA] Jack transport [unknown]\n");
}
return 1;
}
int checkConfig()
{
FILE* EditorPTR;
EditorPTR = fopen(CONFIG_FILE, "r");
if(EditorPTR) // If open Editor
{
gLog("[World of Warcraft Studio - Editor] - Config exist\n##############################################################\n");
if(EditorPTR == NULL) // If conf is empty
{
gLog("[World of Warcraft Studio - Editor] - Config is empty\n##############################################################\n");
exit(1);
}
else
gLog("[World of Warcraft Studio - Editor] - Config have content\n##############################################################\n"); // Config isn't empty
}
else
{
gLog("[World of Warcraft Studio - Editor] - Config doesn't exist\n##############################################################\n"); // Config doesn't exist
exit(1);
}
return 0;
}
bool PlainExpression::ParseItem(const std::string& item) {
const char *ptr = NULL;
ptr = strstr(item.c_str(), ">");
if (ptr == NULL) return false;
Slice keyword(item.c_str(), ptr);
keyword.StrTrim(" ");
if (keyword == "min_interval") {
key_index_ = 0;
} else if (keyword == "mid_interval") {
key_index_ = 1;
} else if (keyword == "max_interval") {
key_index_ = 2;
} else {
gLog("[%s][%d]: wrong keyword %s, item %s\n",
__FILE__, __LINE__, keyword.ToStr().c_str(), item.c_str());
return false;
}
ptr++;
if (*ptr == '=') {
ptr++;
cmp_ = GreaterOrEqual;
} else {
cmp_ = Greater;
}
if (*ptr == '\0') {
gLog("[%s][%d]: wrong syntax item %s\n", __FILE__, __LINE__, item.c_str());
return false;
}
threshold_ = strtoul(ptr, NULL, 10);
return threshold_ > 0;
}
GLuint TextureManager::add(string name)
{
bool ext;
GLuint id;
transform (name.begin(), name.end(), name.begin(), ToLower());
if (names.find(name) != names.end())
{
id = names[name];
items[id]->addref();
return id;
}
glGenTextures(1, &id);
Texture* tex = new Texture(name);
tex->id = id;
ext=LoadBLP(id, tex);
if(!ext)
gLog("[World of Warcraft Studio - Editor] - Loading Texture from MPQ %s\n", name.c_str());
else
gLog("[World of Warcraft Studio - Editor] - Loading Texture from File %s\n", name.c_str());
do_add(name, id, tex);
return id;
}
int gdKeyGrabber::handle(int e)
{
int ret = Fl_Group::handle(e);
switch(e) {
case FL_KEYUP: {
int x = Fl::event_key();
if (strlen(Fl::event_text()) != 0
&& x != FL_BackSpace
&& x != FL_Enter
&& x != FL_Delete
&& x != FL_Tab
&& x != FL_End
&& x != ' ')
{
gLog("set key '%c' (%d) for channel %d\n", x, x, ch->index);
setButtonLabel(x);
updateText(x);
break;
}
else
gLog("invalid key\n");
}
}
return(ret);
}
void print()
{
gLog("[REC] ** print debug **\n");
for (unsigned i=0; i<global.size; i++) {
gLog(" frame %d\n", frames.at(i));
for (unsigned j=0; j<global.at(i).size; j++) {
gLog(" action %d | chan %d | frame %d\n", global.at(i).at(j)->type, global.at(i).at(j)->chan, global.at(i).at(j)->frame);
}
}
}
int startStream() {
try {
system->startStream();
gLog("[KA] latency = %lu\n", system->getStreamLatency());
return 1;
}
catch (RtAudioError &e) {
gLog("[KA] Start stream error: %s\n", e.getMessage().c_str());
return 0;
}
}
Model::Model(std::string name, bool forceAnim) : ManagedItem(name), forceAnim(forceAnim)
{
// replace .MDX with .M2
char tempname[256];
strcpy(tempname,name.c_str());
tempname[name.length()-2] = '2';
tempname[name.length()-1] = 0;
MPQFile f(tempname);
ok = !f.isEof();
if (!ok) {
gLog("Error loading model [%s]\n", tempname);
return;
}
memcpy(&header, f.getBuffer(), sizeof(ModelHeader));
// HACK: these particle systems are way too active and cause horrible horrible slowdowns
// I'm removing them until I can fix emission speed so it doesn't get this crazy
if (false
|| name=="World\\Kalimdor\\Orgrimmar\\Passivedoodads\\Orgrimmarbonfire\\Orgrimmarsmokeemitter.Mdx"
//|| name=="World\\Kalimdor\\Orgrimmar\\Passivedoodads\\Orgrimmarbonfire\\Orgrimmarbonfire01.Mdx"
) {
header.nParticleEmitters = 0;
}
animated = isAnimated(f) || forceAnim; // isAnimated will set animGeometry and animTextures
gLog("Loading model %s%s\n", tempname, animated ? " (animated)" : "");
trans = 1.0f;
vbuf = nbuf = tbuf = 0;
globalSequences = 0;
animtime = 0;
anim = 0;
colors = 0;
lights = 0;
transparency = 0;
particleSystems = 0;
ribbons = 0;
if (header.nGlobalSequences) {
globalSequences = new int[header.nGlobalSequences];
memcpy(globalSequences, (f.getBuffer() + header.ofsGlobalSequences), header.nGlobalSequences * 4);
}
if (animated) initAnimated(f);
else initStatic(f);
f.close();
}
int SampleChannel::load(const char *file)
{
if (strcmp(file, "") == 0 || gIsDir(file)) {
gLog("[SampleChannel] file not specified\n");
return SAMPLE_LEFT_EMPTY;
}
if (strlen(file) > FILENAME_MAX)
return SAMPLE_PATH_TOO_LONG;
Wave *w = new Wave();
if (!w->open(file)) {
gLog("[SampleChannel] %s: read error\n", file);
delete w;
return SAMPLE_READ_ERROR;
}
if (w->channels() > 2) {
gLog("[SampleChannel] %s: unsupported multichannel wave\n", file);
delete w;
return SAMPLE_MULTICHANNEL;
}
if (!w->readData()) {
delete w;
return SAMPLE_READ_ERROR;
}
if (w->channels() == 1) /** FIXME: error checking */
wfx_monoToStereo(w);
if (w->rate() != G_Conf.samplerate) {
gLog("[SampleChannel] input rate (%d) != system rate (%d), conversion needed\n",
w->rate(), G_Conf.samplerate);
w->resample(G_Conf.rsmpQuality, G_Conf.samplerate);
}
pushWave(w);
/* sample name must be unique. Start from k = 1, zero is too nerdy */
std::string oldName = wave->name;
int k = 1;
while (!mh_uniqueSamplename(this, wave->name.c_str())) {
wave->updateName((oldName + "-" + gItoa(k)).c_str());
k++;
}
gLog("[SampleChannel] %s loaded in channel %d\n", file, index);
return SAMPLE_LOADED_OK;
}
void deleteAction(int chan, int frame, char type, bool checkValues, uint32_t iValue, float fValue)
{
/* find the frame 'frame' */
bool found = false;
for (unsigned i=0; i<frames.size && !found; i++) {
if (frames.at(i) == frame) {
/* find the action in frame i */
for (unsigned j=0; j<global.at(i).size; j++) {
action *a = global.at(i).at(j);
/* action comparison logic */
bool doit = (a->chan == chan && a->type == (type & a->type));
if (checkValues)
doit &= (a->iValue == iValue && a->fValue == fValue);
if (doit) {
int lockStatus = 0;
while (lockStatus == 0) {
lockStatus = pthread_mutex_trylock(&G_Mixer.mutex_recs);
if (lockStatus == 0) {
#ifdef WITH_VST
if (type == ACTION_MIDI)
free(a->event);
#endif
free(a);
global.at(i).del(j);
pthread_mutex_unlock(&G_Mixer.mutex_recs);
found = true;
break;
}
else
gLog("[REC] delete action: waiting for mutex...\n");
}
}
}
}
}
if (found) {
optimize();
chanHasActions(chan);
gLog("[REC] action deleted, type=%d frame=%d chan=%d iValue=%d (%X) fValue=%f\n",
type, frame, chan, iValue, iValue, fValue);
}
else
gLog("[REC] unable to find action! type=%d frame=%d chan=%d iValue=%d (%X) fValue=%f\n",
type, frame, chan, iValue, iValue, fValue);
}
int Wave::readData() {
size = inHeader.frames * inHeader.channels;
data = (float *) malloc(size * sizeof(float));
if (data == NULL) {
gLog("[wave] unable to allocate memory\n");
return 0;
}
if (sf_read_float(fileIn, data, size) != size)
gLog("[wave] warning: incomplete read!\n");
sf_close(fileIn);
return 1;
}
void expand(int old_fpb, int new_fpb)
{
/* this algorithm requires multiple passages if we expand from e.g. 2
* to 16 beats, precisely 16 / 2 - 1 = 7 times (-1 is the first group,
* which exists yet). If we expand by a non-multiple, the result is zero,
* due to float->int implicit cast */
unsigned pass = (int) (new_fpb / old_fpb) - 1;
if (pass == 0) pass = 1;
unsigned init_fs = frames.size;
for (unsigned z=1; z<=pass; z++) {
for (unsigned i=0; i<init_fs; i++) {
unsigned newframe = frames.at(i) + (old_fpb*z);
frames.add(newframe);
global.add(actions);
for (unsigned k=0; k<global.at(i).size; k++) {
action *a = global.at(i).at(k);
rec(a->chan, a->type, newframe, a->iValue, a->fValue);
}
}
}
gLog("[REC] expanded recs\n");
//print();
}
Channel::Channel(int type, int status, char side, int bufferSize)
: bufferSize(bufferSize),
type (type),
status (status),
side (side),
volume (DEFAULT_VOL),
volume_i (1.0f),
volume_d (0.0f),
panLeft (1.0f),
panRight (1.0f),
mute_i (false),
mute_s (false),
mute (false),
solo (false),
hasActions(false),
recStatus (REC_STOPPED),
vChan (NULL),
guiChannel(NULL),
midiIn (true),
midiInKeyPress(0x0),
midiInKeyRel (0x0),
midiInKill (0x0),
midiInVolume (0x0),
midiInMute (0x0),
midiInSolo (0x0)
{
vChan = (float *) malloc(bufferSize * sizeof(float));
if (!vChan)
gLog("[Channel] unable to alloc memory for vChan\n");
memset(vChan, 0, bufferSize * sizeof(float));
}
void gKeyboard::__cb_addColumn()
{
int colx;
int colxw;
int colw = 380;
if (columns.size == 0) {
colx = x() - xposition(); // mind the offset with xposition()
colxw = colx + colw;
}
else {
gColumn *prev = columns.last();
colx = prev->x()+prev->w() + 16;
colxw = colx + colw;
}
/* add gColumn to gKeyboard and to columns vector */
gColumn *gc = new gColumn(colx, y(), colw-20, 2000, indexColumn, this);
add(gc);
columns.add(gc);
indexColumn++;
/* move addColumn button */
addColumnBtn->position(colxw-4, y());
redraw();
gLog("[gKeyboard::__cb_addColumn] new column added (index = %d), total count=%d, addColumn(x)=%d\n",
gc->getIndex(), columns.size, addColumnBtn->x());
}
void Skies::initSky(Vec3D pos, int t)
{
if (numSkies==0)
return;
findSkyWeights(pos);
for (int i=0; i<18; i++) colorSet[i] = Vec3D(1,1,1);
// interpolation
for (size_t j=0; j<skies.size(); j++) {
if (skies[j].weight>0) {
// now calculate the color rows
for (int i=0; i<18; i++) {
if((skies[j].colorFor(i,t).x>1.0f)||(skies[j].colorFor(i,t).y>1.0f)||(skies[j].colorFor(i,t).z>1.0f))
{
gLog("Sky %d %d is out of bounds!\n",j,i);
continue;
}
colorSet[i] += skies[j].colorFor(i,t) * skies[j].weight;
}
}
}
for (int i=0; i<18; i++)
{
colorSet[i] -= Vec3D( 1, 1, 1 );
}
}
Skies::Skies( int mapid )
{
gLog( "Skies::Skies( %i );\n", mapid );
numSkies = 0;
cs = -1;
stars = 0;
for( DBCFile::Iterator i = gLightDB.begin(); i != gLightDB.end(); ++i )
{
if( mapid == i->getUInt( LightDB::Map ) )
{
Sky s( i );
skies.push_back( s );
numSkies++;
}
}
// sort skies from smallest to largest; global last.
// smaller skies will have precedence when calculating weights to achieve smooth transitions etc.
std::sort( skies.begin( ), skies.end( ) );
stars = new Model( "Environments\\Stars\\Stars.mdx", true );
}
std::string gGetHomePath()
{
char path[PATH_MAX];
#if defined(__linux__)
snprintf(path, PATH_MAX, "%s/.giada", getenv("HOME"));
#elif defined(_WIN32)
snprintf(path, PATH_MAX, ".");
#elif defined(__APPLE__)
struct passwd *p = getpwuid(getuid());
if (p == NULL) {
gLog("[gGetHomePath] unable to fetch user infos\n");
return "";
}
else {
const char *home = p->pw_dir;
snprintf(path, PATH_MAX, "%s/Library/Application Support/Giada", home);
}
#endif
return std::string(path);
}
void clearChan(int index)
{
gLog("[REC] clearing chan %d...\n", index);
for (unsigned i=0; i<global.size; i++) { // for each frame i
unsigned j=0;
while (true) {
if (j == global.at(i).size) break; // for each action j of frame i
action *a = global.at(i).at(j);
if (a->chan == index) {
#ifdef WITH_VST
if (a->type == ACTION_MIDI)
free(a->event);
#endif
free(a);
global.at(i).del(j);
}
else
j++;
}
}
Channel *ch = G_Mixer.getChannelByIndex(index);
ch->hasActions = false;
optimize();
//print();
}
std::string DataStorageIni::getValue(const char *in)
{
/* on each call reset the pointe to the beginning of the file. Not so
* good but necessary if you want to pick up random values from the
* file. */
fseek(fp, 0L, SEEK_SET);
std::string out = "";
while (!feof(fp)) {
char buffer[MAX_LINE_LEN];
if (fgets(buffer, MAX_LINE_LEN, fp) == NULL) {
gLog("[PATCH] get_value error (key=%s)\n", in);
return "";
}
if (buffer[0] == '#')
continue;
unsigned len = strlen(in);
if (strncmp(buffer, in, len) == 0) {
for (unsigned i=len+1; i<MAX_LINE_LEN; i++) {
if (buffer[i] == '\0' || buffer[i] == '\n' || buffer[i] == '\r')
break;
out += buffer[i];
}
break; // string found
}
}
return out;
}
int PluginHost::allocBuffers() {
/** FIXME - ERROR CHECKING! */
/* never, ever use G_Conf.buffersize to alloc these chunks of memory.
* If you use JACK, that value would be meaningless. Always refer to
* kernelAudio::realBufsize. */
int bufSize = kernelAudio::realBufsize*sizeof(float);
bufferI = (float **) malloc(2 * sizeof(float*));
bufferI[0] = (float *) malloc(bufSize);
bufferI[1] = (float *) malloc(bufSize);
bufferO = (float **) malloc(2 * sizeof(float*));
bufferO[0] = (float *) malloc(bufSize);
bufferO[1] = (float *) malloc(bufSize);
memset(bufferI[0], 0, bufSize);
memset(bufferI[1], 0, bufSize);
memset(bufferO[0], 0, bufSize);
memset(bufferO[1], 0, bufSize);
gLog("[pluginHost] buffers allocated, buffersize = %d\n", 2*kernelAudio::realBufsize);
//printOpcodes();
return 1;
}
int Plugin::setProgram(int index) {
plugin->dispatcher(plugin, effBeginSetProgram, 0, 0, 0, 0);
plugin->dispatcher(plugin, effSetProgram, 0, index, 0, 0);
gLog("[plugin] program changed, index %d\n", index);
program = index;
return plugin->dispatcher(plugin, effEndSetProgram, 0, 0, 0, 0);
}
int PluginHost::addPlugin(const char *fname, int stackType, Channel *ch) {
Plugin *p = new Plugin();
bool success = true;
gVector <Plugin *> *pStack;
pStack = getStack(stackType, ch);
if (!p->load(fname)) {
//delete p;
//return 0;
success = false;
}
/* if the load failed we add a 'dead' plugin into the stack. This is
* useful to report a missing plugin. */
if (!success) {
pStack->add(p);
return 0;
}
/* otherwise let's try to initialize it. */
else {
/* try to init the plugin. If fails, delete it and return error. */
if (!p->init(&PluginHost::HostCallback)) {
delete p;
return 0;
}
/* plugin setup */
p->setup(G_Conf.samplerate, kernelAudio::realBufsize);
/* try to add the new plugin until succeed */
int lockStatus;
while (true) {
lockStatus = pthread_mutex_trylock(&G_Mixer.mutex_plugins);
if (lockStatus == 0) {
pStack->add(p);
pthread_mutex_unlock(&G_Mixer.mutex_plugins);
break;
}
}
char name[256]; p->getName(name);
gLog("[pluginHost] plugin id=%d loaded (%s), stack type=%d, stack size=%d\n", p->getId(), name, stackType, pStack->size);
/* p->resume() is suggested. Who knows... */
p->resume();
return 1;
}
}
