--- /dev/null
+/*
+ Copyright (C) 2000-2009 Paul Davis
+
+ 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __ardour_butler_h__
+#define __ardour_butler_h__
+
+#include <glibmm/thread.h>
+#include "ardour/types.h"
+
+namespace ARDOUR {
+
+class Butler {
+public:
+ Butler();
+ ~Butler();
+
+ pthread_t thread;
+ Glib::Mutex request_lock;
+ Glib::Cond paused;
+ bool should_run;
+ mutable gint should_do_transport_work;
+ int request_pipe[2];
+};
+
+} // namespace ARDOUR
+
+#endif // __ardour_butler_h__
class Source;
class TempoMap;
class VSTPlugin;
+class Butler;
class Session : public PBD::StatefulDestructible, public boost::noncopyable
{
bool pending_abort;
bool pending_auto_loop;
- pthread_t butler_thread;
- Glib::Mutex butler_request_lock;
- Glib::Cond butler_paused;
- bool butler_should_run;
- mutable gint butler_should_do_transport_work;
- int butler_request_pipe[2];
+ Butler* butler;
- inline bool transport_work_requested() const {
- return g_atomic_int_get(&butler_should_do_transport_work);
- }
+ bool transport_work_requested() const;
struct ButlerRequest {
enum Type {
--- /dev/null
+/*
+ Copyright (C) 1999-2009 Paul Davis
+
+ 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include "ardour/butler.h"
+
+namespace ARDOUR {
+
+Butler::Butler()
+ : thread(0)
+{
+ g_atomic_int_set(&should_do_transport_work, 0);
+}
+
+Butler::~Butler()
+{
+}
+
+} // namespace ARDOUR
#include "ardour/auditioner.h"
#include "ardour/buffer_set.h"
#include "ardour/bundle.h"
+#include "ardour/butler.h"
#include "ardour/click.h"
#include "ardour/configuration.h"
#include "ardour/crossfade.h"
_session_dir (new SessionDirectory(fullpath)),
pending_events (2048),
state_tree (0),
+ butler (new Butler ()),
post_transport_work((PostTransportWork)0),
_send_smpte_update (false),
midi_thread (pthread_t (0)),
_session_dir ( new SessionDirectory(fullpath)),
pending_events (2048),
state_tree (0),
+ butler (new Butler ()),
post_transport_work((PostTransportWork)0),
_send_smpte_update (false),
midi_thread (pthread_t (0)),
delete state_tree;
/* reset dynamic state version back to default */
-
+
Stateful::loading_state_version = 0;
terminate_butler_thread ();
#include "ardour/audio_diskstream.h"
#include "ardour/audioengine.h"
+#include "ardour/butler.h"
#include "ardour/configuration.h"
#include "ardour/crossfade.h"
#include "ardour/io.h"
Crossfade::set_buffer_size (audio_dstream_buffer_size);
- butler_should_run = false;
+ butler->should_run = false;
- if (pipe (butler_request_pipe)) {
+ if (pipe (butler->request_pipe)) {
error << string_compose(_("Cannot create transport request signal pipe (%1)"), strerror (errno)) << endmsg;
return -1;
}
- if (fcntl (butler_request_pipe[0], F_SETFL, O_NONBLOCK)) {
+ if (fcntl (butler->request_pipe[0], F_SETFL, O_NONBLOCK)) {
error << string_compose(_("UI: cannot set O_NONBLOCK on butler request pipe (%1)"), strerror (errno)) << endmsg;
return -1;
}
- if (fcntl (butler_request_pipe[1], F_SETFL, O_NONBLOCK)) {
+ if (fcntl (butler->request_pipe[1], F_SETFL, O_NONBLOCK)) {
error << string_compose(_("UI: cannot set O_NONBLOCK on butler request pipe (%1)"), strerror (errno)) << endmsg;
return -1;
}
- if (pthread_create_and_store ("disk butler", &butler_thread, 0, _butler_thread_work, this)) {
+ if (pthread_create_and_store ("disk butler", &butler->thread, 0, _butler_thread_work, this)) {
error << _("Session: could not create butler thread") << endmsg;
return -1;
}
- // pthread_detach (butler_thread);
+ // pthread_detach (butler->thread);
return 0;
}
void
Session::terminate_butler_thread ()
{
- if (butler_thread) {
+ if (butler->thread) {
void* status;
char c = ButlerRequest::Quit;
- ::write (butler_request_pipe[1], &c, 1);
- pthread_join (butler_thread, &status);
+ ::write (butler->request_pipe[1], &c, 1);
+ pthread_join (butler->thread, &status);
}
}
void
Session::schedule_butler_transport_work ()
{
- g_atomic_int_inc (&butler_should_do_transport_work);
+ g_atomic_int_inc (&butler->should_do_transport_work);
summon_butler ();
}
Session::summon_butler ()
{
char c = ButlerRequest::Run;
- ::write (butler_request_pipe[1], &c, 1);
+ ::write (butler->request_pipe[1], &c, 1);
// PBD::stacktrace (cerr);
}
void
Session::stop_butler ()
{
- Glib::Mutex::Lock lm (butler_request_lock);
+ Glib::Mutex::Lock lm (butler->request_lock);
char c = ButlerRequest::Pause;
- ::write (butler_request_pipe[1], &c, 1);
- butler_paused.wait(butler_request_lock);
+ ::write (butler->request_pipe[1], &c, 1);
+ butler->paused.wait(butler->request_lock);
}
void
Session::wait_till_butler_finished ()
{
- Glib::Mutex::Lock lm (butler_request_lock);
+ Glib::Mutex::Lock lm (butler->request_lock);
char c = ButlerRequest::Wake;
- ::write (butler_request_pipe[1], &c, 1);
- butler_paused.wait(butler_request_lock);
+ ::write (butler->request_pipe[1], &c, 1);
+ butler->paused.wait(butler->request_lock);
}
void *
DiskstreamList::iterator i;
while (true) {
- pfd[0].fd = butler_request_pipe[0];
+ pfd[0].fd = butler->request_pipe[0];
pfd[0].events = POLLIN|POLLERR|POLLHUP;
if (poll (pfd, 1, (disk_work_outstanding ? 0 : -1)) < 0) {
/* empty the pipe of all current requests */
while (1) {
- size_t nread = ::read (butler_request_pipe[0], &req, sizeof (req));
+ size_t nread = ::read (butler->request_pipe[0], &req, sizeof (req));
if (nread == 1) {
switch ((ButlerRequest::Type) req) {
break;
case ButlerRequest::Run:
- butler_should_run = true;
+ butler->should_run = true;
break;
case ButlerRequest::Pause:
- butler_should_run = false;
+ butler->should_run = false;
break;
case ButlerRequest::Quit:
// cerr << "BEFORE " << (*i)->name() << ": pb = " << (*i)->playback_buffer_load() << " cp = " << (*i)->capture_buffer_load() << endl;
// }
- for (i = dsl->begin(); !transport_work_requested() && butler_should_run && i != dsl->end(); ++i) {
+ for (i = dsl->begin(); !transport_work_requested() && butler->should_run && i != dsl->end(); ++i) {
boost::shared_ptr<Diskstream> ds = *i;
compute_io = true;
begin = get_microseconds();
- for (i = dsl->begin(); !transport_work_requested() && butler_should_run && i != dsl->end(); ++i) {
+ for (i = dsl->begin(); !transport_work_requested() && butler->should_run && i != dsl->end(); ++i) {
// cerr << "write behind for " << (*i)->name () << endl;
/* note that we still try to flush diskstreams attached to inactive routes
{
- Glib::Mutex::Lock lm (butler_request_lock);
+ Glib::Mutex::Lock lm (butler->request_lock);
- if (butler_should_run && (disk_work_outstanding || transport_work_requested())) {
+ if (butler->should_run && (disk_work_outstanding || transport_work_requested())) {
// for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
// cerr << "AFTER " << (*i)->name() << ": pb = " << (*i)->playback_buffer_load() << " cp = " << (*i)->capture_buffer_load() << endl;
// }
continue;
}
- butler_paused.signal();
+ butler->paused.signal();
}
}
g_atomic_int_set (&_capture_load_min, 100);
}
-
void
Session::reset_playback_load_min ()
{
g_atomic_int_set (&_playback_load_min, 100);
}
+
+bool
+Session::transport_work_requested () const
+{
+ return g_atomic_int_get(&butler->should_do_transport_work);
+}
#include "pbd/error.h"
#include <glibmm/thread.h>
-#include "ardour/session.h"
#include "ardour/audio_diskstream.h"
#include "ardour/audioengine.h"
+#include "ardour/butler.h"
#include "ardour/export_failed.h"
#include "ardour/export_file_io.h"
#include "ardour/export_handler.h"
#include "ardour/export_status.h"
#include "ardour/export_utilities.h"
#include "ardour/route.h"
+#include "ardour/session.h"
#include "i18n.h"
set_transport_speed (1.0, false);
butler_transport_work ();
- g_atomic_int_set (&butler_should_do_transport_work, 0);
+ g_atomic_int_set (&butler->should_do_transport_work, 0);
post_transport ();
/* we are ready to go ... */
session_send_mmc = false;
session_send_mtc = false;
post_transport_work = PostTransportWork (0);
- g_atomic_int_set (&butler_should_do_transport_work, 0);
g_atomic_int_set (&_playback_load, 100);
g_atomic_int_set (&_capture_load, 100);
g_atomic_int_set (&_playback_load_min, 100);
destructive_index = 0;
first_file_data_format_reset = true;
first_file_header_format_reset = true;
- butler_thread = (pthread_t) 0;
//midi_thread = (pthread_t) 0;
AudioDiskstream::allocate_working_buffers();
#include "midi++/port.h"
#include "ardour/ardour.h"
-#include "ardour/audioengine.h"
-#include "ardour/session.h"
#include "ardour/audio_diskstream.h"
+#include "ardour/audioengine.h"
#include "ardour/auditioner.h"
-#include "ardour/slave.h"
+#include "ardour/butler.h"
#include "ardour/location.h"
+#include "ardour/session.h"
+#include "ardour/slave.h"
#include "i18n.h"
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- int on_entry = g_atomic_int_get (&butler_should_do_transport_work);
+ int on_entry = g_atomic_int_get (&butler->should_do_transport_work);
finished = true;
if (post_transport_work & PostTransportCurveRealloc) {
if (!(*i)->hidden()) {
(*i)->non_realtime_locate (_transport_frame);
}
- if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+ if (on_entry != g_atomic_int_get (&butler->should_do_transport_work)) {
/* new request, stop seeking, and start again */
- g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ g_atomic_int_dec_and_test (&butler->should_do_transport_work);
goto restart;
}
}
if (post_transport_work & PostTransportStop) {
non_realtime_stop (post_transport_work & PostTransportAbort, on_entry, finished);
if (!finished) {
- g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ g_atomic_int_dec_and_test (&butler->should_do_transport_work);
goto restart;
}
}
if (post_transport_work & PostTransportOverWrite) {
non_realtime_overwrite (on_entry, finished);
if (!finished) {
- g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ g_atomic_int_dec_and_test (&butler->should_do_transport_work);
goto restart;
}
}
non_realtime_set_audition ();
}
- g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ g_atomic_int_dec_and_test (&butler->should_do_transport_work);
}
void
if ((*i)->pending_overwrite) {
(*i)->overwrite_existing_buffers ();
}
- if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+ if (on_entry != g_atomic_int_get (&butler->should_do_transport_work)) {
finished = false;
return;
}
if (!(*i)->hidden()) {
(*i)->non_realtime_locate (_transport_frame);
}
- if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+ if (on_entry != g_atomic_int_get (&butler->should_do_transport_work)) {
finished = false;
/* we will be back */
return;
the picture.
*/
- g_atomic_int_set (&butler_should_do_transport_work, 0);
+ g_atomic_int_set (&butler->should_do_transport_work, 0);
post_transport_work = PostTransportWork (0);
stop_butler ();
'buffer.cc',
'buffer_set.cc',
'bundle.cc',
+ 'butler.cc',
'chan_count.cc',
'chan_mapping.cc',
'configuration.cc',
projects / ardour.git / commitdiff