}
int
-ARDOUR_UI::ambiguous_file (std::string file, std::string path, std::vector<std::string> hits)
+ARDOUR_UI::ambiguous_file (std::string file, std::string /*path*/, std::vector<std::string> hits)
{
AmbiguousFileDialog dialog (file, hits);
void step_edit_status_change (bool);
+ void platform_specific ();
+ void platform_setup ();
+
/* these are used only in response to a platform-specific "ShouldQuit" signal
*/
bool idle_finish ();
void queue_finish ();
+ void fontconfig_dialog ();
std::list<WindowProxyBase*> _window_proxies;
smaller_hbox->set_spacing (6);
smaller_hbox->pack_start (preset_label, false, false, 4);
- smaller_hbox->pack_start (preset_combo, false, false);
+ smaller_hbox->pack_start (_preset_combo, false, false);
smaller_hbox->pack_start (save_button, false, false);
#if 0
/* one day these might be useful with an AU plugin, but not yet */
pack_start (low_box, false, false);
preset_label.show ();
- preset_combo.show ();
+ _preset_combo.show ();
automation_mode_label.show ();
automation_mode_selector.show ();
bypass_button.show ();
UInt32 dataSize;
Boolean isWritable;
NSString* factoryClassName = 0;
- NSURL* CocoaViewBundlePath;
+ NSURL* CocoaViewBundlePath = NULL;
OSStatus result = AudioUnitGetPropertyInfo (*au->get_au(),
kAudioUnitProperty_CocoaUI,
}
bool
-AudioClock::button_release (GdkEventButton *ev, CairoCell* cell)
+AudioClock::button_release (GdkEventButton *ev, CairoCell*)
{
if (editable) {
if (dragging) {
AudioRegionEditor::~AudioRegionEditor ()
{
- pthread_cancel_one (_peak_amplitude_thread_handle);
void* v;
- int const r = pthread_join (_peak_amplitude_thread_handle, &v);
- assert (r == 0);
+ pthread_cancel_one (_peak_amplitude_thread_handle);
+ pthread_join (_peak_amplitude_thread_handle, &v);
}
void
}
int
-AutomationTimeAxisView::set_state (const XMLNode& node, int /*version*/)
+AutomationTimeAxisView::set_state (const XMLNode&, int /*version*/)
{
return 0;
}
}
static void
-gnome_canvas_simpleline_draw (GnomeCanvasItem *item,
+gnome_canvas_simpleline_draw (GnomeCanvasItem *canvas,
GdkDrawable *drawable,
int x, int y,
int width, int height)
(void) cx;
(void) cy;
- GnomeCanvasSimpleLine *simpleline;
double x1, y1, x2, y2;
double dx, dy;
}
bool
-Editor::track_canvas_key_press (GdkEventKey* event)
+Editor::track_canvas_key_press (GdkEventKey*)
{
/* XXX: event does not report the modifier key pressed down, AFAICS, so use the Keyboard object instead */
if (mouse_mode == Editing::MouseZoom && Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
}
bool
-Editor::track_canvas_key_release (GdkEventKey* event)
+Editor::track_canvas_key_release (GdkEventKey*)
{
if (mouse_mode == Editing::MouseZoom && !Keyboard::the_keyboard().key_is_down (GDK_Control_L)) {
set_canvas_cursor (_cursors->zoom_in, true);
}
bool
-Editor::key_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType type)
+Editor::key_press_handler (ArdourCanvas::Item*, GdkEvent*, ItemType)
{
return false;
}
}
void
-MarkerDrag::update_item (Location* location)
+MarkerDrag::update_item (Location*)
{
/* noop */
}
}
bool
-Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
+Editor::leave_handler (ArdourCanvas::Item* item, GdkEvent*, ItemType item_type)
{
AutomationLine* al;
ControlPoint* cp;
}
void
-Editor::add_region_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view)
+Editor::add_region_drag (ArdourCanvas::Item* item, GdkEvent*, RegionView* region_view)
{
assert (region_view);
}
void
-Editor::add_region_copy_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view)
+Editor::add_region_copy_drag (ArdourCanvas::Item* item, GdkEvent*, RegionView* region_view)
{
assert (region_view);
}
void
-Editor::add_region_brush_drag (ArdourCanvas::Item* item, GdkEvent* event, RegionView* region_view)
+Editor::add_region_brush_drag (ArdourCanvas::Item* item, GdkEvent*, RegionView* region_view)
{
assert (region_view);
* used by the `join object/range' tool mode.
*/
void
-Editor::update_join_object_range_location (double x, double y)
+Editor::update_join_object_range_location (double /*x*/, double y)
{
/* XXX: actually, this decides based on whether the mouse is in the top or bottom half of a RouteTimeAxisView;
entered_{track,regionview} is not always setup (e.g. if the mouse is over a TimeSelection), and to get a Region
Editor::toggle_region_fades (int dir)
{
boost::shared_ptr<AudioRegion> ar;
- bool yn;
+ bool yn = false;
RegionSelection rs = get_regions_from_selection_and_entered ();
}
bool
-EditorRegions::enter_notify (GdkEventCrossing* ev)
+EditorRegions::enter_notify (GdkEventCrossing*)
{
if (name_editable) {
return true;
#endif
void
-EditorRegions::populate_row_used (boost::shared_ptr<Region> region, TreeModel::Row const& row, uint32_t used)
+EditorRegions::populate_row_used (boost::shared_ptr<Region>, TreeModel::Row const& row, uint32_t used)
{
char buf[8];
snprintf (buf, sizeof (buf), "%4d" , used);
}
gint
-Editor::metric_get_samples (GtkCustomRulerMark **marks, gdouble lower, gdouble upper, gint /*maxchars*/)
+Editor::metric_get_samples (GtkCustomRulerMark **marks, gdouble lower, gdouble /*upper*/, gint /*maxchars*/)
{
framepos_t pos;
framepos_t const ilower = (framepos_t) floor (lower);
}
void
-Editor::select_all_internal_edit (Selection::Operation op)
+Editor::select_all_internal_edit (Selection::Operation)
{
/* currently limited to MIDI only */
}
bool
-GainMeterBase::gain_slider_button_release (GdkEventButton* ev)
+GainMeterBase::gain_slider_button_release (GdkEventButton*)
{
_amp->gain_control()->stop_touch (false, _amp->session().transport_frame());
return true;
}
void
-GroupTabs::route_added_to_route_group (RouteGroup* rg, boost::weak_ptr<Route> w)
+GroupTabs::route_added_to_route_group (RouteGroup*, boost::weak_ptr<Route> w)
{
/* Similarly-spirited hack as in route_group_property_changed */
}
void
-GroupTabs::route_removed_from_route_group (RouteGroup* rg, boost::weak_ptr<Route> w)
+GroupTabs::route_removed_from_route_group (RouteGroup*, boost::weak_ptr<Route> w)
{
/* Similarly-spirited hack as in route_group_property_changed */
}
static gint
-keyboard_event_handler(GtkWidget *mk, GdkEventKey *event, gpointer notused)
+keyboard_event_handler(GtkWidget *mk, GdkEventKey *event, gpointer ignored)
{
int note;
char *key;
}
static gboolean
-mouse_button_event_handler(PianoKeyboard *pk, GdkEventButton *event, gpointer notused)
+mouse_button_event_handler(PianoKeyboard *pk, GdkEventButton *event, gpointer ignored)
{
int x = event->x;
int y = event->y;
}
static gboolean
-mouse_motion_event_handler(PianoKeyboard *pk, GdkEventMotion *event, gpointer notused)
+mouse_motion_event_handler(PianoKeyboard *pk, GdkEventMotion *event, gpointer ignored)
{
int note;
}
void
-LocationEditRow::end_changed (ARDOUR::Location *loc)
+LocationEditRow::end_changed (ARDOUR::Location *)
{
ENSURE_GUI_THREAD (*this, &LocationEditRow::end_changed, loc)
}
bool
-MidiRegionView::leave_notify (GdkEventCrossing* ev)
+MidiRegionView::leave_notify (GdkEventCrossing*)
{
_mouse_mode_connection.disconnect ();
MidiRegionView::channel_edit ()
{
bool first = true;
- uint8_t current_channel;
+ uint8_t current_channel = 0;
if (_selection.empty()) {
return;
}
bool
-MixerStrip::input_active_button_press (GdkEventButton* ev)
+MixerStrip::input_active_button_press (GdkEventButton*)
{
/* nothing happens on press */
return true;
void
MonitorSection::update_solo_model ()
{
- const char* action_name;
+ const char* action_name = 0;
Glib::RefPtr<Action> act;
if (Config->get_solo_control_is_listen_control()) {
}
bool
-MonoPanner::on_expose_event (GdkEventExpose* ev)
+MonoPanner::on_expose_event (GdkEventExpose*)
{
Glib::RefPtr<Gdk::Window> win (get_window());
Glib::RefPtr<Gdk::GC> gc (get_style()->get_base_gc (get_state()));
}
bool
-MonoPanner::on_key_release_event (GdkEventKey* ev)
+MonoPanner::on_key_release_event (GdkEventKey*)
{
return false;
}
bool
-MonoPanner::on_enter_notify_event (GdkEventCrossing* ev)
+MonoPanner::on_enter_notify_event (GdkEventCrossing*)
{
grab_focus ();
Keyboard::magic_widget_grab_focus ();
}
bool
-Panner2dWindow::on_key_release_event (GdkEventKey *event)
+Panner2dWindow::on_key_release_event (GdkEventKey*)
{
return true;
}
}
void
-RegionView::set_silent_frames (const AudioIntervalResult& silences, double threshold)
+RegionView::set_silent_frames (const AudioIntervalResult& silences, double /*threshold*/)
{
framecnt_t shortest = max_framecnt;
}
void
-RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::ProcessorAutomationNode* pan, boost::shared_ptr<Processor> i)
+RouteTimeAxisView::processor_automation_track_hidden (RouteTimeAxisView::ProcessorAutomationNode* pan, boost::shared_ptr<Processor>)
{
if (!_hidden) {
pan->menu_item->set_active (false);
}
void
-RouteTimeAxisView::add_underlay (StreamView* v, bool update_xml)
+RouteTimeAxisView::add_underlay (StreamView* v, bool /*update_xml*/)
{
if (!v) {
return;
}
bool
-ShuttleControl::on_expose_event (GdkEventExpose* event)
+ShuttleControl::on_expose_event (GdkEventExpose*)
{
cairo_text_extents_t extents;
Glib::RefPtr<Gdk::Window> win (get_window());
}
bool
-StereoPanner::on_key_release_event (GdkEventKey* ev)
+StereoPanner::on_key_release_event (GdkEventKey*)
{
return false;
}
bool
-StereoPanner::on_enter_notify_event (GdkEventCrossing* ev)
+StereoPanner::on_enter_notify_event (GdkEventCrossing*)
{
grab_focus ();
Keyboard::magic_widget_grab_focus ();
}
bool
-TimeAxisView::controls_ebox_leave (GdkEventCrossing* ev)
+TimeAxisView::controls_ebox_leave (GdkEventCrossing*)
{
if (_have_preresize_cursor) {
gdk_window_set_cursor (controls_ebox.get_window()->gobj(), _preresize_cursor);
}
TimeAxisViewItem::TimeAxisViewItem (const TimeAxisViewItem& other)
- : sigc::trackable(other)
+ : Selectable (other)
, PBD::ScopedConnectionList()
, trackview (other.trackview)
, _recregion (other._recregion)
private:
ACLRefCounter () : mLayout(NULL) { }
- ACLRefCounter(const ACLRefCounter&) : mLayout(NULL) { }
+ ACLRefCounter(const ACLRefCounter& other) : CAReferenceCounted (other), mLayout(NULL) { }
ACLRefCounter& operator=(const ACLRefCounter&) { return *this; }
};
private:
// get the compiler to tell us when we do a bad thing!!!
AUState () {}
- AUState (const AUState&) {}
+ AUState (const AUState& other) : CAReferenceCounted (other) {}
AUState& operator= (const AUState&) { return *this; }
};
OSStatus CAAudioUnit::GetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
Float32 &outValue) const
{
- return mDataPtr ? mDataPtr->GetParameter (inID, scope, element, outValue) : paramErr;
+ return mDataPtr ? (OSStatus) mDataPtr->GetParameter (inID, scope, element, outValue) : paramErr;
}
OSStatus CAAudioUnit::SetParameter(AudioUnitParameterID inID, AudioUnitScope scope, AudioUnitElement element,
Float32 value, UInt32 bufferOffsetFrames)
{
- return mDataPtr ? mDataPtr->SetParameter (inID, scope, element, value, bufferOffsetFrames) : paramErr;
+ return mDataPtr ? (OSStatus) mDataPtr->SetParameter (inID, scope, element, value, bufferOffsetFrames) : paramErr;
}
OSStatus CAAudioUnit::MIDIEvent (UInt32 inStatus,
UInt32 inData2,
UInt32 inOffsetSampleFrame)
{
- return mDataPtr ? mDataPtr->MIDIEvent (inStatus, inData1, inData2, inOffsetSampleFrame) : paramErr;
+ return mDataPtr ? (OSStatus) mDataPtr->MIDIEvent (inStatus, inData1, inData2, inOffsetSampleFrame) : paramErr;
}
OSStatus CAAudioUnit::StartNote (MusicDeviceInstrumentID inInstrument,
UInt32 inOffsetSampleFrame,
const MusicDeviceNoteParams * inParams)
{
- return mDataPtr ? mDataPtr->StartNote (inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams)
- : paramErr;
+ return mDataPtr ? (OSStatus) mDataPtr->StartNote (inInstrument, inGroupID, outNoteInstanceID, inOffsetSampleFrame, inParams)
+ : paramErr;
}
OSStatus CAAudioUnit::StopNote (MusicDeviceGroupID inGroupID,
NoteInstanceID inNoteInstanceID,
UInt32 inOffsetSampleFrame)
{
- return mDataPtr ? mDataPtr->StopNote (inGroupID, inNoteInstanceID, inOffsetSampleFrame) : paramErr;
+ return mDataPtr ? (OSStatus) mDataPtr->StopNote (inGroupID, inNoteInstanceID, inOffsetSampleFrame) : paramErr;
}
#pragma mark __Render
UInt32 inNumberFrames,
AudioBufferList * ioData)
{
- return mDataPtr ? mDataPtr->Render (ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData) : paramErr;
+ return mDataPtr ? (OSStatus) mDataPtr->Render (ioActionFlags, inTimeStamp, inOutputBusNumber, inNumberFrames, ioData) : paramErr;
}
static AURenderCallbackStruct sRenderCallback;
}
protected:
- virtual ~CAReferenceCounted() { }
-
+ virtual ~CAReferenceCounted() { }
+ CAReferenceCounted(const CAReferenceCounted &) : mRefCount(0) { }
+
private:
SInt32 mRefCount;
- CAReferenceCounted(const CAReferenceCounted &) : mRefCount(0) { }
CAReferenceCounted operator=(const CAReferenceCounted &) { return *this; }
};
int set_state(const XMLNode& node, int);
- PresetRecord save_preset (std::string name);
bool load_preset (PresetRecord);
std::string current_preset() const;
static std::string maybe_fix_broken_au_id (const std::string&);
+ protected:
+ std::string do_save_preset (std::string name);
+ void do_remove_preset (std::string);
+
private:
void find_presets ();
virtual framecnt_t read_unlocked (Sample *dst, framepos_t start, framecnt_t cnt) const = 0;
virtual framecnt_t write_unlocked (Sample *dst, framecnt_t cnt) = 0;
virtual std::string peak_path(std::string audio_path) = 0;
- virtual std::string find_broken_peakfile (std::string missing_peak_path,
+ virtual std::string find_broken_peakfile (std::string /* missing_peak_path */,
std::string audio_path) { return peak_path (audio_path); }
virtual int read_peaks_with_fpp (PeakData *peaks,
CAImportableSource (const std::string& path);
virtual ~CAImportableSource();
- nframes_t read (Sample* buffer, nframes_t nframes);
+ framecnt_t read (Sample* buffer, framecnt_t nframes);
uint32_t channels() const;
framecnt_t length() const;
- nframes_t samplerate() const;
- void seek (nframes_t pos);
+ framecnt_t samplerate() const;
+ void seek (framepos_t pos);
framepos_t natural_position() const { return 0; }
bool clamped_at_unity () const { return false; }
uint16_t n_channels;
void init_cafile ();
- int safe_read (Sample*, nframes_t start, framecnt_t cnt, AudioBufferList&) const;
+ int safe_read (Sample*, framepos_t start, framecnt_t cnt, AudioBufferList&) const;
};
}; /* namespace ARDOUR */
virtual ~ExportChannel () {}
- virtual void set_max_buffer_size(framecnt_t frames) { }
+ virtual void set_max_buffer_size(framecnt_t) { }
virtual void read (Sample const *& data, framecnt_t frames) const = 0;
virtual bool empty () const = 0;
std::string state_node_name() const { return "lxvst"; }
void print_parameter (uint32_t, char*, uint32_t len) const;
- bool parameter_is_audio(uint32_t i) const { return false; }
- bool parameter_is_control(uint32_t i) const { return true; }
- bool parameter_is_input(uint32_t i) const { return true; }
- bool parameter_is_output(uint32_t i) const { return false; }
+ bool parameter_is_audio(uint32_t) const { return false; }
+ bool parameter_is_control(uint32_t) const { return true; }
+ bool parameter_is_input(uint32_t) const { return true; }
+ bool parameter_is_output(uint32_t) const { return false; }
bool load_preset (PresetRecord);
int first_user_preset_index () const;
typedef std::map<const std::string, const float> ScalePoints;
- virtual boost::shared_ptr<ScalePoints>
- get_scale_points(uint32_t port_index) const {
+ virtual boost::shared_ptr<ScalePoints> get_scale_points(uint32_t /*port_index*/) const {
return boost::shared_ptr<ScalePoints>();
}
}
framecnt_t
-AudioPlaylistSource::write_unlocked (Sample *src, framecnt_t cnt)
+AudioPlaylistSource::write_unlocked (Sample *, framecnt_t)
{
fatal << string_compose (_("programming error: %1"), "AudioPlaylistSource::write() called - should be impossible") << endmsg;
/*NOTREACHED*/
}
void
-AudioPort::cycle_end (pframes_t nframes)
+AudioPort::cycle_end (pframes_t)
{
if (sends_output() && !_buffer->written()) {
/* we can't use nframes here because the current buffer capacity may
float beat;
beat = metric.meter().beats_per_bar() * bbt.bars;
beat += bbt.beats;
- beat += bbt.ticks / BBT_Time::ticks_per_beat;
+ beat += bbt.ticks / Timecode::BBT_Time::ticks_per_beat;
*outCurrentBeat = beat;
}
/* on the beat */
*outDeltaSampleOffsetToNextBeat = 0;
} else {
- *outDeltaSampleOffsetToNextBeat = (UInt32) floor (((BBT_Time::ticks_per_beat - bbt.ticks)/BBT_Time::ticks_per_beat) * // fraction of a beat to next beat
- metric.tempo().frames_per_beat(_session.frame_rate(), metric.meter())); // frames per beat
+ *outDeltaSampleOffsetToNextBeat = (UInt32)
+ floor (((Timecode::BBT_Time::ticks_per_beat - bbt.ticks)/Timecode::BBT_Time::ticks_per_beat) * // fraction of a beat to next beat
+ metric.tempo().frames_per_beat(_session.frame_rate(), metric.meter())); // frames per beat
}
}
float beat;
beat = metric.meter().beats_per_bar() * bbt.bars;
beat += bbt.beats;
- beat += bbt.ticks / BBT_Time::ticks_per_beat;
+ beat += bbt.ticks / Timecode::BBT_Time::ticks_per_beat;
*outCycleStartBeat = beat;
}
float beat;
beat = metric.meter().beats_per_bar() * bbt.bars;
beat += bbt.beats;
- beat += bbt.ticks / BBT_Time::ticks_per_beat;
+ beat += bbt.ticks / Timecode::BBT_Time::ticks_per_beat;
*outCycleEndBeat = beat;
}
}
void
-AUPlugin::add_state (XMLNode* root)
+AUPlugin::add_state (XMLNode* root) const
{
LocaleGuard lg (X_("POSIX"));
if (!xmlData) {
error << _("Could not create XML version of property list") << endmsg;
- return *root;
+ return;
}
/* re-parse XML bytes to create a libxml++ XMLTree that we can merge into
}
bool
-AUPlugin::load_preset (PluginRecord r)
+AUPlugin::load_preset (PresetRecord r)
{
Plugin::load_preset (r);
/* look first in "user" presets */
- if ((ux = user_preset_map.find (preset_label)) != user_preset_map.end()) {
+ if ((ux = user_preset_map.find (r.label)) != user_preset_map.end()) {
if ((propertyList = load_property_list (ux->second)) != 0) {
TRACE_API ("set preset from user presets\n");
CFRelease(propertyList);
}
- } else if ((fx = factory_preset_map.find (preset_label)) != factory_preset_map.end()) {
+ } else if ((fx = factory_preset_map.find (r.label)) != factory_preset_map.end()) {
AUPreset preset;
#endif
}
-PresetRecord
-AUPlugin::save_preset (string preset_name)
+void
+AUPlugin::do_remove_preset (std::string)
+{
+}
+
+string
+AUPlugin::do_save_preset (string preset_name)
{
#ifdef AU_STATE_SUPPORT
CFPropertyListRef propertyList;
CFRelease(propertyList);
- return ret;
+ return string ("file:///") + user_preset_path;
#else
if (!seen_saving_message) {
info << string_compose (_("Saving AudioUnit presets is not supported in this build of %1. Consider paying for a newer version"),
<< endmsg;
seen_saving_message = true;
}
- return false;
+ return string();
#endif
}
/* now fill the vector<string> with the names we have */
for (UserPresetMap::iterator i = user_preset_map.begin(); i != user_preset_map.end(); ++i) {
- _presets.insert (i->second, Plugin::PresetRecord (i->second, i->first));
+ _presets.insert (make_pair (i->second, Plugin::PresetRecord (i->second, i->first)));
}
/* add factory presets */
for (FactoryPresetMap::iterator i = factory_preset_map.begin(); i != factory_preset_map.end(); ++i) {
/* XXX: dubious */
string const uri = string_compose ("%1", _presets.size ());
- _presets.push_back (uri, Plugin::PresetRecord (uri, i->first));
+ _presets.insert (make_pair (uri, Plugin::PresetRecord (uri, i->first)));
}
#endif
PluginInfoList* plugs = new PluginInfoList;
+#if 0
discover_fx (*plugs);
discover_music (*plugs);
discover_generators (*plugs);
discover_instruments (*plugs);
+#endif
return plugs;
}
}
void
-RouteExportChannel::get_state (XMLNode * node) const
+RouteExportChannel::get_state (XMLNode *) const
{
// TODO
}
void
-RouteExportChannel::set_state (XMLNode * node, Session & session)
+RouteExportChannel::set_state (XMLNode *, Session &)
{
// TODO
}
*/
bool
FileSource::find (Session& s, DataType type, const string& path, bool must_exist,
- bool& isnew, uint16_t& chan, string& found_path)
+ bool& isnew, uint16_t& /* chan */, string& found_path)
{
bool ret = false;
string keeppath;
/* XXX: should be in liblrdf */
static void
-lrdf_remove_preset (const char *source, const char *setting_uri)
+lrdf_remove_preset (const char* /*source*/, const char *setting_uri)
{
lrdf_statement p;
lrdf_statement *q;
}
float
-LXVSTPlugin::default_value (uint32_t port)
+LXVSTPlugin::default_value (uint32_t)
{
return 0;
}
int index;
int const p = sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index);
assert (p == 2);
-
+
_vstfx->want_program = index;
return true;
}
}
void
-LXVSTPlugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
+LXVSTPlugin::print_parameter (uint32_t param, char *buf, uint32_t /*len*/) const
{
char *first_nonws;
int
MidiDiskstream::set_destructive (bool yn)
{
+ yn = 0; // stop pedantic gcc complaints about unused parameter
assert( ! destructive());
assert( ! yn);
return -1;
********************************************************************************/
MidiPlaylistSource::MidiPlaylistSource (Session& s, const ID& orig, const std::string& name, boost::shared_ptr<MidiPlaylist> p,
- uint32_t chn, frameoffset_t begin, framecnt_t len, Source::Flag flags)
+ uint32_t /*chn*/, frameoffset_t begin, framecnt_t len, Source::Flag flags)
: Source (s, DataType::MIDI, name)
, MidiSource (s, name, flags)
, PlaylistSource (s, orig, name, p, DataType::MIDI, begin, len, flags)
framepos_t
MidiPlaylistSource::read_unlocked (Evoral::EventSink<framepos_t>& dst,
- framepos_t position,
+ framepos_t /*position*/,
framepos_t start, framecnt_t cnt,
- MidiStateTracker* tracker) const
+ MidiStateTracker*) const
{
boost::shared_ptr<MidiPlaylist> mp = boost::dynamic_pointer_cast<MidiPlaylist> (_playlist);
framepos_t
MidiPlaylistSource::write_unlocked (MidiRingBuffer<framepos_t>& dst,
- framepos_t position,
- framecnt_t cnt)
+ framepos_t,
+ framecnt_t)
{
fatal << string_compose (_("programming error: %1"), "MidiPlaylistSource::write_unlocked() called - should be impossible") << endmsg;
/*NOTREACHED*/
}
void
-MidiPlaylistSource::append_event_unlocked_frames(const Evoral::Event<framepos_t>& ev, framepos_t source_start)
+MidiPlaylistSource::append_event_unlocked_frames(const Evoral::Event<framepos_t>& /* ev */, framepos_t /*source_start*/)
{
fatal << string_compose (_("programming error: %1"), "MidiPlaylistSource::append_event_unlocked_frames() called - should be impossible") << endmsg;
/*NOTREACHED*/
}
void
-MidiPort::flush_buffers (pframes_t nframes, framepos_t time)
+MidiPort::flush_buffers (pframes_t nframes, framepos_t /*time*/)
{
if (sends_output ()) {
}
int
-MidiStretch::run (boost::shared_ptr<Region> r, Progress* progress)
+MidiStretch::run (boost::shared_ptr<Region> r, Progress*)
{
SourceList nsrcs;
char suffix[32];
}
XMLNode&
-Pannable::state (bool full)
+Pannable::state (bool /*full*/)
{
XMLNode* node = new XMLNode (X_("Pannable"));
using namespace PBD;
PlaylistSource::PlaylistSource (Session& s, const ID& orig, const std::string& name, boost::shared_ptr<Playlist> p, DataType type,
- frameoffset_t begin, framecnt_t len, Source::Flag flags)
+ frameoffset_t begin, framecnt_t len, Source::Flag /*flags*/)
: Source (s, type, name)
, _playlist (p)
, _original (orig)
}
int
-PlaylistSource::set_state (const XMLNode& node, int version)
+PlaylistSource::set_state (const XMLNode& node, int /*version*/)
{
/* check that we have a playlist ID */
int
Plugin::connect_and_run (BufferSet& bufs,
- ChanMapping in_map, ChanMapping out_map,
+ ChanMapping /*in_map*/, ChanMapping /*out_map*/,
pframes_t nframes, framecnt_t offset)
{
if (bufs.count().n_midi() > 0) {
}
int
-Plugin::set_state (const XMLNode& node, int version)
+Plugin::set_state (const XMLNode& node, int /*version*/)
{
XMLProperty const * p = node.property (X_("last-preset-uri"));
if (p) {
return -1;
}
-static bool lxvst_filter (const string& str, void *arg)
+static bool lxvst_filter (const string& str, void *)
{
/* Not a dotfile, has a prefix before a period, suffix is "so" */
}
void
-Port::cycle_start (pframes_t nframes)
+Port::cycle_start (pframes_t)
{
_port_buffer_offset = 0;
}
}
jack_latency_range_t
-Port::public_latency_range (bool playback) const
+Port::public_latency_range (bool /*playback*/) const
{
jack_latency_range_t r;
: Evoral::ControlSet (other)
, SessionObject (other.session(), other.name())
, Automatable (other.session())
+ , Latent (other)
, _pending_active(other._pending_active)
, _active(other._active)
, _next_ab_is_active(false)
}
void
-Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool others_on)
+Session::set_exclusive_input_active (boost::shared_ptr<Route> rt, bool /*others_on*/)
{
RouteList rl;
vector<string> connections;
}
void
-Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t this_delta)
+Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/)
{
if (slave_speed != 0.0f) {
}
Speakers::Speakers (const Speakers& s)
+ : Stateful ()
{
_speakers = s._speakers;
}
/* A simple 'dummy' audiomaster callback which should be ok,
we will only be instantiating the plugin in order to get its info*/
-static long simple_master_callback(struct AEffect *fx, long opcode, long index, long value, void *ptr, float opt)
+static long simple_master_callback(struct AEffect *, long opcode, long, long, void *, float)
{
- if(opcode == audioMasterVersion)
+ if (opcode == audioMasterVersion)
return 2;
- else
+ else
return 0;
}
bool debug_level (DebugLevel level) {
#ifdef NDEBUG
+ level = DEFAULT_DEBUG_LEVEL; /* stop pedantic gcc complaints about unused parameter */
return false;
#else
return L >= level;
/// Normal copy constructor
ProcessContext (ProcessContext<T> const & other)
- : _data (other._data), _frames (other._frames), _channels (other._channels), _flags (other._flags)
+ : _data (other._data), _frames (other._frames), _channels (other._channels), _flags (other._flags)
{ /* No need to validate data */ }
/// "Copy constructor" with unique data, frame and channel count, but copies flags
case 2:
return _program_change;
default:
- assert (false);
+ abort ();
+ /*NOTREACHED*/
+ return _program_change;
}
}
{
}
-ControlSet::ControlSet (const ControlSet& other)
+ControlSet::ControlSet (const ControlSet&)
: noncopyable ()
{
/* derived class must copy controls */
void
Sequence<Time>::dump (ostream& str) const
{
- Sequence<Time>::const_iterator i;
+ typename Sequence<Time>::const_iterator i;
str << "+++ dump\n";
for (i = begin(); i != end(); ++i) {
str << *i << endl;
static int32_t
expected_sysex_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
{
- uint32_t sysex_length, len;
+ uint32_t sysex_length = 0;
+ uint32_t len = 0;
assert(status == 0xF0);
(void) last_status;
int status;
- int32_t message_length, vlq_length;
+ int32_t message_length = 0;
+ int32_t vlq_length = 0;
const unsigned char *c = buf;
status = *buf;
char *
smf_event_extract_text(const smf_event_t *event)
{
- uint32_t string_length, length_length;
+ uint32_t string_length = 0;
+ uint32_t length_length = 0;
if (!smf_event_is_textual(event))
return (NULL);
}
assert(i <= length);
+ length = length; // get rid of stupid gcc warnings about unused params if assert() is null
/* + 1, because "i" is an offset, not a count. */
return (i + 1);
}
static void
-gnome_canvas_bpath_init (GnomeCanvasBpath *bpath)
+gnome_canvas_bpath_init (GnomeCanvasBpath* bpath)
{
}
}
static void
-item_to_canvas (GnomeCanvas *canvas, double *item_coords, GdkPoint *canvas_coords, int num_points,
+item_to_canvas (GnomeCanvas * canvas, double *item_coords, GdkPoint *canvas_coords, int num_points,
int *num_drawn_points, double i2c[6], int x, int y)
{
int i;
} /* gnome_canvas_rich_text_move_cursor */
static gboolean
-whitespace(gunichar ch, gpointer user_data)
+whitespace(gunichar ch, gpointer ignored)
{
return (ch == ' ' || ch == '\t');
} /* whitespace */
static gboolean
-not_whitespace(gunichar ch, gpointer user_data)
+not_whitespace(gunichar ch, gpointer ignored)
{
- return !whitespace(ch, user_data);
+ return !whitespace(ch, ignored);
} /* not_whitespace */
static gboolean
static gint
selection_motion_event_handler(GnomeCanvasRichText *text, GdkEvent *event,
- gpointer data)
+ gpointer ignored)
{
GtkTextIter newplace;
GtkTextMark *mark;
static void
gnome_canvas_rich_text_start_selection_drag(GnomeCanvasRichText *text,
const GtkTextIter *iter,
- GdkEventButton *button)
+ GdkEventButton * button)
{
GtkTextIter newplace;
static gboolean
gnome_canvas_rich_text_end_selection_drag(GnomeCanvasRichText *text,
- GdkEventButton *event)
+ GdkEventButton * event)
{
if (text->_priv->selection_drag_handler == 0)
return FALSE;
} /* gnome_canvas_rich_text_key_press_event */
static gint
-gnome_canvas_rich_text_key_release_event(GnomeCanvasItem *item,
+gnome_canvas_rich_text_key_release_event(GnomeCanvasItem * item,
GdkEventKey *event)
{
return FALSE;
static gint
gnome_canvas_rich_text_focus_in_event(GnomeCanvasItem *item,
- GdkEventFocus *event)
+ GdkEventFocus * event)
{
GnomeCanvasRichText *text = GNOME_CANVAS_RICH_TEXT(item);
static gint
gnome_canvas_rich_text_focus_out_event(GnomeCanvasItem *item,
- GdkEventFocus *event)
+ GdkEventFocus * event)
{
GnomeCanvasRichText *text = GNOME_CANVAS_RICH_TEXT(item);
} /* request_update */
static void
-invalidated_handler(GtkTextLayout *layout, gpointer data)
+invalidated_handler(GtkTextLayout * layout, gpointer data)
{
GnomeCanvasRichText *text = GNOME_CANVAS_RICH_TEXT(data);
} /* scale_fonts */
static void
-changed_handler(GtkTextLayout *layout, gint start_y,
+changed_handler(GtkTextLayout * layout, gint start_y,
gint old_height, gint new_height, gpointer data)
{
GnomeCanvasRichText *text = GNOME_CANVAS_RICH_TEXT(data);
static void
-gnome_canvas_rich_text_set_attributes_from_style(GnomeCanvasRichText *text,
+gnome_canvas_rich_text_set_attributes_from_style(GnomeCanvasRichText * text,
GtkTextAttributes *values,
GtkStyle *style)
{
break;
case PROP_ANCHOR:
- if (witem->anchor != g_value_get_enum (value))
+ if (witem->anchor != (unsigned int) g_value_get_enum (value))
{
witem->anchor = g_value_get_enum (value);
update = TRUE;
}
static void
-gnome_canvas_widget_render (GnomeCanvasItem *item,
- GnomeCanvasBuf *buf)
+gnome_canvas_widget_render (GnomeCanvasItem * item,
+ GnomeCanvasBuf * buf)
{
#if 0
GnomeCanvasWidget *witem;
}
static void
-gnome_canvas_widget_draw (GnomeCanvasItem *item,
- GdkDrawable *drawable,
+gnome_canvas_widget_draw (GnomeCanvasItem * item,
+ GdkDrawable * drawable,
int x, int y,
int width, int height)
{
/* Update handler for canvas items */
static void
-gnome_canvas_item_update (GnomeCanvasItem *item, double *affine, ArtSVP *clip_path, int flags)
+gnome_canvas_item_update (GnomeCanvasItem *item, double *affine, ArtSVP * clip_path, int flags)
{
GTK_OBJECT_UNSET_FLAGS (item, GNOME_CANVAS_ITEM_NEED_UPDATE);
GTK_OBJECT_UNSET_FLAGS (item, GNOME_CANVAS_ITEM_NEED_AFFINE);
/* Object initialization function for GnomeCanvasGroup */
static void
-gnome_canvas_group_init (GnomeCanvasGroup *group)
+gnome_canvas_group_init (GnomeCanvasGroup * group)
{
#if 0
group->xpos = 0.0;
bool
Bindings::activate (KeyboardKey kb, Operation op)
{
- KeybindingMap* kbm;
+ KeybindingMap* kbm = 0;
switch (op) {
case Press:
void
Bindings::add (KeyboardKey kb, Operation op, RefPtr<Action> what)
{
- KeybindingMap* kbm;
+ KeybindingMap* kbm = 0;
switch (op) {
case Press:
void
Bindings::remove (KeyboardKey kb, Operation op)
{
- KeybindingMap* kbm;
+ KeybindingMap* kbm = 0;
switch (op) {
case Press:
bool
Bindings::activate (MouseButton bb, Operation op)
{
- MouseButtonBindingMap* bbm;
+ MouseButtonBindingMap* bbm = 0;
switch (op) {
case Press:
void
Bindings::add (MouseButton bb, Operation op, RefPtr<Action> what)
{
- MouseButtonBindingMap* bbm;
+ MouseButtonBindingMap* bbm = 0;
switch (op) {
case Press:
void
Bindings::remove (MouseButton bb, Operation op)
{
- MouseButtonBindingMap* bbm;
+ MouseButtonBindingMap* bbm = 0;
switch (op) {
case Press:
}
bool
-CairoEditableText::on_focus_in_event (GdkEventFocus* ev)
+CairoEditableText::on_focus_in_event (GdkEventFocus*)
{
return false;
}
bool
-CairoEditableText::on_focus_out_event (GdkEventFocus* ev)
+CairoEditableText::on_focus_out_event (GdkEventFocus*)
{
if (editing_cell) {
queue_draw_cell (editing_cell);
* Boston, MA 02111-1307, USA.
*/
+#include <sigc++/signal.h>
+#include <sigc++/slot.h>
+
+#include <string.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <gtkmm2ext/gtkapplication.h>
+#include <gtkmm2ext/gtkapplication-private.h>
+
#import <AppKit/NSMenu.h>
#import <AppKit/NSMenuItem.h>
#import <AppKit/NSCell.h>
#import <Foundation/NSString.h>
#import <Foundation/NSNotification.h>
-#include <string.h>
-#include <gtk/gtk.h>
-#include <gdk/gdkkeysyms.h>
-#include <gtkmm2ext/gtkapplication.h>
-#include <gtkmm2ext/gtkapplication-private.h>
-
#define UNUSED_PARAMETER(a) (void) (a)
// #define DEBUG(format, ...) g_printerr ("%s: " format, G_STRFUNC, ## __VA_ARGS__)
}
void
-gtk_application_set_menu_bar (GtkMenuShell *menu_shell)
+gtk_application_set_menu_bar (GtkMenuShell* menushell)
{
}
void
-gtk_application_add_app_menu_item (GtkApplicationMenuGroup *group,
- GtkMenuItem *menu_item)
+gtk_application_add_app_menu_item (GtkApplicationMenuGroup* group, GtkMenuItem* item)
{
}
#ifndef __gtkmm2ext_cell_renderer_pixbuf_multi_h__
#define __gtkmm2ext_cell_renderer_pixbuf_multi_h__
-#ifdef GTKOSX
-#include <MacTypes.h>
-#if defined(Style)
-#undef style
-#endif
-#endif
-
#include <map>
#include <stdint.h>
*/
-#ifdef GTKOSX
-#include <MacTypes.h>
-#if defined(Style)
-#undef style
-#endif
-#endif
-
#ifndef __gtkmm2ext_cell_renderer_pixbuf_toggle_h__
#define __gtkmm2ext_cell_renderer_pixbuf_toggle_h__
}
/* Draw the drag icon */
- bool icon_expose (GdkEventExpose* ev)
+ bool icon_expose (GdkEventExpose*)
{
/* Just grab the child's widget and use that */
}
void drag_data_received (
- Glib::RefPtr<Gdk::DragContext> const & context, int x, int y, Gtk::SelectionData const & selection_data, guint /*info*/, guint time
+ Glib::RefPtr<Gdk::DragContext> const & context, int /*x*/, int y, Gtk::SelectionData const & selection_data, guint /*info*/, guint time
)
{
/* work out where it was dropped */
}
}
- bool drag_motion (Glib::RefPtr<Gdk::DragContext> const &, int x, int y, guint)
+ bool drag_motion (Glib::RefPtr<Gdk::DragContext> const &, int /*x*/, int y, guint)
{
if (_children.empty ()) {
return false;
const char* Keyboard::secondary_modifier_name() { return _("Option"); }
const char* Keyboard::tertiary_modifier_name() { return _("Shift"); }
const char* Keyboard::level4_modifier_name() { return _("Control"); }
-const char* Keyboard::copy_modifier_name() { return _("Mod1"; ); }
+const char* Keyboard::copy_modifier_name() { return _("Mod1"); }
const char* Keyboard::rangeselect_modifier_name() { return _("Shift"); }
#else
}
bool
-MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing *ev)
+MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing*)
{
pixwin.grab_focus();
return false;
}
bool
-MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing *ev)
+MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing*)
{
pixwin.unset_flags (HAS_FOCUS);
return false;
}
bool
-MotionFeedback::pixwin_expose_event (GdkEventExpose* ev)
+MotionFeedback::pixwin_expose_event (GdkEventExpose*)
{
if (!_controllable) {
return true;
using namespace Gtk;
void
-Gtkmm2ext::treeview_select_one (RefPtr<TreeSelection> selection, RefPtr<TreeModel> model, TreeView& view,
- TreeIter iter, TreePath path, TreeViewColumn* col)
+Gtkmm2ext::treeview_select_one (RefPtr<TreeSelection> selection, RefPtr<TreeModel> /*model*/, TreeView& view,
+ TreeIter /*iter*/, TreePath path, TreeViewColumn* col)
{
if (!view.row_expanded (path)) {
// cerr << "!! selecting a row that isn't expanded! " << path.to_string() << endl;
case MIDI_CTL_POLY:
return "Polyphonic Mode"; break;
default:
- return "Unnamed"; break;
+ break;
}
+
+ return "Unnamed";
+
}
#endif /* __midinames_h__ */
extern "C" { PanPluginDescriptor* panner_descriptor () { return &_descriptor; } }
-VBAPanner::Signal::Signal (Session& session, VBAPanner& p, uint32_t n, uint32_t n_speakers)
+VBAPanner::Signal::Signal (Session&, VBAPanner&, uint32_t, uint32_t n_speakers)
{
resize_gains (n_speakers);
}
void
-VBAPanner::distribute_one_automated (AudioBuffer& src, BufferSet& obufs,
- framepos_t start, framepos_t end, pframes_t nframes, pan_t** buffers, uint32_t which)
+VBAPanner::distribute_one_automated (AudioBuffer& /*src*/, BufferSet& /*obufs*/,
+ framepos_t /*start*/, framepos_t /*end*/,
+ pframes_t /*nframes*/, pan_t** /*buffers*/, uint32_t /*which*/)
{
+ /* XXX to be implemented */
}
XMLNode&
namespace boost {
-void sp_scalar_constructor_hook( void * object, std::size_t size, void * pn )
+void sp_scalar_constructor_hook( void *, std::size_t, void *)
{
}
-void sp_scalar_destructor_hook( void * object, std::size_t size, void * pn )
+void sp_scalar_destructor_hook( void *, std::size_t, void *)
{
}
-void sp_counter_ref_hook (void* pn, long use_count)
+void sp_counter_ref_hook (void* /*pn*/, long /* use count */)
{
}
-void sp_counter_release_hook (void* pn, long use_count)
+void sp_counter_release_hook (void* /*pn*/, long /*use_count*/)
{
}
-void sp_array_constructor_hook(void * p)
+void sp_array_constructor_hook(void *)
{
}
-void sp_array_destructor_hook(void * p)
+void sp_array_destructor_hook(void *)
{
}
-void sp_scalar_constructor_hook(void * p)
+void sp_scalar_constructor_hook(void *)
{
}
-void sp_scalar_destructor_hook(void * p)
+void sp_scalar_destructor_hook(void *)
{
}
// data directly), we will have to use the next smallest power of
// two from the block size. Results may vary accordingly!
- int actualLength = MathUtilities::previousPowerOfTwo(m_dataLength);
+ unsigned int actualLength = MathUtilities::previousPowerOfTwo(m_dataLength);
if (actualLength != m_dataLength) {
// Pre-fill mag and phase vectors with zero, as the FFT output
// will not fill the arrays
- for (int i = actualLength/2; i < m_dataLength/2; ++i) {
+ for (unsigned int i = actualLength/2; i < m_dataLength/2; ++i) {
m_magnitude[i] = 0;
m_thetaAngle[0] = 0;
}
quadEval( m_maxima, onsets );
- for( int b = 0; b < m_maxima.size(); b++)
+ for(unsigned int b = 0; b < m_maxima.size(); b++)
{
src[ b ] = m_maxima[ b ];
}
p = TPolyFit::PolyFit2( m_err, m_maxFit, m_poly);
double f = m_poly[0];
- double g = m_poly[1];
double h = m_poly[2];
- int kk = m_poly.size();
-
if (h < -Qfilta || f > Qfiltc)
{
idx.push_back(m_maxIndex[j]);
MathUtilities::getAlphaNorm( src, m_length, m_alphaNormParam, &DFAlphaNorm );
- for( unsigned int i = 0; i< m_length; i++)
+ for(int i = 0; i< m_length; i++)
{
dst[ i ] = ( src[ i ] - DFMin ) / DFAlphaNorm;
}
lpd.clear();
hpd.clear();
- int flength = 0;
+ unsigned int flength = 0;
switch (wavelet) {
}
else
{
- for(int i=0; i<v1.size(); i++)
+ for(unsigned int i=0; i<v1.size(); i++)
{
dSum1 += v1[i]*v2[i];
dDen1 += v1[i]*v1[i];
{
double sum = 0.;
- for (int i = 0; i < count; ++i)
+ for (unsigned int i = 0; i < count; ++i)
{
sum += src[start + i];
}
{
unsigned int i;
double temp = 0.0;
- double a=0.0;
if (len == 0) {
*min = *max = 0;
case NormaliseUnitSum:
{
double sum = 0.0;
- for (int i = 0; i < data.size(); ++i) sum += data[i];
+ for (unsigned int i = 0; i < data.size(); ++i) sum += data[i];
if (sum != 0.0) {
- for (int i = 0; i < data.size(); ++i) data[i] /= sum;
+ for (unsigned int i = 0; i < data.size(); ++i) data[i] /= sum;
}
}
break;
case NormaliseUnitMax:
{
double max = 0.0;
- for (int i = 0; i < data.size(); ++i) {
+ for (unsigned int i = 0; i < data.size(); ++i) {
if (fabs(data[i]) > max) max = fabs(data[i]);
}
if (max != 0.0) {
- for (int i = 0; i < data.size(); ++i) data[i] /= max;
+ for (unsigned int i = 0; i < data.size(); ++i) data[i] /= max;
}
}
break;
// nterms = coefs.size()
// npoints = x.size()
{
- int i, j;
+ unsigned int i, j;
double xi, yi, yc, srs, sum_y, sum_y2;
Matrix xmatr; // Data matrix
Matrix a;
vector<double> g; // Constant vector
- const int npoints(x.size());
- const int nterms(coefs.size());
+ const unsigned int npoints(x.size());
+ const unsigned int nterms(coefs.size());
double correl_coef;
zeroise(g, nterms);
zeroise(a, nterms, nterms);
double big, t;
double pivot;
double determ;
- int irow, icol;
+ int irow = 0;
+ int icol = 0;
int ncol(b.size());
int nv = 1; // single constant vector
for(int i = 0; i < ncol; ++i)
if (!cd.draining) {
size_t got = cd.inbuf->peek(cd.fltbuf, m_windowSize);
assert(got == m_windowSize || cd.inputSize >= 0);
+ got = 0;
cd.inbuf->skip(m_increment);
analyseChunk(c);
}
ChannelData &cd = *m_channelData[c];
if (!cd.draining) {
size_t got = cd.inbuf->peek(cd.fltbuf, m_windowSize);
+ got = 0;
assert(got == m_windowSize || cd.inputSize >= 0);
cd.inbuf->skip(m_increment);
analyseChunk(c);
*/
-#define __STDC_FORMAT_MACROS 1
#include <stdint.h>
#include <cmath>
#include <climits>
}
int
-OSC::catchall (const char *path, const char *types, lo_arg **argv, int argc, lo_message msg)
+OSC::catchall (const char *path, const char* /*types*/, lo_arg **argv, int argc, lo_message msg)
{
size_t len;
int ret = 1; /* unhandled */
static int _ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { \
return static_cast<OSC*>(user_data)->cb_ ## name (path, types, argv, argc, data); \
} \
- int cb_ ## name (const char *, const char *, lo_arg **argv, int argc, void *data) { \
+ int cb_ ## name (const char *, const char *, lo_arg **, int, void *data) { \
name (data); \
return 0; \
}
static int _ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { \
return static_cast<OSC*>(user_data)->cb_ ## name (path, types, argv, argc, data); \
} \
- int cb_ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data) { \
+ int cb_ ## name (const char *, const char *, lo_arg **argv, int argc, void *data) { \
if (argc > 1) { \
name (argv[0]->arg1type, argv[1]->arg2type,argv[2]->arg3type); \
} \
static int _ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data) { \
return static_cast<OSC*>(user_data)->cb_ ## name (path, types, argv, argc, data); \
} \
- int cb_ ## name (const char *path, const char *types, lo_arg **argv, int argc, void *data) { \
+ int cb_ ## name (const char *, const char *, lo_arg **argv, int argc, void *data) { \
if (argc > 1) { \
name (argv[0]->arg1type, argv[1]->arg2type,argv[2]->arg3type,argv[3]->arg4type); \
} \
bool readAudioProperties = true,
AudioProperties::ReadStyle
audioPropertiesStyle = AudioProperties::Average) const = 0;
+ virtual ~FileTypeResolver() {}
};
/*!
* ISO-8859-1.
*/
virtual ByteVector render(const String &s) const;
+ virtual ~StringHandler() {}
};
//! The main class in the ID3v1 implementation
}
void
-PluginAdapterBase::Impl::vampReleaseFeatureSet(VampFeatureList *fs)
+PluginAdapterBase::Impl::vampReleaseFeatureSet(VampFeatureList *)
{
#ifdef DEBUG_PLUGIN_ADAPTER
std::cerr << "PluginAdapterBase::Impl::vampReleaseFeatureSet" << std::endl;
projects / ardour.git / commitdiff