--- /dev/null
+Last merged with trunk revision:
+
+579
from sets import Set
import SCons.Node.FS
-#import pickle
-
SConsignFile()
EnsureSConsVersion(0, 96)
-version = '2.0alpha2'
+version = '2.0beta1'
subst_dict = { }
BoolOption('FPU_OPTIMIZATION', 'Build runtime checked assembler code', 1),
BoolOption('FFT_ANALYSIS', 'Include FFT analysis window', 0),
BoolOption('SURFACES', 'Build support for control surfaces', 0),
- BoolOption('DMALLOC', 'Compile and link using the dmalloc library', 0)
- )
+ BoolOption('DMALLOC', 'Compile and link using the dmalloc library', 0),
+ BoolOption('LIBLO', 'Compile with support for liblo library', 1),
+ BoolOption('COREAUDIO', 'Compile with Apple\'s CoreAudio library -- UNSTABLE', 0)
+)
#----------------------------------------------------------------------
# a handy helper that provides a way to merge compile/link information
libraries['glib2'].ParseConfig ('pkg-config --cflags --libs glib-2.0')
libraries['glib2'].ParseConfig ('pkg-config --cflags --libs gobject-2.0')
libraries['glib2'].ParseConfig ('pkg-config --cflags --libs gmodule-2.0')
+libraries['glib2'].ParseConfig ('pkg-config --cflags --libs gthread-2.0')
libraries['gtk2'] = LibraryInfo()
libraries['gtk2'].ParseConfig ('pkg-config --cflags --libs gtk+-2.0')
#
# Check for liblo
-libraries['lo'] = LibraryInfo ()
+if env['LIBLO']:
+ libraries['lo'] = LibraryInfo ()
-conf = Configure (libraries['lo'])
-if conf.CheckLib ('lo', 'lo_server_new') == False:
- print "liblo does not appear to be installed."
- exit (0)
+ conf = Configure (libraries['lo'])
+ if conf.CheckLib ('lo', 'lo_server_new') == False:
+ print "liblo does not appear to be installed."
+ sys.exit (1)
-libraries['lo'] = conf.Finish ()
+ libraries['lo'] = conf.Finish ()
#
# Check for dmalloc
conf = Configure(env)
-if conf.CheckCHeader('jack/midiport.h'):
- libraries['sysmidi'] = LibraryInfo (LIBS='jack')
- env['SYSMIDI'] = 'JACK MIDI'
- subst_dict['%MIDITAG%'] = "control"
- subst_dict['%MIDITYPE%'] = "jack"
-elif conf.CheckCHeader('alsa/asoundlib.h'):
+if conf.CheckCHeader('alsa/asoundlib.h'):
libraries['sysmidi'] = LibraryInfo (LIBS='asound')
env['SYSMIDI'] = 'ALSA Sequencer'
subst_dict['%MIDITAG%'] = "seq"
env['SYSMIDI'] = 'CoreMIDI'
subst_dict['%MIDITAG%'] = "ardour"
subst_dict['%MIDITYPE%'] = "coremidi"
-
+else:
+ print "It appears you don't have the required MIDI libraries installed."
+ sys.exit (1)
+
env = conf.Finish()
if env['SYSLIBS']:
if os.environ.has_key('PATH'):
env.Append(PATH = os.environ['PATH'])
-if os.environ.has_key('TERM'):
- env.Append(PATH = os.environ['TERM'])
-
-if os.environ.has_key('HOME'):
- env.Append(HOME = os.environ['HOME'])
-
if os.environ.has_key('PKG_CONFIG_PATH'):
env.Append(PKG_CONFIG_PATH = os.environ['PKG_CONFIG_PATH'])
print "\nWarning: you are building Ardour with SSE support even though your system does not support these instructions. (This may not be an error, especially if you are a package maintainer)"
# end optimization section
+#
+# save off guessed arch element in an env
+#
+env.Append(CONFIG_ARCH=config[config_arch])
+
+
#
# ARCH="..." overrides all
#
if env['VST']:
env.Append(CCFLAGS="-DVST_SUPPORT")
+if env['LIBLO']:
+ env.Append(CCFLAGS="-DHAVE_LIBLO")
+
#
# everybody needs this
#
for sublistdir in [ subdirs, gtk_subdirs, surface_subdirs ]:
for subdir in sublistdir:
SConscript (subdir + '/SConscript')
-
-#pickle.dump(env, open('.scons_env', 'w'), pickle.HIGHEST_PROTOCOL)
-
+
# cleanup
env.Clean ('scrub', [ 'scache.conf', '.sconf_temp', '.sconsign.dblite', 'config.log'])
env.Alias ('tarball', env.Distribute (env['DISTTREE'],
[ 'SConscript',
'i18n.h', 'gettext.h',
+ 'ardour.sh.in',
'ardour2_ui.rc', 'splash.ppm',
'ardour.menus', 'ardour.bindings', 'ardour.colors',
'editor_xpms'
{
track_list_ready = false;
{
- LockMonitor lm (track_list_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (track_list_lock);
// Empty track list & free old graphs
clear_tracklist();
#include <gtkmm2ext/dndtreeview.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include "ardour_dialog.h"
FFTGraph fft_graph;
bool track_list_ready;
- PBD::Lock track_list_lock;
+ Glib::Mutex track_list_lock;
friend class FFTGraph;
};
#include <pbd/error.h>
#include <pbd/compose.h>
-#include <pbd/basename.h>
#include <pbd/pathscanner.h>
#include <pbd/failed_constructor.h>
#include <gtkmm2ext/gtk_ui.h>
keyboard = new Keyboard;
- string meter_path;
-
- meter_path = ARDOUR::find_data_file("v_meter_strip.xpm", "pixmaps");
- if (meter_path.empty()) {
- error << _("no vertical meter strip image found") << endmsg;
- exit (1);
- }
- FastMeter::set_vertical_xpm (meter_path);
-
- meter_path = ARDOUR::find_data_file("h_meter_strip.xpm", "pixmaps");
- if (meter_path.empty()) {
- error << _("no horizontal meter strip image found") << endmsg;
- exit (1);
- }
- FastMeter::set_horizontal_xpm (meter_path);
-
if (setup_windows ()) {
throw failed_constructor ();
}
TreeModel::Row row = *(recent_session_model->append());
- row[recent_session_columns.visible_name] = PBD::basename (fullpath);
+ row[recent_session_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_session_columns.fullpath] = fullpath;
if (states->size() > 1) {
return false;
}
+ // XXX Portability
+
string session_file = info.filename;
session_file += '/';
- session_file += PBD::basename (info.filename);
+ session_file += Glib::path_get_basename (info.filename);
session_file += ".ardour";
if (stat (session_file.c_str(), &statbuf) != 0) {
shuttle_grabbed = false;
shuttle_box.remove_modal_grab ();
if (shuttle_behaviour == Sprung) {
- shuttle_fract = SHUTTLE_FRACT_SPEED1;
- session->request_transport_speed (1.0);
+ if (session->get_auto_play() || roll_button.get_state()) {
+ shuttle_fract = SHUTTLE_FRACT_SPEED1;
+ session->request_transport_speed (1.0);
+ stop_button.set_active (false);
+ roll_button.set_active (true);
+ } else {
+ shuttle_fract = 0;
+ session->request_transport_speed (0.0);
+ }
shuttle_box.queue_draw ();
}
return true;
if (session->transport_rolling()) {
shuttle_fract = SHUTTLE_FRACT_SPEED1;
session->request_transport_speed (1.0);
+ stop_button.set_active (false);
+ roll_button.set_active (true);
} else {
shuttle_fract = 0;
}
using namespace Gtk;
using PBD::atoi;
+using PBD::atof;
const uint32_t AudioClock::field_length[(int) AudioClock::AudioFrames+1] = {
2, /* SMPTE_Hours */
SMPTE::Time smpte2;
jack_nframes_t sample_increment;
- sample_increment = (long)rint(session->frame_rate() / SMPTE::frames_per_second);
+ sample_increment = (long)rint(session->frame_rate() / session->smpte_frames_per_second);
#ifdef SMPTE_SAMPLE_TEST_1
// Test 1: use_offset = false, use_subframes = false
cout << "use_offset = false, use_subframes = false" << endl;
for (int i = 0; i < 108003; i++) {
- SMPTE::to_sample( smpte1, sample1, false /* use_offset */, false /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, false /* use_offset */, false /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, false /* use_offset */, false /* use_subframes */ );
if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1)))) {
break;
}
oldsample = sample1;
- SMPTE::increment( smpte1 );
+ session->smpte_increment( smpte1 );
}
cout << "sample_increment: " << sample_increment << endl;
cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
for (int i = 0; i < 108003; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
// cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
break;
}
oldsample = sample1;
- SMPTE::increment( smpte1 );
+ session->smpte_increment( smpte1 );
}
cout << "sample_increment: " << sample_increment << endl;
cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
for (int i = 0; i < 108003; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
// cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
break;
}
oldsample = sample1;
- SMPTE::decrement( smpte1 );
+ session->smpte_decrement( smpte1 );
}
cout << "sample_decrement: " << sample_increment << endl;
cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
for (int i = 0; i < 108003; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, true /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, true /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, true /* use_subframes */ );
if ((i > 0) && ( ((sample1 - oldsample) != sample_increment) && ((sample1 - oldsample) != (sample_increment + 1)) && ((sample1 - oldsample) != (sample_increment - 1)))) {
break;
}
oldsample = sample1;
- SMPTE::increment( smpte1 );
+ session->smpte_increment( smpte1 );
}
cout << "sample_increment: " << sample_increment << endl;
cout << "smpte: " << (smpte2.negative ? "-" : "") << smpte2.hours << ":" << smpte2.minutes << ":" << smpte2.seconds << ":" << smpte2.frames << "::" << smpte2.subframes << endl;
for (int i = 0; i < 108003; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, true /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, true /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, true /* use_subframes */ );
if ((i > 0) && ( ((oldsample - sample1) != sample_increment) && ((oldsample - sample1) != (sample_increment + 1)) && ((oldsample - sample1) != (sample_increment - 1)))) {
break;
}
oldsample = sample1;
- SMPTE::decrement( smpte1 );
+ session->smpte_decrement( smpte1 );
}
cout << "sample_decrement: " << sample_increment << endl;
cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
for (int i = 0; i < 3600; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
// cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
break;
}
oldsample = sample1;
- SMPTE::increment_seconds( smpte1 );
+ session->smpte_increment_seconds( smpte1 );
}
cout << "sample_increment: " << sample_increment << endl;
cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
for (int i = 0; i < 60; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
// cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
break;
}
oldsample = sample1;
- SMPTE::increment_minutes( smpte1 );
+ session->smpte_increment_minutes( smpte1 );
}
cout << "sample_increment: " << sample_increment << endl;
cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << endl;
for (int i = 0; i < 10; i++) {
- SMPTE::to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
+ session->smpte_to_sample( smpte1, sample1, true /* use_offset */, false /* use_subframes */ );
session->sample_to_smpte( sample1, smpte2, true /* use_offset */, false /* use_subframes */ );
// cout << "smpte: " << (smpte1.negative ? "-" : "") << smpte1.hours << ":" << smpte1.minutes << ":" << smpte1.seconds << ":" << smpte1.frames << "::" << smpte1.subframes << " -> ";
break;
}
oldsample = sample1;
- SMPTE::increment_hours( smpte1 );
+ session->smpte_increment_hours( smpte1 );
}
cout << "sample_increment: " << sample_increment << endl;
jack_nframes_t start_adjusted = session_frame_to_track_frame(start, speed);
jack_nframes_t end_adjusted = session_frame_to_track_frame(end, speed);
- if (view && touched (top, bot)) {
+ if (view && ((top < 0.0 && bot < 0.0)) || touched (top, bot)) {
view->get_selectables (start_adjusted, end_adjusted, results);
}
}
/**
- * The abstract base class for time-axis trackviews and routes.
+ * AxisView defines the abstract base class for time-axis trackviews and routes.
*
*/
class AxisView : public virtual sigc::trackable
void
ConnectionEditor::display_connection_state (bool for_input)
{
- LockMonitor lm (port_display_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_display_lock);
uint32_t limit;
if (session == 0 || current_connection == 0) {
void
ConnectionEditor::connection_port_button_press_event (GdkEventButton* ev, TreeView* tview)
{
- LockMonitor lm (port_display_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_display_lock);
int which_port = reinterpret_cast<intptr_t> (treeview->get_data ("port"));
#include "ardour_dialog.h"
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
namespace ARDOUR {
class Session;
Gtk::Button clear_button;
Gtk::Button add_port_button;
- PBD::Lock port_display_lock;
+ Glib::Mutex port_display_lock;
slist<Gtk::ScrolledWindow *> port_displays;
Gtk::Button ok_button;
AudioRegionView& right_view;
std::string get_item_name();
- void set_height (double h);
+ void set_height (double);
bool valid() const { return _valid; }
bool visible() const { return _visible; }
bool copy;
bool was_rolling;
bool first_move;
- bool move_threshold_passsed;
+ bool move_threshold_passed;
bool want_move_threshold;
bool brushing;
ARDOUR::Location* copied_location;
using namespace Editing;
using PBD::internationalize;
+using PBD::atoi;
const double Editor::timebar_height = 15.0;
last_canvas_frame = 0;
edit_cursor = 0;
playhead_cursor = 0;
+ button_release_can_deselect = true;
location_marker_color = color_map[cLocationMarker];
location_range_color = color_map[cLocationRange];
}
if ((prop = node.property ("zoom"))) {
- set_frames_per_unit (atof (prop->value()));
+ set_frames_per_unit (PBD::atof (prop->value()));
}
if ((prop = node.property ("snap-to"))) {
for (vector<ustring>::iterator i = uris.begin(); i != uris.end(); ++i) {
if ((*i).substr (0,7) == "file://") {
string p = *i;
- url_decode (p);
+ PBD::url_decode (p);
paths.push_back (p.substr (7));
}
}
}
}
-void
-Editor::set_selected_track_from_click (Selection::Operation op, bool with_undo, bool no_remove)
+bool
+Editor::set_selected_track_from_click (bool press, Selection::Operation op, bool with_undo, bool no_remove)
{
+ bool commit = false;
+
if (!clicked_trackview) {
- return;
+ return false;
}
- if (with_undo) {
- begin_reversible_command (_("set selected trackview"));
- }
-
switch (op) {
case Selection::Toggle:
if (selection->selected (clicked_trackview)) {
if (!no_remove) {
selection->remove (clicked_trackview);
+ commit = true;
}
} else {
- selection->toggle (clicked_trackview);
+ selection->add (clicked_trackview);
+ commit = false;
}
break;
+
case Selection::Set:
if (selection->selected (clicked_trackview) && selection->tracks.size() == 1) {
/* no commit necessary */
- return;
}
selection->set (clicked_trackview);
/* not defined yet */
break;
}
-
- if (with_undo) {
- commit_reversible_command ();
- }
+
+ return commit;
}
-void
-Editor::set_selected_control_point_from_click (Selection::Operation op, bool with_undo, bool no_remove)
+bool
+Editor::set_selected_control_point_from_click (bool press, Selection::Operation op, bool with_undo, bool no_remove)
{
if (!clicked_control_point) {
- return;
+ return false;
}
/* select this point and any others that it represents */
- bool commit;
-
- if (with_undo) {
- begin_reversible_command (_("select control points"));
- }
-
double y1, y2;
jack_nframes_t x1, x2;
y1 = clicked_control_point->get_x() - 10;
y2 = clicked_control_point->get_y() + 10;
- commit = select_all_within (x1, x2, y1, y2, op);
-
- if (with_undo && commit) {
- commit_reversible_command ();
- }
+ return select_all_within (x1, x2, y1, y2, op);
}
void
-Editor::mapover_audio_tracks (slot<void,AudioTimeAxisView&,uint32_t> sl)
+Editor::get_relevant_audio_tracks (AudioTimeAxisView& base, set<AudioTimeAxisView*>& relevant_tracks)
{
- set<AudioTimeAxisView*> relevant_tracks;
-
/* step one: get all selected tracks and all tracks in the relevant edit groups */
for (TrackSelection::iterator ti = selection->tracks.begin(); ti != selection->tracks.end(); ++ti) {
/* no active group, or no group */
- relevant_tracks.insert (atv);
+ relevant_tracks.insert (&base);
}
}
+}
+
+void
+Editor::mapover_audio_tracks (slot<void,AudioTimeAxisView&,uint32_t> sl)
+{
+ set<AudioTimeAxisView*> relevant_tracks;
+
+ if (!clicked_audio_trackview) {
+ return;
+ }
- /* step two: apply operation to each track */
+ get_relevant_audio_tracks (*clicked_audio_trackview, relevant_tracks);
uint32_t sz = relevant_tracks.size();
vector<AudioRegion*> results;
AudioRegionView* marv;
DiskStream* ds;
-
+
if ((ds = atv.get_diskstream()) == 0) {
/* bus */
return;
}
+
+ if (&atv == &basis->get_time_axis_view()) {
+ /* looking in same track as the original */
+ return;
+ }
+
if ((pl = ds->playlist()) != 0) {
pl->get_equivalent_regions (basis->region, results);
}
}
-void
-Editor::set_selected_regionview_from_click (Selection::Operation op, bool no_track_remove)
+bool
+Editor::set_selected_regionview_from_click (bool press, Selection::Operation op, bool no_track_remove)
{
- cerr << "In SSRfC\n";
-
vector<AudioRegionView*> all_equivalent_regions;
+ bool commit = false;
- if (!clicked_regionview) {
- return;
+ if (!clicked_regionview || !clicked_audio_trackview) {
+ return false;
}
- mapover_audio_tracks (bind (mem_fun (*this, &Editor::mapped_set_selected_regionview_from_click),
- clicked_regionview, &all_equivalent_regions));
-
+ if (op == Selection::Toggle || op == Selection::Set) {
+
+ mapover_audio_tracks (bind (mem_fun (*this, &Editor::mapped_set_selected_regionview_from_click),
+ clicked_regionview, &all_equivalent_regions));
+
+
+ /* add clicked regionview since we skipped all other regions in the same track as the one it was in */
+
+ all_equivalent_regions.push_back (clicked_regionview);
+
+ switch (op) {
+ case Selection::Toggle:
+
+ if (clicked_regionview->get_selected()) {
+ if (press) {
- cerr << "mapover done\n";
+ /* whatever was clicked was selected already; do nothing here but allow
+ the button release to deselect it
+ */
- begin_reversible_command (_("set selected regionview"));
+ button_release_can_deselect = true;
- switch (op) {
- case Selection::Toggle:
- selection->toggle (clicked_regionview);
-#if 0
- if (clicked_regionview->get_selected()) {
- if (/* group && group->is_active() && */ selection->audio_regions.size() > 1) {
- /* reduce selection down to just the one clicked */
- selection->set (clicked_regionview);
+ } else {
+
+ if (button_release_can_deselect) {
+
+ /* just remove this one region, but only on a permitted button release */
+
+ selection->remove (clicked_regionview);
+ commit = true;
+
+ /* no more deselect action on button release till a new press
+ finds an already selected object.
+ */
+
+ button_release_can_deselect = false;
+ }
+ }
+
+ } else {
+
+ if (press) {
+ /* add all the equivalent regions, but only on button press */
+
+ if (!all_equivalent_regions.empty()) {
+ commit = true;
+ }
+
+ for (vector<AudioRegionView*>::iterator i = all_equivalent_regions.begin(); i != all_equivalent_regions.end(); ++i) {
+ selection->add (*i);
+ }
+ }
+ }
+ break;
+
+ case Selection::Set:
+ if (!clicked_regionview->get_selected()) {
+ selection->set (all_equivalent_regions);
+ commit = true;
} else {
- selection->remove (clicked_regionview);
+ /* no commit necessary: clicked on an already selected region */
+ goto out;
}
- } else {
- selection->add (all_equivalent_regions);
+ break;
+
+ default:
+ /* silly compiler */
+ break;
}
-#endif
- set_selected_track_from_click (op, false, no_track_remove);
- break;
- case Selection::Set:
- // karsten wiese suggested these two lines to make
- // a selected region rise to the top. but this
- // leads to a mismatch between actual layering
- // and visual layering. resolution required ....
- //
- // gnome_canvas_item_raise_to_top (clicked_regionview->get_canvas_group());
- // gnome_canvas_item_raise_to_top (clicked_regionview->get_time_axis_view().canvas_display);
-
- if (clicked_regionview->get_selected()) {
- /* no commit necessary: we are the one selected. */
- return;
+ } else if (op == Selection::Extend) {
- } else {
-
- selection->set (all_equivalent_regions);
- set_selected_track_from_click (op, false, false);
+ list<Selectable*> results;
+ jack_nframes_t last_frame;
+ jack_nframes_t first_frame;
+
+ /* 1. find the last selected regionview in the track that was clicked in */
+
+ last_frame = 0;
+ first_frame = max_frames;
+
+ for (AudioRegionSelection::iterator x = selection->audio_regions.begin(); x != selection->audio_regions.end(); ++x) {
+ if (&(*x)->get_time_axis_view() == &clicked_regionview->get_time_axis_view()) {
+
+ if ((*x)->region.last_frame() > last_frame) {
+ last_frame = (*x)->region.last_frame();
+ }
+
+ if ((*x)->region.first_frame() < first_frame) {
+ first_frame = (*x)->region.first_frame();
+ }
+ }
}
- break;
- case Selection::Extend:
- /* not defined yet */
- break;
+ /* 2. figure out the boundaries for our search for new objects */
+
+ switch (clicked_regionview->region.coverage (first_frame, last_frame)) {
+ case OverlapNone:
+ cerr << "no overlap, first = " << first_frame << " last = " << last_frame << " region = "
+ << clicked_regionview->region.first_frame() << " .. " << clicked_regionview->region.last_frame() << endl;
+
+ if (last_frame < clicked_regionview->region.first_frame()) {
+ first_frame = last_frame;
+ last_frame = clicked_regionview->region.last_frame();
+ } else {
+ last_frame = first_frame;
+ first_frame = clicked_regionview->region.first_frame();
+ }
+ break;
+
+ case OverlapExternal:
+ cerr << "external overlap, first = " << first_frame << " last = " << last_frame << " region = "
+ << clicked_regionview->region.first_frame() << " .. " << clicked_regionview->region.last_frame() << endl;
+
+ if (last_frame < clicked_regionview->region.first_frame()) {
+ first_frame = last_frame;
+ last_frame = clicked_regionview->region.last_frame();
+ } else {
+ last_frame = first_frame;
+ first_frame = clicked_regionview->region.first_frame();
+ }
+ break;
+
+ case OverlapInternal:
+ cerr << "internal overlap, first = " << first_frame << " last = " << last_frame << " region = "
+ << clicked_regionview->region.first_frame() << " .. " << clicked_regionview->region.last_frame() << endl;
+
+ if (last_frame < clicked_regionview->region.first_frame()) {
+ first_frame = last_frame;
+ last_frame = clicked_regionview->region.last_frame();
+ } else {
+ last_frame = first_frame;
+ first_frame = clicked_regionview->region.first_frame();
+ }
+ break;
+
+ case OverlapStart:
+ case OverlapEnd:
+ /* nothing to do except add clicked region to selection, since it
+ overlaps with the existing selection in this track.
+ */
+ break;
+ }
+
+ /* 2. find all selectable objects (regionviews in this case) between that one and the end of the
+ one that was clicked.
+ */
+
+ set<AudioTimeAxisView*> relevant_tracks;
+
+ get_relevant_audio_tracks (*clicked_audio_trackview, relevant_tracks);
+
+ for (set<AudioTimeAxisView*>::iterator t = relevant_tracks.begin(); t != relevant_tracks.end(); ++t) {
+ (*t)->get_selectables (first_frame, last_frame, -1.0, -1.0, results);
+ }
+
+ /* 3. convert to a vector of audio regions */
+
+ vector<AudioRegionView*> audio_regions;
+
+ for (list<Selectable*>::iterator x = results.begin(); x != results.end(); ++x) {
+ AudioRegionView* arv;
+
+ if ((arv = dynamic_cast<AudioRegionView*>(*x)) != 0) {
+ audio_regions.push_back (arv);
+ }
+ }
+
+ if (!audio_regions.empty()) {
+ selection->add (audio_regions);
+ commit = true;
+ }
}
- cerr << "case done\n";
- commit_reversible_command () ;
+ out:
+ return commit;
}
void
switch (op) {
case Selection::Toggle:
/* XXX this is not correct */
- selection->add (all_equivalent_regions);
+ selection->toggle (all_equivalent_regions);
break;
case Selection::Set:
selection->set (all_equivalent_regions);
break;
case Selection::Extend:
- /* not defined yet */
+ selection->add (all_equivalent_regions);
break;
}
CrossfadeView* clicked_crossfadeview;
ControlPoint* clicked_control_point;
+ void get_relevant_audio_tracks (AudioTimeAxisView& base, std::set<AudioTimeAxisView*>& relevant_tracks);
void mapover_audio_tracks (sigc::slot<void,AudioTimeAxisView&,uint32_t> sl);
/* functions to be passed to mapover_audio_tracks(), possibly with sigc::bind()-supplied arguments */
/* end */
+ void button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type);
+ bool button_release_can_deselect;
+
void catch_vanishing_audio_regionview (AudioRegionView *);
- void set_selected_control_point_from_click (Selection::Operation op = Selection::Set, bool with_undo = true, bool no_remove=false);
- void set_selected_track_from_click (Selection::Operation op = Selection::Set, bool with_undo = true, bool no_remove=false);
- void set_selected_regionview_from_click (Selection::Operation op = Selection::Set, bool no_track_remove=false);
+
+ bool set_selected_control_point_from_click (bool press, Selection::Operation op = Selection::Set, bool with_undo = true, bool no_remove=false);
+ bool set_selected_track_from_click (bool press, Selection::Operation op = Selection::Set, bool with_undo = true, bool no_remove=false);
+ bool set_selected_regionview_from_click (bool press, Selection::Operation op = Selection::Set, bool no_track_remove=false);
+
void set_selected_regionview_from_region_list (ARDOUR::Region& region, Selection::Operation op = Selection::Set);
bool set_selected_regionview_from_map_event (GdkEventAny*, StreamView*, ARDOUR::Region*);
void collect_new_region_view (AudioRegionView *);
void start_grab (GdkEvent*, Gdk::Cursor* cursor = 0);
bool end_grab (ArdourCanvas::Item*, GdkEvent*);
+ void swap_grab (ArdourCanvas::Item*, Gdk::Cursor* cursor, uint32_t time);
Gtk::Menu fade_context_menu;
void popup_fade_context_menu (int, int, ArdourCanvas::Item*, ItemType);
/* lets see if we can link it into the session */
linked_path = session->sound_dir();
- linked_path += PBD::basename (path);
+ linked_path += Glib::path_get_basename (path);
if (link (path.c_str(), linked_path.c_str()) == 0) {
}
last_autoscroll_direction = autoscroll_direction;
- drag_info.last_pointer_frame = drag_info.current_pointer_frame;
}
gint
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
- cerr << "here\n";
// track_canvas.w2c(event->key.x, event->key.y, *pcx, *pcy);
break;
default:
}
}
-bool
-Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
+void
+Editor::button_selection (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
- jack_nframes_t where = event_frame (event, 0, 0);
-
- track_canvas.grab_focus();
-
- if (session && session->actively_recording()) {
- return true;
- }
+ bool commit;
+ bool c1;
+ bool c2;
/* in object/audition/timefx mode, any button press sets
the selection if the object can be selected. this is a
bit of hack, because we want to avoid this if the
mouse operation is a region alignment.
- */
-
- if (((mouse_mode == MouseObject) ||
- (mouse_mode == MouseAudition && item_type == RegionItem) ||
- (mouse_mode == MouseTimeFX && item_type == RegionItem)) &&
- event->type == GDK_BUTTON_PRESS &&
- event->button.button <= 3) {
-
- AudioRegionView* rv;
- ControlPoint* cp;
-
- /* not dbl-click or triple-click */
- switch (item_type) {
- case RegionItem:
- set_selected_regionview_from_click (Keyboard::selection_type (event->button.state), true);
- break;
-
- case AudioRegionViewNameHighlight:
- case AudioRegionViewName:
- if ((rv = static_cast<AudioRegionView *> (item->get_data ("regionview"))) != 0) {
- set_selected_regionview_from_click (Keyboard::selection_type (event->button.state), true);
- }
- break;
-
- case GainAutomationControlPointItem:
- case PanAutomationControlPointItem:
- case RedirectAutomationControlPointItem:
- if ((cp = static_cast<ControlPoint *> (item->get_data ("control_point"))) != 0) {
- set_selected_control_point_from_click (Keyboard::selection_type (event->button.state), false);
- }
- break;
+ note: not dbl-click or triple-click
+ */
- case StreamItem:
- set_selected_track_from_click (Keyboard::selection_type (event->button.state), true, true);
- break;
+ if (((mouse_mode != MouseObject) &&
+ (mouse_mode != MouseAudition || item_type != RegionItem) &&
+ (mouse_mode != MouseTimeFX || item_type != RegionItem)) ||
+ (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE || event->button.button > 3)) {
+
+ return;
+ }
+
+ Selection::Operation op = Keyboard::selection_type (event->button.state);
+ bool press = (event->type == GDK_BUTTON_PRESS);
- case AutomationTrackItem:
- break;
+ begin_reversible_command (_("select on click"));
- default:
- break;
- }
+ switch (item_type) {
+ case RegionItem:
+ c1 = set_selected_track_from_click (press, op, true, true);
+ c2 = set_selected_regionview_from_click (press, op, true);
+ commit = (c1 || c2);
+ break;
+
+ case AudioRegionViewNameHighlight:
+ case AudioRegionViewName:
+ c1 = set_selected_track_from_click (press, op, true, true);
+ c2 = set_selected_regionview_from_click (press, op, true);
+ commit = (c1 || c2);
+ break;
+
+ case GainAutomationControlPointItem:
+ case PanAutomationControlPointItem:
+ case RedirectAutomationControlPointItem:
+ c1 = set_selected_track_from_click (press, op, true, true);
+ c2 = set_selected_control_point_from_click (press, op, false);
+ commit = (c1 || c2);
+ break;
+
+ case StreamItem:
+ commit = set_selected_track_from_click (press, op, true, true);
+ break;
+
+ case AutomationTrackItem:
+ commit = set_selected_track_from_click (press, op, true, true);
+ break;
+
+ default:
+ break;
}
-
+
#define SELECT_TRACK_FROM_CANVAS_IN_RANGE_MODE
#ifdef SELECT_TRACK_FROM_CANVAS_IN_RANGE_MODE
/* in range mode, button 1/2/3 press potentially selects a track */
event->type == GDK_BUTTON_PRESS &&
event->button.button <= 3) {
- AudioRegionView* rv;
-
switch (item_type) {
case StreamItem:
case RegionItem:
case AutomationTrackItem:
- set_selected_track_from_click (Keyboard::selection_type (event->button.state), true, true);
+ commit = set_selected_track_from_click (press, op, true, true);
break;
- case AudioRegionViewNameHighlight:
- case AudioRegionViewName:
- rv = reinterpret_cast<AudioRegionView *> (item->get_data ("regionview"));
default:
break;
}
}
#endif
+ if (commit) {
+ commit_reversible_command ();
+ }
+}
+
+bool
+Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
+{
+ jack_nframes_t where = event_frame (event, 0, 0);
+
+ track_canvas.grab_focus();
+ if (session && session->actively_recording()) {
+ return true;
+ }
+
+ button_selection (item, event, item_type);
+
if (drag_info.item == 0 &&
(Keyboard::is_delete_event (&event->button) ||
Keyboard::is_context_menu_event (&event->button) ||
start_range_markerbar_op (item, event, CreateRangeMarker);
return true;
break;
+
case TransportMarkerBarItem:
start_range_markerbar_op (item, event, CreateTransportMarker);
return true;
break ;
/* </CMT Additions> */
+ case MarkerBarItem:
+
+ break;
+
default:
break;
}
}
}
+ button_selection (item, event, item_type);
+
/* edit events get handled here */
if (drag_info.item == 0 && Keyboard::is_edit_event (&event->button)) {
if (!from_autoscroll && drag_info.item) {
/* item != 0 is the best test i can think of for dragging.
*/
- if (!drag_info.move_threshold_passsed) {
+ if (!drag_info.move_threshold_passed) {
- drag_info.move_threshold_passsed = (abs ((int) (drag_info.current_pointer_x - drag_info.grab_x)) > 4);
+ drag_info.move_threshold_passed = (abs ((int) (drag_info.current_pointer_x - drag_info.grab_x)) > 4);
// and change the initial grab loc/frame if this drag info wants us to
- if (drag_info.want_move_threshold && drag_info.move_threshold_passsed) {
+ if (drag_info.want_move_threshold && drag_info.move_threshold_passed) {
drag_info.grab_frame = drag_info.current_pointer_frame;
drag_info.grab_x = drag_info.current_pointer_x;
drag_info.grab_y = drag_info.current_pointer_y;
handled:
track_canvas_motion (event);
+ // drag_info.last_pointer_frame = drag_info.current_pointer_frame;
return true;
not_handled:
drag_info.cumulative_x_drag = 0;
drag_info.cumulative_y_drag = 0;
drag_info.first_move = true;
- drag_info.move_threshold_passsed = false;
+ drag_info.move_threshold_passed = false;
drag_info.want_move_threshold = false;
drag_info.pointer_frame_offset = 0;
drag_info.brushing = false;
}
}
+void
+Editor::swap_grab (ArdourCanvas::Item* new_item, Gdk::Cursor* cursor, uint32_t time)
+{
+ drag_info.item->ungrab (0);
+ drag_info.item = new_item;
+
+ if (cursor == 0) {
+ cursor = grabber_cursor;
+ }
+
+ drag_info.item->grab (Gdk::POINTER_MOTION_MASK|Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK, *cursor, time);
+}
+
bool
Editor::end_grab (ArdourCanvas::Item* item, GdkEvent* event)
{
bool is_start;
bool move_both = false;
+
jack_nframes_t newframe;
if (drag_info.pointer_frame_offset <= (long) drag_info.current_pointer_frame) {
newframe = drag_info.current_pointer_frame - drag_info.pointer_frame_offset;
else {
newframe = 0;
}
-
+
jack_nframes_t next = newframe;
if (!Keyboard::modifier_state_contains (event->button.state, Keyboard::snap_modifier())) {
snap_to (newframe, 0, true);
}
- if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) return;
+ if (drag_info.current_pointer_frame == drag_info.last_pointer_frame) {
+ return;
+ }
/* call this to find out if its the start or end */
bool is_start;
-
begin_reversible_command ( _("move marker") );
session->add_undo( session->locations()->get_memento() );
return;
}
- /* this is committed in the grab finished callback. */
-
- begin_reversible_command (_("Drag region copy"));
-
- /* duplicate the region(s) */
-
- vector<AudioRegionView*> new_regionviews;
-
- set<Playlist*> affected_playlists;
- pair<set<Playlist*>::iterator,bool> insert_result;
-
- for (list<AudioRegionView*>::const_iterator i = selection->audio_regions.by_layer().begin(); i != selection->audio_regions.by_layer().end(); ++i) {
- AudioRegionView* rv;
-
- rv = (*i);
-
- Playlist* to_playlist = rv->region.playlist();
- AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(&rv->get_time_axis_view());
-
- insert_result = affected_playlists.insert (to_playlist);
- if (insert_result.second) {
- session->add_undo (to_playlist->get_memento ());
- }
-
- latest_regionview = 0;
-
- sigc::connection c = atv->view->AudioRegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
-
- /* create a new region with the same name.
- */
-
- AudioRegion* newregion = new AudioRegion (rv->region);
-
- /* if the original region was locked, we don't care */
-
- newregion->set_locked (false);
-
- to_playlist->add_region (*newregion, (jack_nframes_t) (rv->region.position() * atv->get_diskstream()->speed()));
-
- c.disconnect ();
-
- if (latest_regionview) {
- new_regionviews.push_back (latest_regionview);
- }
- }
-
- if (new_regionviews.empty()) {
- return;
- }
-
- /* reset selection to new regionviews */
-
- selection->set (new_regionviews);
-
- /* reset drag_info data to reflect the fact that we are dragging the copies */
-
- drag_info.data = new_regionviews.front();
- drag_info.item = new_regionviews.front()->get_canvas_group ();
-
drag_info.copy = true;
- drag_info.motion_callback = &Editor::region_drag_motion_callback;
- drag_info.finished_callback = &Editor::region_drag_finished_callback;
+ drag_info.item = item;
+ drag_info.data = clicked_regionview;
start_grab(event);
drag_info.pointer_frame_offset = drag_info.grab_frame - drag_info.last_frame_position;
// we want a move threshold
drag_info.want_move_threshold = true;
-
- show_verbose_time_cursor (drag_info.last_frame_position, 10);
-
- //begin_reversible_command (_("copy region(s)"));
+ drag_info.motion_callback = &Editor::region_drag_motion_callback;
+ drag_info.finished_callback = &Editor::region_drag_finished_callback;
}
void
vector<int32_t> height_list(512) ;
vector<int32_t>::iterator j;
+ show_verbose_time_cursor (drag_info.last_frame_position, 10);
+
+ if (drag_info.copy && drag_info.move_threshold_passed && drag_info.want_move_threshold) {
+
+ drag_info.want_move_threshold = false; // don't copy again
+
+ /* this is committed in the grab finished callback. */
+
+ begin_reversible_command (_("Drag region copy"));
+
+ /* duplicate the region(s) */
+
+ vector<AudioRegionView*> new_regionviews;
+
+ set<Playlist*> affected_playlists;
+ pair<set<Playlist*>::iterator,bool> insert_result;
+
+ for (list<AudioRegionView*>::const_iterator i = selection->audio_regions.by_layer().begin(); i != selection->audio_regions.by_layer().end(); ++i) {
+ AudioRegionView* rv;
+
+ rv = (*i);
+
+ Playlist* to_playlist = rv->region.playlist();
+ AudioTimeAxisView* atv = dynamic_cast<AudioTimeAxisView*>(&rv->get_time_axis_view());
+
+ insert_result = affected_playlists.insert (to_playlist);
+ if (insert_result.second) {
+ session->add_undo (to_playlist->get_memento ());
+ }
+
+ latest_regionview = 0;
+
+ sigc::connection c = atv->view->AudioRegionViewAdded.connect (mem_fun(*this, &Editor::collect_new_region_view));
+
+ /* create a new region with the same name.
+ */
+
+ AudioRegion* newregion = new AudioRegion (rv->region);
+
+ /* if the original region was locked, we don't care */
+
+ newregion->set_locked (false);
+
+ to_playlist->add_region (*newregion, (jack_nframes_t) (rv->region.position() * atv->get_diskstream()->speed()));
+
+ c.disconnect ();
+
+ if (latest_regionview) {
+ new_regionviews.push_back (latest_regionview);
+ }
+ }
+
+ if (new_regionviews.empty()) {
+ return;
+ }
+
+ /* reset selection to new regionviews */
+
+ selection->set (new_regionviews);
+
+ /* reset drag_info data to reflect the fact that we are dragging the copies */
+
+ drag_info.data = new_regionviews.front();
+ swap_grab (new_regionviews.front()->get_canvas_group (), 0, event->motion.time);
+ }
+
/* Which trackview is this ? */
TimeAxisView* tvp = trackview_by_y_position (drag_info.current_pointer_y);
the region would be if we moved it by that much.
*/
- if (drag_info.move_threshold_passsed) {
+ if (drag_info.move_threshold_passed) {
if ((int32_t)drag_info.current_pointer_frame > drag_info.pointer_frame_offset) {
/* XXX fix this to compute min/sec properly */
session->smpte_duration (end - start, smpte);
secs = smpte.seconds + ((float) smpte.frames / session->smpte_frames_per_second);
- snprintf (buf, sizeof (buf), "%02ld:%02ld:%.4f", smpte.hours, smpte.minutes, secs);
+ snprintf (buf, sizeof (buf), "%02" PRId32 ":%02" PRId32 ":%.4f", smpte.hours, smpte.minutes, secs);
break;
default:
switch (op) {
case CreateSelection:
-
if (Keyboard::modifier_state_equals (event->button.state, Keyboard::Shift)) {
drag_info.copy = true;
} else {
break;
case SelectionStartTrim:
- clicked_trackview->order_selection_trims (item, true);
+ if (clicked_trackview) {
+ clicked_trackview->order_selection_trims (item, true);
+ }
start_grab (event, trimmer_cursor);
start = selection->time[clicked_selection].start;
drag_info.pointer_frame_offset = drag_info.grab_frame - start;
break;
case SelectionEndTrim:
- clicked_trackview->order_selection_trims (item, false);
+ if (clicked_trackview) {
+ clicked_trackview->order_selection_trims (item, false);
+ }
start_grab (event, trimmer_cursor);
end = selection->time[clicked_selection].end;
drag_info.pointer_frame_offset = drag_info.grab_frame - end;
void
Editor::start_range_markerbar_op (ArdourCanvas::Item* item, GdkEvent* event, RangeMarkerOp op)
{
-
if (session == 0) {
return;
}
}
/* first drag: Either add to the selection
- or create a new selection->
+ or create a new selection.
*/
if (drag_info.first_move) {
break;
}
} else {
- /* just a click, no pointer movement.*/
+ /* just a click, no pointer movement. remember that context menu stuff was handled elsewhere */
if (Keyboard::no_modifier_keys_pressed (&event->button)) {
- // nothing yet
+ jack_nframes_t start;
+ jack_nframes_t end;
+ start = session->locations()->first_mark_before (drag_info.grab_frame);
+ end = session->locations()->first_mark_after (drag_info.grab_frame);
+
+ if (end == max_frames) {
+ end = session->current_end_frame ();
+ }
+
+ if (start == 0) {
+ start = session->current_start_frame ();
+ }
+
+ switch (mouse_mode) {
+ case MouseObject:
+ /* find the two markers on either side and then make the selection from it */
+ cerr << "select between " << start << " .. " << end << endl;
+ select_all_within (start, end, 0.0f, FLT_MAX, Selection::Set);
+ break;
+
+ case MouseRange:
+ /* find the two markers on either side of the click and make the range out of it */
+ selection->set (0, start, end);
+ break;
+
+ default:
+ break;
+ }
}
}
#include <string>
#include <ardour/tempo.h>
-#include <ardour/smpte.h>
#include <gtkmm2ext/gtk_ui.h>
#include "editor.h"
if ((smpte.subframes % mark_modulo) == 0) {
if (smpte.subframes == 0) {
(*marks)[n].style = GtkCustomRulerMarkMajor;
- snprintf (buf, sizeof(buf), "%s%02ld:%02ld:%02ld:%02ld", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
+ snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
} else {
(*marks)[n].style = GtkCustomRulerMarkMinor;
- snprintf (buf, sizeof(buf), ".%02ld", smpte.subframes);
+ snprintf (buf, sizeof(buf), ".%02u", smpte.subframes);
}
} else {
snprintf (buf, sizeof(buf)," ");
(*marks)[n].style = GtkCustomRulerMarkMinor;
(*marks)[n].position = pos;
}
- snprintf (buf, sizeof(buf), "%s%02ld:%02ld:%02ld:%02ld", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
+ snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
} else {
snprintf (buf, sizeof(buf)," ");
(*marks)[n].style = GtkCustomRulerMarkMicro;
} else {
(*marks)[n].style = GtkCustomRulerMarkMinor;
}
- snprintf (buf, sizeof(buf), "%s%02ld:%02ld:%02ld:%02ld", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
+ snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
} else {
snprintf (buf, sizeof(buf)," ");
(*marks)[n].style = GtkCustomRulerMarkMicro;
session->smpte_to_sample(smpte, pos, true /* use_offset */, false /* use_subframes */ );
if ((smpte.hours % mark_modulo) == 0) {
(*marks)[n].style = GtkCustomRulerMarkMajor;
- snprintf (buf, sizeof(buf), "%s%02ld:%02ld:%02ld:%02ld", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
+ snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
} else {
snprintf (buf, sizeof(buf)," ");
(*marks)[n].style = GtkCustomRulerMarkMicro;
if ((smpte.frames % mark_modulo) == 0) {
(*marks)[n].style = GtkCustomRulerMarkMajor;
(*marks)[n].position = pos;
- snprintf (buf, sizeof(buf), "%s%02ld:%02ld:%02ld:%02ld", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
+ snprintf (buf, sizeof(buf), "%s%02u:%02u:%02u:%02u", smpte.negative ? "-" : "", smpte.hours, smpte.minutes, smpte.seconds, smpte.frames);
} else {
snprintf (buf, sizeof(buf)," ");
(*marks)[n].style = GtkCustomRulerMarkMicro;
#include <samplerate.h>
#include <pbd/convert.h>
-#include <pbd/dirname.h>
#include <pbd/xml++.h>
#include <gtkmm2ext/utils.h>
// directory needs to exist and be writable
- string dirpath = PBD::dirname (filepath);
+ string dirpath = Glib::path_get_dirname (filepath);
if (::access (dirpath.c_str(), W_OK) != 0) {
string txt = _("Cannot write file in: ") + dirpath;
MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
#include <ardour/audioengine.h>
#include <ardour/sndfile_helpers.h>
-#include <pbd/dirname.h>
-
#include "ardour_ui.h"
#include "export_range_markers_dialog.h"
}
// directory needs to exist and be writable
- string dirpath = PBD::dirname (filepath);
+ string dirpath = Glib::path_get_dirname (filepath);
if (::access (dirpath.c_str(), W_OK) != 0) {
string txt = _("Cannot write file in: ") + dirpath;
MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
FFTGraph::setWindowSize(int windowSize)
{
if (_a_window) {
- LockMonitor lm (_a_window->track_list_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_a_window->track_list_lock);
setWindowSize_internal(windowSize);
} else {
setWindowSize_internal(windowSize);
void
FFTGraph::redraw()
{
- LockMonitor lm (_a_window->track_list_lock, __LINE__, __FILE__ );
+ Glib::Mutex::Lock lm (_a_window->track_list_lock);
draw_scales(get_window());
typedef Glib::RefPtr<Gnome::Glade::Xml> GladeRef;
/**
- * This is the base class for all glade factories so that the same domain
- * is used.
- */
+ This is the base class for all glade
+ factories so that the same domain is
+ used.
+*/
class GladeFactory {
protected:
{
GtkWidget *widget;
GdkGC *gc, *bg_gc;
- GdkFont *font;
gint i;
GtkCustomRulerMark *marks;
gint xthickness;
gc = widget->style->fg_gc[GTK_STATE_NORMAL];
bg_gc = widget->style->bg_gc[GTK_STATE_NORMAL];
- font = gtk_style_get_font(widget->style);
layout = gtk_widget_create_pango_layout (widget, "012456789");
pango_layout_get_extents (layout, &ink_rect, &logical_rect);
gtk_widget_queue_draw (GTK_WIDGET (ruler));
}
-/** Retrieves values indicating the range and current position of a #GtkCustomRuler.
- * See gtk_custom_ruler_set_range().
- *
- * @param ruler: a #GtkCustomRuler
- * @param lower: location to store lower limit of the ruler, or %NULL
- * @param upper: location to store upper limit of the ruler, or %NULL
- * @param position: location to store the current position of the mark on the ruler, or %NULL
- * @param max_size: location to store the maximum size of the ruler used when calculating
+/**
+ * gtk_custom_ruler_get_range:
+ * @ruler: a #GtkCustomRuler
+ * @lower: location to store lower limit of the ruler, or %NULL
+ * @upper: location to store upper limit of the ruler, or %NULL
+ * @position: location to store the current position of the mark on the ruler, or %NULL
+ * @max_size: location to store the maximum size of the ruler used when calculating
* the space to leave for the text, or %NULL.
- */
+ *
+ * Retrieves values indicating the range and current position of a #GtkCustomRuler.
+ * See gtk_custom_ruler_set_range().
+ **/
void
gtk_custom_ruler_get_range (GtkCustomRuler *ruler,
gdouble *lower,
}
}
-/** * Retrieves the current policy values for the horizontal and vertical
+/**
+ * gtk_scrolled_window_get_policy:
+ * @scrolled_window: a #GtkScrolledWindow
+ * @hscrollbar_policy: location to store the policy for the horizontal scrollbar, or %NULL.
+ * @vscrollbar_policy: location to store the policy for the horizontal scrollbar, or %NULL.
+ *
+ * Retrieves the current policy values for the horizontal and vertical
* scrollbars. See gtk_scrolled_window_set_policy().
- *
- * @param scrolled_window a GtkScrolledWindow
- * @param hscrollbar_policy location to store the policy for the horizontal scrollbar, or %NULL.
- * @param vscrollbar_policy location to store the policy for the horizontal scrollbar, or %NULL.
- */
+ **/
void
gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,
GtkPolicyType *hscrollbar_policy,
}
}
-/** Gets the placement of the scrollbars for the scrolled window.
- * See gtk_scrolled_window_set_placement().
+/**
+ * gtk_scrolled_window_get_placement:
+ * @scrolled_window: a #GtkScrolledWindow
*
- * @param scrolled_window a GtkScrolledWindow
- * \return the current placement value.
+ * Gets the placement of the scrollbars for the scrolled window. See
+ * gtk_scrolled_window_set_placement().
+ *
+ * Return value: the current placement value.
**/
GtkCornerType
gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window)
return scrolled_window->window_placement;
}
-/** Changes the type of shadow drawn around the contents of \a scrolled_window.
- * @param scrolled_window a GtkScrolledWindow
- * @param type kind of shadow to draw around scrolled window contents
- */
+/**
+ * gtk_scrolled_window_set_shadow_type:
+ * @scrolled_window: a #GtkScrolledWindow
+ * @type: kind of shadow to draw around scrolled window contents
+ *
+ * Changes the type of shadow drawn around the contents of
+ * @scrolled_window.
+ *
+ **/
void
gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,
GtkShadowType type)
}
}
-/** Gets the shadow type of the scrolled window.
- * See gtk_scrolled_window_set_shadow_type().
+/**
+ * gtk_scrolled_window_get_shadow_type:
+ * @scrolled_window: a #GtkScrolledWindow
*
- * @param scrolled_window a GtkScrolledWindow
- * \return the current shadow type
- */
+ * Gets the shadow type of the scrolled window. See
+ * gtk_scrolled_window_set_shadow_type().
+ *
+ * Return value: the current shadow type
+ **/
GtkShadowType
gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)
{
gtk_container_add (GTK_CONTAINER (viewport), child);
}
-/** Gets the spacing between the scrolled window's scrollbars and
- * the scrolled widget. Used by GtkCombo.
- *
- * @param scrolled_window: a scrolled window
- * \return the spacing, in pixels.
+/**
+ * _gtk_scrolled_window_get_spacing:
+ * @scrolled_window: a scrolled window
+ *
+ * Gets the spacing between the scrolled window's scrollbars and
+ * the scrolled widget. Used by GtkCombo
+ *
+ * Return value: the spacing, in pixels.
**/
gint
_gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window)
/**
* Send a message indicating that an ImageFrameView has been renamed
*
- * @param new_id the renamed item's new ID
- * @param old_id the renamed item's old ID
- * @param src the identity of the object that initiated the change
* @param item the ImageFrameView which has been renamed
+ * @param src the identity of the object that initiated the change
+ * @param item the renamed item
*/
void send_imageframe_view_renamed(const string & new_id, const string & old_id, void* src, ImageFrameView* item) ;
*
* @param h the TrackHeight value to set
*/
- virtual void set_height(TimeAxisView::TrackHeight h) ;
+ virtual void set_height(TimeAxisView::TrackHeight) ;
/**
* Sets the number of samples per unit that are used.
*
* @param height the new height
*/
- int set_item_heights(gdouble height) ;
+ int set_item_heights(gdouble) ;
/**
* Sets the current samples per unit.
*
* @param color the new base color
*/
- void apply_item_color(Gdk::Color& color) ;
+ void apply_item_color(Gdk::Color&) ;
//---------------------------------------------------------------------------------------//
* the new ImageFrameView is returned
*
* @param item_id the unique id of the new item
+ * @param image_id the id/name of the image data we are usin
* @param start the position the new item should be placed upon the time line
* @param duration the duration the new item should be placed upon the timeline
* @param rgb_data the rgb data of the image
* @param num_channels the number of channles within the rgb_data
* @param src the identity of the object that initiated the change
*/
- ImageFrameView* add_imageframe_item(const string & item_id, jack_nframes_t start, jack_nframes_t duration,
- unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src) ;
+ ImageFrameView* add_imageframe_item(const string & item_id, jack_nframes_t start, jack_nframes_t duration, unsigned char* rgb_data, uint32_t width, uint32_t height, uint32_t num_channels, void* src) ;
/**
* Returns the named ImageFrameView or 0 if the named view does not exist on this view helper
* if ifv is not upon this TimeAxis, this method takes no action
*
* @param ifv the ImageFrameView to remove
- * @param src the identity of the object that initiated the change
*/
- void remove_imageframe_item(ImageFrameView* ifv, void* src) ;
+ void remove_imageframe_item(ImageFrameView*, void* src) ;
//---------------------------------------------------------------------------------------//
*
* @param height the new height
*/
- int set_height(gdouble height) ;
+ int set_height(gdouble) ;
/**
* Sets the position of this view helper on the canvas
*
* @param color the new base color
*/
- void apply_color (Gdk::Color& color) ;
+ void apply_color (Gdk::Color&) ;
//---------------------------------------------------------------------------------------//
// Child ImageFrameTimeAxisGroup Accessors/Mutators
* Removes the specified ImageFrameTimeAxisGroup from the list of ImageFrameTimeAxisGroups upon this TimeAxis.
*
* @param iftag the ImageFrameView to remove
- * @param src the identity of the object that initiated the change
*/
void remove_imageframe_group(ImageFrameTimeAxisGroup* iftag, void* src) ;
/**
* Sets the currently selected group upon this time axis
*
- * @param iftag the item to set selected
+ * @param ifv the item to set selected
*/
void set_selected_imageframe_group(ImageFrameTimeAxisGroup* iftag) ;
* @param tv the time axis view that this item is to be placed upon
* @param group the ImageFrameGroup that this item is a member of
* @param spu the current samples per canvas unit
- * @param base_color the base color of this item
* @param start the start frame ogf this item
* @param duration the duration of this item
* @param rgb_data the rgb data of the image
* @param num_channels the number of color channels within rgb_data
*/
ImageFrameView(const std::string & item_id,
- ArdourCanvas::Group *parent,
+ ArdourCanvas::Group *parent,
ImageFrameTimeAxis *tv,
ImageFrameTimeAxisGroup* group,
double spu,
- Gdk::Color& base_color,
+ Gdk::Color& base_color,
jack_nframes_t start,
jack_nframes_t duration,
unsigned char* rgb_data,
#include <gtkmm/messagedialog.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <ardour/io.h>
#include <ardour/route.h>
TreeView *selected_port_tview = 0;
{
- LockMonitor lm (port_display_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_display_lock);
Port *port;
uint32_t limit;
if (Keyboard::is_delete_event (event)) {
Port* port;
{
- LockMonitor lm (port_display_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_display_lock);
port = static_cast<Port *> (treeview->get_data (_("port")));
switch.
*/
- LockMonitor lm (port_display_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_display_lock);
Port* port = reinterpret_cast<Port *> (tview->get_data (_("port")));
if (port != selected_port) {
#endif
#include <string>
+
+#include <glibmm/thread.h>
+
#include <gtkmm/box.h>
#include <gtkmm/frame.h>
#include <gtkmm/button.h>
#include <ardour_dialog.h>
+
namespace ARDOUR {
class IO;
class Session;
Gtk::Button clear_connections_button;
Gtk::ScrolledWindow port_display_scroller;
- PBD::Lock port_display_lock;
+ Glib::Mutex port_display_lock;
slist<Gtk::TreeView *> port_displays;
void display_ports ();
ARDOUR::AudioEngine *engine;
vector<Glib::ustring> null_file_list;
+ // needs a better home.
+ Glib::thread_init();
+
gtk_set_locale ();
(void) bindtextdomain (PACKAGE, LOCALEDIR);
* the new MarkerView is returned
*
* @param ifv the ImageFrameView that the new item is marking up
- * @param mark_type the text to be displayed uopn the new marker item
+ * @param mark_text the text to be displayed uopn the new marker item
* @param mark_id the unique id of the new item
* @param start the position the new item should be placed upon the time line
- * @param dur the duration the new item should be placed upon the timeline
+ * @param duration the duration the new item should be placed upon the timeline
* @param src the identity of the object that initiated the change
*/
MarkerView* add_marker_view(ImageFrameView* ifv, std::string mark_type, std::string mark_id, jack_nframes_t start, jack_nframes_t dur, void* src) ;
/**
* Removes mv from the list of MarkerView upon this TimeAxis
*
- * @param item the MarkerView to remove
+ * @param mv the MarkerView to remove
* @param src the identity of the object that initiated the change
*/
void remove_marker_view(MarkerView* item, void* src) ;
#include <gtkmm/accelmap.h>
#include <pbd/convert.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <gtkmm2ext/gtk_ui.h>
#include <gtkmm2ext/utils.h>
#include <ardour/recent_sessions.h>
#include <ardour/session.h>
-#include <pbd/basename.h>
-
#include <gtkmm/entry.h>
#include <gtkmm/filechooserbutton.h>
#include <gtkmm/spinbutton.h>
Gtk::TreeModel::Row row = *(recent_model->append());
- row[recent_columns.visible_name] = PBD::basename (fullpath);
+ row[recent_columns.visible_name] = Glib::path_get_basename (fullpath);
row[recent_columns.fullpath] = fullpath;
if (states->size() > 1) {
bool GTK_ARDOUR::use_vst = true;
bool GTK_ARDOUR::new_session = false;
char* GTK_ARDOUR::curvetest_file = 0;
-bool GTK_ARDOUR::try_hw_optimization = false;
+bool GTK_ARDOUR::try_hw_optimization = true;
using namespace GTK_ARDOUR;
ARDOUR_UI::instance()->tooltips().set_tip (pan_automation_state_button, _("Pan automation mode"));
ARDOUR_UI::instance()->tooltips().set_tip (pan_automation_style_button, _("Pan automation type"));
- set_size_request_to_display_given_text (pan_automation_state_button, X_("M"), 2, 2);
- set_size_request_to_display_given_text (pan_automation_style_button, X_("M"), 2, 2);
+ //set_size_request_to_display_given_text (pan_automation_state_button, X_("O"), 2, 2);
+ //set_size_request_to_display_given_text (pan_automation_style_button, X_("0"), 2, 2);
pan_bar_packer.set_size_request (-1, 61);
panning_viewport.set_size_request (61, 61);
panning_link_button.set_name (X_("PanningLinkButton"));
panning_link_direction_button.set_name (X_("PanningLinkDirectionButton"));
- /* the pixmap will be reset at some point, but the key thing is that
- we need a pixmap in the button just to get started.
- */
-
- Gtk::HBox* pan_button_hbox = manage (new Gtk::HBox());
-
panning_link_box.pack_start (panning_link_button, true, true);
panning_link_box.pack_start (panning_link_direction_button, true, true);
- pan_button_hbox->pack_start (panning_link_box, true, true);
- pan_button_hbox->pack_start (pan_automation_state_button, true, true);
+ panning_link_box.pack_start (pan_automation_state_button, true, true);
+ /* the pixmap will be reset at some point, but the key thing is that
+ we need a pixmap in the button just to get started.
+ */
panning_link_direction_button.add (*(manage (new Image (get_xpm("forwardblarrow.xpm")))));
panning_link_direction_button.signal_clicked().connect
pan_vbox.set_spacing (4);
pan_vbox.pack_start (panning_viewport, Gtk::PACK_SHRINK);
- pan_vbox.pack_start (*pan_button_hbox, Gtk::PACK_SHRINK);
+ pan_vbox.pack_start (panning_link_box, Gtk::PACK_SHRINK);
pack_start (pan_vbox, true, false);
switch (_io.panner().size()) {
case 0:
- panning_link_box.set_sensitive (false);
+ panning_link_direction_button.set_sensitive (false);
+ panning_link_button.set_sensitive (false);
return;
case 1:
- panning_link_box.set_sensitive (false);
+ panning_link_direction_button.set_sensitive (false);
+ panning_link_button.set_sensitive (false);
break;
default:
- panning_link_box.set_sensitive (true);
+ panning_link_direction_button.set_sensitive (true);
+ panning_link_button.set_sensitive (true);
}
uint32_t nouts = _io.n_outputs();
~VSTPluginUI ();
gint get_preferred_height ();
- bool start_updating(GdkEventAny*) {}
- bool stop_updating(GdkEventAny*) {}
+ bool start_updating(GdkEventAny*) {return false;}
+ bool stop_updating(GdkEventAny*) {return false;}
int package (Gtk::Window&);
Gtk::HBox preset_box;
Gtk::VBox vpacker;
- gboolean configure_handler (GdkEventConfigure*, GtkSocket*);
+ gboolean configure_handler (GdkEventConfigure*, Gtk::Socket*);
void save_plugin_setting ();
};
#endif
void set_valid (bool yn) { valid = yn; }
std::string get_item_name();
- void set_height (double h);
- void set_samples_per_unit (double spu);
- bool set_duration (jack_nframes_t dur, void* src);
+ void set_height (double);
+ void set_samples_per_unit (double);
+ bool set_duration (jack_nframes_t, void*);
void set_amplitude_above_axis (gdouble spp);
void store_flags ();
void set_colors ();
- void compute_colors (Gdk::Color& color);
+ void compute_colors (Gdk::Color&);
virtual void set_frame_color ();
void reset_width_dependent_items (double pixel_width);
void set_waveview_data_src();
#include <algorithm>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm2ext/stop_signal.h>
{
AudioRegionSelection::iterator i;
- cerr << "about to toggle a regionview\n";
-
if ((i = find (audio_regions.begin(), audio_regions.end(), r)) == audio_regions.end()) {
audio_regions.add (r);
- cerr << "\tadded\n";
} else {
audio_regions.erase (i);
- cerr << "\tremoved\n";
}
RegionsChanged ();
- cerr << "done\n";
+}
+
+void
+Selection::toggle (vector<AudioRegionView*>& r)
+{
+ AudioRegionSelection::iterator i;
+
+ for (vector<AudioRegionView*>::iterator x = r.begin(); x != r.end(); ++x) {
+ if ((i = find (audio_regions.begin(), audio_regions.end(), (*x))) == audio_regions.end()) {
+ audio_regions.add ((*x));
+ } else {
+ audio_regions.erase (i);
+ }
+ }
+
+ RegionsChanged ();
}
long
if (!autos.empty()) {
add (autos);
}
-
- cerr << "Selection @ " << this << " has " << points.size() << " points\n";
}
void
#include <gtkmm/box.h>
#include <gtkmm/stock.h>
-#include <pbd/basename.h>
#include <pbd/convert.h>
#include <gtkmm2ext/utils.h>
}
string result;
- _session->region_name (result, PBD::basename(srclist[0]->name()), false);
+ _session->region_name (result, Glib::path_get_basename(srclist[0]->name()), false);
AudioRegion* a_region = new AudioRegion(srclist, 0, srclist[0]->length(), result, 0, Region::DefaultFlags, false);
region_cache[path] = a_region;
}
/**
* Displays the standard LHS controls size menu for the track heights
*
- * @param when the popup activation time
+ * @parem when the popup activation time
*/
void popup_size_menu(guint32 when);
*
* @param pos the new position
* @param src the identity of the object that initiated the change
- * @param delta ignored
* @return true if the position change was a success, false otherwise
*/
virtual bool set_position(jack_nframes_t pos, void* src, double* delta = 0) ;
/**
* Sets the minimu duration that this item may be set to
*
- * @param dur the minimum duration that this item may be set to
+ * @param the minimum duration that this item may be set to
* @param src the identity of the object that initiated the change
*/
virtual void set_min_duration(jack_nframes_t dur, void* src) ;
* @param parent the parent canvas group
* @param tv the TimeAxisView we are going to be added to
* @param spu samples per unit
- * @param base_color base color
+ * @param base_color
* @param start the start point of this item
* @param duration the duration of this item
- * @param v visibility
*/
- TimeAxisViewItem(const std::string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu,
- Gdk::Color& base_color, jack_nframes_t start, jack_nframes_t duration, Visibility v = Visibility (0));
+ TimeAxisViewItem(const std::string & it_name, ArdourCanvas::Group& parent, TimeAxisView& tv, double spu, Gdk::Color& base_color,
+ jack_nframes_t start, jack_nframes_t duration, Visibility v = Visibility (0));
/**
* Calculates some contrasting color for displaying various parts of this item, based upon the base color
*/
#include <fst.h>
-#include <gdk/gdkx.h>
-#include <X11/Xlib.h>
#include <ardour/insert.h>
#include <ardour/vst_plugin.h>
#include "plugin_ui.h"
-#include "prompter.h"
-#include "i18n.h"
+#include <gdk/gdkx.h>
using namespace Gtk;
using namespace ARDOUR;
{
/* for GTK+2, remove this: you cannot add to a realized socket */
- socket.realize ();
+ //socket.realize ();
/* forward configure events to plugin window */
- win.signal_configure_event().connect (bind (mem_fun (*this, &VSTPluginUI::configure_handler), socket.gobj()));
+ win.signal_configure_event().connect (bind (mem_fun (*this, &VSTPluginUI::configure_handler), &socket));
/* XXX in GTK2, use add_id() instead of steal, although add_id()
assumes that the window's owner understands the XEmbed protocol.
*/
- socket.steal (fst_get_XID (vst.fst()));
+ socket.add_id (fst_get_XID (vst.fst()));
return 0;
}
gboolean
-VSTPluginUI::configure_handler (GdkEventConfigure* ev, GtkSocket *socket)
+VSTPluginUI::configure_handler (GdkEventConfigure* ev, Gtk::Socket *socket)
{
XEvent event;
gint x, y;
- if (socket->plug_window == NULL) {
+ if (socket->gobj() == NULL) {
return FALSE;
}
event.xconfigure.type = ConfigureNotify;
- event.xconfigure.event = GDK_WINDOW_XWINDOW (socket->plug_window);
- event.xconfigure.window = GDK_WINDOW_XWINDOW (socket->plug_window);
+ event.xconfigure.event = GDK_WINDOW_XWINDOW (socket->get_window()->gobj());
+ event.xconfigure.window = GDK_WINDOW_XWINDOW (socket->get_window()->gobj());
/* The ICCCM says that synthetic events should have root relative
* coordinates. We still aren't really ICCCM compliant, since
* we don't send events when the real toplevel is moved.
*/
gdk_error_trap_push ();
- gdk_window_get_origin (socket->plug_window, &x, &y);
+ gdk_window_get_origin (socket->get_window()->gobj(), &x, &y);
gdk_error_trap_pop ();
event.xconfigure.x = x;
event.xconfigure.override_redirect = False;
gdk_error_trap_push ();
- XSendEvent (GDK_WINDOW_XDISPLAY (socket->plug_window),
- GDK_WINDOW_XWINDOW (socket->plug_window),
+ XSendEvent (GDK_WINDOW_XDISPLAY (socket->get_window()->gobj()),
+ GDK_WINDOW_XWINDOW (socket->get_window()->gobj()),
False, StructureNotifyMask, &event);
// gdk_display_sync (GDK_WINDOW_XDISPLAY (socket->plug_window));
gdk_error_trap_pop ();
location.cc
mtc_slave.cc
named_selection.cc
-osc.cc
panner.cc
pcm_utils.cc
playlist.cc
arch_specific_objects = [ ]
+osc_files = [ 'osc.cc' ]
vst_files = [ 'vst_plugin.cc', 'session_vst.cc' ]
coreaudio_files = [ 'coreaudio_source.cc' ]
extra_sources = [ ]
if ardour['VST']:
extra_sources += vst_files
+if ardour['LIBLO']:
+ extra_sources += osc_files
+
ardour.Append(CCFLAGS="-D_REENTRANT -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE")
ardour.Append(CXXFLAGS="-DDATA_DIR=\\\""+final_prefix+"/share\\\"")
ardour.Append(CXXFLAGS="-DMODULE_DIR=\\\""+final_prefix+"/lib\\\"")
if conf.CheckCHeader('/System/Library/Frameworks/CoreMIDI.framework/Headers/CoreMIDI.h'):
ardour.Append(LINKFLAGS="-framework CoreMIDI")
-if conf.CheckCHeader('/System/Library/Frameworks/AudioToolbox.framework/Headers/ExtendedAudioFile.h'):
+if conf.CheckCHeader('/System/Library/Frameworks/AudioToolbox.framework/Headers/ExtendedAudioFile.h') and ardour['COREAUDIO'] == 1:
ardour.Append(CXXFLAGS="-DHAVE_COREAUDIO")
ardour.Append(LINKFLAGS="-framework AudioToolbox")
libraries['pbd3'],
libraries['soundtouch'],
libraries['midi++2'],
- libraries['lo'],
+ libraries['glib2'],
+ libraries['glibmm2']
])
+if ardour['LIBLO']:
+ ardour.Merge ([ libraries['lo'] ])
ardour.VersionBuild(['version.cc', 'ardour/version.h'], 'SConscript')
#include <signal.h>
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
#include <pbd/failed_constructor.h>
#include <ardour/configuration.h>
#include <ardour/types.h>
-using namespace PBD;
-
namespace MIDI {
class MachineControl;
class Port;
#include <string>
#include <sigc++/signal.h>
-#include <pthread.h>
+
+#include <glibmm/thread.h>
+
#include <ardour/ardour.h>
#include <jack/jack.h>
#include <jack/transport.h>
int start ();
bool running() const { return _running; }
- PBD::NonBlockingLock& process_lock() { return _process_lock; }
+ Glib::Mutex& process_lock() { return _process_lock; }
jack_nframes_t frame_rate();
jack_nframes_t frames_per_cycle();
ARDOUR::Session *session;
jack_client_t *_jack;
std::string jack_client_name;
- PBD::NonBlockingLock port_lock;
- PBD::NonBlockingLock _process_lock;
- PBD::Lock session_remove_lock;
- pthread_cond_t session_removed;
+ Glib::Mutex port_lock;
+ Glib::Mutex _process_lock;
+ Glib::Mutex session_remove_lock;
+ Glib::Cond session_removed;
bool session_remove_pending;
bool _running;
bool _has_run;
sigc::slot<int,jack_nframes_t> freewheel_action;
bool reconnect_on_halt;
int _usecs_per_cycle;
- jack_nframes_t last_meter_point;
- jack_nframes_t meter_interval;
typedef std::set<Port*> Ports;
Ports ports;
AudioRegion (SourceList &, const XMLNode&);
~AudioRegion();
- bool region_list_equivalent (const AudioRegion&);
- bool source_equivalent (const AudioRegion&);
- bool equivalent (const AudioRegion&);
- bool size_equivalent (const AudioRegion&);
+ bool region_list_equivalent (const AudioRegion&) const ;
+ bool source_equivalent (const AudioRegion&) const;
+ bool equivalent (const AudioRegion&) const;
+ bool size_equivalent (const AudioRegion&) const;
+ bool overlap_equivalent (const AudioRegion&) const;
bool speed_mismatch (float) const;
#define __ardour_auditioner_h__
#include <string>
-#include <pthread.h>
-#include <pbd/lockmonitor.h>
-#include <pbd/atomic.h>
+#include <glibmm/thread.h>
#include <ardour/ardour.h>
#include <ardour/audio_track.h>
int play_audition (jack_nframes_t nframes);
void cancel_audition () {
- atomic_set (&_active, 0);
+ g_atomic_int_set (&_active, 0);
}
- bool active() const { return atomic_read (&_active); }
+ bool active() const { return g_atomic_int_get (&_active); }
private:
AudioRegion *the_region;
#include <cmath>
#include <sigc++/signal.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/undo.h>
#include <pbd/xml++.h>
#include <ardour/ardour.h>
std::pair<AutomationList::iterator,AutomationList::iterator> control_points_adjacent (double when);
template<class T> void apply_to_points (T& obj, void (T::*method)(const AutomationList&)) {
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
(obj.*method)(*this);
}
double get_max_xval() const { return max_xval; }
double eval (double where) {
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
return unlocked_eval (where);
}
double rt_safe_eval (double where, bool& ok) {
- TentativeLockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock, Glib::TRY_LOCK);
if ((ok = lm.locked())) {
return unlocked_eval (where);
};
AutomationEventList events;
- mutable PBD::NonBlockingLock lock;
+ mutable Glib::Mutex lock;
bool _frozen;
bool changed_when_thawed;
bool _dirty;
#include <vector>
#include <string>
#include <sigc++/signal.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <ardour/stateful.h>
using std::vector;
Connection (const XMLNode&);
private:
- mutable PBD::Lock port_lock;
+ mutable Glib::Mutex port_lock;
vector<PortList> _ports;
string _name;
bool _sysdep;
#include <sigc++/sigc++.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <ardour/stateful.h>
static ControlProtocolManager* _instance;
Session* _session;
- PBD::Lock protocols_lock;
+ Glib::Mutex protocols_lock;
std::list<ControlProtocol*> control_protocols;
void drop_session ();
mutable float *tmpbuf;
mutable jack_nframes_t tmpbufsize;
- mutable PBD::Lock _tmpbuf_lock;
+ mutable Glib::Mutex _tmpbuf_lock;
void init (const string &str, bool build_peak);
};
#include <sys/types.h>
#include <sigc++/signal.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/undo.h>
#include <list>
#include <algorithm>
-#include <pthread.h>
#include <ardour/automation_event.h>
namespace ARDOUR {
#include <pbd/fastlog.h>
#include <pbd/ringbufferNPT.h>
-#include <pbd/atomic.h>
+
#include <ardour/ardour.h>
#include <ardour/configuration.h>
}
void set_record_enabled (bool yn, void *src);
- bool record_enabled() const { return atomic_read (&_record_enabled); }
+ bool record_enabled() const { return g_atomic_int_get (&_record_enabled); }
void punch_in ();
void punch_out ();
AlignStyle _persistent_alignment_style;
bool first_input_change;
- PBD::NonBlockingLock state_lock;
+ Glib::Mutex state_lock;
jack_nframes_t scrub_start;
jack_nframes_t scrub_buffer_size;
};
vector<CaptureInfo*> capture_info;
- PBD::Lock capture_info_lock;
+ Glib::Mutex capture_info_lock;
void init (Flag);
#include <sigc++/signal.h>
#include <jack/jack.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
+
#include <pbd/fastlog.h>
#include <pbd/undo.h>
-#include <pbd/atomic.h>
+
#include <midi++/controllable.h>
#include <ardour/ardour.h>
}
}
- static sigc::signal<void> Meter;
+ static void update_meters();
+
+private:
+
+ static sigc::signal<void> Meter;
+ static Glib::StaticMutex m_meter_signal_lock;
+ sigc::connection m_meter_connection;
+
+public:
/* automation */
int ports_became_legal ();
private:
- mutable PBD::Lock io_lock;
+ mutable Glib::Mutex io_lock;
protected:
Session& _session;
gain_t _gain;
gain_t _effective_gain;
gain_t _desired_gain;
- PBD::NonBlockingLock declick_lock;
+ Glib::Mutex declick_lock;
vector<Port*> _outputs;
vector<Port*> _inputs;
vector<float> _peak_power;
jack_nframes_t last_automation_snapshot;
static jack_nframes_t _automation_interval;
- AutoState _gain_automation_state;
+ AutoState _gain_automation_state;
AutoStyle _gain_automation_style;
bool apply_gain_automation;
int save_automation (const string&);
int load_automation (const string&);
- PBD::NonBlockingLock automation_lock;
+ Glib::Mutex automation_lock;
/* AudioTrack::deprecated_use_diskstream_connections() needs these */
#include <map>
#include <sys/types.h>
-#include <pthread.h>
#include <sigc++/signal.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
+
#include <pbd/undo.h>
#include "ardour.h"
Location *first_location_before (jack_nframes_t);
Location *first_location_after (jack_nframes_t);
+ jack_nframes_t first_mark_before (jack_nframes_t);
+ jack_nframes_t first_mark_after (jack_nframes_t);
+
sigc::signal<void,Location*> current_changed;
sigc::signal<void> changed;
sigc::signal<void,Location*> added;
sigc::signal<void,Location*> removed;
template<class T> void apply (T& obj, void (T::*method)(LocationList&)) {
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
(obj.*method)(locations);
}
template<class T1, class T2> void apply (T1& obj, void (T1::*method)(LocationList&, T2& arg), T2& arg) {
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
(obj.*method)(locations, arg);
}
LocationList locations;
Location *current_location;
- mutable PBD::Lock lock;
+ mutable Glib::Mutex lock;
int set_current_unlocked (Location *);
void location_changed (Location*);
#define __ardour_logcurve_h__
#include <pbd/fastlog.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
namespace ARDOUR {
}
void set_length (uint32_t len) { l = len; }
- mutable PBD::NonBlockingLock lock;
+ mutable Glib::Mutex lock;
protected:
float a;
#include <sys/stat.h>
+#include <glib.h>
+
#include <sigc++/signal.h>
-#include <pbd/atomic.h>
#include <pbd/undo.h>
#include <ardour/ardour.h>
void init (bool hide);
bool holding_state () const {
- return atomic_read (&block_notifications) != 0 ||
- atomic_read (&ignore_state_changes) != 0;
+ return g_atomic_int_get (&block_notifications) != 0 ||
+ g_atomic_int_get (&ignore_state_changes) != 0;
}
/* prevent the compiler from ever generating these */
#include <map>
#include <sigc++/signal.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
+
#include <pbd/undo.h>
#include <ardour/ardour.h>
map<uint32_t,AutomationList*> parameter_automation;
set<uint32_t> visible_parameter_automation;
- mutable PBD::NonBlockingLock _automation_lock;
+ mutable Glib::Mutex _automation_lock;
void can_automate (uint32_t);
set<uint32_t> can_automate_list;
string _name;
mutable RegionEditState _first_edit;
int _frozen;
- PBD::Lock lock;
+ Glib::Mutex lock;
ARDOUR::id_t _id;
ARDOUR::Playlist* _playlist;
mutable uint32_t _read_data_count; // modified in read()
#include <map>
#include <string>
-#include <pthread.h>
-
-#include <pbd/atomic.h>
#include <pbd/fastlog.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/xml++.h>
#include <pbd/undo.h>
#include <midi++/controllable.h>
void flush_redirects ();
template<class T> void foreach_redirect (T *obj, void (T::*func)(Redirect *)) {
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
(obj->*func) (*i);
}
}
Redirect *nth_redirect (uint32_t n) {
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
RedirectList::iterator i;
for (i = _redirects.begin(); i != _redirects.end() && n; ++i, --n);
if (i == _redirects.end()) {
jack_nframes_t _roll_delay;
jack_nframes_t _own_latency;
RedirectList _redirects;
- PBD::NonBlockingRWLock redirect_lock;
+ Glib::RWLock redirect_lock;
IO *_control_outs;
- PBD::NonBlockingLock control_outs_lock;
+ Glib::Mutex control_outs_lock;
RouteGroup *_edit_group;
RouteGroup *_mix_group;
std::string _comment;
#include <sndfile.h>
+#include <glibmm/thread.h>
+
#include <pbd/error.h>
-#include <pbd/atomic.h>
-#include <pbd/lockmonitor.h>
#include <pbd/undo.h>
#include <pbd/pool.h>
#include <ardour/gain.h>
#include <ardour/io.h>
+#include <ardour/smpte.h>
+
class XMLTree;
class XMLNode;
class AEffect;
typedef list<DiskStream *> DiskStreamList;
Session::DiskStreamList disk_streams() const {
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
return diskstreams; /* XXX yes, force a copy */
}
typedef list<Route *> RouteList;
RouteList get_routes() const {
- RWLockMonitor rlock (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rlock (route_lock);
return routes; /* XXX yes, force a copy */
}
}
RecordState record_status() const {
- return (RecordState) atomic_read (&_record_status);
+ return (RecordState) g_atomic_int_get (&_record_status);
}
bool actively_recording () {
static MultiAllocSingleReleasePool pool;
};
-<<<<<<< .working
+ mutable gint butler_active;
+
//PBD::Lock midi_lock;
//pthread_t midi_thread;
//int midi_request_pipe[2];
- atomic_t butler_active;
- //RingBuffer<MIDIRequest*> midi_requests;
-/*
-=======
- Glib::Mutex midi_lock;
- pthread_t midi_thread;
- int midi_request_pipe[2];
- mutable gint butler_active;
- RingBuffer<MIDIRequest*> midi_requests;
->>>>>>> .merge-right.r579
- int start_midi_thread ();
+ //RingBuffer<MIDIRequest*> midi_requests;
+ /*int start_midi_thread ();
void terminate_midi_thread ();
void poke_midi_thread ();
static void *_midi_thread_work (void *arg);
/* disk-streams */
DiskStreamList diskstreams;
- mutable PBD::NonBlockingRWLock diskstream_lock;
+ mutable Glib::RWLock diskstream_lock;
uint32_t dstream_buffer_size;
void add_diskstream (DiskStream*);
int load_diskstreams (const XMLNode&);
/* routes stuff */
RouteList routes;
- mutable PBD::NonBlockingRWLock route_lock;
+ mutable Glib::RWLock route_lock;
void add_route (Route*);
uint32_t destructive_index;
/* REGION MANAGEMENT */
- mutable PBD::Lock region_lock;
+ mutable Glib::Mutex region_lock;
typedef map<ARDOUR::id_t,AudioRegion *> AudioRegionList;
AudioRegionList audio_regions;
/* SOURCES */
- mutable PBD::Lock source_lock;
+ mutable Glib::Mutex source_lock;
typedef std::map<id_t, Source *> SourceList;
SourceList sources;
/* PLAYLISTS */
- mutable PBD::Lock playlist_lock;
+ mutable Glib::Mutex playlist_lock;
typedef set<Playlist *> PlaylistList;
PlaylistList playlists;
PlaylistList unused_playlists;
/* NAMED SELECTIONS */
- mutable PBD::Lock named_selection_lock;
+ mutable Glib::Mutex named_selection_lock;
typedef set<NamedSelection *> NamedSelectionList;
NamedSelectionList named_selections;
vector<space_and_path> session_dirs;
vector<space_and_path>::iterator last_rr_session_dir;
uint32_t _total_free_4k_blocks;
- PBD::Lock space_lock;
+ Glib::Mutex space_lock;
static const char* sound_dir_name;
static const char* tape_dir_name;
int ensure_sound_dir (string, string&);
void refresh_disk_space ();
-<<<<<<< .working
- atomic_t _playback_load;
- atomic_t _capture_load;
- atomic_t _playback_load_min;
- atomic_t _capture_load_min;
-=======
mutable gint _playback_load;
mutable gint _capture_load;
mutable gint _playback_load_min;
mutable gint _capture_load_min;
->>>>>>> .merge-right.r579
/* I/O Connections */
typedef list<Connection *> ConnectionList;
- mutable PBD::Lock connection_lock;
+ mutable Glib::Mutex connection_lock;
ConnectionList _connections;
int load_connections (const XMLNode&);
Sample* click_emphasis_data;
jack_nframes_t click_length;
jack_nframes_t click_emphasis_length;
- mutable PBD::NonBlockingRWLock click_lock;
+ mutable Glib::RWLock click_lock;
static const Sample default_click[];
static const jack_nframes_t default_click_length;
template<class T> void
Session::foreach_connection (T *obj, void (T::*func)(Connection *))
{
- LockMonitor lm (connection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (connection_lock);
for (ConnectionList::iterator i = _connections.begin(); i != _connections.end(); i++) {
(obj->*func) (*i);
}
template<class T> void
Session::foreach_diskstream (T *obj, void (T::*func)(DiskStream&))
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); i++) {
if (!(*i)->hidden()) {
(obj->*func) (**i);
template<class T> void
Session::foreach_playlist (T *obj, void (T::*func)(Playlist *))
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); i++) {
if (!(*i)->hidden()) {
(obj->*func) (*i);
template<class T> void Session::foreach_audio_region (T *obj, void (T::*func)(AudioRegion *))
{
- LockMonitor lm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (region_lock);
for (AudioRegionList::iterator i = audio_regions.begin(); i != audio_regions.end(); i++) {
(obj->*func) ((*i).second);
}
#include <iostream>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
+
#include <ardour/session.h>
#include <ardour/route.h>
RouteList public_order;
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
public_order = routes;
}
RouteList public_order;
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
public_order = routes;
}
RouteList public_order;
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
public_order = routes;
}
template<class T> void
Session::foreach_named_selection (T& obj, void (T::*func)(NamedSelection&))
{
- LockMonitor lm (named_selection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (named_selection_lock);
for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); i++) {
(obj.*func) (**i);
}
#include <jack/jack.h>
-#include <pthread.h>
#include <sigc++/signal.h>
#include <ardour/ardour.h>
#include <midi++/parser.h>
mutable float *tmpbuf;
mutable jack_nframes_t tmpbufsize;
- mutable PBD::Lock _tmpbuf_lock;
+ mutable Glib::Mutex _tmpbuf_lock;
void init (const string &str, bool build_peak);
};
#include <vector>
#include <string>
-#include <time.h>
+#include <ctime>
#include <sigc++/signal.h>
+#include <glibmm/thread.h>
+
#include <ardour/ardour.h>
#include <ardour/stateful.h>
#include <pbd/xml++.h>
string _name;
uint32_t _use_cnt;
bool _peaks_built;
- mutable PBD::Lock _lock;
+ mutable Glib::Mutex _lock;
jack_nframes_t _length;
bool next_peak_clear_should_notify;
string peakpath;
};
static vector<Source*> pending_peak_sources;
- static PBD::Lock pending_peak_sources_lock;
+ static Glib::StaticMutex pending_peak_sources_lock;
static void queue_for_peaks (Source&);
static void clear_queue_for_peaks ();
#include <string>
#include <vector>
#include <cmath>
-#include <pthread.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/undo.h>
#include <sigc++/signal.h>
typedef vector<BBTPoint> BBTPointList;
template<class T> void apply_with_metrics (T& obj, void (T::*method)(const Metrics&)) {
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
(obj.*method)(*metrics);
}
jack_nframes_t last_bbt_when;
bool last_bbt_valid;
BBT_Time last_bbt;
- mutable PBD::Lock lock;
+ mutable Glib::Mutex lock;
void timestamp_metrics ();
#include <inttypes.h>
#include <jack/types.h>
-#include <ardour/smpte.h>
#include <map>
#if __GNUC__ < 3
Destructive
};
+ enum smpte_wrap_t {
+ smpte_wrap_none = 0,
+ smpte_wrap_frames,
+ smpte_wrap_seconds,
+ smpte_wrap_minutes,
+ smpte_wrap_hours
+ };
+
+ struct SMPTE_Time {
+ bool negative;
+ uint32_t hours;
+ uint32_t minutes;
+ uint32_t seconds;
+ uint32_t frames;
+ uint32_t subframes; // mostly not used
+
+ SMPTE_Time() {
+ negative = false;
+ hours = 0;
+ minutes = 0;
+ seconds = 0;
+ frames = 0;
+ subframes = 0;
+ }
+
+ };
+
struct BBT_Time {
uint32_t bars;
uint32_t beats;
Type type;
- SMPTE::Time smpte;
+ SMPTE_Time smpte;
BBT_Time bbt;
union {
#include <ardour/stateful.h>
#include <ardour/plugin_state.h>
#include <ardour/plugin.h>
-#include <ardour/vst_plugin.h>
using std::string;
using std::vector;
its OK to block (for short intervals).
*/
- LockMonitor rm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock rm (region_lock);
end = start + cnt - 1;
void AudioPlaylist::notify_crossfade_added (Crossfade *x)
{
- if (atomic_read(&block_notifications)) {
+ if (g_atomic_int_get(&block_notifications)) {
_pending_xfade_adds.insert (_pending_xfade_adds.end(), x);
} else {
NewCrossfade (x); /* EMIT SIGNAL */
AudioRegion* ar = dynamic_cast<AudioRegion*> (*i);
- if (ar && ar->equivalent (other)) {
- results.push_back (ar);
+ if (ar) {
+ if (Config->get_use_overlap_equivalency()) {
+ if (ar->overlap_equivalent (other)) {
+ results.push_back (ar);
+ } else if (ar->equivalent (other)) {
+ results.push_back (ar);
+ }
+ }
}
}
}
jack_nframes_t transport_frame;
{
- TentativeRWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
if (lm.locked()) {
// automation snapshot can also be called from the non-rt context
// and it uses the redirect list, so we take the lock out here
/* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
if (!diskstream->record_enabled() && _session.transport_rolling()) {
- TentativeLockMonitor am (automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
if (am.locked() && gain_automation_playback()) {
apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes);
vector<Sample*>::iterator bi;
Sample * b;
- RWLockMonitor rlock (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rlock (redirect_lock);
if (diskstream->playlist()->read (buffers[0], mix_buffer, gain_buffer, workbuf, start, nframes) != nframes) {
return -1;
_freeze_record.have_mementos = true;
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); ++r) {
} else {
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__); // should this be a write lock? jlc
+ Glib::RWLock::ReaderLock lm (redirect_lock); // should this be a write lock? jlc
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
for (vector<FreezeRecordInsertInfo*>::iterator ii = _freeze_record.insert_info.begin(); ii != _freeze_record.insert_info.end(); ++ii) {
if ((*ii)->id == (*i)->id()) {
#include <cerrno>
#include <vector>
+#include <glibmm/timer.h>
#include <pbd/pthread_utils.h>
#include <ardour/audioengine.h>
AudioEngine::AudioEngine (string client_name)
{
- pthread_cond_init (&session_removed, 0);
session = 0;
session_remove_pending = false;
_running = false;
_buffer_size = 0;
_freewheeling = false;
_freewheel_thread_registered = false;
- last_meter_point = 0;
- meter_interval = 0;
- meter_thread_id = (pthread_t) 0;
+
+ m_meter_thread = 0;
+ m_meter_exit = false;
+ start_metering_thread();
+
if (connect_to_jack (client_name)) {
throw NoBackendAvailable ();
}
jack_client_close (_jack);
}
- if (meter_thread_id != (pthread_t) 0) {
- pthread_cancel (meter_thread_id);
- }
+ if(m_meter_thread) {
+ g_atomic_int_inc(&m_meter_exit);
+ }
}
void
return 0;
}
-/** @callgraph */
int
AudioEngine::_process_callback (jack_nframes_t nframes, void *arg)
{
static_cast<AudioEngine*>(arg)->_freewheeling = onoff;
}
-/** @callgraph */
int
AudioEngine::process_callback (jack_nframes_t nframes)
{
- TentativeLockMonitor tm (_process_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock tm (_process_lock, Glib::TRY_LOCK);
jack_nframes_t next_processed_frames;
/* handle wrap around of total frames counter */
if (session_remove_pending) {
session = 0;
session_remove_pending = false;
- pthread_cond_signal (&session_removed);
+ session_removed.signal();
_processed_frames = next_processed_frames;
return 0;
}
_processed_frames = next_processed_frames;
return 0;
}
-
- /* manage meters */
- if ((meter_interval > _buffer_size) && (last_meter_point + meter_interval < next_processed_frames)) {
- IO::Meter ();
- last_meter_point = next_processed_frames;
- }
-
if (last_monitor_check + monitor_check_interval < next_processed_frames) {
for (Ports::iterator i = ports.begin(); i != ports.end(); ++i) {
monitor_check_interval = nframes / 10;
last_monitor_check = 0;
- meter_interval = nframes / 100;
- last_meter_point = 0;
-
- maybe_start_metering_thread ();
-
if (session) {
session->set_frame_rate (nframes);
}
session->set_block_size (_buffer_size);
}
- maybe_start_metering_thread ();
-
return 0;
}
void
-AudioEngine::maybe_start_metering_thread ()
-{
- if (meter_interval == 0) {
- return;
- }
-
- if (_buffer_size == 0) {
- return;
- }
-
- if (meter_interval < _buffer_size) {
- if (meter_thread_id != (pthread_t) 0) {
- pthread_cancel (meter_thread_id);
- }
- pthread_create (&meter_thread_id, 0, _meter_thread, this);
- }
-}
-
-void*
-AudioEngine::_meter_thread (void *arg)
+AudioEngine::start_metering_thread ()
{
- return static_cast<AudioEngine*>(arg)->meter_thread ();
+ if(m_meter_thread == 0) {
+ m_meter_thread = Glib::Thread::create (sigc::mem_fun(this, &AudioEngine::meter_thread), false);
+ }
}
-void*
+void
AudioEngine::meter_thread ()
{
- PBD::ThreadCreated (pthread_self(), "Metering");
-
- while (true) {
- usleep (10000); /* 1/100th sec interval */
- pthread_testcancel();
- IO::Meter ();
+ while (g_atomic_int_get(&m_meter_exit) != true) {
+ Glib::usleep (10000); /* 1/100th sec interval */
+ IO::update_meters ();
}
-
- return 0;
+ return;
}
void
void
AudioEngine::remove_session ()
{
- LockMonitor lm (_process_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_process_lock);
if (_running) {
if (session) {
session_remove_pending = true;
- pthread_cond_wait (&session_removed, _process_lock.mutex());
+ session_removed.wait(_process_lock);
}
} else {
} else {
- pthread_mutex_unlock (_process_lock.mutex());
+ _process_lock.unlock();
throw PortRegistrationFailure();
}
} else {
- pthread_mutex_unlock (_process_lock.mutex());
+ _process_lock.unlock();
throw PortRegistrationFailure ();
}
Port *
AudioEngine::get_port_by_name (const string& portname, bool keep)
{
- LockMonitor lm (_process_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_process_lock);
if (!_running) {
if (!_has_run) {
if (_jack) {
disconnect_from_jack ();
/* XXX give jackd a chance */
- usleep (250000);
+ Glib::usleep (250000);
}
if (connect_to_jack (jack_client_name)) {
#include <sigc++/bind.h>
#include <sigc++/class_slot.h>
+#include <glibmm/thread.h>
+
#include <pbd/basename.h>
-#include <pbd/lockmonitor.h>
#include <pbd/xml++.h>
#include <ardour/audioregion.h>
}
bool
-AudioRegion::region_list_equivalent (const AudioRegion& other)
+AudioRegion::region_list_equivalent (const AudioRegion& other) const
{
return size_equivalent (other) && source_equivalent (other) && _name == other._name;
}
bool
-AudioRegion::source_equivalent (const AudioRegion& other)
+AudioRegion::source_equivalent (const AudioRegion& other) const
{
- SourceList::iterator i;
+ SourceList::const_iterator i;
SourceList::const_iterator io;
for (i = sources.begin(), io = other.sources.begin(); i != sources.end() && io != other.sources.end(); ++i, ++io) {
}
bool
-AudioRegion::equivalent (const AudioRegion& other)
+AudioRegion::overlap_equivalent (const AudioRegion& other) const
+{
+ return coverage (other.first_frame(), other.last_frame()) != OverlapNone;
+}
+
+bool
+AudioRegion::equivalent (const AudioRegion& other) const
{
return _start == other._start &&
_position == other._position &&
}
bool
-AudioRegion::size_equivalent (const AudioRegion& other)
+AudioRegion::size_equivalent (const AudioRegion& other) const
{
return _start == other._start &&
_length == other._length;
$Id$
*/
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <ardour/diskstream.h>
#include <ardour/audioregion.h>
IO::output_changed.connect (mem_fun (*this, &Auditioner::output_changed));
the_region = 0;
- atomic_set (&_active, 0);
+ g_atomic_int_set (&_active, 0);
}
Auditioner::~Auditioner ()
void
Auditioner::audition_current_playlist ()
{
- if (atomic_read (&_active)) {
+ if (g_atomic_int_get (&_active)) {
/* don't go via session for this, because we are going
to remain active.
*/
cancel_audition ();
}
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
diskstream->seek (0);
length = diskstream->playlist()->get_maximum_extent();
current_frame = 0;
_panner->reset (n_outputs(), diskstream->n_channels());
- atomic_set (&_active, 1);
+ g_atomic_int_set (&_active, 1);
}
void
Auditioner::audition_region (AudioRegion& region)
{
- if (atomic_read (&_active)) {
+ if (g_atomic_int_get (&_active)) {
/* don't go via session for this, because we are going
to remain active.
*/
cancel_audition ();
}
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
the_region = new AudioRegion (region);
the_region->set_position (0, this);
length = the_region->length();
diskstream->seek (0);
current_frame = 0;
- atomic_set (&_active, 1);
+ g_atomic_int_set (&_active, 1);
}
int
jack_nframes_t this_nframes;
int ret;
- if (atomic_read (&_active) == 0) {
+ if (g_atomic_int_get (&_active) == 0) {
silence (nframes, 0);
return 0;
}
AutomationList::clear ()
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
events.clear ();
if (!no_state) {
save_state (_("cleared"));
void
AutomationList::x_scale (double factor)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
_x_scale (factor);
}
bool
AutomationList::extend_to (double when)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
if (events.empty() || events.back()->when == when) {
return false;
}
// cerr << "RT: alist @ " << this << " add " << value << " @ " << when << endl;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
iterator where;
TimeComparator cmp;
/* this is for graphical editing and loading data from storage */
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
TimeComparator cmp;
ControlEvent cp (when, 0.0f);
bool insert = true;
AutomationList::erase (AutomationList::iterator i)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
events.erase (i);
reposition_for_rt_add (0);
if (!no_state) {
AutomationList::erase (AutomationList::iterator start, AutomationList::iterator end)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
events.erase (start, end);
reposition_for_rt_add (0);
if (!no_state) {
bool reset = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
TimeComparator cmp;
ControlEvent cp (start, 0.0f);
iterator s;
bool erased = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
TimeComparator cmp;
ControlEvent cp (start, 0.0f);
iterator s;
*/
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
while (start != end) {
(*start)->when += xdelta;
*/
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
(*iter)->when = when;
(*iter)->value = val;
if (!no_state) {
std::pair<AutomationList::iterator,AutomationList::iterator>
AutomationList::control_points_adjacent (double xval)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
iterator i;
TimeComparator cmp;
ControlEvent cp (xval, 0.0f);
AutomationList::restore_state (StateManager::State& state)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
State* lstate = dynamic_cast<State*> (&state);
events.clear ();
AutomationList::truncate_end (double last_coordinate)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
ControlEvent cp (last_coordinate, 0);
list<ControlEvent*>::reverse_iterator i;
double last_val;
AutomationList::truncate_start (double overall_length)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
AutomationList::iterator i;
double first_legal_value;
double first_legal_coordinate;
AutomationList* nal = new AutomationList (default_value);
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
for (iterator x = start; x != end; ) {
iterator tmp;
bool changed = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
if ((s = lower_bound (events.begin(), events.end(), &cp, cmp)) == events.end()) {
return nal;
AutomationList* nal = new AutomationList (default_value);
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
for (iterator x = start; x != end; ) {
iterator tmp;
}
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
iterator where;
iterator prev;
double end = 0;
#include "i18n.h"
using namespace ARDOUR;
-using namespace PBD;
Connection::Connection (const XMLNode& node)
{
Connection::add_connection (int port, string portname)
{
{
- LockMonitor lm (port_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_lock);
_ports[port].push_back (portname);
}
ConnectionsChanged (port); /* EMIT SIGNAL */
bool changed = false;
{
- LockMonitor lm (port_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_lock);
PortList& pl = _ports[port];
PortList::iterator i = find (pl.begin(), pl.end(), portname);
const Connection::PortList&
Connection::port_connections (int port) const
{
- LockMonitor lm (port_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_lock);
return _ports[port];
}
Connection::add_port ()
{
{
- LockMonitor lm (port_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_lock);
_ports.push_back (PortList());
}
ConfigurationChanged(); /* EMIT SIGNAL */
bool changed = false;
{
- LockMonitor lm (port_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_lock);
vector<PortList>::iterator i;
int n;
Connection::clear ()
{
{
- LockMonitor lm (port_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (port_lock);
_ports.clear ();
}
using namespace ARDOUR;
-using namespace PBD;
using namespace std;
#include "i18n.h"
ControlProtocolManager::~ControlProtocolManager()
{
- LockMonitor lm (protocols_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (protocols_lock);
for (list<ControlProtocol*>::iterator i = control_protocols.begin(); i != control_protocols.end(); ++i) {
delete (*i);
_session = 0;
{
- LockMonitor lm (protocols_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (protocols_lock);
for (list<ControlProtocol*>::iterator p = control_protocols.begin(); p != control_protocols.end(); ++p) {
delete *p;
}
return 0;
}
- LockMonitor lm (protocols_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (protocols_lock);
control_protocols.push_back (cpi.protocol);
return cpi.protocol;
cpi.descriptor->destroy (cpi.descriptor, cpi.protocol);
{
- LockMonitor lm (protocols_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (protocols_lock);
list<ControlProtocol*>::iterator p = find (control_protocols.begin(), control_protocols.end(), cpi.protocol);
if (p != control_protocols.end()) {
control_protocols.erase (p);
ControlProtocolManager::get_state (void)
{
XMLNode* root = new XMLNode (state_node_name);
- LockMonitor lm (protocols_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (protocols_lock);
for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
XMLNode* child = new XMLNode (X_("Protocol"));
}
/* note that we temporarily truncated _id at the colon */
- FSRef ref;
- err = FSPathMakeRef ((UInt8*)file.c_str(), &ref, 0);
+ FSRef fsr;
+ err = FSPathMakeRef ((UInt8*)file.c_str(), &fsr, 0);
if (err != noErr) {
+ cerr << "FSPathMakeRef " << err << endl;
throw failed_constructor();
}
- err = ExtAudioFileOpen (&ref, &af);
+ err = ExtAudioFileOpen (&fsr, &af);
if (err != noErr) {
+ cerr << "ExtAudioFileOpen " << err << endl;
ExtAudioFileDispose (af);
throw failed_constructor();
}
AudioStreamBasicDescription file_asbd;
- memset(&file_asbd, 0, sizeof(file_asbd));
- size_t asbd_size = sizeof(file_asbd);
+ memset(&file_asbd, 0, sizeof(AudioStreamBasicDescription));
+ size_t asbd_size = sizeof(AudioStreamBasicDescription);
err = ExtAudioFileGetProperty(af,
kExtAudioFileProperty_FileDataFormat, &asbd_size, &file_asbd);
if (err != noErr) {
+ cerr << "ExtAudioFileGetProperty1 " << err << endl;
ExtAudioFileDispose (af);
throw failed_constructor();
}
n_channels = file_asbd.mChannelsPerFrame;
+ cerr << "number of channels: " << n_channels << endl;
+
if (channel >= n_channels) {
error << string_compose(_("CoreAudioSource: file only contains %1 channels; %2 is invalid as a channel number"), n_channels, channel) << endmsg;
ExtAudioFileDispose (af);
}
int64_t ca_frames;
- size_t prop_size = sizeof(ca_frames);
+ size_t prop_size = sizeof(int64_t);
err = ExtAudioFileGetProperty(af, kExtAudioFileProperty_FileLengthFrames, &prop_size, &ca_frames);
if (err != noErr) {
+ cerr << "ExtAudioFileGetProperty2 " << err << endl;
ExtAudioFileDispose (af);
throw failed_constructor();
}
- _length = ca_frames;
+ _length = ca_frames;
_path = file;
- if (build_peak) {
- if (initialize_peakfile (false, file)) {
- error << "initialize peakfile failed" << endmsg;
- ExtAudioFileDispose (af);
- throw failed_constructor ();
- }
- }
-
AudioStreamBasicDescription client_asbd;
- memset(&client_asbd, 0, sizeof(client_asbd));
+ memset(&client_asbd, 0, sizeof(AudioStreamBasicDescription));
+ client_asbd.mSampleRate = file_asbd.mSampleRate;
client_asbd.mFormatID = kAudioFormatLinearPCM;
client_asbd.mFormatFlags = kLinearPCMFormatFlagIsFloat;
- client_asbd.mSampleRate = file_asbd.mSampleRate;
-
- err = AudioFormatGetProperty(kAudioFormatProperty_FormatInfo, 0, NULL, &asbd_size, &client_asbd);
- if (err != noErr) {
- ExtAudioFileDispose (af);
- throw failed_constructor ();
- }
+ client_asbd.mBytesPerPacket = file_asbd.mChannelsPerFrame * 4;
+ client_asbd.mFramesPerPacket = 1;
+ client_asbd.mBytesPerFrame = client_asbd.mBytesPerPacket;
+ client_asbd.mChannelsPerFrame = file_asbd.mChannelsPerFrame;
+ client_asbd.mBitsPerChannel = 32;
err = ExtAudioFileSetProperty (af, kExtAudioFileProperty_ClientDataFormat, asbd_size, &client_asbd);
if (err != noErr) {
+ cerr << "ExtAudioFileSetProperty3 " << err << endl;
ExtAudioFileDispose (af);
throw failed_constructor ();
}
+
+ if (build_peak) {
+ if (initialize_peakfile (false, file)) {
+ error << "initialize peakfile failed" << endmsg;
+ ExtAudioFileDispose (af);
+ throw failed_constructor ();
+ }
+ }
}
CoreAudioSource::~CoreAudioSource ()
uint32_t real_cnt = cnt * n_channels;
{
- LockMonitor lm (_tmpbuf_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_tmpbuf_lock);
if (tmpbufsize < real_cnt) {
#include <cfloat>
#include <cmath>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <sigc++/bind.h>
#include "ardour/curve.h"
using namespace std;
using namespace ARDOUR;
-using namespace PBD;
using namespace sigc;
Curve::Curve (double minv, double maxv, double canv, bool nostate)
bool
Curve::rt_safe_get_vector (double x0, double x1, float *vec, int32_t veclen)
{
- TentativeLockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock, Glib::TRY_LOCK);
if (!lm.locked()) {
return false;
void
Curve::get_vector (double x0, double x1, float *vec, int32_t veclen)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
_get_vector (x0, x1, vec, veclen);
}
DestructiveFileSource::write (Sample* data, jack_nframes_t cnt, char * workbuf)
{
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
jack_nframes_t old_file_pos;
#include <pbd/error.h>
#include <pbd/basename.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/xml++.h>
#include <ardour/ardour.h>
first_input_change = true;
_playlist = 0;
i_am_the_modifier = 0;
- atomic_set (&_record_enabled, 0);
+ g_atomic_int_set (&_record_enabled, 0);
was_recording = false;
capture_start_frame = 0;
capture_captured = 0;
DiskStream::~DiskStream ()
{
- LockMonitor lm (state_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (state_lock);
if (_playlist) {
_playlist->unref ();
void
DiskStream::handle_input_change (IOChange change, void *src)
{
- LockMonitor lm (state_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (state_lock);
if (!(input_change_pending & change)) {
input_change_pending = IOChange (input_change_pending|change);
DiskStream::non_realtime_input_change ()
{
{
- LockMonitor lm (state_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (state_lock);
if (input_change_pending == NoChange) {
return;
DiskStream::use_playlist (AudioPlaylist* playlist)
{
{
- LockMonitor lm (state_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (state_lock);
if (playlist == _playlist) {
return 0;
{
if (_buffer_reallocation_required)
{
- LockMonitor lm (state_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (state_lock);
allocate_temporary_buffers ();
_buffer_reallocation_required = false;
returns a non-zero value, in which case, ::commit should not be called.
*/
- if (pthread_mutex_trylock (state_lock.mutex())) {
+ // If we can't take the state lock return.
+ if (!state_lock.trylock()) {
return 1;
}
be called. unlock the state lock.
*/
- pthread_mutex_unlock (state_lock.mutex());
+ state_lock.unlock();
}
return ret;
void
DiskStream::recover ()
{
- pthread_mutex_unlock (state_lock.mutex());
+ state_lock.unlock();
_processed = false;
}
|| channels[0].capture_buf->read_space() >= disk_io_chunk_frames;
}
- pthread_mutex_unlock (state_lock.mutex());
+ state_lock.unlock();
_processed = false;
int
DiskStream::seek (jack_nframes_t frame, bool complete_refill)
{
- LockMonitor lm (state_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (state_lock);
uint32_t n;
int ret;
ChannelList::iterator chan;
}
/* XXX is there anything we can do if err != 0 ? */
- LockMonitor lm (capture_info_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (capture_info_lock);
if (capture_info.empty()) {
return;
if (record_enabled() != yn) {
if (yn) {
- atomic_set (&_record_enabled, 1);
+ g_atomic_int_set (&_record_enabled, 1);
capturing_sources.clear ();
if (Config->get_use_hardware_monitoring()) {
for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
}
} else {
- atomic_set (&_record_enabled, 0);
+ g_atomic_int_set (&_record_enabled, 0);
if (Config->get_use_hardware_monitoring()) {
for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
if ((*chan).source) {
jack_nframes_t
DiskStream::get_capture_start_frame (uint32_t n)
{
- LockMonitor lm (capture_info_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (capture_info_lock);
if (capture_info.size() > n) {
return capture_info[n]->start;
jack_nframes_t
DiskStream::get_captured_frames (uint32_t n)
{
- LockMonitor lm (capture_info_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (capture_info_lock);
if (capture_info.size() > n) {
return capture_info[n]->frames;
#include <vector>
#include <cstdio> /* for rename(2) */
+#include <glibmm.h>
+
#include <pbd/stl_delete.h>
-#include <pbd/basename.h>
-#include <pbd/dirname.h>
-#include <pbd/lockmonitor.h>
+
+#include <glibmm/thread.h>
#include <pbd/pathscanner.h>
#include <ardour/ardour.h>
int
FileSource::set_name (string newname, bool destructive)
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
string oldpath = _path;
string newpath = Session::change_audio_path_by_name (oldpath, _name, newname, destructive);
return -1;
}
- _name = basename (newpath);
+ _name = Glib::path_get_basename (newpath);
_path = newpath;
return rename_peakfile (peak_path (_path));
int
FileSource::update_header (jack_nframes_t when, struct tm& now, time_t tnow)
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
if (is_bwf) {
/* random code is 9 digits */
jack_nframes_t
FileSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt, char * workbuf) const
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
return read_unlocked (dst, start, cnt, workbuf);
}
FileSource::write (Sample *data, jack_nframes_t cnt, char * workbuf)
{
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
jack_nframes_t oldlen;
int32_t frame_pos = _length;
void
FileSource::mark_streaming_write_completed ()
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
next_peak_clear_should_notify = true;
on whichever filesystem it was already on.
*/
- newpath = PBD::dirname (_path);
- newpath = PBD::dirname (newpath);
+ // XXX Portability
+
+ newpath = Glib::path_get_dirname (_path);
+ newpath = Glib::path_get_dirname (newpath);
newpath += '/';
newpath += trash_dir_name;
newpath += '/';
- newpath += PBD::basename (_path);
+ newpath += Glib::path_get_basename (_path);
if (access (newpath.c_str(), F_OK) == 0) {
const int clamp_l)
{
uint32_t pos, i;
- u_int8_t *o8 = (u_int8_t*) y;
+ uint8_t *o8 = (uint8_t*) y;
int16_t *o16 = (int16_t*) y;
int32_t *o32 = (int32_t*) y;
float tmp, r, ideal;
#include <midi++/mmc.h>
#include <ardour/ardour.h>
-#include <ardour/audioengine.h>
#include <ardour/audio_library.h>
#include <ardour/configuration.h>
#include <ardour/plugin_manager.h>
#include <ardour/utils.h>
#include <ardour/session.h>
#include <ardour/control_protocol_manager.h>
+
+#ifdef HAVE_LIBLO
#include <ardour/osc.h>
+#endif
#include <ardour/mix.h>
ARDOUR::Configuration* ARDOUR::Config = 0;
ARDOUR::AudioLibrary* ARDOUR::Library = 0;
+
+#ifdef HAVE_LIBLO
ARDOUR::OSC* ARDOUR::osc = 0;
+#endif
using namespace ARDOUR;
using namespace std;
Change ARDOUR::NameChanged = ARDOUR::new_change ();
Change ARDOUR::BoundsChanged = Change (0); // see init(), below
+#ifdef HAVE_LIBLO
static int
setup_osc ()
{
return 0;
}
}
+#endif
static int
-setup_midi (AudioEngine& engine)
+setup_midi ()
{
std::map<string,Configuration::MidiPortDescriptor*>::iterator i;
int nports;
return 0;
}
- MIDI::Manager::instance()->set_api_data(engine.jack());
-
for (i = Config->midi_ports.begin(); i != Config->midi_ports.end(); ++i) {
Configuration::MidiPortDescriptor* port_descriptor;
port_descriptor->type);
if (request.status != MIDI::PortRequest::OK) {
- error << string_compose(
- _("MIDI port specifications for \"%1\" (%2, %3) are not understandable."),
- port_descriptor->tag, port_descriptor->mode, port_descriptor->type) << endmsg;
+ error << string_compose(_("MIDI port specifications for \"%1\" are not understandable."), port_descriptor->tag) << endmsg;
continue;
}
if (default_mmc_port == 0) {
warning << string_compose (_("No MMC control (MIDI port \"%1\" not available)"), Config->get_mmc_port_name())
<< endmsg;
+ return 0;
}
if (default_mtc_port == 0) {
Config->set_use_vst (use_vst);
- if (setup_midi (engine)) {
+ if (setup_midi ()) {
return -1;
}
-
+
+#ifdef HAVE_LIBLO
if (setup_osc ()) {
return -1;
}
+#endif
#ifdef VST_SUPPORT
if (Config->get_use_vst() && fst_init (sighandler)) {
Change c;
static uint32_t change_bit = 1;
- /* XXX catch out-of-range */
+ /* catch out-of-range */
+ if (!change_bit)
+ {
+ fatal << _("programming error: ")
+ << "change_bit out of range in ARDOUR::new_change()"
+ << endmsg;
+ /*NOTREACHED*/
+ }
c = Change (change_bit);
- change_bit <<= 1;
+ change_bit <<= 1; // if it shifts too far, change_bit == 0
return c;
}
#include <sndfile.h>
#include <samplerate.h>
+#include <glibmm.h>
+
#include <pbd/basename.h>
+
#include <ardour/ardour.h>
#include <ardour/session.h>
#include <ardour/diskstream.h>
sources.push_back(newfiles[n]);
}
- AudioRegion *r = new AudioRegion (sources, 0, newfiles[0]->length(), region_name_from_path (PBD::basename(basepath)),
+ AudioRegion *r = new AudioRegion (sources, 0, newfiles[0]->length(), region_name_from_path (Glib::path_get_basename (basepath)),
0, AudioRegion::Flag (AudioRegion::DefaultFlags | AudioRegion::WholeFile));
status.new_regions.push_back (r);
did not bother to create whole-file AudioRegions for them. Do it now.
*/
- AudioRegion *r = new AudioRegion (*newfiles[n], 0, newfiles[n]->length(), region_name_from_path (PBD::basename (newfiles[n]->name())),
+ AudioRegion *r = new AudioRegion (*newfiles[n], 0, newfiles[n]->length(), region_name_from_path (Glib::path_get_basename (newfiles[n]->name())),
0, AudioRegion::Flag (AudioRegion::DefaultFlags | AudioRegion::WholeFile | AudioRegion::Import));
status.new_regions.push_back (r);
string
Session::build_tmp_convert_name(string infile)
{
- string tmp_name(_path + "/." + PBD::basename (infile.c_str()) + "XXXXXX");
+ string tmp_name(_path + "/." + Glib::path_get_basename (infile.c_str()) + "XXXXXX");
char* tmp = new char[tmp_name.length() + 1];
tmp_name.copy(tmp, string::npos);
tmp[tmp_name.length()] = 0;
save_state (_("initial state"));
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
IO::MoreOutputs (output_streams ());
}
_plugins[0]->ParameterChanged.connect (mem_fun (*this, &PluginInsert::parameter_changed));
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
IO::MoreOutputs (output_streams());
}
}
jack_nframes_t now = _session.transport_frame ();
jack_nframes_t end = now + nframes;
- TentativeLockMonitor lm (_automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_automation_lock, Glib::TRY_LOCK);
if (!lm.locked()) {
connect_and_run (bufs, nbufs, nframes, offset, false);
#include <sigc++/bind.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
+
#include <pbd/xml++.h>
#include <ardour/audioengine.h>
sigc::signal<void,uint32_t> IO::MoreOutputs;
sigc::signal<int> IO::PortsCreated;
+Glib::StaticMutex IO::m_meter_signal_lock = GLIBMM_STATIC_MUTEX_INIT;
+
/* this is a default mapper of MIDI control values to a gain coefficient.
others can be imagined. see IO::set_midi_to_gain_function().
*/
_gain_automation_state = Off;
_gain_automation_style = Absolute;
-
- Meter.connect (mem_fun (*this, &IO::meter));
+
+ {
+ // IO::Meter is emitted from another thread so the
+ // Meter signal must be protected.
+ Glib::Mutex::Lock guard (m_meter_signal_lock);
+ m_meter_connection = Meter.connect (mem_fun (*this, &IO::meter));
+ }
}
IO::~IO ()
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+
+ Glib::Mutex::Lock guard (m_meter_signal_lock);
+ Glib::Mutex::Lock lm (io_lock);
vector<Port *>::iterator i;
for (i = _inputs.begin(); i != _inputs.end(); ++i) {
for (i = _outputs.begin(); i != _outputs.end(); ++i) {
_session.engine().unregister_port (*i);
}
+
+ m_meter_connection.disconnect();
}
void
gain_t pangain = _gain;
{
- TentativeLockMonitor dm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
if (dm.locked()) {
dg = _desired_gain;
} else {
- TentativeLockMonitor dm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
if (dm.locked()) {
dg = _desired_gain;
}
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
/* check that our_port is really one of ours */
}
{
- LockMonitor em(_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em(_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
/* check that our_port is really one of ours */
}
{
- LockMonitor em(_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em(_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
if (find (_outputs.begin(), _outputs.end(), our_port) == _outputs.end()) {
return -1;
}
{
- LockMonitor em(_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em(_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
/* check that our_port is really one of ours */
IOChange change (NoChange);
{
- LockMonitor em(_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em(_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
if (_noutputs - 1 == (uint32_t) _output_minimum) {
/* sorry, you can't do this */
char buf[64];
{
- LockMonitor em(_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em(_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
if (_output_maximum >= 0 && (int) _noutputs == _output_maximum) {
return -1;
IOChange change (NoChange);
{
- LockMonitor em(_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em(_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
if (((int)_ninputs - 1) < _input_minimum) {
/* sorry, you can't do this */
char buf[64];
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
if (_input_maximum >= 0 && (int) _ninputs == _input_maximum) {
return -1;
IO::disconnect_inputs (void* src)
{
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
for (vector<Port *>::iterator i = _inputs.begin(); i != _inputs.end(); ++i) {
_session.engine().disconnect (*i);
IO::disconnect_outputs (void* src)
{
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
_session.engine().disconnect (*i);
}
{
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
+ Glib::Mutex::Lock lm (io_lock);
Port* port;
}
if (lockit) {
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
- LockMonitor im (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
+ Glib::Mutex::Lock im (io_lock);
changed = ensure_inputs_locked (n, clear, src);
} else {
changed = ensure_inputs_locked (n, clear, src);
/* XXX caller should hold io_lock, but generally doesn't */
if (lockit) {
- LockMonitor em (_session.engine().process_lock(), __LINE__, __FILE__);
- LockMonitor im (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock em (_session.engine().process_lock());
+ Glib::Mutex::Lock im (io_lock);
changed = ensure_outputs_locked (n, clear, src);
} else {
changed = ensure_outputs_locked (n, clear, src);
bool need_ins = true;
bool need_outs = true;
LocaleGuard lg (X_("POSIX"));
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
node->add_property("name", _name);
snprintf (buf, sizeof(buf), "%" PRIu64, id());
void
IO::set_port_latency (jack_nframes_t nframes)
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock);
for (vector<Port *>::iterator i = _outputs.begin(); i != _outputs.end(); ++i) {
(*i)->set_latency (nframes);
uint32_t limit;
{
- LockMonitor lm (_session.engine().process_lock(), __LINE__, __FILE__);
- LockMonitor lm2 (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_session.engine().process_lock());
+ Glib::Mutex::Lock lm2 (io_lock);
limit = c.nports();
uint32_t limit;
{
- LockMonitor lm (_session.engine().process_lock(), __LINE__, __FILE__);
- LockMonitor lm2 (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_session.engine().process_lock());
+ Glib::Mutex::Lock lm2 (io_lock);
limit = c.nports();
return;
}
+/**
+ Update the peak meters.
+
+ The meter signal lock is taken to prevent modification of the
+ Meter signal while updating the meters, taking the meter signal
+ lock prior to taking the io_lock ensures that all IO will remain
+ valid while metering.
+*/
+void
+IO::update_meters()
+{
+ Glib::Mutex::Lock guard (m_meter_signal_lock);
+
+ Meter();
+}
+
void
IO::meter ()
{
- LockMonitor lm (io_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (io_lock); // READER: meter thread.
uint32_t limit = max (_ninputs, _noutputs);
for (uint32_t n = 0; n < limit; ++n) {
void
IO::clear_automation ()
{
- LockMonitor lm (automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (automation_lock);
_gain_automation_curve.clear ();
_panner->clear_automation ();
}
bool changed = false;
{
- LockMonitor lm (automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (automation_lock);
if (state != _gain_automation_curve.automation_state()) {
changed = true;
bool changed = false;
{
- LockMonitor lm (automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (automation_lock);
if (style != _gain_automation_curve.automation_style()) {
changed = true;
if (val>1.99526231f) val=1.99526231f;
{
- LockMonitor dm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock dm (declick_lock);
_desired_gain = val;
}
int ret;
if (want_lock) {
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
ret = set_current_unlocked (loc);
} else {
ret = set_current_unlocked (loc);
Locations::clear ()
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
LocationList::iterator tmp;
for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
tmp = i;
Locations::clear_markers ()
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
LocationList::iterator tmp;
for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
Locations::clear_ranges ()
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
LocationList::iterator tmp;
for (LocationList::iterator i = locations.begin(); i != locations.end(); ) {
Locations::add (Location *loc, bool make_current)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
locations.push_back (loc);
if (make_current) {
}
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
for (i = locations.begin(); i != locations.end(); ++i) {
if ((*i) == loc) {
{
XMLNode *node = new XMLNode ("Locations");
LocationList::iterator iter;
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
for (iter = locations.begin(); iter != locations.end(); ++iter) {
node->add_child_nocopy ((*iter)->get_state ());
nlist = node.children();
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
Location *loc = new Location;
LocationList locs;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
locs = locations;
}
LocationList locs;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
locs = locations;
}
return 0;
}
+jack_nframes_t
+Locations::first_mark_before (jack_nframes_t frame)
+{
+ LocationList locs;
+
+ {
+ Glib::Mutex::Lock lm (lock);
+ locs = locations;
+ }
+
+ LocationStartLaterComparison cmp;
+ locs.sort (cmp);
+
+ /* locs is now sorted latest..earliest */
+
+ for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
+ if (!(*i)->is_hidden()) {
+ if ((*i)->is_mark()) {
+ /* MARK: start == end */
+ if ((*i)->start() < frame) {
+ return (*i)->start();
+ }
+ } else {
+ /* RANGE: start != end, compare start and end */
+ if ((*i)->end() < frame) {
+ return (*i)->end();
+ }
+ if ((*i)->start () < frame) {
+ return (*i)->start();
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+jack_nframes_t
+Locations::first_mark_after (jack_nframes_t frame)
+{
+ LocationList locs;
+
+ {
+ Glib::Mutex::Lock lm (lock);
+ locs = locations;
+ }
+
+ LocationStartEarlierComparison cmp;
+ locs.sort (cmp);
+
+ /* locs is now sorted earliest..latest */
+
+ for (LocationList::iterator i = locs.begin(); i != locs.end(); ++i) {
+ if (!(*i)->is_hidden()) {
+ if ((*i)->is_mark()) {
+ /* MARK, start == end so just compare start */
+ if ((*i)->start() > frame) {
+ return (*i)->start();
+ }
+ } else {
+ /* RANGE, start != end, compare start and end */
+ if ((*i)->start() > frame ) {
+ return (*i)->start ();
+ }
+ if ((*i)->end() > frame) {
+ return (*i)->end ();
+ }
+ }
+ }
+ }
+
+ return max_frames;
+}
+
Location*
Locations::end_location () const
{
Locations::restore_state (StateManager::State& state)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
State* lstate = dynamic_cast<State*> (&state);
locations = lstate->locations;
Locations::num_range_markers () const
{
uint32_t cnt = 0;
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
if ((*i)->is_range_marker()) {
++cnt;
#include <unistd.h>
#include <float.h>
+#include <glibmm.h>
+
#include <pbd/error.h>
#include <pbd/failed_constructor.h>
-#include <pbd/basename.h>
#include <pbd/xml++.h>
#include <ardour/session.h>
if (full) {
if (save () == 0) {
- root->add_property (X_("automation"), PBD::basename (automation_path));
+ root->add_property (X_("automation"), Glib::path_get_basename (automation_path));
}
}
void
Playlist::init (bool hide)
{
- atomic_set (&block_notifications, 0);
- atomic_set (&ignore_state_changes, 0);
+ g_atomic_int_set (&block_notifications, 0);
+ g_atomic_int_set (&ignore_state_changes, 0);
pending_modified = false;
pending_length = false;
_refcnt = 0;
Playlist::freeze ()
{
delay_notifications ();
- atomic_inc (&ignore_state_changes);
+ g_atomic_int_inc (&ignore_state_changes);
}
void
Playlist::thaw ()
{
- atomic_dec (&ignore_state_changes);
+ g_atomic_int_dec_and_test (&ignore_state_changes);
release_notifications ();
}
void
Playlist::delay_notifications ()
{
- atomic_inc (&block_notifications);
+ g_atomic_int_inc (&block_notifications);
freeze_length = _get_maximum_extent();
}
void
Playlist::release_notifications ()
{
- if (atomic_dec_and_test(&block_notifications)) {
+ if (g_atomic_int_dec_and_test (&block_notifications)) {
flush_notifications ();
}
}
return 1;
}
- LockMonitor lm (_automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_automation_lock);
set<uint32_t> tosave;
parameter_automation.clear ();
int
Redirect::save_automation (string path)
{
- LockMonitor lm (_automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_automation_lock);
string fullpath;
if (parameter_automation.empty()) {
void
Redirect::what_has_automation (set<uint32_t>& s) const
{
- LockMonitor lm (_automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_automation_lock);
map<uint32_t,AutomationList*>::const_iterator li;
for (li = parameter_automation.begin(); li != parameter_automation.end(); ++li) {
void
Redirect::what_has_visible_automation (set<uint32_t>& s) const
{
- LockMonitor lm (_automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_automation_lock);
set<uint32_t>::const_iterator li;
for (li = visible_parameter_automation.begin(); li != visible_parameter_automation.end(); ++li) {
#include <sigc++/bind.h>
#include <sigc++/class_slot.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/xml++.h>
#include <ardour/region.h>
Change what_changed = Change (0);
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
if (_start != state._start) {
what_changed = Change (what_changed|StartChanged);
Change what_changed = Change (0);
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
if (_frozen && --_frozen > 0) {
return;
Region::send_change (Change what_changed)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
if (_frozen) {
pending_changed = Change (pending_changed|what_changed);
return;
declick = _pending_declick;
{
- TentativeLockMonitor cm (control_outs_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock cm (control_outs_lock, Glib::TRY_LOCK);
if (cm.locked()) {
co = _control_outs;
}
{
- TentativeLockMonitor dm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock dm (declick_lock, Glib::TRY_LOCK);
if (dm.locked()) {
dmg = desired_mute_gain;
-------------------------------------------------------------------------------------------------- */
if (with_redirects) {
- TentativeRWLockMonitor rm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_pre_fader) {
for (i = _redirects.begin(); i != _redirects.end(); ++i) {
if (post_fader_work) {
- TentativeRWLockMonitor rm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rm (redirect_lock, Glib::TRY_LOCK);
if (rm.locked()) {
if (mute_gain > 0 || !_mute_affects_post_fader) {
for (i = _redirects.begin(); i != _redirects.end(); ++i) {
solo_audible = solo_gain > 0;
mute_audible = dmg > 0 || !_mute_affects_control_outs;
- cerr << _name << " have control outs, solo audible = " << solo_audible << " mute audible = " << mute_audible
- << endl;
-
if ( // silent anyway
(_gain == 0 && !apply_gain_automation) ||
void
Route::set_solo_mute (bool yn)
{
- LockMonitor lm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (declick_lock);
/* Called by Session in response to another Route being soloed.
*/
_midi_mute_control.send_feedback (_muted);
}
- LockMonitor lm (declick_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (declick_lock);
desired_mute_gain = (yn?0.0f:1.0f);
}
}
}
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
PluginInsert* pi;
PortInsert* porti;
}
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
RedirectList::iterator existing_end = _redirects.end();
--existing_end;
}
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
delete *i;
redirect_max_outs = 0;
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
RedirectList::iterator i;
bool removed = false;
int
Route::reset_plugin_counts (uint32_t* lpc)
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
return _reset_plugin_counts (lpc);
}
RedirectList to_be_deleted;
{
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
RedirectList::iterator tmp;
RedirectList the_copy;
void
Route::all_redirects_flip ()
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
if (_redirects.empty()) {
return;
void
Route::all_redirects_active (bool state)
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
if (_redirects.empty()) {
return;
{
{
RedirectSorter comparator;
- RWLockMonitor lm (redirect_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (redirect_lock);
uint32_t old_rmo = redirect_max_outs;
/* the sweet power of C++ ... */
}
{
- TentativeRWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
if (lm.locked()) {
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
int
Route::set_control_outs (const vector<string>& ports)
{
- LockMonitor lm (control_outs_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (control_outs_lock);
vector<string>::const_iterator i;
if (_control_outs) {
jack_nframes_t now = _session.transport_frame();
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
if (!did_locate) {
automation_snapshot (now);
bool can_record, bool rec_monitors_input)
{
{
- TentativeRWLockMonitor lm(redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK);
if (lm.locked()) {
// automation snapshot can also be called from the non-rt context
// and it uses the redirect list, so we take the lock out here
apply_gain_automation = false;
{
- TentativeLockMonitor am (automation_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK);
if (am.locked() && _session.transport_rolling()) {
if (_session.get_midi_feedback()) {
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
(*i)->send_all_midi_feedback ();
}
buf = _midi_mute_control.write_feedback (buf, bufsize, _muted);
{
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
buf = (*i)->write_midi_feedback (buf, bufsize);
}
this is called from the RT audio thread.
*/
- RWLockMonitor lm (redirect_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (redirect_lock);
for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) {
(*i)->deactivate ();
#include <sigc++/bind.h>
#include <sigc++/retype.h>
+#include <glibmm.h>
+
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/pathscanner.h>
#include <pbd/stl_delete.h>
#include <pbd/basename.h>
-#include <pbd/dirname.h>
#include <ardour/audioengine.h>
#include <ardour/configuration.h>
#include <ardour/crossfade.h>
#include <ardour/playlist.h>
#include <ardour/click.h>
+
+#ifdef HAVE_LIBLO
#include <ardour/osc.h>
+#endif
#include "i18n.h"
}
if (take_lock) {
- route_lock.read_lock ();
+ route_lock.reader_lock ();
}
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
}
if (take_lock) {
- route_lock.unlock ();
+ route_lock.reader_unlock ();
}
}
_engine.set_session (this);
+#ifdef HAVE_LIBLO
/* and to OSC */
osc->set_session (*this);
+#endif
_state_of_the_state = Clean;
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
Session::reset_input_monitor_state ()
{
if (transport_rolling()) {
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
}
}
} else {
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
Session::enable_record ()
{
/* XXX really atomic compare+swap here */
- if (atomic_read (&_record_status) != Recording) {
- atomic_set (&_record_status, Recording);
+ if (g_atomic_int_get (&_record_status) != Recording) {
+ g_atomic_int_set (&_record_status, Recording);
_last_record_location = _transport_frame;
- // FIXME
//send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordStrobe);
if (Config->get_use_hardware_monitoring() && auto_input) {
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
{
RecordState rs;
- if ((rs = (RecordState) atomic_read (&_record_status)) != Disabled) {
+ if ((rs = (RecordState) g_atomic_int_get (&_record_status)) != Disabled) {
if (!Config->get_latched_record_enable () || force) {
- atomic_set (&_record_status, Disabled);
+ g_atomic_int_set (&_record_status, Disabled);
} else {
if (rs == Recording) {
- atomic_set (&_record_status, Enabled);
+ g_atomic_int_set (&_record_status, Enabled);
}
}
- // FIXME
//send_mmc_in_another_thread (MIDI::MachineControl::cmdRecordExit);
if (Config->get_use_hardware_monitoring() && auto_input) {
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
void
Session::step_back_from_record ()
{
- atomic_set (&_record_status, Enabled);
+ g_atomic_int_set (&_record_status, Enabled);
if (Config->get_use_hardware_monitoring()) {
/* Even though this can be called from RT context we are using
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if (auto_input && (*i)->record_enabled ()) {
void
Session::maybe_enable_record ()
{
- atomic_set (&_record_status, Enabled);
+ g_atomic_int_set (&_record_status, Enabled);
/* XXX this save should really happen in another thread. its needed so that
pending capture state can be recovered if we crash.
*/
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
vector<Sample*>::iterator i;
uint32_t np;
{
// jlc, WTF is this!
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
AudioRegion::set_default_fade (steepness, fade_frames);
}
/* count existing audio tracks */
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if (dynamic_cast<AudioTrack*>(*i) != 0) {
if (!(*i)->hidden()) {
/* count existing audio busses */
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if (dynamic_cast<AudioTrack*>(*i) == 0) {
if (!(*i)->hidden()) {
Session::add_route (Route* route)
{
{
- RWLockMonitor lm (route_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (route_lock);
routes.push_front (route);
resort_routes(0);
}
dstream->do_refill(0, 0, 0);
{
- RWLockMonitor lm (diskstream_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (diskstream_lock);
diskstreams.push_back (dstream);
}
Session::remove_route (Route& route)
{
{
- RWLockMonitor lm (route_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (route_lock);
routes.remove (&route);
/* deleting the master out seems like a dumb
}
{
- RWLockMonitor lm (diskstream_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (diskstream_lock);
AudioTrack* at;
return;
}
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
bool is_track;
is_track = (dynamic_cast<AudioTrack*>(route) != 0);
basis, but needs the global overview that only the session
has.
*/
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
update_route_solo_state();
}
Route *
Session::route_by_name (string name)
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i)->name() == name) {
Route *
Session::route_by_remote_id (uint32_t id)
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i)->remote_control_id() == id) {
DiskStream *
Session::diskstream_by_name (string name)
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->name() == name) {
DiskStream *
Session::diskstream_by_id (id_t id)
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->id() == id) {
if (base == "") {
- LockMonitor lm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (region_lock);
snprintf (buf, sizeof (buf), "%d", (int)audio_regions.size() + 1);
bool name_taken = true;
{
- LockMonitor lm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (region_lock);
for (int n = 1; n < 5000; ++n) {
bool added = false;
{
- LockMonitor lm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (region_lock);
if ((ar = dynamic_cast<AudioRegion*> (region)) != 0) {
bool removed = false;
{
- LockMonitor lm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (region_lock);
if ((ar = dynamic_cast<AudioRegion*> (region)) != 0) {
if ((i = audio_regions.find (region->id())) != audio_regions.end()) {
{
AudioRegionList::iterator i;
AudioRegion* region;
- LockMonitor lm (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (region_lock);
for (i = audio_regions.begin(); i != audio_regions.end(); ++i) {
{
list<Region*> r;
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
list<Region*>& l = (*i)->last_capture_regions();
pair<SourceList::key_type, SourceList::mapped_type> entry;
{
- LockMonitor lm (source_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (source_lock);
entry.first = source->id();
entry.second = source;
sources.insert (entry);
SourceList::iterator i;
{
- LockMonitor lm (source_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (source_lock);
if ((i = sources.find (source->id())) != sources.end()) {
sources.erase (i);
Source *
Session::get_source (ARDOUR::id_t id)
{
- LockMonitor lm (source_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (source_lock);
SourceList::iterator i;
Source* source = 0;
string res;
- res = PBD::dirname (audio_path);
- res = PBD::dirname (res);
+ res = Glib::path_get_dirname (audio_path);
+ res = Glib::path_get_dirname (res);
res += '/';
res += peak_dir_name;
res += '/';
Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
{
string look_for;
- string old_basename = basename_nosuffix (oldname);
+ string old_basename = PBD::basename_nosuffix (oldname);
string new_legalized = legalize_for_path (newname);
/* note: we know (or assume) the old path is already valid */
Playlist *
Session::playlist_by_name (string name)
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
if ((*i)->name() == name) {
return* i;
}
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
if (find (playlists.begin(), playlists.end(), playlist) == playlists.end()) {
playlists.insert (playlists.begin(), playlist);
// playlist->ref();
PlaylistList::iterator x;
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
if (!inuse) {
//cerr << "shifting playlist to unused: " << pl->name() << endl;
}
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
// cerr << "removing playlist: " << playlist->name() << endl;
PlaylistList::iterator i;
Session::set_all_solo (bool yn)
{
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if (!(*i)->hidden()) {
Session::set_all_mute (bool yn)
{
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if (!(*i)->hidden()) {
uint32_t
Session::n_diskstreams () const
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
uint32_t n = 0;
for (DiskStreamList::const_iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
void
Session::foreach_diskstream (void (DiskStream::*func)(void))
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if (!(*i)->hidden()) {
((*i)->*func)();
if (_state_of_the_state & InitialConnecting) {
return;
}
-
- RWLockMonitor lm1 (route_lock, true, __LINE__, __FILE__);
- RWLockMonitor lm2 (diskstream_lock, false, __LINE__, __FILE__);
+
+ Glib::RWLock::WriterLock lm1 (route_lock);
+ Glib::RWLock::ReaderLock lm2 (diskstream_lock);
resort_routes (0);
void
Session::record_enable_change_all (bool yn)
{
- RWLockMonitor lm1 (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm1 (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
AudioTrack* at;
Session::add_connection (ARDOUR::Connection* connection)
{
{
- LockMonitor (connection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock guard (connection_lock);
_connections.push_back (connection);
}
bool removed = false;
{
- LockMonitor (connection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock guard (connection_lock);
ConnectionList::iterator i = find (_connections.begin(), _connections.end(), connection);
if (i != _connections.end()) {
ARDOUR::Connection *
Session::connection_by_name (string name) const
{
- LockMonitor lm (connection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (connection_lock);
for (ConnectionList::const_iterator i = _connections.begin(); i != _connections.end(); ++i) {
if ((*i)->name() == name) {
_edit_mode = mode;
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
for (PlaylistList::iterator i = playlists.begin(); i != playlists.end(); ++i) {
(*i)->set_edit_mode (mode);
NamedSelection *
Session::named_selection_by_name (string name)
{
- LockMonitor lm (named_selection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (named_selection_lock);
for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
if ((*i)->name == name) {
return* i;
Session::add_named_selection (NamedSelection* named_selection)
{
{
- LockMonitor lm (named_selection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (named_selection_lock);
named_selections.insert (named_selections.begin(), named_selection);
}
bool removed = false;
{
- LockMonitor lm (named_selection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (named_selection_lock);
NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
{
// jlc - WHY take routelock?
//RWLockMonitor lm1 (route_lock, true, __LINE__, __FILE__);
- RWLockMonitor lm2 (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm2 (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
(*i)->reset_write_sources (false);
bool
Session::route_name_unique (string n) const
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i)->name() == n) {
uint32_t
Session::n_playlists () const
{
- LockMonitor lm (playlist_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (playlist_lock);
return playlists.size();
}
int
Session::freeze (InterThreadInfo& itt)
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
char * workbuf = 0;
const jack_nframes_t chunk_size = (256 * 1024)/4;
- atomic_set (&processing_prohibited, 1);
+ g_atomic_int_set (&processing_prohibited, 1);
/* call tree *MUST* hold route_lock */
delete [] workbuf;
}
- atomic_set (&processing_prohibited, 0);
+ g_atomic_int_set (&processing_prohibited, 0);
itt.done = true;
Session::ntracks () const
{
uint32_t n = 0;
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if (dynamic_cast<AudioTrack*> (*i)) {
Session::nbusses () const
{
uint32_t n = 0;
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if (dynamic_cast<AudioTrack*> (*i) == 0) {
#include <fcntl.h>
#include <poll.h>
+#include <glibmm/thread.h>
+
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
#include <pbd/pthread_utils.h>
#include <ardour/configuration.h>
Crossfade::set_buffer_size (dstream_buffer_size);
- pthread_cond_init (&butler_paused, 0);
-
butler_should_run = false;
if (pipe (butler_request_pipe)) {
void
Session::schedule_butler_transport_work ()
{
- atomic_inc (&butler_should_do_transport_work);
+ g_atomic_int_inc (&butler_should_do_transport_work);
summon_butler ();
}
void
Session::stop_butler ()
{
- LockMonitor lm (butler_request_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (butler_request_lock);
char c = ButlerRequest::Pause;
::write (butler_request_pipe[1], &c, 1);
- pthread_cond_wait (&butler_paused, butler_request_lock.mutex());
+ butler_paused.wait(butler_request_lock);
}
void
Session::wait_till_butler_finished ()
{
- LockMonitor lm (butler_request_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (butler_request_lock);
char c = ButlerRequest::Wake;
::write (butler_request_pipe[1], &c, 1);
- pthread_cond_wait (&butler_paused, butler_request_lock.mutex());
+ butler_paused.wait(butler_request_lock);
}
void *
return 0;
}
-#define transport_work_requested() atomic_read(&butler_should_do_transport_work)
+#define transport_work_requested() g_atomic_int_get(&butler_should_do_transport_work)
void *
Session::butler_thread_work ()
gettimeofday (&begin, 0);
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (i = diskstreams.begin(); !transport_work_requested() && butler_should_run && i != diskstreams.end(); ++i) {
{
- LockMonitor lm (butler_request_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (butler_request_lock);
if (butler_should_run && (disk_work_outstanding || transport_work_requested())) {
// for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
continue;
}
- pthread_cond_signal (&butler_paused);
+ butler_paused.signal();
}
}
} else {
- RWLockMonitor dm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
(*i)->set_pending_overwrite (true);
}
uint32_t
Session::playback_load ()
{
- return (uint32_t) atomic_read (&_playback_load);
+ return (uint32_t) g_atomic_int_get (&_playback_load);
}
uint32_t
Session::capture_load ()
{
- return (uint32_t) atomic_read (&_capture_load);
+ return (uint32_t) g_atomic_int_get (&_capture_load);
}
uint32_t
Session::playback_load_min ()
{
- return (uint32_t) atomic_read (&_playback_load_min);
+ return (uint32_t) g_atomic_int_get (&_playback_load_min);
}
uint32_t
Session::capture_load_min ()
{
- return (uint32_t) atomic_read (&_capture_load_min);
+ return (uint32_t) g_atomic_int_get (&_capture_load_min);
}
void
Session::reset_capture_load_min ()
{
- atomic_set (&_capture_load_min, 100);
+ g_atomic_int_set (&_capture_load_min, 100);
}
void
Session::reset_playback_load_min ()
{
- atomic_set (&_playback_load_min, 100);
+ g_atomic_int_set (&_playback_load_min, 100);
}
return;
}
- TentativeRWLockMonitor clickm (click_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock clickm (click_lock, Glib::TRY_LOCK);
if (!clickm.locked() || _transport_speed != 1.0 || !_clicking || click_data == 0) {
_click_io->silence (nframes, offset);
void
Session::clear_clicks ()
{
- RWLockMonitor lm (click_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (click_lock);
for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
delete *i;
#include <ardour/timestamps.h>
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
#include <sigc++/bind.h>
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <ardour/gdither.h>
#include <ardour/timestamps.h>
/* take everyone out of awrite to avoid disasters */
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
(*i)->protect_automation ();
}
/* get everyone to the right position */
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)-> seek (spec.start_frame, true)) {
error << string_compose (_("%1: cannot seek to %2 for export"),
set_transport_speed (1.0, false);
butler_transport_work ();
- atomic_set (&butler_should_do_transport_work, 0);
+ g_atomic_int_set (&butler_should_do_transport_work, 0);
post_transport ();
/* we are ready to go ... */
#include <midi++/types.h>
#include <midi++/port.h>
#include <midi++/manager.h>
+
+#include <glibmm/thread.h>
+
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
#include <pbd/pthread_utils.h>
#include <ardour/configuration.h>
#include <midi++/port.h>
#include <midi++/manager.h>
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/pthread_utils.h>
#include <ardour/configuration.h>
poke_midi_thread ();
if (_midi_port) {
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock guard (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
(*i)->reset_midi_control (_midi_port, midi_control);
}
*/
save_state ("", true);
- atomic_set (&_record_status, Enabled);
+ g_atomic_int_set (&_record_status, Enabled);
RecordStateChanged (); /* EMIT SIGNAL */
request_transport_speed (1.0);
if (mmc_control) {
RouteList::iterator i;
- RWLockMonitor (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock guard (route_lock);
for (i = routes.begin(); i != routes.end(); ++i) {
AudioTrack *at;
mmc_buffer[nbytes++] = 0xf7; // terminate SysEx/MMC message
- LockMonitor lm (midi_lock, __LINE__, __FILE__);
-
+ Glib::Mutex::Lock lm (midi_lock);
+
if (_mmc_port->write (mmc_buffer, nbytes) != nbytes) {
error << string_compose(_("MMC: cannot send command %1%2%3"), &hex, cmd, &dec) << endmsg;
}
#include <algorithm>
#include <unistd.h>
-#include <ardour/timestamps.h>
-
#include <pbd/error.h>
-#include <pbd/atomic.h>
-#include <pbd/lockmonitor.h>
+
+#include <glibmm/thread.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
+#include <ardour/timestamps.h>
#include <ardour/diskstream.h>
#include <ardour/audioengine.h>
#include <ardour/slave.h>
}
if (non_realtime_work_pending()) {
- if (atomic_read (&butler_should_do_transport_work) == 0) {
+ if (g_atomic_int_get (&butler_should_do_transport_work) == 0) {
post_transport ();
}
}
this is really bad ...
*/
- if (atomic_read (&processing_prohibited)) {
+ if (g_atomic_int_get (&processing_prohibited)) {
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
(*i)->silence (nframes, offset);
}
cworst = min (cworst, (*i)->capture_buffer_load());
}
- uint32_t pmin = atomic_read (&_playback_load);
- uint32_t pminold = atomic_read (&_playback_load_min);
- uint32_t cmin = atomic_read (&_capture_load);
- uint32_t cminold = atomic_read (&_capture_load_min);
+ uint32_t pmin = g_atomic_int_get (&_playback_load);
+ uint32_t pminold = g_atomic_int_get (&_playback_load_min);
+ uint32_t cmin = g_atomic_int_get (&_capture_load);
+ uint32_t cminold = g_atomic_int_get (&_capture_load_min);
- atomic_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
- atomic_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
- atomic_set (&_playback_load_min, min (pmin, pminold));
- atomic_set (&_capture_load_min, min (cmin, cminold));
+ g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
+ g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
+ g_atomic_int_set (&_playback_load_min, min (pmin, pminold));
+ g_atomic_int_set (&_capture_load_min, min (cmin, cminold));
if (actively_recording()) {
set_dirty();
end_frame = _transport_frame + nframes;
{
- TentativeRWLockMonitor rm (route_lock, false, __LINE__, __FILE__);
- TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
-
+ Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
+
Event* this_event;
Events::iterator the_next_one;
if (slave_state == Waiting) {
// cerr << "waiting at " << slave_transport_frame << endl;
- TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
-
+ Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
+
if (dsm.locked() && slave_transport_frame >= slave_wait_end) {
// cerr << "\tstart at " << _transport_frame << endl;
bool need_butler;
- TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
if (!dsm.locked()) {
goto noroll;
}
long frames_moved;
{
- TentativeRWLockMonitor rm (route_lock, false, __LINE__, __FILE__);
- TentativeRWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock, Glib::TRY_LOCK);
if (!rm.locked() || !dsm.locked() || (post_transport_work & (PostTransportLocate|PostTransportStop))) {
no_roll (nframes, 0);
void
Session::process_audition (jack_nframes_t nframes)
{
- TentativeRWLockMonitor rm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock rm (route_lock, Glib::TRY_LOCK);
Event* ev;
if (rm.locked()) {
#include <sys/param.h>
#endif
+#include <glibmm.h>
+
#include <midi++/mmc.h>
#include <midi++/port.h>
#include <pbd/error.h>
-#include <pbd/dirname.h>
-#include <pbd/lockmonitor.h>
+
+#include <glibmm/thread.h>
#include <pbd/pathscanner.h>
#include <pbd/pthread_utils.h>
-#include <pbd/basename.h>
#include <pbd/strsplit.h>
#include <ardour/audioengine.h>
_tempo_map = new TempoMap (_current_frame_rate);
_tempo_map->StateChanged.connect (mem_fun (*this, &Session::tempo_map_changed));
- atomic_set (&processing_prohibited, 0);
+ g_atomic_int_set (&processing_prohibited, 0);
send_cnt = 0;
insert_cnt = 0;
_transport_speed = 0;
end_location = new Location (0, 0, _("end"), Location::Flags ((Location::IsMark|Location::IsEnd)));
start_location = new Location (0, 0, _("start"), Location::Flags ((Location::IsMark|Location::IsStart)));
_end_location_is_free = true;
- atomic_set (&_record_status, Disabled);
+ g_atomic_int_set (&_record_status, Disabled);
auto_play = false;
punch_in = false;
punch_out = false;
state_was_pending = false;
set_next_event ();
outbound_mtc_smpte_frame = 0;
- next_quarter_frame_to_send = 0;
+ next_quarter_frame_to_send = -1;
current_block_size = 0;
_solo_latched = true;
_solo_model = InverseMute;
midi_control = true;
mmc = 0;
post_transport_work = PostTransportWork (0);
- atomic_set (&butler_should_do_transport_work, 0);
- atomic_set (&butler_active, 0);
- atomic_set (&_playback_load, 100);
- atomic_set (&_capture_load, 100);
- atomic_set (&_playback_load_min, 100);
- atomic_set (&_capture_load_min, 100);
+ g_atomic_int_set (&butler_should_do_transport_work, 0);
+ g_atomic_int_set (&butler_active, 0);
+ g_atomic_int_set (&_playback_load, 100);
+ g_atomic_int_set (&_capture_load, 100);
+ g_atomic_int_set (&_playback_load_min, 100);
+ g_atomic_int_set (&_capture_load_min, 100);
pending_audition_region = 0;
_edit_mode = Slide;
pending_edit_mode = _edit_mode;
return -1;
}
- /* FIXME
- if (start_midi_thread ()) {
+ /*if (start_midi_thread ()) {
return -1;
- }
- */
+ }*/
if (state_tree) {
if (set_state (*state_tree->root())) {
first_time_running = _engine.Running.connect (mem_fun (*this, &Session::when_engine_running));
}
- // FIXME
//send_full_time_code ();
_engine.transport_locate (0);
- //deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
- //deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
+ deliver_mmc (MIDI::MachineControl::cmdMmcReset, 0);
+ deliver_mmc (MIDI::MachineControl::cmdLocate, 0);
ControlProtocolManager::instance().set_session (*this);
child = node->add_child ("Sources");
if (full_state) {
- LockMonitor sl (source_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock sl (source_lock);
for (SourceList::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
child = node->add_child ("Regions");
if (full_state) {
- LockMonitor rl (region_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock rl (region_lock);
for (AudioRegionList::const_iterator i = audio_regions.begin(); i != audio_regions.end(); ++i) {
child = node->add_child ("DiskStreams");
{
- RWLockMonitor dl (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dl (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if (!(*i)->hidden()) {
child->add_child_nocopy ((*i)->get_state());
child = node->add_child ("Connections");
{
- LockMonitor lm (connection_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (connection_lock);
for (ConnectionList::iterator i = _connections.begin(); i != _connections.end(); ++i) {
if (!(*i)->system_dependent()) {
child->add_child_nocopy ((*i)->get_state());
child = node->add_child ("Routes");
{
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
RoutePublicOrderSorter cmp;
RouteList public_order(routes);
{
XMLNode* node = new XMLNode (X_("Sources"));
- LockMonitor lm (source_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (source_lock);
for (SourceList::iterator i = sources.begin(); i != sources.end(); ++i) {
node->add_child_nocopy ((*i).second->get_state());
#if HAVE_SYS_VFS_H
struct statfs statfsbuf;
vector<space_and_path>::iterator i;
- LockMonitor lm (space_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (space_lock);
double scale;
/* get freespace on every FS that is part of the session path */
void
Session::swap_configuration(Configuration** new_config)
{
- RWLockMonitor lm (route_lock, true, __LINE__, __FILE__); // jlc - WHY?
+ Glib::RWLock::WriterLock lm (route_lock); // jlc - WHY?
Configuration* tmp = *new_config;
*new_config = Config;
Config = tmp;
void
Session::copy_configuration(Configuration* new_config)
{
- RWLockMonitor lm (route_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock lm (route_lock);
new_config = new Configuration(*Config);
}
Session::get_global_route_boolean (bool (Route::*method)(void) const)
{
GlobalRouteBooleanState s;
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if (!(*i)->hidden()) {
Session::get_global_route_metering ()
{
GlobalRouteMeterState s;
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
if (!(*i)->hidden()) {
on whichever filesystem it was already on.
*/
- newpath = PBD::dirname (*x);
- newpath = PBD::dirname (newpath);
+ newpath = Glib::path_get_dirname (*x);
+ newpath = Glib::path_get_dirname (newpath);
newpath += '/';
newpath += dead_sound_dir_name;
newpath += '/';
- newpath += PBD::basename ((*x));
+ newpath += Glib::path_get_basename ((*x));
if (access (newpath.c_str(), F_OK) == 0) {
#include <pbd/undo.h>
#include <pbd/error.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/pthread_utils.h>
#include <midi++/mmc.h>
void
Session::butler_transport_work ()
{
- RWLockMonitor rm (route_lock, false, __LINE__, __FILE__);
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
-
+ Glib::RWLock::ReaderLock rm (route_lock);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
+
if (post_transport_work & PostTransportCurveRealloc) {
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
(*i)->curve_reallocate();
non_realtime_set_audition ();
}
- atomic_dec (&butler_should_do_transport_work);
+ g_atomic_int_dec_and_test (&butler_should_do_transport_work);
}
void
Session::non_realtime_set_speed ()
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
(*i)->non_realtime_set_speed ();
void
Session::non_realtime_overwrite ()
{
- RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->pending_overwrite) {
*/
if (!Config->get_latched_record_enable()) {
- atomic_set (&_record_status, Disabled);
+ g_atomic_int_set (&_record_status, Disabled);
} else {
- atomic_set (&_record_status, Enabled);
+ g_atomic_int_set (&_record_status, Enabled);
}
RecordStateChanged (); /* emit signal */
}
/* this is functionally what clear_clicks() does but with a tentative lock */
- TentativeRWLockMonitor clickm (click_lock, true, __LINE__, __FILE__);
+ Glib::RWLock::WriterLock clickm (click_lock, Glib::TRY_LOCK);
if (clickm.locked()) {
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if ((*i)->record_enabled ()) {
//cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
a non-tentative rwlock here, because the action must occur.
The rarity and short potential lock duration makes this "OK"
*/
- RWLockMonitor dsm (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock dsm (diskstream_lock);
for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
if (auto_input && (*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
the picture.
*/
- atomic_set (&butler_should_do_transport_work, 0);
+ g_atomic_int_set (&butler_should_do_transport_work, 0);
post_transport_work = PostTransportWork (0);
stop_butler ();
return;
}
- RWLockMonitor lm (route_lock, false, __LINE__, __FILE__);
- RWLockMonitor lm2 (diskstream_lock, false, __LINE__, __FILE__);
+ Glib::RWLock::ReaderLock lm (route_lock);
+ Glib::RWLock::ReaderLock lm2 (diskstream_lock);
_worst_track_latency = 0;
for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
real_cnt = cnt * _info.channels;
{
- LockMonitor lm (_tmpbuf_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_tmpbuf_lock);
if (tmpbufsize < real_cnt) {
#include <iomanip>
#include <algorithm>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/xml++.h>
#include <pbd/pthread_utils.h>
using std::max;
using namespace ARDOUR;
-using namespace PBD;
-sigc::signal<void,Source *> Source::SourceCreated;
+sigc::signal<void,Source *> Source::SourceCreated;
pthread_t Source::peak_thread;
bool Source::have_peak_thread = false;
vector<Source*> Source::pending_peak_sources;
-PBD::Lock Source::pending_peak_sources_lock;
+Glib::StaticMutex Source::pending_peak_sources_lock = GLIBMM_STATIC_MUTEX_INIT;
int Source::peak_request_pipe[2];
bool Source::_build_missing_peakfiles = false;
PBD::ThreadCreated (pthread_self(), X_("Peak"));
struct pollfd pfd[1];
- LockMonitor lm (pending_peak_sources_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (pending_peak_sources_lock);
while (true) {
pfd[0].fd = peak_request_pipe[0];
pfd[0].events = POLLIN|POLLERR|POLLHUP;
- pthread_mutex_unlock (pending_peak_sources_lock.mutex());
+ pending_peak_sources_lock.unlock();
if (poll (pfd, 1, -1) < 0) {
if (errno == EINTR) {
- pthread_mutex_lock (pending_peak_sources_lock.mutex());
+ pending_peak_sources_lock.lock();
continue;
}
}
}
- pthread_mutex_lock (pending_peak_sources_lock.mutex());
+ pending_peak_sources_lock.lock();
while (!pending_peak_sources.empty()) {
Source* s = pending_peak_sources.front();
pending_peak_sources.erase (pending_peak_sources.begin());
- pthread_mutex_unlock (pending_peak_sources_lock.mutex());
+ pending_peak_sources_lock.unlock();
s->build_peaks();
- pthread_mutex_lock (pending_peak_sources_lock.mutex());
+ pending_peak_sources_lock.lock();
}
}
{
if (have_peak_thread) {
- LockMonitor lm (pending_peak_sources_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (pending_peak_sources_lock);
source.next_peak_clear_should_notify = true;
{
/* this is done to cancel a group of running peak builds */
if (have_peak_thread) {
- LockMonitor lm (pending_peak_sources_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (pending_peak_sources_lock);
pending_peak_sources.clear ();
}
}
Source::peaks_ready (sigc::slot<void> the_slot, sigc::connection& conn) const
{
bool ret;
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
/* check to see if the peak data is ready. if not
connect the slot while still holding the lock.
int
Source::read_peaks (PeakData *peaks, jack_nframes_t npeaks, jack_nframes_t start, jack_nframes_t cnt, double samples_per_visual_peak) const
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
double scale;
double expected_peaks;
PeakData::PeakDatum xmax;
list<PeakBuildRecord*> copy;
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
copy = pending_peak_builds;
pending_peak_builds.clear ();
}
}
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
if (status == 0) {
_peaks_built = true;
void
Source::build_peaks_from_scratch ()
{
- LockMonitor lp (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lp (_lock);
next_peak_clear_should_notify = true;
pending_peak_builds.push_back (new PeakBuildRecord (0, _length));
}
{
- LockMonitor lm (_lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (_lock);
end = lseek (peakfile, 0, SEEK_END);
}
#include <sigc++/bind.h>
-#include <pbd/lockmonitor.h>
+#include <glibmm/thread.h>
#include <pbd/xml++.h>
#include <ardour/tempo.h>
#include <ardour/utils.h>
return 1;
}
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
MetricSectionSorter cmp;
BBT_Time corrected (when);
bool removed = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
Metrics::iterator i;
for (i = metrics->begin(); i != metrics->end(); ++i) {
bool removed = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
Metrics::iterator i;
for (i = metrics->begin(); i != metrics->end(); ++i) {
TempoMap::add_tempo (const Tempo& tempo, BBT_Time where)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
/* new tempos always start on a beat */
bool replaced = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
Metrics::iterator i;
for (i = metrics->begin(); i != metrics->end(); ++i) {
TempoMap::add_meter (const Meter& meter, BBT_Time where)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
/* a new meter always starts a new bar on the first beat. so
round the start time appropriately. remember that
bool replaced = false;
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
Metrics::iterator i;
for (i = metrics->begin(); i != metrics->end(); ++i) {
void
TempoMap::bbt_time (jack_nframes_t frame, BBT_Time& bbt) const
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
bbt_time_unlocked (frame, bbt);
}
bbt_time(pos,when);
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
frames = bbt_duration_at_unlocked (when, bbt,dir);
}
jack_nframes_t
TempoMap::round_to_bar (jack_nframes_t fr, int dir)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
return round_to_type (fr, dir, Bar);
}
jack_nframes_t
TempoMap::round_to_beat (jack_nframes_t fr, int dir)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
return round_to_type (fr, dir, Beat);
}
TempoMap::round_to_beat_subdivision (jack_nframes_t fr, int sub_num)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
TempoMap::BBTPointList::iterator i;
TempoMap::BBTPointList *more_zoomed_bbt_points;
jack_nframes_t frame_one_beats_worth;
XMLNode&
TempoMap::get_state ()
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
Metrics::const_iterator i;
XMLNode *root = new XMLNode ("TempoMap");
TempoMap::set_state (const XMLNode& node)
{
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
XMLNodeList nlist;
XMLNodeConstIterator niter;
Change
TempoMap::restore_state (StateManager::State& state)
{
- LockMonitor lm (lock, __LINE__, __FILE__);
+ Glib::Mutex::Lock lm (lock);
TempoMapState* tmstate = dynamic_cast<TempoMapState*> (&state);
}
int
-touch_file(string path)
+touch_file (string path)
{
- FILE* file = fopen(path.c_str(), "a");
- fclose(file);
+ int fd = open (path.c_str(), O_RDONLY|O_CREAT);
+ if (fd >= 0) {
+ close (fd);
+ return 0;
+ }
return 1;
}
#include <gtkmm2ext/fastmeter.h>
#include <gtkmm2ext/utils.h>
#include <gtkmm/style.h>
+#include <string.h>
using namespace Gtk;
using namespace Gdk;
using namespace Gtkmm2ext;
using namespace std;
-string FastMeter::v_image_path;
-string FastMeter::h_image_path;
-RefPtr<Pixbuf> FastMeter::v_pixbuf;
-gint FastMeter::v_pixheight = 0;
-gint FastMeter::v_pixwidth = 0;
-RefPtr<Pixbuf> FastMeter::h_pixbuf;
-gint FastMeter::h_pixheight = 0;
-gint FastMeter::h_pixwidth = 0;
+int FastMeter::min_v_pixbuf_size = 50;
+int FastMeter::max_v_pixbuf_size = 1024;
+Glib::RefPtr<Gdk::Pixbuf>* FastMeter::v_pixbuf_cache = 0;
+
+int FastMeter::min_h_pixbuf_size = 50;
+int FastMeter::max_h_pixbuf_size = 1024;
+Glib::RefPtr<Gdk::Pixbuf>* FastMeter::h_pixbuf_cache = 0;
+
FastMeter::FastMeter (long hold, unsigned long dimen, Orientation o)
{
pixrect.x = 0;
pixrect.y = 0;
- if (!v_image_path.empty() && v_pixbuf == 0) {
- v_pixbuf = Pixbuf::create_from_file (v_image_path);
- v_pixheight = v_pixbuf->get_height();
- v_pixwidth = v_pixbuf->get_width();
- }
- if (!h_image_path.empty() && h_pixbuf == 0) {
- h_pixbuf = Pixbuf::create_from_file (h_image_path);
- h_pixheight = h_pixbuf->get_height();
- h_pixwidth = h_pixbuf->get_width();
+ if (orientation == Vertical) {
+ pixbuf = request_vertical_meter(250);
+ } else {
+ pixbuf = request_horizontal_meter(186);
}
+ pixheight = pixbuf->get_height();
+ pixwidth = pixbuf->get_width();
+
if (orientation == Vertical) {
- pixrect.width = min (v_pixwidth, (gint) dimen);
- pixrect.height = v_pixheight;
+ pixrect.width = min (pixwidth, (gint) dimen);
+ pixrect.height = pixheight;
} else {
- pixrect.width = h_pixwidth;
- pixrect.height = min (h_pixheight, (gint) dimen);
+ pixrect.width = pixwidth;
+ pixrect.height = min (pixheight, (gint) dimen);
}
request_width = pixrect.width;
request_height= pixrect.height;
}
-FastMeter::~FastMeter ()
+Glib::RefPtr<Gdk::Pixbuf> FastMeter::request_vertical_meter(int length)
{
+ if (length < min_v_pixbuf_size)
+ length = min_v_pixbuf_size;
+ if (length > max_v_pixbuf_size)
+ length = max_v_pixbuf_size;
+
+ int index = length - 1;
+
+ if (v_pixbuf_cache == 0) {
+ v_pixbuf_cache = (Glib::RefPtr<Gdk::Pixbuf>*) malloc(sizeof(Glib::RefPtr<Gdk::Pixbuf>) * max_v_pixbuf_size);
+ memset(v_pixbuf_cache,0,sizeof(Glib::RefPtr<Gdk::Pixbuf>) * max_v_pixbuf_size);
+ }
+ Glib::RefPtr<Gdk::Pixbuf> ret = v_pixbuf_cache[index];
+ if (ret)
+ return ret;
+
+ guint8* data;
+ int width = 5;
+ int height = length;
+
+ data = (guint8*) malloc(width*height * 3);
+
+ guint8 r,g,b;
+ r=0;
+ g=255;
+ b=0;
+
+ // fake log calculation copied from log_meter.h
+ // actual calculation:
+ // log_meter(0.0f) =
+ // def = (0.0f + 20.0f) * 2.5f + 50f
+ // return def / 115.0f
+ int knee = (int)floor((float)height * 100.0f / 115.0f);
+
+ int y;
+
+ for (y = 0; y < knee / 2; y++) {
+
+ r = (guint8)floor(255.0 * (float)y/(float)(knee / 2));
+
+ for (int x = 0; x < width; x++) {
+ data[ (x+(height-y-1)*width) * 3 + 0 ] = r;
+ data[ (x+(height-y-1)*width) * 3 + 1 ] = g;
+ data[ (x+(height-y-1)*width) * 3 + 2 ] = b;
+ }
+ }
+
+ for (; y < knee; y++) {
+
+ g = 255 - (guint8)floor(170.0 * (float)(y - knee/ 2)/(float)(knee / 2));
+
+ for (int x = 0; x < width; x++) {
+ data[ (x+(height-y-1)*width) * 3 + 0 ] = r;
+ data[ (x+(height-y-1)*width) * 3 + 1 ] = g;
+ data[ (x+(height-y-1)*width) * 3 + 2 ] = b;
+ }
+ }
+
+ r=255;
+ g=0;
+ b=0;
+ for (; y < height; y++) {
+ for (int x = 0; x < width; x++) {
+ data[ (x+(height-y-1)*width) * 3 + 0 ] = r;
+ data[ (x+(height-y-1)*width) * 3 + 1 ] = g;
+ data[ (x+(height-y-1)*width) * 3 + 2 ] = b;
+ }
+ }
+
+ ret = Pixbuf::create_from_data(data, COLORSPACE_RGB, false, 8, width, height, width * 3);
+ v_pixbuf_cache[index] = ret;
+
+ return ret;
}
-void
-FastMeter::set_vertical_xpm (std::string path)
+Glib::RefPtr<Gdk::Pixbuf> FastMeter::request_horizontal_meter(int length)
{
- v_image_path = path;
+ if (length < min_h_pixbuf_size)
+ length = min_h_pixbuf_size;
+ if (length > max_h_pixbuf_size)
+ length = max_h_pixbuf_size;
+
+ int index = length - 1;
+
+ if (h_pixbuf_cache == 0) {
+ h_pixbuf_cache = (Glib::RefPtr<Gdk::Pixbuf>*) malloc(sizeof(Glib::RefPtr<Gdk::Pixbuf>) * max_h_pixbuf_size);
+ memset(h_pixbuf_cache,0,sizeof(Glib::RefPtr<Gdk::Pixbuf>) * max_h_pixbuf_size);
+ }
+ Glib::RefPtr<Gdk::Pixbuf> ret = h_pixbuf_cache[index];
+ if (ret)
+ return ret;
+
+ guint8* data;
+ int width = length;
+ int height = 5;
+
+ data = (guint8*) malloc(width*height * 3);
+
+ guint8 r,g,b;
+ r=0;
+ g=255;
+ b=0;
+
+ // fake log calculation copied from log_meter.h
+ // actual calculation:
+ // log_meter(0.0f) =
+ // def = (0.0f + 20.0f) * 2.5f + 50f
+ // return def / 115.0f
+ int knee = (int)floor((float)width * 100.0f / 115.0f);
+
+ int x;
+
+ for (x = 0; x < knee / 2; x++) {
+
+ r = (guint8)floor(255.0 * (float)x/(float)(knee / 2));
+
+ for (int y = 0; y < height; y++) {
+ data[ (x+(height-y-1)*width) * 3 + 0 ] = r;
+ data[ (x+(height-y-1)*width) * 3 + 1 ] = g;
+ data[ (x+(height-y-1)*width) * 3 + 2 ] = b;
+ }
+ }
+
+ for (; x < knee; x++) {
+
+ g = 255 - (guint8)floor(170.0 * (float)(x - knee/ 2)/(float)(knee / 2));
+
+ for (int y = 0; y < height; y++) {
+ data[ (x+(height-y-1)*width) * 3 + 0 ] = r;
+ data[ (x+(height-y-1)*width) * 3 + 1 ] = g;
+ data[ (x+(height-y-1)*width) * 3 + 2 ] = b;
+ }
+ }
+
+ r=255;
+ g=0;
+ b=0;
+ for (; x < width; x++) {
+ for (int y = 0; y < height; y++) {
+ data[ (x+(height-y-1)*width) * 3 + 0 ] = r;
+ data[ (x+(height-y-1)*width) * 3 + 1 ] = g;
+ data[ (x+(height-y-1)*width) * 3 + 2 ] = b;
+ }
+ }
+
+ ret = Pixbuf::create_from_data(data, COLORSPACE_RGB, false, 8, width, height, width * 3);
+ h_pixbuf_cache[index] = ret;
+
+ return ret;
}
-void
-FastMeter::set_horizontal_xpm (std::string path)
+FastMeter::~FastMeter ()
{
- h_image_path = path;
}
void
void
FastMeter::on_size_request (GtkRequisition* req)
{
- req->width = request_width;
- req->height = request_height;
+ if (orientation == Vertical) {
+ req->height = request_height;
+
+ req->height = max(req->height, min_v_pixbuf_size);
+ req->height = min(req->height, max_v_pixbuf_size);
+
+ req->width = 5;
+ } else {
+ req->width = request_width;
+
+ req->width = max(req->width, min_h_pixbuf_size);
+ req->width = min(req->width, max_h_pixbuf_size);
+
+ req->height = 5;
+ }
+
+}
+
+void
+FastMeter::on_size_allocate (Gtk::Allocation &alloc)
+{
+ if (orientation == Vertical) {
+ if (alloc.get_width() != 5) {
+ alloc.set_width(5);
+ }
+
+ int h = alloc.get_height();
+ h = max(h, min_v_pixbuf_size);
+ h = min(h, max_v_pixbuf_size);
+
+ if ( h != alloc.get_height())
+ alloc.set_height(h);
+
+ if (pixheight != h) {
+ pixbuf = request_vertical_meter(h);
+ }
+ } else {
+ if (alloc.get_height() != 5) {
+ alloc.set_height(5);
+ }
+
+ int w = alloc.get_width();
+ w = max(w, min_h_pixbuf_size);
+ w = min(w, max_h_pixbuf_size);
+
+ if ( w != alloc.get_width())
+ alloc.set_width(w);
+
+ if (pixwidth != w) {
+ pixbuf = request_horizontal_meter(w);
+ }
+ }
+
+ pixheight = pixbuf->get_height();
+ pixwidth = pixbuf->get_width();
+
+ DrawingArea::on_size_allocate(alloc);
}
bool
GdkRectangle intersection;
GdkRectangle background;
- top_of_meter = (gint) floor (v_pixheight * current_level);
+ top_of_meter = (gint) floor (pixheight * current_level);
pixrect.height = top_of_meter;
background.x = 0;
background.y = 0;
background.width = pixrect.width;
- background.height = v_pixheight - top_of_meter;
+ background.height = pixheight - top_of_meter;
- if (gdk_rectangle_intersect (&background, &ev->area, &intersection)) {
+ if (gdk_rectangle_intersect (&background, &ev->area, &intersection)) {
get_window()->draw_rectangle (get_style()->get_black_gc(), true,
intersection.x, intersection.y,
intersection.width, intersection.height);
}
if (gdk_rectangle_intersect (&pixrect, &ev->area, &intersection)) {
-
- /* draw the part of the meter image that we need. the area we draw is bounded "in reverse" (top->bottom)
- */
-
- get_window()->draw_pixbuf(get_style()->get_fg_gc(get_state()), v_pixbuf,
- intersection.x, v_pixheight - top_of_meter,
- intersection.x, v_pixheight - top_of_meter,
+ // draw the part of the meter image that we need. the area we draw is bounded "in reverse" (top->bottom)
+ get_window()->draw_pixbuf(get_style()->get_fg_gc(get_state()), pixbuf,
+ intersection.x, pixheight - top_of_meter,
+ intersection.x, pixheight - top_of_meter,
intersection.width, intersection.height,
Gdk::RGB_DITHER_NONE, 0, 0);
}
- /* draw peak bar */
-
- if (hold_state) {
- get_window()->draw_pixbuf (get_style()->get_fg_gc(get_state()), v_pixbuf,
- intersection.x, v_pixheight - (gint) floor (v_pixheight * current_peak),
- intersection.x, v_pixheight - (gint) floor (v_pixheight * current_peak),
+ // draw peak bar
+ if (hold_state && intersection.width > 0) {
+ gint y = pixheight - (gint) floor (pixheight * current_peak);
+
+ get_window()->draw_pixbuf (get_style()->get_fg_gc(get_state()), pixbuf,
+ intersection.x, y,
+ intersection.x, y,
intersection.width, 3,
Gdk::RGB_DITHER_NONE, 0, 0);
}
- return true;
+ return TRUE;
}
bool
FastMeter::horizontal_expose (GdkEventExpose* ev)
{
- GdkRectangle intersection;
gint right_of_meter;
+ GdkRectangle intersection;
+ GdkRectangle background;
- right_of_meter = (gint) floor (h_pixwidth * current_level);
+ right_of_meter = (gint) floor (pixwidth * current_level);
pixrect.width = right_of_meter;
- if (gdk_rectangle_intersect (&pixrect, &ev->area, &intersection)) {
-
- /* draw the part of the meter image that we need.
- */
-
- get_window()->draw_pixbuf (get_style()->get_fg_gc(get_state()), h_pixbuf,
- intersection.x, intersection.y,
- intersection.x, intersection.y,
- intersection.width, intersection.height,
- Gdk::RGB_DITHER_NONE, 0, 0);
+ background.x = 0;
+ background.y = 0;
+ background.width = pixwidth - right_of_meter;
+ background.height = pixrect.height;
+ if (gdk_rectangle_intersect (&background, &ev->area, &intersection)) {
+ get_window()->draw_rectangle (get_style()->get_black_gc(), true,
+ intersection.x + right_of_meter, intersection.y,
+ intersection.width, intersection.height);
}
- /* draw peak bar */
-
- if (hold_state) {
- get_window()->draw_pixbuf (get_style()->get_fg_gc(get_state()), h_pixbuf,
- right_of_meter, intersection.y,
- right_of_meter, intersection.y,
+ if (gdk_rectangle_intersect (&pixrect, &ev->area, &intersection)) {
+ // draw the part of the meter image that we need. the area we draw is bounded "in reverse" (top->bottom)
+ get_window()->draw_pixbuf(get_style()->get_fg_gc(get_state()), pixbuf,
+ intersection.x, intersection.y,
+ intersection.x, intersection.y,
+ intersection.width, intersection.height,
+ Gdk::RGB_DITHER_NONE, 0, 0);
+ }
+
+ // draw peak bar
+ // XXX: peaks don't work properly
+ /*
+ if (hold_state && intersection.height > 0) {
+ gint x = (gint) floor(pixwidth * current_peak);
+
+ get_window()->draw_pixbuf (get_style()->get_fg_gc(get_state()), pixbuf,
+ x, intersection.y,
+ x, intersection.y,
3, intersection.height,
Gdk::RGB_DITHER_NONE, 0, 0);
-
}
-
+ */
+
return true;
}
long hold_count() { return hold_cnt; }
void set_hold_count (long);
- static void set_horizontal_xpm (std::string);
- static void set_vertical_xpm (std::string);
-
protected:
bool on_expose_event (GdkEventExpose*);
void on_size_request (GtkRequisition*);
+ void on_size_allocate (Gtk::Allocation&);
private:
- static std::string h_image_path;
- static std::string v_image_path;
- static Glib::RefPtr<Gdk::Pixbuf> h_pixbuf;
- static gint h_pixheight;
- static gint h_pixwidth;
- static Glib::RefPtr<Gdk::Pixbuf> v_pixbuf;
- static gint v_pixheight;
- static gint v_pixwidth;
+ Glib::RefPtr<Gdk::Pixbuf> pixbuf;
+ gint pixheight;
+ gint pixwidth;
Orientation orientation;
GdkRectangle pixrect;
bool vertical_expose (GdkEventExpose*);
bool horizontal_expose (GdkEventExpose*);
+
+ static Glib::RefPtr<Gdk::Pixbuf> request_vertical_meter(int);
+
+ static Glib::RefPtr<Gdk::Pixbuf> *v_pixbuf_cache;
+ static int min_v_pixbuf_size;
+ static int max_v_pixbuf_size;
+
+ static Glib::RefPtr<Gdk::Pixbuf> request_horizontal_meter(int);
+
+ static Glib::RefPtr<Gdk::Pixbuf> *h_pixbuf_cache;
+ static int min_h_pixbuf_size;
+ static int max_h_pixbuf_size;
};
#include <gdkmm/color.h>
#include <pbd/abstract_ui.h>
#include <pbd/ringbufferNPT.h>
-#include <pbd/atomic.h>
+
#include <pbd/pool.h>
#include <pbd/error.h>
#include <pbd/receiver.h>
-#include <pbd/lockmonitor.h>
using std::string;
using std::queue;
Import('env libraries install_prefix')
midi2 = env.Copy()
-midi2.Merge([ libraries['sigc2'], libraries['xml'], libraries['pbd3'] ])
+midi2.Merge([ libraries['sigc2'], libraries['xml'], libraries['glib2'], libraries['pbd3'] ])
domain = 'midipp'
*/
#include <fcntl.h>
+
+#include <glib.h>
+
#include <pbd/error.h>
-#include <pbd/basename.h>
#include <midi++/types.h>
#include <midi++/manager.h>
"devicename" is the full path to the requested file
"tagname" (optional) is the name used to refer to the
- port. If not given, PBD::basename (devicename)
+ port. If not given, g_path_get_basename (devicename)
will be used.
"mode" (optional) is either "r" or "w" or something else.
}
} else {
- req->tagname = strdup (PBD::basename (req->devname));
+ req->tagname = g_path_get_basename (req->devname);
req->mode = O_RDWR;
}
libraries['pbd3'],
libraries['midi++2'],
libraries['xml'],
- libraries['usb']
+ libraries['usb'],
+ libraries['glib2'],
+ libraries['glibmm2']
])
libardour_cp = cp.SharedLibrary('ardour_cp', cp_files)
env.Alias('install', env.Install(os.path.join(install_prefix, 'lib/ardour2'), libardour_cp))
env.Alias('tarball', env.Distribute (env['DISTTREE'],
- [ 'SConscript', 'i18n.h', 'gettext.h' ] +
+ [ 'SConscript' ] +
cp_files +
glob.glob('po/*.po') + glob.glob('*.h')))
libraries['pbd3'],
libraries['sigc2'],
libraries['usb'],
- libraries['xml']
+ libraries['xml'],
+ libraries['glib2'],
+ libraries['glibmm2']
])
libardour_genericmidi = genericmidi.SharedLibrary('ardour_genericmidi', genericmidi_files)
env.Alias('install', env.Install(os.path.join(install_prefix, 'lib/ardour2/surfaces'), libardour_genericmidi))
env.Alias('tarball', env.Distribute (env['DISTTREE'],
- [ 'SConscript', 'i18n.h', 'gettext.h' ] +
+ [ 'SConscript' ] +
genericmidi_files +
glob.glob('po/*.po') + glob.glob('*.h')))
return;
}
- // FIXME
- //_port->write (buf, (int32_t) (end - buf));
+ _port->write (buf, 0, (int32_t) (end - buf));
//cerr << "MIDI feedback: wrote " << (int32_t) (end - buf) << " to midi port\n";
}
}
libraries['pbd3'],
libraries['midi++2'],
libraries['xml'],
- libraries['usb']
+ libraries['usb'],
+ libraries['glib2'],
+ libraries['glibmm2']
])
libardour_tranzport = tranzport.SharedLibrary('ardour_tranzport', tranzport_files)
env.Alias('install', env.Install(os.path.join(install_prefix, 'lib/ardour2/surfaces'), libardour_tranzport))
env.Alias('tarball', env.Distribute (env['DISTTREE'],
- [ 'SConscript', 'i18n.h', 'gettext.h' ] +
+ [ 'SConscript' ] +
tranzport_files +
glob.glob('po/*.po') + glob.glob('*.h')))
#include <vector>
#include <sys/time.h>
-#include <pbd/lockmonitor.h>
#include <pthread.h>
#include <usb.h>
+#include <glibmm/thread.h>
+
#include <ardour/types.h>
#include "control_protocol.h"
DisplayMode display_mode;
ARDOUR::gain_t gain_fraction;
- PBD::Lock update_lock;
+ Glib::Mutex update_lock;
char current_screen[2][20];
char pending_screen[2][20];
bool lights[7];
struct timeval last_wheel_motion;
int last_wheel_dir;
- PBD::Lock io_lock;
+ Glib::Mutex io_lock;
int open ();
int read (uint32_t timeout_override = 0);
projects / ardour.git / commitdiff