mtest.cc
""")
+
+rcu_files=Split("""
+rcu.cc
+""")
+
itest_files=Split("""
itest.cc
""")
if gtkardour['COREAUDIO']:
extra_sources += coreaudio_files
gtkardour.Append(CCFLAGS='-DHAVE_COREAUDIO')
+ gtkardour.Append(LINKFLAGS='-framework Carbon')
gtkardour.Merge([libraries['appleutility']])
if env['FFT_ANALYSIS']:
mtest = gtkardour.Program(target = 'mtest', source = mtest_files)
itest = gtkardour.Program(target = 'itest', source = itest_files)
+rcu = gtkardour.Program(target = 'rcu', source = rcu_files)
my_subst_dict = { }
my_subst_dict['%INSTALL_PREFIX%'] = install_prefix
settings for a new session
*/
session->save_state ("");
- session->save_history ();
+ session->save_history ("");
}
/* there is too much going on, in too many threads, for us to
}
if ((ret = session->save_state (name)) != 0) {
- session->save_history();
+ session->save_history (name);
return ret;
}
}
case 1:
session->save_state ("");
- session->save_history();
+ session->save_history ("");
break;
}
}
*/
-#include <ardour/insert.h>
#include <ardour/audio_unit.h>
+#include <ardour/insert.h>
+
+#include <gtkmm2ext/doi.h>
+
+#include "au_pluginui.h"
+#include "gui_thread.h"
+
+#include <appleutility/CAAudioUnit.h>
+#include <appleutility/CAComponent.h>
-#include "plugin_ui.h"
+#include <AudioUnit/AudioUnit.h>
+
+#include "i18n.h"
using namespace ARDOUR;
using namespace PBD;
-AUPluginUI::AUPluginUI (ARDOUR::AudioEngine& engine, boost::shared_ptr<PluginInsert> ap)
+AUPluginUI::AUPluginUI (boost::shared_ptr<PluginInsert> insert)
{
+ if ((au = boost::dynamic_pointer_cast<AUPlugin> (insert->plugin())) == 0) {
+ error << _("unknown type of editor-supplying plugin (note: no AudioUnit support in this version of ardour)") << endmsg;
+ throw failed_constructor ();
+ }
+
+ OSStatus err = noErr;
+
+ CAComponentDescription desc;
+ Component carbonViewComponent = NULL;
+ AudioUnitCarbonView carbonView = NULL;
+
+ GetComponentInfo(au->get_comp()->Comp(), &desc, 0, 0, 0);
+ carbonViewComponent = get_carbon_view_component(desc.componentSubType);
+ err = OpenAComponent(carbonViewComponent, &carbonView);
+
+ Rect rec;
+ rec.top = 0;
+ rec.left = 0;
+ rec.bottom = 400;
+ rec.right = 500;
+
+ ProcessSerialNumber ourPSN;
+
+ /* Here we will set the MacOSX native section of the process to the foreground for putting up this
+ * dialog box. First step is to get our process serial number. We do this by calling
+ * GetCurrentProcess.
+ * First Argument: On success this PSN will be our PSN on return.
+ * Return Value: A Macintosh error indicating success or failure.
+ */
+ err = GetCurrentProcess(&ourPSN);
+
+ //If no error then set this process to be frontmost.
+ if (err == noErr) {
+ /* Calling SetFrontProcess to make us frontmost.
+ * First Argument: The Process Serial Number of the process we want to make frontmost. Here
+ * of course we pass our process serial number
+ * Return Value: An error value indicating success or failure. We just ignore the return
+ * value here.
+ */
+ (void)SetFrontProcess(&ourPSN);
+ } else {
+ error << "couldn't get current process" << endmsg;
+ }
+
+ err = CreateNewWindow (kDocumentWindowClass, kWindowStandardFloatingAttributes, &rec, &wr);
+
+ ComponentResult auResult;
+ ControlRef rootControl = NULL;
+ GetRootControl(wr, &rootControl);
+
+ int width = 500;
+ int height = 400;
+ Float32Point location = {30, 30};
+ Float32Point size = {width, height};
+ ControlRef audioUnitControl = NULL;
+
+ auResult = AudioUnitCarbonViewCreate(carbonView,
+ au->get_au()->AU(),
+ wr,
+ rootControl,
+ &location,
+ &size,
+ &audioUnitControl);
+
+ ShowWindow (wr);
+ BringToFront (wr);
+// AudioUnitCarbonViewSetEventListener(carbonView, EventListener, this);
+#if 0
+ set_name ("PluginEditor");
+ add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
+
+ signal_delete_event().connect (bind (sigc::ptr_fun (just_hide_it), reinterpret_cast<Window*> (this)));
+#endif
+
+ insert->GoingAway.connect (mem_fun(*this, &AUPluginUI::plugin_going_away));
+
info << "AUPluginUI created" << endmsg;
}
{
// nothing to do here - plugin destructor destroys the GUI
}
+
+void
+AUPluginUI::plugin_going_away (ARDOUR::Redirect* ignored)
+{
+ ENSURE_GUI_THREAD(bind (mem_fun(*this, &AUPluginUI::plugin_going_away), ignored));
+
+ delete_when_idle (this);
+}
+
+Component
+AUPluginUI::get_carbon_view_component(OSType subtype)
+{
+ ComponentDescription desc;
+ Component component;
+
+ desc.componentType = kAudioUnitCarbonViewComponentType; // 'auvw'
+ desc.componentSubType = subtype;
+ desc.componentManufacturer = 0;
+ desc.componentFlags = 0;
+ desc.componentFlagsMask = 0;
+
+ // First see if we can find a carbon view designed specifically for this
+ // plug-in:
+
+ component = FindNextComponent(NULL, &desc);
+ if (component)
+ return component;
+
+ // If not, grab the generic carbon view, which will create a GUI for
+ // any Audio Unit.
+
+ desc.componentSubType = kAUCarbonViewSubType_Generic;
+ component = FindNextComponent(NULL, &desc);
+
+ return component;
+}
+
--- /dev/null
+/*
+ Copyright (C) 2006 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 __au_plugin_ui_h__
+#define __au_plugin_ui_h__
+
+#include <boost/shared_ptr.hpp>
+
+#include <Carbon/Carbon.h>
+#include <AudioUnit/AudioUnit.h>
+
+namespace ARDOUR {
+ class AUPlugin;
+ class PluginInsert;
+ class Redirect;
+}
+
+class AUPluginUI
+{
+ public:
+ AUPluginUI (boost::shared_ptr<ARDOUR::PluginInsert>);
+ ~AUPluginUI ();
+
+ private:
+ WindowRef wr;
+ boost::shared_ptr<ARDOUR::AUPlugin> au;
+
+ void plugin_going_away (ARDOUR::Redirect*);
+ Component get_carbon_view_component(OSType subtype);
+};
+
+#endif // __au_plugin_ui_h__
#include "keyboard.h"
#include "pan_automation_time_axis.h"
#include "playlist_selector.h"
-#include "plugin_selector.h"
-#include "plugin_ui.h"
#include "prompter.h"
#include "public_editor.h"
#include "audio_region_view.h"
if (_follow_playhead) {
- playhead_cursor->canvas_item.show();
+
+ playhead_cursor->canvas_item.show();
if (frame != last_update_frame) {
+ const jack_nframes_t page_width = current_page_frames();
+
+ // Percentage width of the visible range to use as a scroll interval
+ // Idea: snap this to the nearest bar/beat/tick/etc, would make scrolling much
+ // less jarring when zoomed in.. and it would be fun to watch :)
+ static const double scroll_pct = 3.0/4.0;
+
+ const jack_nframes_t rightmost_frame = leftmost_frame + page_width;
+ const jack_nframes_t scroll_interval = (jack_nframes_t)(page_width * scroll_pct);
+ const jack_nframes_t padding = (jack_nframes_t)floor((page_width-scroll_interval) / 2.0);
+
+ if (frame < leftmost_frame + padding || frame > rightmost_frame - padding) {
- if (frame < leftmost_frame || frame > leftmost_frame + current_page_frames()) {
-
if (session->transport_speed() < 0) {
- if (frame > (current_page_frames()/2)) {
- center_screen (frame-(current_page_frames()/2));
+ if (frame > scroll_interval) {
+ center_screen (frame - scroll_interval/2);
} else {
- center_screen (current_page_frames()/2);
+ center_screen (scroll_interval);
}
} else {
- center_screen (frame+(current_page_frames()/2));
+ center_screen(frame + scroll_interval/2);
}
}
}
} else {
-
+
if (frame != last_update_frame) {
if (frame < leftmost_frame || frame > leftmost_frame + current_page_frames()) {
playhead_cursor->canvas_item.hide();
if (current_mixer_strip) {
current_mixer_strip->fast_update ();
}
-
+
}
}
#include <midi++/manager.h>
-#include <ardour/audioengine.h>
#include <ardour/plugin.h>
#include <ardour/insert.h>
#include <ardour/ladspa_plugin.h>
using namespace Gtk;
using namespace sigc;
-LadspaPluginUI::LadspaPluginUI (
AudioEngine &engine, boost::shared_ptr<PluginInsert> pi, bool scrollable)
+LadspaPluginUI::LadspaPluginUI (boost::shared_ptr<PluginInsert> pi, bool scrollable)
: PlugUIBase (pi),
- engine(engine),
button_table (initial_button_rows, initial_button_cols),
output_table (initial_output_rows, initial_output_cols),
hAdjustment(0.0, 0.0, 0.0),
insert->active_changed.connect (mem_fun(*this, &LadspaPluginUI::redirect_active_changed));
bypass_button.set_active (!insert->active());
- build (engine);
+ build ();
}
LadspaPluginUI::~LadspaPluginUI ()
}
void
-LadspaPluginUI::build (AudioEngine &engine)
+LadspaPluginUI::build ()
{
guint32 i = 0;
int button_row, button_col;
int output_rows, output_cols;
int button_rows, button_cols;
- guint32 n_ins=0, n_outs = 0;
prefheight = 30;
hpacker.set_spacing (10);
}
}
- if ((cui = build_control_ui (engine, i, plugin->get_nth_control (i))) == 0) {
+ if ((cui = build_control_ui (i, plugin->get_nth_control (i))) == 0) {
error << string_compose(_("Plugin Editor: could not build control element for port %1"), i) << endmsg;
continue;
}
}
}
- n_ins = plugin->get_info()->n_inputs;
- n_outs = plugin->get_info()->n_outputs;
-
if (box->children().empty()) {
hpacker.remove (*frame);
}
}
LadspaPluginUI::ControlUI*
-LadspaPluginUI::build_control_ui (AudioEngine &engine, guint32 port_index, PBD::Controllable* mcontrol)
+LadspaPluginUI::build_control_ui (guint32 port_index, PBD::Controllable* mcontrol)
{
ControlUI* control_ui;
return enums;
}
+
#include "mixer_strip.h"
#include "mixer_ui.h"
#include "keyboard.h"
-#include "plugin_selector.h"
#include "public_editor.h"
-#include "plugin_ui.h"
#include "send_ui.h"
#include "io_selector.h"
#include "utils.h"
#include <midi++/manager.h>
-#include <ardour/audioengine.h>
#include <ardour/plugin.h>
#include <ardour/insert.h>
#include <ardour/ladspa_plugin.h>
using namespace Gtk;
using namespace sigc;
-PluginUIWindow::PluginUIWindow (
AudioEngine &engine, boost::shared_ptr<PluginInsert> insert, bool scrollable)
+PluginUIWindow::PluginUIWindow (boost::shared_ptr<PluginInsert> insert, bool scrollable)
: ArdourDialog ("plugin ui")
{
if (insert->plugin()->has_editor()) {
} else {
- LadspaPluginUI* pu = new LadspaPluginUI (engine, insert, scrollable);
+ LadspaPluginUI* pu = new LadspaPluginUI (insert, scrollable);
_pluginui = pu;
get_vbox()->add (*pu);
/*
- Copyright (C) 2000 Paul Davis
+ Copyright (C) 2000-2006 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
#include <ardour/types.h>
namespace ARDOUR {
- class AudioEngine;
class PluginInsert;
class Plugin;
class VSTPlugin;
class LadspaPluginUI : public PlugUIBase, public Gtk::VBox
{
public:
- LadspaPluginUI (
ARDOUR::AudioEngine &, boost::shared_ptr<ARDOUR::PluginInsert> plug, bool scrollable=false);
+ LadspaPluginUI (boost::shared_ptr<ARDOUR::PluginInsert> plug, bool scrollable=false);
~LadspaPluginUI ();
gint get_preferred_height () { return prefheight; }
bool stop_updating(GdkEventAny*);
private:
- ARDOUR::AudioEngine &engine;
Gtk::HBox settings_box;
Gtk::HBox hpacker;
sigc::connection screen_update_connection;
void output_update();
- void build (ARDOUR::AudioEngine &);
- ControlUI* build_control_ui (ARDOUR::AudioEngine &, guint32 port_index, PBD::Controllable *);
+ void build ();
+ ControlUI* build_control_ui (guint32 port_index, PBD::Controllable *);
std::vector<string> setup_scale_values(guint32 port_index, ControlUI* cui);
void control_adjustment_changed (ControlUI* cui);
void parameter_changed (uint32_t, float, ControlUI* cui);
class PluginUIWindow : public ArdourDialog
{
public:
- PluginUIWindow (
ARDOUR::AudioEngine &, boost::shared_ptr<ARDOUR::PluginInsert> insert, bool scrollable=false);
+ PluginUIWindow (boost::shared_ptr<ARDOUR::PluginInsert> insert, bool scrollable=false);
~PluginUIWindow ();
PlugUIBase& pluginui() { return *_pluginui; }
};
#endif // VST_SUPPORT
-#ifdef HAVE_COREAUDIO
-class AUPluginUI
-{
- public:
- AUPluginUI (ARDOUR::AudioEngine&, boost::shared_ptr<ARDOUR::PluginInsert>);
- ~AUPluginUI ();
-
- private:
- boost::shared_ptr<ARDOUR::AUPlugin> au;
-};
-#endif // HAVE_COREAUDIO
-
#endif /* __ardour_plugin_ui_h__ */
#include "route_redirect_selection.h"
#include "mixer_ui.h"
#include "actions.h"
-
#include "plugin_ui.h"
#include "send_ui.h"
#include "io_selector.h"
#include "i18n.h"
+#ifdef HAVE_COREAUDIO
+#include "au_pluginui.h"
+#endif
+
using namespace sigc;
using namespace ARDOUR;
using namespace PBD;
} else {
- /* its an insert */
+ /* it's an insert */
boost::shared_ptr<PluginInsert> plugin_insert;
boost::shared_ptr<PortInsert> port_insert;
title = string_compose(_("ardour: %1: %2 (by %3)"), _route->name(), plugin_insert->name(), maker);
- plugin_ui = new PluginUIWindow (_session.engine(), plugin_insert);
+ plugin_ui = new PluginUIWindow (plugin_insert);
if (_owner_is_mixer) {
ARDOUR_UI::instance()->the_mixer()->ensure_float (*plugin_ui);
} else {
} else if (type == ARDOUR::AudioUnit) {
AUPluginUI* plugin_ui;
if (plugin_insert->get_gui() == 0) {
- plugin_ui = new AUPluginUI (_session.engine(), plugin_insert);
+ plugin_ui = new AUPluginUI (plugin_insert);
} else {
plugin_ui = reinterpret_cast<AUPluginUI*> (plugin_insert->get_gui());
}
warning << "Unsupported plugin sent to RedirectBox::edit_redirect()" << endmsg;
return;
}
+
} else if ((port_insert = boost::dynamic_pointer_cast<PortInsert> (insert)) != 0) {
if (!_session.engine().connected()) {
compute_colors (basic_color);
name_highlight->set_data ("regionview", this);
- name_text->set_data ("regionview", this);
+
+ if (name_text) {
+ name_text->set_data ("regionview", this);
+ }
/* an equilateral triangle */
- ArdourCanvas::Points shape;
+
+ ArdourCanvas::Points shape;
shape.push_back (Gnome::Art::Point (-((sync_mark_width-1)/2), 1));
shape.push_back (Gnome::Art::Point ((sync_mark_width - 1)/2, 1));
shape.push_back (Gnome::Art::Point (0, sync_mark_width - 1));
if ((plugin_insert = boost::dynamic_pointer_cast<PluginInsert> (insert)) != 0) {
- LadspaPluginUI *plugin_ui = new LadspaPluginUI (session->engine(), plugin_insert, true);
+ LadspaPluginUI *plugin_ui = new LadspaPluginUI (plugin_insert, true);
if (place == PreFader) {
cleanup_pre_view();
#include "gui_thread.h"
#include "keyboard.h"
#include "playlist_selector.h"
-#include "plugin_selector.h"
-#include "plugin_ui.h"
#include "point_selection.h"
#include "prompter.h"
#include "public_editor.h"
bool has_editor () const;
+ CAAudioUnit* get_au () { return unit; }
+ CAComponent* get_comp () { return comp; }
+
private:
CAComponent* comp;
CAAudioUnit* unit;
private:
static std::string get_name (CAComponentDescription&);
+ void setup_nchannels (CAComponentDescription&);
};
typedef boost::shared_ptr<AUPluginInfo> AUPluginInfoPtr;
/* begin mach */
#elif defined(__APPLE__)
-#include <CoreAudio/CoreAudioTypes.h>
+
+#ifdef HAVE_COREAUDIO
#include <CoreAudio/HostTime.h>
+#else // Due to MacTypes.h and libgnomecanvasmm Rect conflict
+typedef unsigned long long UInt64;
+
+extern UInt64
+AudioGetCurrentHostTime();
+
+extern UInt64
+AudioConvertHostTimeToNanos(UInt64 inHostTime);
+#endif
+
typedef UInt64 cycles_t;
static inline cycles_t get_cycles (void)
{
int save_state (string snapshot_name, bool pending = false);
int restore_state (string snapshot_name);
int save_template (string template_name);
- int save_history ();
+ int save_history (string snapshot_name = "");
static int rename_template (string old_name, string new_name);
int
AUPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const
{
- return -1;
+ return 0;
}
uint32_t
plug->type = ARDOUR::AudioUnit;
plug->n_inputs = 0;
plug->n_outputs = 0;
+ // plug->setup_nchannels (temp);
plug->category = "AudioUnit";
plug->desc = new CAComponentDescription(temp);
return CFStringRefToStdString(itemName);
}
+
+void
+AUPluginInfo::setup_nchannels (CAComponentDescription& comp_desc)
+{
+ CAAudioUnit unit;
+
+ CAAudioUnit::Open (comp_desc, unit);
+
+ if (unit.SupportsNumChannels()) {
+ n_inputs = n_outputs = 0;
+ } else {
+ AUChannelInfo cinfo;
+ size_t info_size = sizeof(cinfo);
+ OSStatus err = AudioUnitGetProperty (unit.AU(), kAudioUnitProperty_SupportedNumChannels, kAudioUnitScope_Global,
+ 0, &cinfo, &info_size);
+ }
+}
if (get_record_enabled() && get_punch_in()) {
/* capture start has been changed, so save new pending state */
save_state ("", true);
- save_history();
+ save_history("");
}
}
*/
save_state ("", true);
- save_history();
+ save_history ("");
if (_transport_speed) {
if (!punch_in) {
set_dirty();
save_state (_current_snapshot_name);
+ save_history (_current_snapshot_name);
RouteAdded (route); /* EMIT SIGNAL */
}
set_dirty();
save_state (_current_snapshot_name);
- save_history();
+ save_history (_current_snapshot_name);
DiskstreamAdded (dstream); /* EMIT SIGNAL */
}
/* XXX should we disconnect from the Route's signals ? */
save_state (_current_snapshot_name);
+ save_history (_current_snapshot_name);
/* all shared ptrs to route should go out of scope here */
}
*/
save_state (_current_snapshot_name);
- save_history();
+ save_history (_current_snapshot_name);
}
SourceRemoved(source); /* EMIT SIGNAL */
{
PBD::ID id;
XMLNode *before, *after;
- //void *obj;
/* get obj_id */
if (Diskstream *obj = diskstream_by_id(id))
return new MementoCommand<Diskstream>(*obj, *before, *after);
// etc.
+
return 0;
}
*/
save_state ("", true);
+ save_history ("");
g_atomic_int_set (&_record_status, Enabled);
RecordStateChanged (); /* EMIT SIGNAL */
_state_of_the_state = Clean;
if (save_state (_current_snapshot_name)) {
- save_history();
+ save_history (_current_snapshot_name);
return -1;
}
}
if (state_was_pending) {
save_state (_current_snapshot_name);
- save_history();
+ save_history (_current_snapshot_name);
remove_pending_capture_state ();
state_was_pending = false;
}
Session::auto_save()
{
save_state (_current_snapshot_name);
- save_history();
+ save_history (_current_snapshot_name);
}
RouteGroup *
*/
save_state ("");
+ save_history ("");
out:
_state_of_the_state = (StateOfTheState) (_state_of_the_state & ~InCleanup);
int
-Session::save_history ()
+Session::save_history (string snapshot_name)
{
XMLTree tree;
string xml_path;
tree.set_root (&history.get_state());
- xml_path = _path + _current_snapshot_name + ".history";
+ if (snapshot_name.empty()) {
+ snapshot_name = _current_snapshot_name;
+ }
+
+ xml_path = _path + snapshot_name + ".history";
bak_path = xml_path + ".bak";
if ((post_transport_work & PostTransportLocate) && get_record_enabled()) {
/* capture start has been changed, so save pending state */
save_state ("", true);
- save_history();
+ save_history ("");
}
/* always try to get rid of this */
if (did_record) {
save_state (_current_snapshot_name);
+ save_history (_current_snapshot_name);
}
if (post_transport_work & PostTransportDuration) {
if ((ret = IO::set_name (str, src)) == 0) {
_session.save_state ("");
- _session.save_history();
+ _session.save_history ("");
}
return ret;
}
#include <list>
+
template<class T>
class RCUManager
{
-public:
-
- RCUManager (T* new_rcu_value)
- : m_rcu_value(new_rcu_value)
- {
+ public:
+ RCUManager (T* new_rcu_value) {
+ m_rcu_value = new boost::shared_ptr<T> (new_rcu_value);
}
- virtual ~RCUManager() { }
+ virtual ~RCUManager() { delete m_rcu_value; }
- boost::shared_ptr<T> reader () const { return m_rcu_value; }
+ boost::shared_ptr<T> reader () const { return *((boost::shared_ptr<T> *) g_atomic_pointer_get (&m_rcu_value)); }
- // should be private
virtual boost::shared_ptr<T> write_copy () = 0;
-
- // should be private
- virtual void update (boost::shared_ptr<T> new_value) = 0;
-
-protected:
-
- boost::shared_ptr<T> m_rcu_value;
-
-
+ virtual bool update (boost::shared_ptr<T> new_value) = 0;
+
+ protected:
+ boost::shared_ptr<T>* m_rcu_value;
+
+ // this monstrosity is needed because of some wierd behavior by g++
+
+ gpointer * the_pointer() const { return (gpointer *) &m_rcu_value; }
};
virtual boost::shared_ptr<T> write_copy ()
{
m_lock.lock();
-
- // I hope this is doing what I think it is doing :)
- boost::shared_ptr<T> new_copy(new T(*RCUManager<T>::m_rcu_value));
-
- // XXX todo remove old copies with only 1 reference from the list.
-
+
+ // clean out any dead wood
+
+ typename std::list<boost::shared_ptr<T> >::iterator i;
+
+ for (i = m_dead_wood.begin(); i != m_dead_wood.end(); ) {
+ if ((*i).use_count() == 1) {
+ i = m_dead_wood.erase (i);
+ } else {
+ ++i;
+ }
+ }
+
+ // store the current
+
+ current_write_old = RCUManager<T>::m_rcu_value;
+
+ boost::shared_ptr<T> new_copy (new T(**current_write_old));
+
return new_copy;
}
- virtual void update (boost::shared_ptr<T> new_value)
+ virtual bool update (boost::shared_ptr<T> new_value)
{
- // So a current reader doesn't hold the only reference to
- // the existing value when we assign it a new value which
- // should ensure that deletion of old values doesn't
- // occur in a reader thread.
- boost::shared_ptr<T> old_copy = RCUManager<T>::m_rcu_value;
-
// we hold the lock at this point effectively blocking
// other writers.
- RCUManager<T>::m_rcu_value = new_value;
-
-
- // XXX add the old value to the list of old copies.
-
+
+ boost::shared_ptr<T>* new_spp = new boost::shared_ptr<T> (new_value);
+
+ // update, checking that nobody beat us to it
+
+ bool ret = g_atomic_pointer_compare_and_exchange (RCUManager<T>::the_pointer(),
+ (gpointer) current_write_old,
+ (gpointer) new_spp);
+
+ if (ret) {
+
+ // successful update : put the old value into dead_wood,
+
+ m_dead_wood.push_back (*current_write_old);
+
+ // now delete it - this gets rid of the shared_ptr<T> but
+ // because dead_wood contains another shared_ptr<T> that
+ // references the same T, the underlying object lives on
+
+ delete current_write_old;
+ }
+
m_lock.unlock();
+
+ return ret;
}
private:
- Glib::Mutex m_lock;
-
- std::list<boost::shared_ptr<T> > m_old_values;
+ Glib::Mutex m_lock;
+ boost::shared_ptr<T>* current_write_old;
+ std::list<boost::shared_ptr<T> > m_dead_wood;
};
template<class T>
BasicUI::save_state ()
{
session->save_state ("");
- session->save_history();
+ session->save_history("");
}
void
projects / ardour.git / commitdiff