2 Copyright (C) 2000-2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include "libardour-config.h"
25 #include "pbd/boost_debug.h"
26 #include "pbd/error.h"
27 #include "pbd/convert.h"
28 #include "pbd/pthread_utils.h"
29 #include "pbd/stacktrace.h"
31 #include "ardour/audioplaylist.h"
32 #include "ardour/audio_playlist_source.h"
33 #include "ardour/midi_playlist.h"
34 #include "ardour/midi_playlist_source.h"
35 #include "ardour/source_factory.h"
36 #include "ardour/sndfilesource.h"
37 #include "ardour/silentfilesource.h"
38 #include "ardour/rc_configuration.h"
39 #include "ardour/smf_source.h"
40 #include "ardour/session.h"
43 #define USE_COREAUDIO_FOR_FILES
46 #ifdef USE_COREAUDIO_FOR_FILES
47 #include "ardour/coreaudiosource.h"
53 using namespace ARDOUR
;
57 PBD::Signal1
<void,boost::shared_ptr
<Source
> > SourceFactory::SourceCreated
;
58 Glib::Cond
* SourceFactory::PeaksToBuild
;
59 Glib::StaticMutex
SourceFactory::peak_building_lock
= GLIBMM_STATIC_MUTEX_INIT
;
60 std::list
<boost::weak_ptr
<AudioSource
> > SourceFactory::files_with_peaks
;
65 SessionEvent::create_per_thread_pool (X_("PeakFile Builder "), 64);
69 SourceFactory::peak_building_lock
.lock ();
72 if (SourceFactory::files_with_peaks
.empty()) {
73 SourceFactory::PeaksToBuild
->wait (SourceFactory::peak_building_lock
);
76 if (SourceFactory::files_with_peaks
.empty()) {
80 boost::shared_ptr
<AudioSource
> as (SourceFactory::files_with_peaks
.front().lock());
81 SourceFactory::files_with_peaks
.pop_front ();
82 SourceFactory::peak_building_lock
.unlock ();
88 as
->setup_peakfile ();
93 SourceFactory::init ()
95 PeaksToBuild
= new Glib::Cond();
97 for (int n
= 0; n
< 2; ++n
) {
98 Glib::Thread::create (sigc::ptr_fun (::peak_thread_work
), false);
103 SourceFactory::setup_peakfile (boost::shared_ptr
<Source
> s
, bool async
)
105 boost::shared_ptr
<AudioSource
> as (boost::dynamic_pointer_cast
<AudioSource
> (s
));
111 Glib::Mutex::Lock
lm (peak_building_lock
);
112 files_with_peaks
.push_back (boost::weak_ptr
<AudioSource
> (as
));
113 PeaksToBuild
->broadcast ();
117 if (as
->setup_peakfile ()) {
118 error
<< string_compose("SourceFactory: could not set up peakfile for %1", as
->name()) << endmsg
;
127 boost::shared_ptr
<Source
>
128 SourceFactory::createSilent (Session
& s
, const XMLNode
& node
, framecnt_t nframes
, float sr
)
130 Source
* src
= new SilentFileSource (s
, node
, nframes
, sr
);
131 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
132 // boost_debug_shared_ptr_mark_interesting (src, "Source");
134 boost::shared_ptr
<Source
> ret (src
);
135 // no analysis data - the file is non-existent
140 boost::shared_ptr
<Source
>
141 SourceFactory::create (Session
& s
, const XMLNode
& node
, bool defer_peaks
)
143 DataType type
= DataType::AUDIO
;
144 const XMLProperty
* prop
= node
.property("type");
147 type
= DataType (prop
->value());
150 if (type
== DataType::AUDIO
) {
152 /* it could be nested */
154 if (node
.property ("playlist") != 0) {
157 boost::shared_ptr
<AudioPlaylistSource
> ap (new AudioPlaylistSource (s
, node
));
159 if (setup_peakfile (ap
, true)) {
160 return boost::shared_ptr
<Source
>();
163 ap
->check_for_analysis_data_on_disk ();
168 } catch (failed_constructor
&) {
169 /* oh well, so much for that then ... */
176 Source
* src
= new SndFileSource (s
, node
);
177 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
178 // boost_debug_shared_ptr_mark_interesting (src, "Source");
180 boost::shared_ptr
<Source
> ret (src
);
181 if (setup_peakfile (ret
, defer_peaks
)) {
182 return boost::shared_ptr
<Source
>();
184 ret
->check_for_analysis_data_on_disk ();
189 catch (failed_constructor
& err
) {
191 #ifdef USE_COREAUDIO_FOR_FILES
193 /* this is allowed to throw */
195 Source
*src
= new CoreAudioSource (s
, node
);
196 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
197 // boost_debug_shared_ptr_mark_interesting (src, "Source");
199 boost::shared_ptr
<Source
> ret (src
);
201 if (setup_peakfile (ret
, defer_peaks
)) {
202 return boost::shared_ptr
<Source
>();
205 ret
->check_for_analysis_data_on_disk ();
213 } else if (type
== DataType::MIDI
) {
214 boost::shared_ptr
<SMFSource
> src (new SMFSource (s
, node
));
215 src
->load_model (true, true);
216 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
217 // boost_debug_shared_ptr_mark_interesting (src, "Source");
219 src
->check_for_analysis_data_on_disk ();
224 return boost::shared_ptr
<Source
>();
227 boost::shared_ptr
<Source
>
228 SourceFactory::createReadable (DataType type
, Session
& s
, const string
& path
,
229 int chn
, Source::Flag flags
, bool announce
, bool defer_peaks
)
231 if (type
== DataType::AUDIO
) {
233 if (!(flags
& Destructive
)) {
237 Source
* src
= new SndFileSource (s
, path
, chn
, flags
);
238 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
239 // boost_debug_shared_ptr_mark_interesting (src, "Source");
241 boost::shared_ptr
<Source
> ret (src
);
243 if (setup_peakfile (ret
, defer_peaks
)) {
244 return boost::shared_ptr
<Source
>();
247 ret
->check_for_analysis_data_on_disk ();
254 catch (failed_constructor
& err
) {
255 #ifdef USE_COREAUDIO_FOR_FILES
257 Source
* src
= new CoreAudioSource (s
, path
, chn
, flags
);
258 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
259 // boost_debug_shared_ptr_mark_interesting (src, "Source");
261 boost::shared_ptr
<Source
> ret (src
);
262 if (setup_peakfile (ret
, defer_peaks
)) {
263 return boost::shared_ptr
<Source
>();
265 ret
->check_for_analysis_data_on_disk ();
280 } else if (type
== DataType::MIDI
) {
282 SMFSource
* src
= new SMFSource (s
, path
, SMFSource::Flag(0));
283 src
->load_model (true, true);
284 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
285 // boost_debug_shared_ptr_mark_interesting (src, "Source");
287 boost::shared_ptr
<Source
> ret (src
);
297 return boost::shared_ptr
<Source
>();
300 boost::shared_ptr
<Source
>
301 SourceFactory::createWritable (DataType type
, Session
& s
, const std::string
& path
, const std::string
& origin
,
302 bool destructive
, framecnt_t rate
, bool announce
, bool defer_peaks
)
304 /* this might throw failed_constructor(), which is OK */
306 if (type
== DataType::AUDIO
) {
307 Source
* src
= new SndFileSource (s
, path
, origin
,
308 s
.config
.get_native_file_data_format(),
309 s
.config
.get_native_file_header_format(),
312 ? Source::Flag (SndFileSource::default_writable_flags
| Source::Destructive
)
313 : SndFileSource::default_writable_flags
));
314 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
315 // boost_debug_shared_ptr_mark_interesting (src, "Source");
317 boost::shared_ptr
<Source
> ret (src
);
319 if (setup_peakfile (ret
, defer_peaks
)) {
320 return boost::shared_ptr
<Source
>();
323 // no analysis data - this is a new file
330 } else if (type
== DataType::MIDI
) {
331 // XXX writable flags should belong to MidiSource too
332 boost::shared_ptr
<SMFSource
> src (new SMFSource (s
, path
, SndFileSource::default_writable_flags
));
333 assert (src
->writable ());
335 src
->load_model (true, true);
336 #ifdef BOOST_SP_ENABLE_DEBUG_HOOKS
337 // boost_debug_shared_ptr_mark_interesting (src, "Source");
340 // no analysis data - this is a new file
349 return boost::shared_ptr
<Source
> ();
352 boost::shared_ptr
<Source
>
353 SourceFactory::createFromPlaylist (DataType type
, Session
& s
, boost::shared_ptr
<Playlist
> p
, const ID
& orig
, const std::string
& name
,
354 uint32_t chn
, frameoffset_t start
, framecnt_t len
, bool copy
, bool defer_peaks
)
356 if (type
== DataType::AUDIO
) {
359 boost::shared_ptr
<AudioPlaylist
> ap
= boost::dynamic_pointer_cast
<AudioPlaylist
>(p
);
364 ap
.reset (new AudioPlaylist (ap
, start
, len
, name
, true));
368 Source
* src
= new AudioPlaylistSource (s
, orig
, name
, ap
, chn
, start
, len
, Source::Flag (0));
369 boost::shared_ptr
<Source
> ret (src
);
371 if (setup_peakfile (ret
, defer_peaks
)) {
372 return boost::shared_ptr
<Source
>();
375 ret
->check_for_analysis_data_on_disk ();
381 catch (failed_constructor
& err
) {
382 /* relax - return at function scope */
385 } else if (type
== DataType::MIDI
) {
389 boost::shared_ptr
<MidiPlaylist
> ap
= boost::dynamic_pointer_cast
<MidiPlaylist
>(p
);
394 ap
.reset (new MidiPlaylist (ap
, start
, len
, name
, true));
398 Source
* src
= new MidiPlaylistSource (s
, orig
, name
, ap
, chn
, start
, len
, Source::Flag (0));
399 boost::shared_ptr
<Source
> ret (src
);
406 catch (failed_constructor
& err
) {
407 /* relax - return at function scope */
412 return boost::shared_ptr
<Source
>();