Audacity  3.0.3
ODManager.h
Go to the documentation of this file.
1 /**********************************************************************
2 
3  Audacity: A Digital Audio Editor
4 
5  ODManager.h
6 
7  Created by Michael Chinen (mchinen) on 6/8/08
8  Audacity(R) is copyright (c) 1999-2008 Audacity Team.
9  License: GPL v2. See License.txt.
10 
11 ******************************************************************//*******************************************************************/
18 
19 #ifndef __AUDACITY_ODMANAGER__
20 #define __AUDACITY_ODMANAGER__
21 
22 #include <vector>
23 #include "ODTaskThread.h"
24 #include <wx/event.h> // for DECLARE_EXPORTED_EVENT_TYPE
25 
26 #ifdef __WXMAC__
27 // On Mac OS X, it's better not to use the wxThread class.
28 // We use our own implementation based on pthreads instead.
29 #include <pthread.h>
30 #include <time.h>
31 #endif //__WXMAC__
32 
33 // This event is posted to the application
34 wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API,
35  EVT_ODTASK_UPDATE, wxCommandEvent);
36 
38 int CompareNoCaseFileName(const wxString& first, const wxString& second);
41 class TranslatableString;
42 class Track;
43 class WaveTrack;
45 class ODManager final
46 {
47  public:
51  static ODManager* (*Instance)();
53  static ODManager* InstanceFirstTime();
55  static ODManager* InstanceNormal();
56 
58  static void Quit();
59 
61  void DemandTrackUpdate(WaveTrack* track, double seconds);
62 
65 
67  void AddNewTask(std::unique_ptr<ODTask> &&mtask, bool lockMutex=true);
68 
70  void SignalTaskQueueLoop();
71 
73  void MakeWaveTrackIndependent( const std::shared_ptr< WaveTrack > &track);
74 
78  const std::shared_ptr< WaveTrack > &dependentTrack,
79  WaveTrack* masterTrack
80  );
81 
84  void ReplaceWaveTrack(Track *oldTrack,
85  const std::shared_ptr< Track > &newTrack);
86 
88  void AddTask(ODTask* task);
89 
90  void RemoveTaskIfInQueue(ODTask* task);
91 
93  static void MarkLoadedODFlag();
94 
96  static void UnmarkLoadedODFlag();
97 
99  static bool HasLoadedODFlag();
100 
102  static bool IsInstanceCreated();
103 
105  void FillTipForWaveTrack( const WaveTrack * t, TranslatableString &tip );
106 
109 
111  int GetTotalNumTasks();
112 
113  // RAII object for pausing and resuming..
114  class Pauser
115  {
116  //Pause/unpause all OD Tasks. Does not occur immediately.
117  static void Pause(bool pause = true);
118  static void Resume();
119  public:
120  Pauser() { Pause(); }
121  ~Pauser() { Resume(); }
122  Pauser(const Pauser&) PROHIBITED;
123  Pauser &operator= (const Pauser&) PROHIBITED;
124  };
125 
126 
127 
128  protected:
129  //private constructor - Singleton.
130  ODManager();
131  //private constructor - DELETE with static method Quit()
132  friend std::default_delete < ODManager > ;
133  ~ODManager();
135  void Init();
136 
138  void Start();
139 
141  void UpdateQueues();
142 
143  //instance
144  static std::unique_ptr<ODManager> pMan;
145 
146  //List of tracks and their active and inactive tasks.
147  std::vector<std::unique_ptr<ODWaveTrackTaskQueue>> mQueues;
149 
150  //List of current Task to do.
151  std::vector<ODTask*> mTasks;
152  //mutex for above variable
154 
155  //global pause switch for OD
156  volatile bool mPause;
158 
159  volatile int mNeedsDraw;
160 
162  volatile int mCurrentThreads;
163  //mutex for above variable
165 
168 
169  volatile bool mTerminate;
171 
172  volatile bool mTerminated;
174 
175  //for the queue not empty comdition
177  std::unique_ptr<ODCondition> mQueueNotEmptyCond;
178 
179 #ifdef __WXMAC__
180 
181 // On Mac OS X, it's better not to use the wxThread class.
182 // We use our own implementation based on pthreads instead.
183 
184 class ODManagerHelperThread {
185  public:
186  typedef int ExitCode;
187  ODManagerHelperThread() { mDestroy = false; mThread = NULL; }
188  /* ExitCode*/ void Entry(){
190  }
191 
192  void Create() {}
193  void Delete() {
194  mDestroy = true;
195  pthread_join(mThread, NULL);
196  }
197  bool TestDestroy() { return mDestroy; }
198  void Sleep(int ms) {
199  struct timespec spec;
200  spec.tv_sec = 0;
201  spec.tv_nsec = ms * 1000 * 1000;
202  nanosleep(&spec, NULL);
203  }
204  static void *callback(void *p) {
206  /* return (void *) */th->Entry();
207  return NULL;
208  }
209 
212  void SetPriority(int priority)
213  {
214  mPriority=priority;
215  }
216 
217  void Run() {
218  pthread_create(&mThread, NULL, callback, this);
219  }
220  private:
221  bool mDestroy;
222  pthread_t mThread;
223  int mPriority;
224 };
225 #else
226  class ODManagerHelperThread final : public wxThread
227  {
228  public:
231  ODManagerHelperThread(): wxThread(){}
232 
233  protected:
235  void *Entry()
236  {
238  return NULL;
239  }
240 
241  };
242 #endif //__WXMAC__
243 };
244 
245 #endif
246 
ODManager::ODManager
ODManager()
Definition: ODManager.cpp:155
ODManager::GetOverallPercentComplete
float GetOverallPercentComplete()
Gets the total percent complete for all tasks combined.
Definition: ODManager.cpp:629
TranslatableString
Holds a msgid for the translation catalog; may also bind format arguments.
Definition: TranslatableString.h:32
ODManager::mCurrentThreads
volatile int mCurrentThreads
Number of threads currently running. Accessed thru multiple threads.
Definition: ODManager.h:162
ODManager::mCurrentThreadsMutex
ODLock mCurrentThreadsMutex
Definition: ODManager.h:164
ODManager::mTerminated
volatile bool mTerminated
Definition: ODManager.h:172
ODManager::mTerminatedMutex
ODLock mTerminatedMutex
Definition: ODManager.h:173
WaveTrack
A Track that contains audio waveform data.
Definition: WaveTrack.h:69
ODManager::mNeedsDraw
volatile int mNeedsDraw
Definition: ODManager.h:159
ODManager::mQueues
std::vector< std::unique_ptr< ODWaveTrackTaskQueue > > mQueues
Definition: ODManager.h:147
ODManager::MakeWaveTrackIndependent
void MakeWaveTrackIndependent(const std::shared_ptr< WaveTrack > &track)
if it shares a queue/task, creates a NEW queue/task for the track, and removes it from any previously...
Definition: ODManager.cpp:481
ODManager::Pauser::~Pauser
~Pauser()
Definition: ODManager.h:121
ODManager::Pauser::Resume
static void Resume()
Definition: ODManager.cpp:455
ODManager::MakeWaveTrackDependent
bool MakeWaveTrackDependent(const std::shared_ptr< WaveTrack > &dependentTrack, WaveTrack *masterTrack)
Definition: ODManager.cpp:505
ODManager::ODManagerHelperThread
Definition: ODManager.h:227
ODManager::Pauser::Pause
static void Pause(bool pause=true)
Definition: ODManager.cpp:437
ODManager::Pauser
Definition: ODManager.h:115
ODManager::AddNewTask
void AddNewTask(std::unique_ptr< ODTask > &&mtask, bool lockMutex=true)
Adds a wavetrack, creates a queue member.
Definition: ODManager.cpp:245
ODManager::InstanceNormal
static ODManager * InstanceNormal()
Gets the singleton instance.
Definition: ODManager.cpp:300
ODManager::IsInstanceCreated
static bool IsInstanceCreated()
returns whether or not the singleton instance was created yet
Definition: ODManager.cpp:305
ODManager::InstanceFirstTime
static ODManager * InstanceFirstTime()
Gets the singleton instance.
Definition: ODManager.cpp:282
ODManager::Pauser::operator=
Pauser & operator=(const Pauser &) PROHIBITED
ODManager::DemandTrackUpdate
void DemandTrackUpdate(WaveTrack *track, double seconds)
changes the tasks associated with this Waveform to process the task from a different point in the tra...
Definition: ODManager.cpp:554
ODManager::AddTask
void AddTask(ODTask *task)
Adds a task to the running queue. Thread-safe.
Definition: ODManager.cpp:195
ODManager::SignalTaskQueueLoop
void SignalTaskQueueLoop()
Wakes the queue loop up by signalling its condition variable.
Definition: ODManager.cpp:212
ODManager::Quit
static void Quit()
Kills the ODMananger Thread.
Definition: ODManager.cpp:460
ODManager::FillTipForWaveTrack
void FillTipForWaveTrack(const WaveTrack *t, TranslatableString &tip)
fills in the status bar message for a given track
Definition: ODManager.cpp:618
ODManager::MarkLoadedODFlag
static void MarkLoadedODFlag()
sets a flag that is set if we have loaded some OD blockfiles from PCM.
Definition: ODManager.cpp:598
ODManager::mTerminateMutex
ODLock mTerminateMutex
Definition: ODManager.h:170
ODManager::RemoveTaskIfInQueue
void RemoveTaskIfInQueue(ODTask *task)
removes a task from the active task queue
Definition: ODManager.cpp:225
ODManager::mQueueNotEmptyCondLock
ODLock mQueueNotEmptyCondLock
Definition: ODManager.h:176
ODManager::mTasksMutex
ODLock mTasksMutex
Definition: ODManager.h:153
ODManager::Pauser::Pauser
Pauser()
Definition: ODManager.h:120
ODManager::UnmarkLoadedODFlag
static void UnmarkLoadedODFlag()
resets a flag that is set if we have loaded some OD blockfiles from PCM.
Definition: ODManager.cpp:605
ODManager::mTasks
std::vector< ODTask * > mTasks
Definition: ODManager.h:151
ODManager::mPauseLock
ODLock mPauseLock
Definition: ODManager.h:157
ODManager::Pauser::Pauser
Pauser(const Pauser &) PROHIBITED
ODManager::mQueuesMutex
ODLock mQueuesMutex
Definition: ODManager.h:148
ODManager::GetTotalNumTasks
int GetTotalNumTasks()
Get Total Number of Tasks.
Definition: ODManager.cpp:645
ODManager::mQueueNotEmptyCond
std::unique_ptr< ODCondition > mQueueNotEmptyCond
Definition: ODManager.h:177
ODManager::ODManagerHelperThread::Entry
void * Entry()
Executes a part of the task.
Definition: ODManager.h:235
ODManager::pMan
static std::unique_ptr< ODManager > pMan
Definition: ODManager.h:144
ODWaveTrackTaskQueue
A class representing a modular task to be used with the On-Demand structures.
Definition: ODWaveTrackTaskQueue.h:33
ODTask
A class representing a modular task to be used with the On-Demand structures.
Definition: ODTask.h:40
ODManager::mTerminate
volatile bool mTerminate
Definition: ODManager.h:169
ODManager::Start
void Start()
Start the main loop for the manager.
Definition: ODManager.cpp:342
CompareNoCaseFileName
int CompareNoCaseFileName(const wxString &first, const wxString &second)
wxstring compare function for sorting case, which is needed to load correctly.
Definition: ODManager.cpp:149
ODLock
Definition: ODTaskThread.h:89
Track
Abstract base class for an object holding data associated with points on a time axis.
Definition: Track.h:239
ODManager::ODManagerHelperThread::ODManagerHelperThread
ODManagerHelperThread()
Definition: ODManager.h:231
ODTaskThread.h
ODManager::Init
void Init()
Launches a thread for the manager and starts accepting Tasks.
Definition: ODManager.cpp:315
wxDECLARE_EXPORTED_EVENT
wxDECLARE_EXPORTED_EVENT(AUDACITY_DLL_API, EVT_ODTASK_UPDATE, wxCommandEvent)
ODManager::mPause
volatile bool mPause
Definition: ODManager.h:156
ODManager::HasLoadedODFlag
static bool HasLoadedODFlag()
returns a flag that is set if we have loaded some OD blockfiles from PCM.
Definition: ODManager.cpp:612
ODManager::DecrementCurrentThreads
void DecrementCurrentThreads()
Reduces the count of current threads running. Meant to be called when ODTaskThreads end in their own ...
Definition: ODManager.cpp:334
ODManager::~ODManager
~ODManager()
Definition: ODManager.cpp:166
ODManager::Instance
static ODManager *(* Instance)()
Definition: ODManager.h:51
ODManager::ReplaceWaveTrack
void ReplaceWaveTrack(Track *oldTrack, const std::shared_ptr< Track > &newTrack)
replace the wavetrack whose wavecache the gui watches for updates
Definition: ODManager.cpp:469
ODManager
A singleton that manages currently running Tasks on an arbitrary number of threads.
Definition: ODManager.h:46
ODManager::mMaxThreads
int mMaxThreads
Maximum number of threads allowed out.
Definition: ODManager.h:167
ODManager::UpdateQueues
void UpdateQueues()
Remove references in our array to Tasks that have been completed/Schedule NEW ones.
Definition: ODManager.cpp:566