src/engines/EngineChannelFactory.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2005, 2006 Christian Schoenebeck                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "EngineChannelFactory.h"

#include <strings.h>

#include "gig/EngineChannel.h"

namespace LinuxSampler {
    class LockedChannel {
        public:
            const EngineChannel* pChannel;
            bool bDestroyed;

            LockedChannel(const EngineChannel* pChannel)  {
                this->pChannel = pChannel;
                bDestroyed = false;
            }
    };

    class LockedChannelList {
        public:
            void Add(const EngineChannel* pChannel) {
                vChannelList.push_back(LockedChannel(pChannel));
            }

            bool IsDestroyed(const EngineChannel* pChannel) {
                LockedChannel* pLockedChannel = get(pChannel);
                if (pLockedChannel == NULL) return false;
                return pLockedChannel->bDestroyed;
            }

            void SetDestroyed(const EngineChannel* pChannel, bool bDestroyed = true) {
                LockedChannel* pLockedChannel = get(pChannel);
                if (pLockedChannel == NULL) return;
                pLockedChannel->bDestroyed = bDestroyed;
            }

            void Remove(const EngineChannel* pChannel) {
                std::vector<LockedChannel>::iterator it = vChannelList.begin();
                for (; it != vChannelList.end(); it++) {
                    if ((*it).pChannel == pChannel) {
                        vChannelList.erase(it);
                        return;
                    }
                }
            }

            bool Contains(const EngineChannel* pChannel) {
                return get(pChannel) != NULL;
            }

        private:
            std::vector<LockedChannel> vChannelList;

            LockedChannel* get(const EngineChannel* pChannel) {
                for (int i = 0; i < vChannelList.size(); i++) {
                    if (vChannelList[i].pChannel == pChannel) {
                        return &vChannelList[i];
                    }
                }

                return NULL;
            }
    } lockedChannels;

    Mutex EngineChannelFactory::LockedChannelsMutex;

    void EngineChannelFactory::SetDeleteEnabled(const EngineChannel* pEngineChannel, bool enable) {
        LockedChannelsMutex.Lock();
        if (!enable) {
            if (!lockedChannels.Contains(pEngineChannel)) lockedChannels.Add(pEngineChannel);
            LockedChannelsMutex.Unlock();
        } else {
            bool b = lockedChannels.IsDestroyed(pEngineChannel);
            lockedChannels.Remove(pEngineChannel);
            LockedChannelsMutex.Unlock();

            if (b) delete pEngineChannel;
        }
    }

    // all currently existing engine channel instances
    static std::set<LinuxSampler::EngineChannel*> engineChannels;

    LinuxSampler::EngineChannel* EngineChannelFactory::Create(String EngineType) throw (Exception) {
        if (!strcasecmp(EngineType.c_str(),"GigEngine") || !strcasecmp(EngineType.c_str(),"gig")) {
            LinuxSampler::EngineChannel* pEngineChannel = new gig::EngineChannel;
            engineChannels.insert(pEngineChannel);
            return pEngineChannel;
        }
        throw Exception("Unknown engine type");
    }

    void EngineChannelFactory::Destroy(LinuxSampler::EngineChannel* pEngineChannel) {
        pEngineChannel->RemoveAllFxSendCountListeners();
        engineChannels.erase(pEngineChannel);

        // Postpone the deletion of the specified EngineChannel if needed (bug #113)
        LockedChannelsMutex.Lock();
        if (lockedChannels.Contains(pEngineChannel)) {
            lockedChannels.SetDestroyed(pEngineChannel);
            pEngineChannel->SetSamplerChannel(NULL);
            LockedChannelsMutex.Unlock();
            return;
        }
        LockedChannelsMutex.Unlock();
        ///////

        delete pEngineChannel;
    }

    const std::set<LinuxSampler::EngineChannel*>& EngineChannelFactory::EngineChannelInstances() {
        return engineChannels;
    }

} // namespace LinuxSampler
1	/***************************************************************************
2	* *
3	* Copyright (C) 2005, 2006 Christian Schoenebeck *
4	* *
5	* This program is free software; you can redistribute it and/or modify *
6	* it under the terms of the GNU General Public License as published by *
7	* the Free Software Foundation; either version 2 of the License, or *
8	* (at your option) any later version. *
9	* *
10	* This program is distributed in the hope that it will be useful, *
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13	* GNU General Public License for more details. *
14	* *
15	* You should have received a copy of the GNU General Public License *
16	* along with this program; if not, write to the Free Software *
17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
18	* MA 02111-1307 USA *
19	***************************************************************************/
20
21	#include "EngineChannelFactory.h"
22
23	#include <strings.h>
24
25	#include "gig/EngineChannel.h"
26
27	namespace LinuxSampler {
28	class LockedChannel {
29	public:
30	const EngineChannel* pChannel;
31	bool bDestroyed;
32
33	LockedChannel(const EngineChannel* pChannel) {
34	this->pChannel = pChannel;
35	bDestroyed = false;
36	}
37	};
38
39	class LockedChannelList {
40	public:
41	void Add(const EngineChannel* pChannel) {
42	vChannelList.push_back(LockedChannel(pChannel));
43	}
44
45	bool IsDestroyed(const EngineChannel* pChannel) {
46	LockedChannel* pLockedChannel = get(pChannel);
47	if (pLockedChannel == NULL) return false;
48	return pLockedChannel->bDestroyed;
49	}
50
51	void SetDestroyed(const EngineChannel* pChannel, bool bDestroyed = true) {
52	LockedChannel* pLockedChannel = get(pChannel);
53	if (pLockedChannel == NULL) return;
54	pLockedChannel->bDestroyed = bDestroyed;
55	}
56
57	void Remove(const EngineChannel* pChannel) {
58	std::vector<LockedChannel>::iterator it = vChannelList.begin();
59	for (; it != vChannelList.end(); it++) {
60	if ((*it).pChannel == pChannel) {
61	vChannelList.erase(it);
62	return;
63	}
64	}
65	}
66
67	bool Contains(const EngineChannel* pChannel) {
68	return get(pChannel) != NULL;
69	}
70
71	private:
72	std::vector<LockedChannel> vChannelList;
73
74	LockedChannel* get(const EngineChannel* pChannel) {
75	for (int i = 0; i < vChannelList.size(); i++) {
76	if (vChannelList[i].pChannel == pChannel) {
77	return &vChannelList[i];
78	}
79	}
80
81	return NULL;
82	}
83	} lockedChannels;
84
85	Mutex EngineChannelFactory::LockedChannelsMutex;
86
87	void EngineChannelFactory::SetDeleteEnabled(const EngineChannel* pEngineChannel, bool enable) {
88	LockedChannelsMutex.Lock();
89	if (!enable) {
90	if (!lockedChannels.Contains(pEngineChannel)) lockedChannels.Add(pEngineChannel);
91	LockedChannelsMutex.Unlock();
92	} else {
93	bool b = lockedChannels.IsDestroyed(pEngineChannel);
94	lockedChannels.Remove(pEngineChannel);
95	LockedChannelsMutex.Unlock();
96
97	if (b) delete pEngineChannel;
98	}
99	}
100
101	// all currently existing engine channel instances
102	static std::set<LinuxSampler::EngineChannel*> engineChannels;
103
104	LinuxSampler::EngineChannel* EngineChannelFactory::Create(String EngineType) throw (Exception) {
105	if (!strcasecmp(EngineType.c_str(),"GigEngine") \|\| !strcasecmp(EngineType.c_str(),"gig")) {
106	LinuxSampler::EngineChannel* pEngineChannel = new gig::EngineChannel;
107	engineChannels.insert(pEngineChannel);
108	return pEngineChannel;
109	}
110	throw Exception("Unknown engine type");
111	}
112
113	void EngineChannelFactory::Destroy(LinuxSampler::EngineChannel* pEngineChannel) {
114	pEngineChannel->RemoveAllFxSendCountListeners();
115	engineChannels.erase(pEngineChannel);
116
117	// Postpone the deletion of the specified EngineChannel if needed (bug #113)
118	LockedChannelsMutex.Lock();
119	if (lockedChannels.Contains(pEngineChannel)) {
120	lockedChannels.SetDestroyed(pEngineChannel);
121	pEngineChannel->SetSamplerChannel(NULL);
122	LockedChannelsMutex.Unlock();
123	return;
124	}
125	LockedChannelsMutex.Unlock();
126	///////
127
128	delete pEngineChannel;
129	}
130
131	const std::set<LinuxSampler::EngineChannel*>& EngineChannelFactory::EngineChannelInstances() {
132	return engineChannels;
133	}
134
135	} // namespace LinuxSampler