src/effects/EffectFactory.cpp

/*
    Copyright (C) 2010 Christian Schoenebeck
*/

#include "EffectFactory.h"
#include "LadspaEffect.h"

namespace LinuxSampler {

static bool bInitialized = false;

static std::vector<EffectInfo*> vEffectInfos;

static std::vector<Effect*> vEffectInstances;

////////////////////////////////////////////////////////////////////////////
// class 'EffectFactory'

String EffectFactory::AvailableEffectSystemsAsString() {
    return "LADSPA";
}

uint EffectFactory::AvailableEffectsCount() {
    if (!bInitialized) UpdateAvailableEffects();
    bInitialized = true;
    return vEffectInfos.size();
}

EffectInfo* EffectFactory::GetEffectInfo(uint index) {
    if (index >= vEffectInfos.size()) return NULL;
    return vEffectInfos[index];
}

Effect* EffectFactory::Create(EffectInfo* pEffectInfo) throw (Exception) {
    Effect* pEffect = NULL;
    try {
        if (pEffectInfo->EffectSystem() == "LADSPA") {
            pEffect = new LadspaEffect(pEffectInfo);
        } else {
            throw Exception(
                "Effect system '" + pEffectInfo->EffectSystem() +
                "' not supported"
            );
        }
    } catch (Exception e) {
        throw Exception("Could not create effect: " + e.Message());
    } catch (...) {
        throw Exception("Could not create effect: unknown exception");
    }
    if (!pEffect) {
        // should never happen
        throw Exception("Oops, EffectFactory bug: !pEffect");
    }
    vEffectInstances.push_back(pEffect);
    return pEffect;
}

void EffectFactory::Destroy(Effect* pEffect) {
    for (int i = 0; i < vEffectInstances.size(); i++) {
        if  (vEffectInstances[i] == pEffect) {
            vEffectInstances.erase(vEffectInstances.begin() + i);
            delete pEffect;
        }
    }
}

void EffectFactory::UpdateAvailableEffects() {
    // clear out all old effect infos
    for (int i = 0; i < vEffectInfos.size(); i++) delete vEffectInfos[i];
    vEffectInfos.clear();

    // scan for LADSPA effects
    vEffectInfos = LadspaEffect::AvailableEffects();
}

} // namespace LinuxSampler
1	/*
2	Copyright (C) 2010 Christian Schoenebeck
3	*/
4
5	#include "EffectFactory.h"
6	#include "LadspaEffect.h"
7
8	namespace LinuxSampler {
9
10	static bool bInitialized = false;
11
12	static std::vector<EffectInfo*> vEffectInfos;
13
14	static std::vector<Effect*> vEffectInstances;
15
16	////////////////////////////////////////////////////////////////////////////
17	// class 'EffectFactory'
18
19	String EffectFactory::AvailableEffectSystemsAsString() {
20	return "LADSPA";
21	}
22
23	uint EffectFactory::AvailableEffectsCount() {
24	if (!bInitialized) UpdateAvailableEffects();
25	bInitialized = true;
26	return vEffectInfos.size();
27	}
28
29	EffectInfo* EffectFactory::GetEffectInfo(uint index) {
30	if (index >= vEffectInfos.size()) return NULL;
31	return vEffectInfos[index];
32	}
33
34	Effect* EffectFactory::Create(EffectInfo* pEffectInfo) throw (Exception) {
35	Effect* pEffect = NULL;
36	try {
37	if (pEffectInfo->EffectSystem() == "LADSPA") {
38	pEffect = new LadspaEffect(pEffectInfo);
39	} else {
40	throw Exception(
41	"Effect system '" + pEffectInfo->EffectSystem() +
42	"' not supported"
43	);
44	}
45	} catch (Exception e) {
46	throw Exception("Could not create effect: " + e.Message());
47	} catch (...) {
48	throw Exception("Could not create effect: unknown exception");
49	}
50	if (!pEffect) {
51	// should never happen
52	throw Exception("Oops, EffectFactory bug: !pEffect");
53	}
54	vEffectInstances.push_back(pEffect);
55	return pEffect;
56	}
57
58	void EffectFactory::Destroy(Effect* pEffect) {
59	for (int i = 0; i < vEffectInstances.size(); i++) {
60	if (vEffectInstances[i] == pEffect) {
61	vEffectInstances.erase(vEffectInstances.begin() + i);
62	delete pEffect;
63	}
64	}
65	}
66
67	void EffectFactory::UpdateAvailableEffects() {
68	// clear out all old effect infos
69	for (int i = 0; i < vEffectInfos.size(); i++) delete vEffectInfos[i];
70	vEffectInfos.clear();
71
72	// scan for LADSPA effects
73	vEffectInfos = LadspaEffect::AvailableEffects();
74	}
75
76	} // namespace LinuxSampler