/[svn]/linuxsampler/trunk/src/engines/InstrumentManagerThread.cpp
ViewVC logotype

Annotation of /linuxsampler/trunk/src/engines/InstrumentManagerThread.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2316 - (hide annotations) (download)
Sat Feb 18 13:51:38 2012 UTC (12 years, 1 month ago) by persson
File size: 8003 byte(s)
* VST bugfix: instrument loading hang and crashed the host when the
  plugin was loaded a second time (#174)

1 schoenebeck 947 /***************************************************************************
2     * *
3 persson 2316 * Copyright (C) 2005 - 2012 Christian Schoenebeck *
4 schoenebeck 947 * *
5     * This library 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 library 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 library; 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 "InstrumentManagerThread.h"
22    
23 schoenebeck 1424 #include "../common/global_private.h"
24 iliev 1826 #include "EngineChannelFactory.h"
25 schoenebeck 1424
26 schoenebeck 947 namespace LinuxSampler {
27    
28     InstrumentManagerThread::InstrumentManagerThread() : Thread(true, false, 0, -4) {
29 iliev 1761 eventHandler.pThread = this;
30 schoenebeck 947 }
31    
32     InstrumentManagerThread::~InstrumentManagerThread() {
33     }
34    
35     /**
36     * @brief Order loading of a new instrument.
37     *
38     * The request will go into a queue waiting to be processed by the
39     * class internal task thread. This method will immediately return and
40     * the instrument will be loaded in the background.
41     *
42     * @param Filename - file name of the instrument
43     * @param uiInstrumentIndex - index of the instrument within the file
44     * @param pEngineChannel - engine channel on which the instrument should be loaded
45     */
46     void InstrumentManagerThread::StartNewLoad(String Filename, uint uiInstrumentIndex, EngineChannel* pEngineChannel) {
47 persson 1038 dmsg(1,("Scheduling '%s' (Index=%d) to be loaded in background (if not loaded yet).\n",Filename.c_str(),uiInstrumentIndex));
48 iliev 1761
49     static bool listenerRegistered = false;
50     if (!listenerRegistered) {
51     pEngineChannel->GetSampler()->AddChannelCountListener(&eventHandler);
52     listenerRegistered = true;
53     }
54    
55    
56 schoenebeck 947 command_t cmd;
57     cmd.type = command_t::DIRECT_LOAD;
58     cmd.pEngineChannel = pEngineChannel;
59 persson 2277 cmd.instrumentId.Index = uiInstrumentIndex;
60     cmd.instrumentId.FileName = Filename;
61 schoenebeck 989
62     mutex.Lock();
63     queue.push_back(cmd);
64     mutex.Unlock();
65    
66 schoenebeck 947 StartThread(); // ensure thread is running
67     conditionJobsLeft.Set(true); // wake up thread
68     }
69    
70     /**
71     * @brief Order changing the life-time strategy of an instrument.
72     *
73     * The request will go into a queue waiting to be processed by the
74     * class internal task thread. This method will immediately return and
75     * in case the instrument has to be loaded due to a mode change to
76     * PERSISTENT, it will be loaded in the background.
77     *
78     * @param pManager - InstrumentManager which manages the instrument
79     * @param ID - unique ID of the instrument
80     * @param Mode - life-time strategy to set for this instrument
81     */
82     void InstrumentManagerThread::StartSettingMode(InstrumentManager* pManager, const InstrumentManager::instrument_id_t& ID, InstrumentManager::mode_t Mode) {
83     command_t cmd;
84     cmd.type = command_t::INSTR_MODE;
85     cmd.pManager = pManager;
86     cmd.instrumentId = ID;
87     cmd.mode = Mode;
88 schoenebeck 989
89     mutex.Lock();
90     queue.push_back(cmd);
91     mutex.Unlock();
92    
93 schoenebeck 947 StartThread(); // ensure thread is running
94     conditionJobsLeft.Set(true); // wake up thread
95     }
96    
97     // Entry point for the task thread.
98     int InstrumentManagerThread::Main() {
99     while (true) {
100 nagata 1649
101 persson 2185 #if CONFIG_PTHREAD_TESTCANCEL
102     TestCancel();
103     #endif
104 nagata 1649
105 schoenebeck 989 while (!queue.empty()) {
106 schoenebeck 947 command_t cmd;
107 schoenebeck 989
108     // grab a new command from the queue
109     mutex.Lock();
110     cmd = queue.front();
111 iliev 1761 queue.pop_front();
112 schoenebeck 989 mutex.Unlock();
113    
114 schoenebeck 947 try {
115     switch (cmd.type) {
116     case command_t::DIRECT_LOAD:
117 iliev 1826 EngineChannelFactory::SetDeleteEnabled(cmd.pEngineChannel, false);
118 persson 2277 cmd.pEngineChannel->PrepareLoadInstrument(cmd.instrumentId.FileName.c_str(), cmd.instrumentId.Index);
119 schoenebeck 947 cmd.pEngineChannel->LoadInstrument();
120 iliev 1826 EngineChannelFactory::SetDeleteEnabled(cmd.pEngineChannel, true);
121 schoenebeck 947 break;
122     case command_t::INSTR_MODE:
123     cmd.pManager->SetMode(cmd.instrumentId, cmd.mode);
124     break;
125     default:
126     std::cerr << "InstrumentManagerThread: unknown command - BUG!\n" << std::flush;
127     }
128 schoenebeck 1040 } catch (Exception e) {
129 schoenebeck 947 e.PrintMessage();
130 iliev 1826 if (cmd.type == command_t::DIRECT_LOAD) {
131     EngineChannelFactory::SetDeleteEnabled(cmd.pEngineChannel, true);
132     }
133 schoenebeck 1040 } catch (...) {
134     std::cerr << "InstrumentManagerThread: some exception occured, could not finish task\n" << std::flush;
135 iliev 1826 if (cmd.type == command_t::DIRECT_LOAD) {
136     EngineChannelFactory::SetDeleteEnabled(cmd.pEngineChannel, true);
137     }
138 schoenebeck 947 }
139     }
140    
141     // nothing left to do, sleep until new jobs arrive
142     conditionJobsLeft.WaitIf(false);
143     // reset flag
144     conditionJobsLeft.Set(false);
145     // unlock condition object so it can be turned again by other thread
146     conditionJobsLeft.Unlock();
147     }
148 persson 1895 return 0;
149 schoenebeck 947 }
150 persson 1895
151 iliev 1761 void InstrumentManagerThread::EventHandler::ChannelToBeRemoved(SamplerChannel* pChannel) {
152     /*
153     Removing from the queue an eventual scheduled loading of an instrument
154     to a sampler channel which is going to be removed.
155     */
156     pThread->mutex.Lock();
157     std::list<command_t>::iterator it;
158     for (it = pThread->queue.begin(); it != pThread->queue.end();){
159     if ((*it).type != command_t::DIRECT_LOAD) { ++it; continue; }
160     if ((*it).pEngineChannel == pChannel->GetEngineChannel()) {
161     it = pThread->queue.erase(it);
162     // we don't break here because the same engine channel could
163     // occur more than once in the queue, so don't make optimizations
164     } else {
165     ++it;
166     }
167     }
168     pThread->mutex.Unlock();
169     }
170 persson 2185
171 persson 2187 #ifdef __APPLE__
172 persson 2185 int InstrumentManagerThread::StopThread() {
173     // This is a fix for Mac OS X, where SignalStopThread doesn't
174     // wake up a thread waiting for a condition variable.
175     SignalStopThread(); // send stop signal, but don't wait
176     conditionJobsLeft.Set(true); // wake thread
177     return Thread::StopThread(); // then wait for it to cancel
178     }
179 persson 2187 #endif
180 persson 2185
181 persson 2316 #ifdef WIN32
182     int InstrumentManagerThread::StopThread() {
183     int res = Thread::StopThread();
184     conditionJobsLeft.Reset();
185     return res;
186     }
187     #endif
188    
189 schoenebeck 947 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC