Paul Davis was responsible for introducing almost all of this.
AddRouteDialog ();
~AddRouteDialog ();
- enum TypeWanted {
+ enum TypeWanted {
AudioTrack,
MidiTrack,
MixedTrack,
AudioBus
};
TypeWanted type_wanted() const;
-
+
ARDOUR::ChanCount channels ();
int count ();
newrow[tlcols.visible] = true;
newrow[tlcols.color] = rui->color();
newrow[tlcols.graph] = res;
- }
+ }
} else if (source_selection_regions_rb.get_active()) {
RegionSelection ars = s.regions;
// std::cerr << "Analyzing selected regions" << std::endl;
/* TODO make this a dedicated function elsewhere.
*
* Option 1:
- * virtual ArdourButton::render_vector_icon()
+ * virtual ArdourButton::render_vector_icon()
* ArdourIconButton::render_vector_icon
*
* Option 2:
{
if (_splash_pushed) {
Splash* spl = Splash::instance();
-
+
if (spl) {
spl->pop_front();
}
void transport_record (bool roll);
void transport_roll ();
void transport_play_selection();
- void transport_play_preroll();
+ void transport_play_preroll();
void transport_forward (int option);
void transport_rewind (int option);
void transport_loop ();
SessionOptionEditor* create_session_option_editor ();
BundleManager* create_bundle_manager ();
AddVideoDialog* create_add_video_dialog ();
- BigClockWindow* create_big_clock_window();
+ BigClockWindow* create_big_clock_window();
GlobalPortMatrixWindow* create_global_port_matrix (ARDOUR::DataType);
ARDOUR::SystemExec *video_server_process;
void loading_message (const std::string& msg);
PBD::ScopedConnectionList forever_connections;
- PBD::ScopedConnection halt_connection;
+ PBD::ScopedConnection halt_connection;
void step_edit_status_change (bool);
alert_box.pack_start (feedback_alert_button, true, true);
/* all transport buttons should be the same size vertically and
- * horizontally
+ * horizontally
*/
Glib::RefPtr<SizeGroup> transport_button_size_group = SizeGroup::create (SIZE_GROUP_BOTH);
transport_tearoff_hbox.remove (editor_meter_peak_display);
}
- if (_session &&
- _session->master_out() &&
+ if (_session &&
+ _session->master_out() &&
_session->master_out()->n_outputs().n(DataType::AUDIO) > 0) {
if (!ARDOUR::Profile->get_trx()) {
transport_tearoff_hbox.pack_start (editor_meter_peak_display, false, false);
meter_box.show();
editor_meter_peak_display.show();
- }
+ }
}
} else if (p == "waveform-scale") {
ArdourCanvas::WaveView::set_global_logscaled (UIConfiguration::instance().get_waveform_scale() == Logarithmic);
/* ArdourWindows are not dialogs (they have no "OK" or "Close" button) but
they should be considered part of the same "window level" as a dialog. This
works on X11 and Quartz, in that:
-
+
(a) utility & dialog windows are considered to be part of the same level
(b) they will float above normal windows without any particular effort
(c) present()-ing them will make a utility float over a dialog or
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
framepos_t current_time (framepos_t position = 0) const;
framepos_t current_duration (framepos_t position = 0) const;
void set_session (ARDOUR::Session *s);
- void set_negative_allowed (bool yn);
+ void set_negative_allowed (bool yn);
- /** Alter cairo scaling during rendering.
+ /** Alter cairo scaling during rendering.
*
* Used by clocks that resize themselves
* to fit any given space. Can lead
/* this maps the number of input characters/digits when editing
to a cursor position. insert_map[N] = index of character/digit
- where the cursor should be after N chars/digits. it is
+ where the cursor should be after N chars/digits. it is
mode specific and so it is filled during set_mode().
*/
RegionView::set_colors();
if (gain_line) {
- gain_line->set_line_color (audio_region()->envelope_active() ?
- UIConfiguration::instance().color ("gain line") :
+ gain_line->set_line_color (audio_region()->envelope_active() ?
+ UIConfiguration::instance().color ("gain line") :
UIConfiguration::instance().color_mod ("gain line inactive", "gain line inactive"));
}
}
/* first waveview starts at 1.0, not 0.0 since that will overlap the
- * frame
+ * frame
*/
gdouble yoff = which * ht;
AudioRegionView::envelope_active_changed ()
{
if (gain_line) {
- gain_line->set_line_color (audio_region()->envelope_active() ?
- UIConfiguration::instance().color ("gain line") :
+ gain_line->set_line_color (audio_region()->envelope_active() ?
+ UIConfiguration::instance().color ("gain line") :
UIConfiguration::instance().color_mod ("gain line inactive", "gain line inactive"));
update_envelope_visibility ();
}
AutomationLine::hide ()
{
/* leave control points setting unchanged, we are just hiding the
- overall line
+ overall line
*/
set_visibility (AutomationLine::VisibleAspects (_visible & ~Line));
bool operator() (ControlPoint const * a, ControlPoint const * b) const {
if (floateq (a->get_x(), b->get_x(), 1)) {
return a->view_index() < b->view_index();
- }
+ }
return a->get_x() < b->get_x();
}
};
AutomationLine::ContiguousControlPoints::ContiguousControlPoints (AutomationLine& al)
- : line (al), before_x (0), after_x (DBL_MAX)
+ : line (al), before_x (0), after_x (DBL_MAX)
{
}
if (sz > 0 && sz < line.npoints()) {
const TempoMap& map (e.session()->tempo_map());
- /* determine the limits on x-axis motion for this
+ /* determine the limits on x-axis motion for this
contiguous range of control points
*/
}
}
-double
-AutomationLine::ContiguousControlPoints::clamp_dx (double dx)
+double
+AutomationLine::ContiguousControlPoints::clamp_dx (double dx)
{
if (empty()) {
return dx;
cp = front();
}
- tx = cp->get_x() + dx; // new possible position if we just add the motion
+ tx = cp->get_x() + dx; // new possible position if we just add the motion
tx = max (tx, before_x); // can't move later than following point
tx = min (tx, after_x); // can't move earlier than preceeding point
- return tx - cp->get_x ();
+ return tx - cp->get_x ();
}
-void
-AutomationLine::ContiguousControlPoints::move (double dx, double dy)
+void
+AutomationLine::ContiguousControlPoints::move (double dx, double dy)
{
for (std::list<ControlPoint*>::iterator i = begin(); i != end(); ++i) {
(*i)->move_to ((*i)->get_x() + dx, (*i)->get_y() - line.height() * dy, ControlPoint::Full);
if (!_drag_had_movement) {
- /* "first move" ... do some stuff that we don't want to do if
+ /* "first move" ... do some stuff that we don't want to do if
no motion ever took place, but need to do before we handle
motion.
*/
/* OK, now on to the stuff related to *this* motion event. First, for
* each contiguous range, figure out the maximum x-axis motion we are
* allowed (because of neighbouring points that are not moving.
- *
- * if we are moving forwards with push, we don't need to do this,
+ *
+ * if we are moving forwards with push, we don't need to do this,
* since all later points will move too.
*/
}
void
-AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, double tx, double ty,
+AutomationLine::add_visible_control_point (uint32_t view_index, uint32_t pi, double tx, double ty,
AutomationList::iterator model, uint32_t npoints)
{
ControlPoint::ShapeType shape;
bool _our_time_converter;
VisibleAspects _visible;
-
+
bool _uses_gain_mapping;
bool terminal_points_can_slide;
bool update_pending;
if (_automatable != _route && _control) {
return string_compose ("automation %1", _control->id().to_s());
} else if (_parameter) {
- return string_compose ("automation %1 %2/%3/%4",
- _route->id(),
+ return string_compose ("automation %1 %2/%3/%4",
+ _route->id(),
_parameter.type(),
_parameter.id(),
(int) _parameter.channel());
}
GUIObjectState&
-AxisView::gui_object_state()
+AxisView::gui_object_state()
{
return *ARDOUR_UI::instance()->gui_object_state;
}
property_hashtable.emplace(property_name, s.str());
gui_object_state().set_property<T> (state_id(), property_name, value);
}
-
+
void cleanup_gui_properties () {
/* remove related property node from the GUI state */
gui_object_state().remove_node (state_id());
using std::string;
using namespace ARDOUR_UI_UTILS;
-BigClockWindow::BigClockWindow (AudioClock& c)
+BigClockWindow::BigClockWindow (AudioClock& c)
: ArdourWindow (_("Big Clock"))
, clock (c)
{
#include <string>
/** This function must do whatever is necessary to create the right runtime
- * environment for the GTK2 version of ardour, on a per-platform basis.
+ * environment for the GTK2 version of ardour, on a per-platform basis.
*/
void fixup_bundle_environment (int, char* [], std::string & localedir);
g_setenv ("FONTCONFIG_FILE", Glib::build_filename (bundle_dir, "Resources/fonts.conf").c_str(), 1);
}
-void load_custom_fonts()
+void load_custom_fonts()
{
/* this code will only compile on OS X 10.6 and above, and we currently do not
* need it for earlier versions since we fall back on a non-monospace,
}
-void
-load_custom_fonts()
+void
+load_custom_fonts()
{
std::string ardour_mono_file;
}
-void load_custom_fonts()
+void load_custom_fonts()
{
std::string ardour_mono_file;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Gtkmm2ext::rounded_top_rectangle (cr, 0, 0, (get_width() - 20.0)/2.0 , h, 8);
cairo_fill_preserve (cr);
- Gtkmm2ext::rounded_top_rectangle (cr, (get_width() - 20.)/2.0 + 20.0, 0.0,
+ Gtkmm2ext::rounded_top_rectangle (cr, (get_width() - 20.)/2.0 + 20.0, 0.0,
(get_width() - 20.0)/2.0 , h, 8);
cairo_fill_preserve (cr);
if (tact) {
action_toggled ();
tact->signal_toggled().connect (sigc::mem_fun (*this, &ButtonJoiner::action_toggled));
- }
+ }
_action->connect_property_changed ("sensitive", sigc::mem_fun (*this, &ButtonJoiner::action_sensitivity_changed));
_action->connect_property_changed ("visible", sigc::mem_fun (*this, &ButtonJoiner::action_visibility_changed));
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
item_class->draw = gnome_canvas_waveview_draw;
}
-void
+void
gnome_canvas_waveview_set_gradient_waveforms (int yn)
{
_gradient_rendering = yn;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
ArdourCanvas::Item&
-ControlPoint::item() const
+ControlPoint::item() const
{
return *_item;
}
EditNoteDialog (MidiRegionView* rv, std::set<NoteBase*> n);
void done (int);
-
+
private:
MidiRegionView* _region_view;
std::set<NoteBase*> _events;
X: hard to access
Quartz: impossible to access
-
+
so stop that by preventing it from ever getting too narrow. 35
pixels is basically a rough guess at the tab width.
}
void
-Editor::control_select (uint32_t rid, Selection::Operation op)
+Editor::control_select (uint32_t rid, Selection::Operation op)
{
/* handles the (static) signal from the ControlProtocol class that
* requests setting the selected track to a given RID
*/
-
+
if (!_session) {
return;
}
case GDK_NOTIFY_UNKNOWN:
case GDK_NOTIFY_INFERIOR:
case GDK_NOTIFY_ANCESTOR:
- break;
+ break;
case GDK_NOTIFY_VIRTUAL:
case GDK_NOTIFY_NONLINEAR:
case GDK_NOTIFY_NONLINEAR_VIRTUAL:
&_zoom_tearoff->tearoff_window()));
_zoom_tearoff->Visible.connect (sigc::bind (sigc::mem_fun(*this, &Editor::reattach_tearoff), static_cast<Box*> (&toolbar_hbox),
&_zoom_tearoff->tearoff_window(), 0));
- }
+ }
if (Profile->get_sae() || Profile->get_mixbus() ) {
_zoom_tearoff->set_can_be_torn_off (false);
} else if (get_smart_mode()) {
if (selection->time.length()) {
duplicate_selection (times);
- } else
+ } else
duplicate_some_regions (rs, times);
} else {
duplicate_some_regions (rs, times);
h = trackviews_height() / n;
str = _("All");
} else {
- /* negative value means that the visible track count has
+ /* negative value means that the visible track count has
been overridden by explicit track height changes.
*/
visible_tracks_selector.set_text (X_("*"));
void
Editor::detach_tearoff (Box* /*b*/, Window* /*w*/)
{
- if ((_tools_tearoff->torn_off() || !_tools_tearoff->visible()) &&
- (_mouse_mode_tearoff->torn_off() || !_mouse_mode_tearoff->visible()) &&
+ if ((_tools_tearoff->torn_off() || !_tools_tearoff->visible()) &&
+ (_mouse_mode_tearoff->torn_off() || !_mouse_mode_tearoff->visible()) &&
(_zoom_tearoff && (_zoom_tearoff->torn_off() || !_zoom_tearoff->visible()))) {
top_hbox.remove (toolbar_frame);
}
compute_current_bbt_points (leftmost_frame, leftmost_frame + current_page_samples(), begin, end);
draw_measures (begin, end);
- }
+ }
instant_save ();
}
if (!tracks.empty()) {
/* no region selected or entered, but some selected tracks:
* act on all regions on the selected tracks at the edit point
- */
+ */
framepos_t const where = get_preferred_edit_position ();
get_regions_at(regions, where, tracks);
}
if (!tracks.empty()) {
/* no region selected or entered, but some selected tracks:
* act on all regions on the selected tracks at the edit point
- */
+ */
get_regions_at(regions, pos, tracks);
}
}
Gtk::VBox time_bars_vbox;
ArdourCanvas::Pixbuf *logo_item;
-#if 0
+#if 0
/* these will be needed when we have canvas rulers */
ArdourCanvas::Container *minsec_group;
ArdourCanvas::Container *bbt_group;
void remove_metric_marks ();
void draw_metric_marks (const ARDOUR::Metrics& metrics);
- void compute_current_bbt_points (framepos_t left, framepos_t right,
+ void compute_current_bbt_points (framepos_t left, framepos_t right,
ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
ARDOUR::TempoMap::BBTPointList::const_iterator& end);
Glib::RefPtr<ToggleAction> tact = Glib::RefPtr<ToggleAction>::cast_dynamic(act);
tact->set_active (true);
- ActionManager::register_action (editor_actions, X_("toggle-midi-input-active"), _("Toggle MIDI Input Active for Editor-Selected Tracks/Busses"),
+ ActionManager::register_action (editor_actions, X_("toggle-midi-input-active"), _("Toggle MIDI Input Active for Editor-Selected Tracks/Busses"),
sigc::bind (sigc::mem_fun (*this, &Editor::toggle_midi_input_active), false));
ActionManager::add_action_group (rl_actions);
if (atv) {
if (atv->is_audio_track()) {
audio_track_cnt++;
- }
+ }
} else {
MidiTimeAxisView* mtv = dynamic_cast<MidiTimeAxisView*>(*x);
source = boost::dynamic_pointer_cast<AudioFileSource> (
SourceFactory::createExternal (DataType::AUDIO, *_session,
- path, n,
+ path, n,
(mode == ImportAsTapeTrack
? Source::Destructive
: Source::Flag (0)),
*/
no_scroll_group = new ArdourCanvas::Container (_track_canvas->root());
- ArdourCanvas::ScrollGroup* hsg;
+ ArdourCanvas::ScrollGroup* hsg;
ArdourCanvas::ScrollGroup* hg;
ArdourCanvas::ScrollGroup* cg;
CANVAS_DEBUG_NAME (h_scroll_group, "canvas h scroll");
_track_canvas->add_scroller (*hg);
- hv_scroll_group = hsg = new ArdourCanvas::ScrollGroup (_track_canvas->root(),
+ hv_scroll_group = hsg = new ArdourCanvas::ScrollGroup (_track_canvas->root(),
ArdourCanvas::ScrollGroup::ScrollSensitivity (ArdourCanvas::ScrollGroup::ScrollsVertically|
ArdourCanvas::ScrollGroup::ScrollsHorizontally));
CANVAS_DEBUG_NAME (hv_scroll_group, "canvas hv scroll");
/* a group to hold stuff while it gets dragged around. Must be the
* uppermost (last) group with hv_scroll_group as a parent
*/
- _drag_motion_group = new ArdourCanvas::Container (hv_scroll_group);
+ _drag_motion_group = new ArdourCanvas::Container (hv_scroll_group);
CANVAS_DEBUG_NAME (_drag_motion_group, "Canvas Drag Motion");
/* TIME BAR CANVAS */
/* the effective width of the autoscroll boundary so
that we start scrolling before we hit the edge.
-
+
this helps when the window is slammed up against the
right edge of the screen, making it hard to scroll
effectively.
*/
- if (alloc.get_width() > 20) {
+ if (alloc.get_width() > 20) {
alloc.set_width (alloc.get_width() - 20);
alloc.set_x (alloc.get_x() + 10);
- }
+ }
}
// const double vertical_pos = vertical_adjustment.get_value();
const int speed_factor = 10;
- /* vertical */
+ /* vertical */
if (y < autoscroll_boundary.y0) {
/* the motion handler expects events in canvas coordinate space */
/* we asked for the mouse position above (::get_pointer()) via
- * our own top level window (we being the Editor). Convert into
+ * our own top level window (we being the Editor). Convert into
* coordinates within the canvas window.
*/
} else if (no_stop) {
/* not changing visual state but pointer is outside the scrolling boundary
- * so we still need to deliver a fake motion event
+ * so we still need to deliver a fake motion event
*/
GdkEventMotion ev;
double const track_min_y = track.y_position ();
double const track_max_y = track.y_position () + track.effective_height ();
- if (!at_top &&
+ if (!at_top &&
(track_min_y >= current_view_min_y &&
track_max_y < current_view_max_y)) {
/* already visible, and caller did not ask to place it at the
/* redraw the whole thing */
_track_canvas->set_background_color (UIConfiguration::instance().color ("arrange base"));
_track_canvas->queue_draw ();
-
+
/*
redisplay_tempo (true);
hv_scroll_group->add_items_at_point (ArdourCanvas::Duple (x,y), items);
- // first item will be the upper most
+ // first item will be the upper most
if (!items.empty()) {
const ArdourCanvas::Item* i = items.front();
}
return ret;
-}
+}
bool
(boost::dynamic_pointer_cast<MidiRegion> (region) != 0 &&
dynamic_cast<MidiTimeAxisView*> (tv.first) != 0)) {
- /* audio to audio
- OR
+ /* audio to audio
+ OR
midi to midi
*/
_track_canvas_item->set_ignore_events (true);
_track_canvas_item->set_x (0);
-
+
_current_frame = 1; /* force redraw at 0 */
}
_initially_vertical = false;
}
/** check constraints for this drag.
- * Note that the current convention is to use "contains" for
+ * Note that the current convention is to use "contains" for
* key modifiers during motion and "equals" when initiating a drag.
* In this case we haven't moved yet, so "equals" applies here.
*/
}
/* for automation lanes, there is a TimeAxisView but no ->view()
- * if (!tv) -> dropzone
+ * if (!tv) -> dropzone
*/
else if (!tv && cur_y >= 0 && _last_pointer_time_axis_view >= 0) {
/* Moving into the drop-zone.. */
* We do not use negative _last_pointer_time_axis_view because
* the dropzone is "packed" (the actual track offset is ignored)
*
- * As opposed to the actual number
+ * As opposed to the actual number
* of elements in the dropzone (_ndropzone)
* _pdropzone is not constrained. This is necessary
* to allow moving multiple regions with y-distance
Editor::mouse_frame (framepos_t& where, bool& in_track_canvas) const
{
/* gdk_window_get_pointer() has X11's XQueryPointer semantics in that it only
- pays attentions to subwindows. this means that menu windows are ignored, and
+ pays attentions to subwindows. this means that menu windows are ignored, and
if the pointer is in a menu, the return window from the call will be the
the regular subwindow *under* the menu.
break;
case MouseContent:
/* This handles internal edit.
- Clear everything except points and notes.
+ Clear everything except points and notes.
*/
selection->clear_regions();
selection->clear_lines();
Editing::MouseMode eff = effective_mouse_mode ();
/* special case: allow drag of region fade in/out in object mode with join object/range enabled */
- if (get_smart_mode()) {
+ if (get_smart_mode()) {
switch (item_type) {
case FadeInHandleItem:
case FadeInTrimHandleItem:
case StartCrossFadeItem:
case EndCrossFadeItem:
- /* we might allow user to grab inside the fade to trim a region with preserve_fade_anchor. for not this is not fully implemented */
+ /* we might allow user to grab inside the fade to trim a region with preserve_fade_anchor. for not this is not fully implemented */
// if (!clicked_regionview->region()->locked()) {
// _drags->set (new TrimDrag (this, item, clicked_regionview, selection->regions.by_layer(), true), event);
// return true;
return false;
}
-
+
bool
Editor::button_press_handler (ArdourCanvas::Item* item, GdkEvent* event, ItemType item_type)
{
if (!Keyboard::is_context_menu_event (&event->button)) {
/* see if we're finishing a drag */
-
+
if (_drags->active ()) {
bool const r = _drags->end_grab (event);
if (r) {
/* grab dragged, so do nothing else */
return true;
}
-
+
were_dragging = true;
}
bool ret = true;
/* by the time we reach here, entered_regionview and entered trackview
- * will have already been set as appropriate. Things are done this
+ * will have already been set as appropriate. Things are done this
* way because this method isn't passed a pointer to a variable type of
* thing that is entered (which may or may not be canvas item).
* (e.g. the actual entered regionview)
switch (item_type) {
case ControlPointItem:
- _verbose_cursor->hide ();
+ _verbose_cursor->hide ();
break;
case GainLineItem:
if (in_command) {
commit_reversible_command ();
}
- }
-}
+ }
+}
/* DISPLAY MOTION */
continue;
}
- /* find the trackview at the top of the trackview group
+ /* find the trackview at the top of the trackview group
*
* Note that covers_y_position() is recursive and includes child views
*/
/* automation lane (one level, non-recursive)
*
* - if no automation lane exists -> move to prev tack
- * - if no y-axis match is found -> the current track is at the top -> move to prev track
+ * - if no y-axis match is found -> the current track is at the top -> move to prev track
* (actually last automation lane of previous track, see below)
* - if first (top-most) lane is at the top -> move to this track
* - else move up one lane
return;
}
- // Imposing an arbitrary limit to zoom out as too much zoom out produces
+ // Imposing an arbitrary limit to zoom out as too much zoom out produces
// segfaults for lack of memory. If somebody decides this is not high enough I
// believe it can be raisen to higher values but some limit must be in place.
//
} else if (!selection->time.empty()) {
start = selection->time.start();
end = selection->time.end_frame();
- } else
+ } else
ret = false; //no selection found
//range check
location -= get_preroll();
//don't try to locate before the beginning of time
- if ( location < 0 )
+ if ( location < 0 )
location = 0;
//if follow_playhead is on, keep the playhead on the screen
if ( _follow_playhead )
- if ( location < leftmost_frame )
+ if ( location < leftmost_frame )
location = leftmost_frame;
_session->request_locate( location );
return;
}
ts.push_back (entered_track);
- }
+ }
for (TrackViewList::iterator i = ts.begin(); i != ts.end(); ++i) {
(*i)->cut_copy_clear (*selection, op);
}
void
-Editor::remove_time (framepos_t pos, framecnt_t frames, InsertTimeOption opt,
+Editor::remove_time (framepos_t pos, framecnt_t frames, InsertTimeOption opt,
bool ignore_music_glue, bool markers_too, bool glued_markers_too, bool locked_markers_too, bool tempo_too)
{
if (Config->get_edit_mode() == Lock) {
/* compute the per-track height from:
- total canvas visible height -
+ total canvas visible height -
height that will be taken by visible children of selected
- tracks - height of the ruler/hscroll area
+ tracks - height of the ruler/hscroll area
*/
uint32_t h = (uint32_t) floor ((trackviews_height() - child_heights) / visible_tracks);
double first_y_pos = DBL_MAX;
if (ci[i].index > 6) {
col->set_expand (false);
col->set_alignment (ALIGN_CENTER);
- }
+ }
}
_display.set_headers_visible (true);
if (iter) {
group = (*iter)[_columns.routegroup];
- }
+ }
if (Keyboard::is_context_menu_event (ev)) {
_editor->_group_tabs->get_menu(group)->popup (1, ev->time);
return true;
- }
+ }
if (!p) {
/* cancel selection */
group = (*iter)[_columns.routegroup];
switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
- case 0:
+ case 0:
c = (*iter)[_columns.gdkcolor];
color_dialog.get_colorsel()->set_previous_color (c);
color_dialog.get_colorsel()->set_current_color (c);
return;
}
- fr = _session->frame_rate();
+ fr = _session->frame_rate();
if (lower > (spacer = (framepos_t) (128 * Editor::get_current_zoom ()))) {
lower = lower - spacer;
} else if (range <= 8 * 60 * 60 * fr) { /* 4 - 8 hrs*/
timecode_ruler_scale = timecode_show_hours;
timecode_mark_modulo = 1;
- timecode_nmarks = 2 + 8;
+ timecode_nmarks = 2 + 8;
} else if (range <= 16 * 60 * 60 * fr) { /* 16-24 hrs*/
timecode_ruler_scale = timecode_show_hours;
timecode_mark_modulo = 1;
But in this case, where the range defined by lower and uppper can vary
substantially (basically anything from 24hrs+ to several billion years)
- trying to decide which tick marks to show does require us to know
+ trying to decide which tick marks to show does require us to know
about the available width.
*/
mark.position = pos;
marks.push_back (mark);
++n;
- }
+ }
/* can't use Timecode::increment_hours() here because we may be traversing thousands of hours
and doing it 1 hour at a time is just stupid (and slow).
*/
}
}
-static void
+static void
edit_last_mark_label (std::vector<ArdourCanvas::Ruler::Mark>& marks, const std::string& newlabel)
{
ArdourCanvas::Ruler::Mark copy = marks.back();
But in this case, where the range defined by lower and uppper can vary
substantially (anything from 24hrs+ to several billion years)
- trying to decide which tick marks to show does require us to know
+ trying to decide which tick marks to show does require us to know
about the available width.
*/
marks.push_back (mark);
}
break;
-
+
case minsec_show_seconds:
for (n = 0; n < minsec_nmarks; pos += minsec_mark_interval, ++n) {
sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
marks.push_back (mark);
}
break;
-
+
case minsec_show_many_hours:
for (n = 0; n < minsec_nmarks; ) {
sample_to_clock_parts (pos, _session->frame_rate(), &hrs, &mins, &secs, &millisecs);
int32_t width = _view_rectangle_x.second - _view_rectangle_x.first;
int32_t height = _view_rectangle_y.second - _view_rectangle_y.first;
- cairo_rectangle (cr, _view_rectangle_x.first, _view_rectangle_y.first, width, height);
+ cairo_rectangle (cr, _view_rectangle_x.first, _view_rectangle_y.first, width, height);
cairo_set_source_rgba (cr, 1, 1, 1, 0.1);
cairo_fill_preserve (cr);
cairo_set_line_width (cr, 1);
set_editor (ex, ey);
}
-bool
+bool
EditorSummary::on_enter_notify_event (GdkEventCrossing*)
{
grab_focus ();
return false;
}
-bool
+bool
EditorSummary::on_leave_notify_event (GdkEventCrossing*)
{
/* there are no inferior/child windows, so any leave event means that
/* We are dragging, and configured not to update the editor window during drags,
so just return where the editor will be when the drag finishes.
*/
-
+
*x = _pending_editor_x;
*y = _pending_editor_y;
TO_LEFT_OR_RIGHT,
OTHERWISE_OUTSIDE
};
-
+
void on_size_request (Gtk::Requisition *);
bool on_button_press_event (GdkEventButton *);
bool on_button_release_event (GdkEventButton *);
bool on_scroll_event (GdkEventScroll *);
bool on_key_press_event (GdkEventKey*);
bool on_key_release_event (GdkEventKey*);
- bool on_enter_notify_event (GdkEventCrossing*);
- bool on_leave_notify_event (GdkEventCrossing*);
+ bool on_enter_notify_event (GdkEventCrossing*);
+ bool on_leave_notify_event (GdkEventCrossing*);
void centre_on_click (GdkEventButton *);
void render (cairo_t *, cairo_rectangle_t*);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
handler->soundcloud_downloadable = soundcloud_selector->downloadable ();
handler->SoundcloudProgress.connect_same_thread(
- *this,
+ *this,
boost::bind(&ExportDialog::soundcloud_upload_progress, this, _1, _2, _3)
);
#if 0
class ExportTimespanSelector;
class ExportChannelSelector;
-class ExportDialog : public ArdourDialog, public PBD::ScopedConnectionList
+class ExportDialog : public ArdourDialog, public PBD::ScopedConnectionList
{
public:
#ifdef CARBON_FLAT_HEADERS
#include "MacTypes.h"
#else
-#include "/System/Library/Frameworks/CoreServices.framework/Headers/../Frameworks/CarbonCore.framework/Headers/MacTypes.h"
+#include "/System/Library/Frameworks/CoreServices.framework/Headers/../Frameworks/CarbonCore.framework/Headers/MacTypes.h"
#endif
#undef Style
#undef Fixed
if (entry_changed) {
use_text (entry.get_text ());
}
-
+
delete_when_idle ( this);
return false;
}
if (entry_changed) {
use_text (entry.get_text ());
}
-
+
delete_when_idle ( this);
return false;
{
entry.remove_modal_grab ();
- /* No hide button is shown (no decoration on the window),
- so being hidden is equivalent to the Escape key or any other
+ /* No hide button is shown (no decoration on the window),
+ so being hidden is equivalent to the Escape key or any other
method of cancelling the edit.
*/
peak_display.set_alignment(0.5);
/* stuff related to the fact that the peak display is not, in
- fact, supposed to be a text entry.
+ fact, supposed to be a text entry.
*/
peak_display.set_events (peak_display.get_events() & ~(Gdk::EventMask (Gdk::LEAVE_NOTIFY_MASK|Gdk::ENTER_NOTIFY_MASK|Gdk::POINTER_MOTION_MASK)));
peak_display.signal_map().connect (sigc::bind (sigc::ptr_fun (reset_cursor_to_default), &peak_display));
if (!match_or_digit(s1[n], s2[n]))
break;
n++;
- }
+ }
return n;
}
if (!match_or_digit(s1[s1pos], s2[s2pos]) )
break;
n++;
- }
+ }
return n;
}
if (i > 0) {
// A hand-wavy calculation of how similar this control's
// label is to the previous.
- similarity_scores[i] =
- (float) (
- ( matching_chars_at_head(label, previous_label) +
+ similarity_scores[i] =
+ (float) (
+ ( matching_chars_at_head(label, previous_label) +
matching_chars_at_tail(label, previous_label) +
- 1
- )
+ 1
+ )
) / (label.length() + previous_label.length());
if (numbers_in_labels[i] >= 0) {
similarity_scores[i] += (numbers_in_labels[i] == numbers_in_labels[i-1]);
}
// cerr << "label: " << label << " sim: " << fixed << setprecision(3) << similarity_scores[i] << " num: " << numbers_in_labels[i] << endl;
- previous_label = label;
+ previous_label = label;
}
}
// Now iterate over the list of controls to display them, placing an
- // HSeparator between controls of less than a certain similarity, and
+ // HSeparator between controls of less than a certain similarity, and
// starting a new column when necessary.
i = 0;
automation_menu->popup (1, gtk_get_current_event_time());
}
-void
+void
GenericPluginUI::set_all_automation (AutoState as)
{
for (vector<ControlUI*>::iterator i = input_controls_with_automation.begin(); i != input_controls_with_automation.end(); ++i) {
public:
GhostEvent(::NoteBase *, ArdourCanvas::Container *);
virtual ~GhostEvent ();
-
+
NoteBase* event;
ArdourCanvas::Item* item;
};
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* @return value of property `prop_name', or empty.
*/
-string
+string
GUIObjectState::get_string (const string& id, const string& prop_name, bool* empty)
{
XMLNode* child = get_node (&_state, id);
s << val;
child->add_property (prop_name.c_str(), s.str());
}
-
+
std::list<std::string> all_ids () const;
static XMLNode* get_node (const XMLNode *, const std::string &);
XMLNode* get_or_add_node (const std::string &);
static XMLNode* get_or_add_node (XMLNode *, const std::string &);
-
+
void remove_node (const std::string& id);
private:
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
using namespace ARDOUR;
using namespace ArdourCanvas;
-Hit::Hit (MidiRegionView& region, Item* parent, double size, const boost::shared_ptr<NoteType> note, bool with_events)
+Hit::Hit (MidiRegionView& region, Item* parent, double size, const boost::shared_ptr<NoteType> note, bool with_events)
: NoteBase (region, with_events, note)
{
_polygon = new ArdourCanvas::Polygon (parent);
return Keyboard::set_state (node, version);
}
-/* Snap and snap delta modifiers may contain each other, so we use the
+/* Snap and snap delta modifiers may contain each other, so we use the
* following two methods to sort that out:
*/
bool
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Based on code by Paul Davis, Torben Hohn as part of FST
This program is free software; you can redistribute it and/or modify
XErrorHandler olderrorhandler = XSetErrorHandler(TempErrorHandler);
- XGetWindowProperty( LXVST_XDisplay,
- window,
+ XGetWindowProperty( LXVST_XDisplay,
+ window,
atom,
0,
2,
false,
- AnyPropertyType,
+ AnyPropertyType,
&userType,
&userSize,
&userCount,
when opening a preset manager (you might think that should be spawned as a new window...) */
/*if the size has changed, we flag this so that in lxvst_pluginui.cc we can make the
- change to the GTK parent window in ardour, from its UI thread*/
+ change to the GTK parent window in ardour, from its UI thread*/
if (window == (Window) (vstfx->linux_window)) {
if (width != vstfx->width || height!=vstfx->height) {
vstfx->plugin->dispatcher (vstfx->plugin, 68 /* effEndSetProgram */, 0, 0, NULL, 0);
}
- vstfx->want_program = -1;
+ vstfx->want_program = -1;
}
if (vstfx->want_chunk == 1) {
while (!gui_quit)
{
- /* handle window creation requests, destroy requests,
+ /* handle window creation requests, destroy requests,
and run idle callbacks */
/*Look at the XEvent queue - if there are any XEvents we need to handle them,
{
//printf("elapsed %d ms ^= %.2f Hz\n", elapsed_time_ms, 1000.0/(double)elapsed_time_ms); // DEBUG
pthread_mutex_lock (&plugin_mutex);
-
+
again:
/*Parse through the linked list of plugins*/
pthread_mutex_unlock (&vstfx->lock);
goto again;
- }
+ }
/*Window does not yet exist - scheduled for creation*/
if (vstfx->dispatcher_wantcall) {
vstfx->dispatcher_retval = vstfx->plugin->dispatcher (
- vstfx->plugin,
+ vstfx->plugin,
vstfx->dispatcher_opcode,
vstfx->dispatcher_index,
vstfx->dispatcher_val,
pthread_attr_init(&thread_attributes);
- /*Make sure the thread is joinable - this should be the default anyway -
+ /*Make sure the thread is joinable - this should be the default anyway -
so we can join to it on vstfx_exit*/
pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_JOINABLE);
/*Select the events we are interested in receiving - we need Substructure notify so that
if the plugin resizes its window - e.g. Loomer Manifold then we get a message*/
- XSelectInput(LXVST_XDisplay,
+ XSelectInput(LXVST_XDisplay,
parent_window,
SubstructureNotifyMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | ExposureMask);
location->StartChanged.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::start_changed, this), gui_context());
location->EndChanged.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::end_changed, this), gui_context());
location->Changed.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::location_changed, this), gui_context());
- location->FlagsChanged.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::flags_changed, this), gui_context());
+ location->FlagsChanged.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::flags_changed, this), gui_context());
location->LockChanged.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::lock_changed, this), gui_context());
location->PositionLockStyleChanged.connect (connections, invalidator (*this), boost::bind (&LocationEditRow::position_lock_style_changed, this), gui_context());
}
if (!p) {
return ARDOUR_UI::instance()->secondary_clock->mode();
}
-
+
return (AudioClock::Mode) string_2_enum (p->value (), AudioClock::Mode);
}
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2004 Paul Davis
+ Copyright (C) 2004 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
pthread_mutex_lock (&(_vst->state()->lock));
/* The Window may be scheduled for creation
- but not actually created by the gui_event_loop yet -
+ but not actually created by the gui_event_loop yet -
spin here until it has been activated. Possible
deadlock if the window never gets activated but
should not be called here if the window doesn't
pthread_mutex_unlock (&(_vst->state()->lock));
- /* Finally it might be safe to return the ID -
+ /* Finally it might be safe to return the ID -
problems will arise if we return either a zero ID
and GTK tries to socket it or if we return an ID
which hasn't yet become real to the server
static error_handler_t vstfx_error_handler;
static error_handler_t gtk_error_handler;
-static int
+static int
gtk_xerror_handler (Display*, XErrorEvent*)
{
std::cerr << "** ERROR ** LXVSTPluginUI : Trapped an X Window System Error" << std::endl;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
add_button (Stock::OK, RESPONSE_OK);
}
-uint8_t
+uint8_t
MidiChannelDialog::active_channel () const
{
return selector.get_active_channel();
Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to enable recording all channels"));
capture_controls->pack_start (*b);
capture_mask_controls.push_back (b);
- b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::fill_capture_mask));
+ b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::fill_capture_mask));
b = manage (new Button (_("None")));
Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to disable recording all channels"));
capture_controls->pack_start (*b);
capture_mask_controls.push_back (b);
- b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::zero_capture_mask));
+ b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::zero_capture_mask));
b = manage (new Button (_("Invert")));
Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to invert currently selected recording channels"));
capture_controls->pack_start (*b);
capture_mask_controls.push_back (b);
- b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::invert_capture_mask));
+ b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::invert_capture_mask));
vpacker->pack_start (*capture_controls);
Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to enable playback of all channels"));
playback_controls->pack_start (*b);
playback_mask_controls.push_back (b);
- b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::fill_playback_mask));
+ b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::fill_playback_mask));
b = manage (new Button (_("None")));
Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to disable playback of all channels"));
playback_controls->pack_start (*b);
playback_mask_controls.push_back (b);
- b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::zero_playback_mask));
+ b->signal_clicked().connect (sigc::mem_fun (*this, &MidiChannelSelectorWindow::zero_playback_mask));
b = manage (new Button (_("Invert")));
Gtkmm2ext::UI::instance()->set_tip (*b, _("Click to invert current selected playback channels"));
playback_controls->pack_start (*b);
if (mode != ForceChannel) {
set_capture_selected_channels (track->get_capture_channel_mask());
- }
+ }
}
if (mode == AllChannels) {
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
static map<int,std::string> note_length_map;
-static void
+static void
fill_note_length_map ()
{
note_length_map.insert (make_pair<int,string> (BBT_Time::ticks_per_beat, _("Whole")));
redisplay_model ();
- region->midi_source(0)->model()->ContentsChanged.connect (content_connection, invalidator (*this),
+ region->midi_source(0)->model()->ContentsChanged.connect (content_connection, invalidator (*this),
boost::bind (&MidiListEditor::redisplay_model, this), gui_context());
buttons.attach (sound_notes_button, 0, 1, 0, 1);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
- /* we may be dragging some non-note object (eg. patch-change, sysex)
+ /* we may be dragging some non-note object (eg. patch-change, sysex)
*/
return editor.drags()->motion_handler ((GdkEvent *) ev, false);
if (!UIConfiguration::instance().get_never_display_periodic_midi()) {
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
- const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
+ const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
if (mev) {
if (zoom > (video_frame*4)) {
display_periodic_messages = false;
- }
+ }
}
} else {
display_periodic_messages = false;
for (MidiModel::SysExes::const_iterator i = _model->sysexes().begin(); i != _model->sysexes().end(); ++i) {
- const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
+ const boost::shared_ptr<const Evoral::MIDIEvent<Evoral::Beats> > mev =
boost::static_pointer_cast<const Evoral::MIDIEvent<Evoral::Beats> > (*i);
Evoral::Beats time = (*i)->time();
return pc->time() <= time && pc->channel() == channel;
}
-void
+void
MidiRegionView::get_patch_key_at (Evoral::Beats time, uint8_t channel, MIDI::Name::PatchPrimaryKey& key) const
{
// The earliest event not before time
resize_data->note = note;
// create a new SimpleRect from the note which will be the resize preview
- ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
+ ArdourCanvas::Rectangle *resize_rect = new ArdourCanvas::Rectangle (_note_group,
ArdourCanvas::Rect (note->x0(), note->y0(), note->x0(), note->y1()));
// calculate the colors: get the color settings
{
ostringstream s;
/* XXX should get patch name if we can */
- s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
- << _("Program ") << ((int) p->patch()->program()) + MIDI_BP_ZERO << '\n'
+ s << _("Bank ") << (p->patch()->bank() + MIDI_BP_ZERO) << '\n'
+ << _("Program ") << ((int) p->patch()->program()) + MIDI_BP_ZERO << '\n'
<< _("Channel ") << ((int) p->patch()->channel() + 1);
show_verbose_cursor (s.str(), 10, 20);
p->item().grab_focus();
_midnam_custom_device_mode_selector.show ();
_midi_controls_box.pack_start (_midnam_custom_device_mode_selector, false, false, 2);
- }
+ }
model_changed(gui_property(X_("midnam-model-name")));
custom_device_mode_changed(gui_property(X_("midnam-custom-device-mode")));
range_items.push_back (
MenuElem (_("Show Full Range"),
- sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range),
+ sigc::bind (sigc::mem_fun(*this, &MidiTimeAxisView::set_note_range),
MidiStreamView::FullRange, true)));
range_items.push_back (
, collect_button (_("Enabled"))
, delta_time_button (_("Delta times"))
{
- ARDOUR::AudioEngine::instance()->PortRegisteredOrUnregistered.connect
+ ARDOUR::AudioEngine::instance()->PortRegisteredOrUnregistered.connect
(_manager_connection, invalidator (*this), boost::bind (&MidiTracer::ports_changed, this), gui_context());
_last_receipt.tv_sec = 0;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
spinner.signal_activate().connect (sigc::bind (sigc::mem_fun (*this, &MidiVelocityDialog::response), Gtk::RESPONSE_OK));
}
-uint8_t
+uint8_t
MidiVelocityDialog::velocity () const
{
return (uint8_t) adjustment.get_value();
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
myactions.register_action ("Mixer", "scroll-left", _("Scroll Mixer Window to the left"), sigc::mem_fun (*this, &MixerActor::scroll_left));
myactions.register_action ("Mixer", "scroll-right", _("Scroll Mixer Window to the left"), sigc::mem_fun (*this, &MixerActor::scroll_right));
- myactions.register_action ("Mixer", "toggle-midi-input-active", _("Toggle MIDI Input Active for Mixer-Selected Tracks/Busses"),
+ myactions.register_action ("Mixer", "toggle-midi-input-active", _("Toggle MIDI Input Active for Mixer-Selected Tracks/Busses"),
sigc::bind (sigc::mem_fun (*this, &MixerActor::toggle_midi_input_active), false));
}
class ActionGroup;
}
-class MixerActor : virtual public sigc::trackable
+class MixerActor : virtual public sigc::trackable
{
public:
MixerActor ();
Mixer_UI* Mixer_UI::_instance = 0;
Mixer_UI*
-Mixer_UI::instance ()
+Mixer_UI::instance ()
{
if (!_instance) {
_instance = new Mixer_UI;
- }
+ }
return _instance;
}
if (mnode) {
_monitor_section->tearoff().set_state (*mnode);
}
- }
+ }
out_packer.pack_end (_monitor_section->tearoff(), false, false);
_monitor_section->set_session (_session);
for (list<MixerStrip*>::iterator i = strips.begin(); i != strips.end(); ++i) {
if ((*i) == strip) {
- /* hit clicked strip, start accumulating till we hit the first
+ /* hit clicked strip, start accumulating till we hit the first
selected strip
*/
if (accumulate) {
{
/* this happens as the second step of a DnD within the treeview as well
as when a row/route is actually deleted.
-
+
if it was a deletion then we have to force a redisplay because
order keys may not have changed.
*/
void initial_track_display ();
void show_track_list_menu ();
-
+
void set_all_strips_visibility (bool yn);
void set_all_audio_midi_visibility (int, bool);
void track_visibility_changed (std::string const & path);
}
/* these will throw exceptions if their images cannot be found.
-
- the default hotspot coordinates will be overridden by any
+
+ the default hotspot coordinates will be overridden by any
data found by Gtkmm2ext::Cursors::load_cursor_info(). the values
here from the set of cursors used by Ardour; new cursor/icon
sets should come with a hotspot info file.
Gdk::Cursor* expand_left_right;
Gdk::Cursor* expand_up_down;
- /* This cursor is not intended to be used directly, it just
+ /* This cursor is not intended to be used directly, it just
serves as an out-of-bounds value when we need to indicate
"no cursor". NULL/0 doesn't work for this, because it
is actually a valid value for a Gdk::Cursor - it indicates
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
_selected = selected;
set_fill_color (base_color());
-
+
set_outline_color(calculate_outline(base_color(), _selected));
}
case TrackColor:
{
uint32_t color = _region.midi_stream_view()->get_region_color();
- return UINT_INTERPOLATE (UINT_RGBA_CHANGE_A (color, opacity),
- UIConfiguration::instance().color ("midi note selected"),
+ return UINT_INTERPOLATE (UINT_RGBA_CHANGE_A (color, opacity),
+ UIConfiguration::instance().color ("midi note selected"),
0.5);
}
case ChannelColors:
- return UINT_INTERPOLATE (UINT_RGBA_CHANGE_A (NoteBase::midi_channel_colors[_note->channel()], opacity),
+ return UINT_INTERPOLATE (UINT_RGBA_CHANGE_A (NoteBase::midi_channel_colors[_note->channel()], opacity),
UIConfiguration::instance().color ("midi note selected"), 0.5);
default:
* This is not actually a canvas item itself to avoid the dreaded diamond
* inheritance pattern, since various types of canvas items (Note (rect), Hit
* (diamond), etc) need to share this functionality but can't share an
- * ancestor.
+ * ancestor.
*
* Note: Because of this, derived classes need to manually bounce events to
* on_event, it won't happen automatically.
bool _valid;
float _mouse_x_fraction;
float _mouse_y_fraction;
-
+
void set_mouse_fractions (GdkEvent*);
private:
{
if ( _st )
stop();
-
+
if ( _st )
lo_server_thread_free( _st );
else
}
}
-
+
void
Client::broadcast ( lo_message msg )
{
lo_address addr = lo_address_new_from_url( nsm_url );
int proto = lo_address_get_protocol( addr );
lo_address_free( addr );
-
+
_st = lo_server_thread_new_with_proto( NULL, proto, NULL );
_server = lo_server_thread_get_server( _st );
-
+
if ( ! _server || ! _st )
return -1;
lo_server_thread_add_method( _st, "/nsm/client/save", "", &Client::osc_save, this );
lo_server_thread_add_method( _st, "/nsm/client/session_is_loaded", "", &Client::osc_session_is_loaded, this );
lo_server_thread_add_method( _st, NULL, NULL, &Client::osc_broadcast, this );
-
+
return 0;
}
Client::osc_save ( const char *path, const char *types, lo_arg **argv, int argc, lo_message msg, void *user_data )
{
char *out_msg = NULL;
-
+
int r = ((NSM::Client*)user_data)->command_save(&out_msg);
if ( r )
char *out_msg = NULL;
NSM::Client *nsm = (NSM::Client*)user_data;
-
+
nsm->_nsm_client_id = strdup( &argv[2]->s );
nsm->_nsm_client_path = strdup( &argv[0]->s );
int r = ((NSM::Client*)user_data)->command_open( &argv[0]->s, &argv[1]->s, &argv[2]->s, &out_msg);
-
+
if ( r )
OSC_REPLY_ERR( r, ( out_msg ? out_msg : "") );
else
{
if ( strcmp( &argv[0]->s, "/nsm/server/announce" ) )
return -1;
-
+
NSM::Client *nsm = (NSM::Client*)user_data;
nsm->nsm_is_active = false;
-
+
nsm->command_active( nsm->nsm_is_active );
return 0;
{
if ( strcmp( &argv[0]->s, "/nsm/server/announce" ) )
return -1;
-
+
NSM::Client *nsm = (NSM::Client*)user_data;
nsm->nsm_is_active = true;
nsm->_session_manager_name = strdup( &argv[2]->s );
- nsm->nsm_addr = lo_address_new_from_url( lo_address_get_url( lo_message_get_source( msg ) ));
-
+ nsm->nsm_addr = lo_address_new_from_url( lo_address_get_url( lo_message_get_source( msg ) ));
+
nsm->command_active( nsm->nsm_is_active );
return 0;
int init ( const char *nsm_url );
/* init with threading */
int init_thread ( const char *nsm_url );
-
+
/* call this periodically to check for new messages */
void check ( int timeout = 0 );
* @param s Slot to set the variable's value.
*/
BoolComboOption::BoolComboOption (
- string const & i, string const & n, string const & t, string const & f,
+ string const & i, string const & n, string const & t, string const & f,
sigc::slot<bool> g, sigc::slot<bool, bool> s
)
: Option (i, n)
}
-
+
FaderOption::FaderOption (string const & i, string const & n, sigc::slot<gain_t> g, sigc::slot<bool, gain_t> s)
: Option (i, n)
, _db_adjustment (gain_to_slider_position_with_max (1.0, Config->get_max_gain()), 0, 1, 0.01, 0.1)
o->set_state_from_config ();
}
-/** Add a new page
+/** Add a new page
* @param pn Page name (will be created if it doesn't already exist)
* @param w widget that fills the page
*/
set_active_bank_combo ();
bank_combo_changed ();
- _info.Changed.connect (_info_changed_connection, invalidator (*this),
+ _info.Changed.connect (_info_changed_connection, invalidator (*this),
boost::bind (&PatchChangeDialog::instrument_info_changed, this), gui_context());
show_all ();
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Inspired by code from Ben Loftis @ Harrison Consoles
This program is free software; you can redistribute it and/or modify
curl_global_init (CURL_GLOBAL_NOTHING);
c = curl_easy_init ();
- curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, curl_write_data);
- curl_easy_setopt (c, CURLOPT_WRITEDATA, &return_str);
+ curl_easy_setopt (c, CURLOPT_WRITEFUNCTION, curl_write_data);
+ curl_easy_setopt (c, CURLOPT_WRITEDATA, &return_str);
char errbuf[CURL_ERROR_SIZE];
- curl_easy_setopt (c, CURLOPT_ERRORBUFFER, errbuf);
+ curl_easy_setopt (c, CURLOPT_ERRORBUFFER, errbuf);
string url;
return_str = "";
if (curl_easy_perform (c) == 0) {
- long http_status;
+ long http_status;
curl_easy_getinfo (c, CURLINFO_RESPONSE_CODE, &http_status);
namespace ARDOUR {
-void pingback (const string& version, const string& announce_path)
+void pingback (const string& version, const string& announce_path)
{
ping_call* cm = new ping_call (version, announce_path);
pthread_t thread;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Inspired by code from Ben Loftis @ Harrison Consoles
This program is free software; you can redistribute it and/or modify
: ArdourDialog (_("Plugin Manager"), true, false)
, filter_button (Stock::CLEAR)
, manager (mgr)
-
+
{
set_name ("PluginSelectorWindow");
add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
if (_pluginui) {
#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX)
- if (pre_deactivate_x >= 0) {
+ if (pre_deactivate_x >= 0) {
move (pre_deactivate_x, pre_deactivate_y);
- }
+ }
#endif
if (_pluginui->on_window_show (_title)) {
PluginUIWindow::on_hide ()
{
#if defined (HAVE_AUDIOUNITS) && defined(GTKOSX)
- get_position (pre_deactivate_x, pre_deactivate_y);
+ get_position (pre_deactivate_x, pre_deactivate_y);
#endif
Window::on_hide ();
}
break;
}
-#else
+#else
if (!seen_saving_message) {
seen_saving_message = true;
show_no_plugin_message();
if (!r.uri.empty ()) {
plugin->load_preset (r);
}
-#else
+#else
if (!seen_saving_message) {
seen_saving_message = true;
show_no_plugin_message();
the TOP_TO_RIGHT arrangement we reverse the order of the vertical
tabs in setup_notebooks ().
*/
-
+
int n = 0;
if (d == _row_index) {
if (_arrangement == LEFT_TO_BOTTOM) {
* This plugin may have unconnected output-ports (currently only in Mixbus,
* e.g channelstrip-EQ at the top of a MIDI-channel before the synth).
*
- * The *next* processor below this one will only see the
+ * The *next* processor below this one will only see the
* actual available streams (it cannot know the real outputs
* of this plugin).
*
cairo_stroke (cr);
#ifndef NDEBUG
} else if (midi_sources != 0 && midi_sinks != 0) {
- PBD::warning << string_compose("Programming error: midi routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
+ PBD::warning << string_compose("Programming error: midi routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg;
#endif
}
cairo_stroke (cr);
#ifndef NDEBUG
} else if (audio_sources != 0 && audio_sinks != 0) {
- PBD::warning << string_compose("Programming error: audio routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
+ PBD::warning << string_compose("Programming error: audio routing display: A %1 -> %2 | M %3 -> %4 | T %5 -> %6",
audio_sources, audio_sinks, midi_sources, midi_sinks, sources, sinks) << endmsg;
#endif
}
}
bool
-ProcessorBox::processor_operation (ProcessorOperation op)
+ProcessorBox::processor_operation (ProcessorOperation op)
{
ProcSelection targets;
return true;
}
-ProcessorWindowProxy*
+ProcessorWindowProxy*
ProcessorBox::find_window_proxy (boost::shared_ptr<Processor> processor) const
{
return processor->window_proxy();
_visible_prefader_processors = 0;
fader_seen = false;
- _route->foreach_processor (sigc::bind (sigc::mem_fun (*this, &ProcessorBox::help_count_visible_prefader_processors),
+ _route->foreach_processor (sigc::bind (sigc::mem_fun (*this, &ProcessorBox::help_count_visible_prefader_processors),
&_visible_prefader_processors, &fader_seen));
_route->foreach_processor (sigc::mem_fun (*this, &ProcessorBox::add_processor_to_display));
* will be forced back into a model where the fader controls the main gain.
* If the processor is a send, then we map the send controls onto the
* strip.
- *
+ *
* Plugins and others will return a window for control.
*/
}
ARDOUR::SessionHandlePtr*
-ProcessorWindowProxy::session_handle()
+ProcessorWindowProxy::session_handle()
{
/* we don't care */
return 0;
class ProcessorBox;
-class ProcessorWindowProxy : public WM::ProxyBase
+class ProcessorWindowProxy : public WM::ProxyBase
{
public:
ProcessorWindowProxy (std::string const &, ProcessorBox *, boost::weak_ptr<ARDOUR::Processor>);
~ProcessorWindowProxy();
Gtk::Window* get (bool create = false);
-
+
boost::weak_ptr<ARDOUR::Processor> processor () const {
return _processor;
}
MainMenuDisabler () {
/* The global menu bar continues to be accessible to applications
with modal dialogs on mac, which means that we need to desensitize
- all items in the menu bar.
+ all items in the menu bar.
*/
ActionManager::disable_active_actions ();
}
#include <cairo/cairo.h>
-#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string.hpp>
#include <gtkmm/liststore.h>
#include <gtkmm/stock.h>
class ClipLevelOptions : public OptionEditorBox
{
public:
- ClipLevelOptions ()
+ ClipLevelOptions ()
: _clip_level_adjustment (-.5, -50.0, 0.0, 0.1, 1.0) /* units of dB */
, _clip_level_slider (_clip_level_adjustment)
{
sigc::mem_fun (*_rc_config, &RCConfiguration::get_loop_is_mode),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_loop_is_mode)
);
- Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
+ Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
(_("<b>When enabled</b> the loop button does not start playback but forces playback to always play the loop\n\n"
"<b>When disabled</b> the loop button starts playing the loop, but stop then cancels loop playback")));
add_option (_("Transport"), tsf);
sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_recording_on_xrun),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_recording_on_xrun)
);
- Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
+ Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
string_compose (_("<b>When enabled</b> %1 will stop recording if an over- or underrun is detected by the audio engine"),
PROGRAM_NAME));
add_option (_("Transport"), tsf);
sigc::mem_fun (*_rc_config, &RCConfiguration::get_stop_at_session_end),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_stop_at_session_end)
);
- Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
+ Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
string_compose (_("<b>When enabled</b> if %1 is <b>not recording</b>, it will stop the transport "
"when it reaches the current session end marker\n\n"
"<b>When disabled</b> %1 will continue to roll past the session end marker at all times"),
sigc::mem_fun (*_rc_config, &RCConfiguration::get_seamless_loop),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_seamless_loop)
);
- Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
+ Gtkmm2ext::UI::instance()->set_tip (tsf->tip_widget(),
string_compose (_("<b>When enabled</b> this will loop by reading ahead and wrapping around at the loop point, "
"preventing any need to do a transport locate at the end of the loop\n\n"
"<b>When disabled</b> looping is done by locating back to the start of the loop when %1 reaches the end "
sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_sync_frame_rate),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_sync_frame_rate)
);
- Gtkmm2ext::UI::instance()->set_tip
+ Gtkmm2ext::UI::instance()->set_tip
(_sync_framerate->tip_widget(),
string_compose (_("This option controls the value of the video frame rate <i>while chasing</i> an external timecode source.\n\n"
"<b>When enabled</b> the session video frame rate will be changed to match that of the selected external timecode source.\n\n"
sigc::mem_fun (*_rc_config, &RCConfiguration::get_timecode_source_is_synced),
sigc::mem_fun (*_rc_config, &RCConfiguration::set_timecode_source_is_synced)
);
- Gtkmm2ext::UI::instance()->set_tip
+ Gtkmm2ext::UI::instance()->set_tip
(_sync_genlock->tip_widget(),
string_compose (_("<b>When enabled</b> %1 will never varispeed when slaved to external timecode. "
"Sync Lock indicates that the selected external timecode source shares clock-sync "
#endif
)
{
- add_option (_("User interaction"),
+ add_option (_("User interaction"),
new BoolOption (
"enable-translation",
string_compose (_("Use translations of %1 messages\n"
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* pick up the correct freeze state */
map_frozen ();
- }
+ }
_editor.ZoomChanged.connect (sigc::mem_fun(*this, &RouteTimeAxisView::reset_samples_per_pixel));
UIConfiguration::instance().ColorsChanged.connect (sigc::mem_fun (*this, &RouteTimeAxisView::color_handler));
sigc::bind (sigc::mem_fun (*this, &RouteTimeAxisView::hide_all_automation), for_selection)));
/* Attach the plugin submenu. It may have previously been used elsewhere,
- so it was detached above
+ so it was detached above
*/
if (!subplugin_menu.items().empty()) {
if (gain_track) {
items.push_back (CheckMenuElem (_("Fader"), sigc::mem_fun (*this, &RouteTimeAxisView::update_gain_track_visibility)));
gain_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
- gain_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
+ gain_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
(gain_track && string_is_affirmative (gain_track->gui_property ("visible"))));
_main_automation_menu_map[Evoral::Parameter(GainAutomation)] = gain_automation_item;
if (mute_track) {
items.push_back (CheckMenuElem (_("Mute"), sigc::mem_fun (*this, &RouteTimeAxisView::update_mute_track_visibility)));
mute_automation_item = dynamic_cast<Gtk::CheckMenuItem*> (&items.back ());
- mute_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
+ mute_automation_item->set_active ((!for_selection || _editor.get_selection().tracks.size() == 1) &&
(mute_track && string_is_affirmative (mute_track->gui_property ("visible"))));
_main_automation_menu_map[Evoral::Parameter(MuteAutomation)] = mute_automation_item;
pan->view = boost::shared_ptr<AutomationTimeAxisView>(
new AutomationTimeAxisView (_session, _route, processor, control, control->parameter (),
- _editor, *this, false, parent_canvas,
+ _editor, *this, false, parent_canvas,
processor->describe_parameter (what), processor->name()));
pan->view->Hiding.connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::processor_automation_track_hidden), pan, processor));
/* existing state overrides "show" argument */
string s = track->gui_property ("visible");
- if (!s.empty()) {
+ if (!s.empty()) {
show = string_is_affirmative (s);
}
_route.reset (); /* drop reference to route, so that it can be cleaned up */
route_connections.drop_connections ();
-
+
delete solo_menu;
delete mute_menu;
delete sends_menu;
boost::bind (&RouteUI::step_edit_changed, this, _1), gui_context());
}
- }
+ }
/* this will work for busses and tracks, and needs to be called to
set up the name entry/name label display.
boost::shared_ptr<RouteList> rl;
- if (ev->button == 1) {
+ if (ev->button == 1) {
if (_route->route_group()) {
boost::shared_ptr<RouteList> rl;
- if (ev->button == 1) {
+ if (ev->button == 1) {
if (_route->route_group()) {
MonitorChoice mc;
boost::shared_ptr<RouteList> rl;
- /* XXX for now, monitoring choices are orthogonal. cue monitoring
+ /* XXX for now, monitoring choices are orthogonal. cue monitoring
will follow in 3.X but requires mixing the input and playback (disk)
signal together, which requires yet more buffers.
*/
TreeModel::Row row = (*iter);
string s = row[session_template_columns.path];
return s;
- }
+ }
return string();
}
row[recent_session_columns.time_formatted] = gdt.format ("%F %H:%M");
}
- recent_session_display.set_tooltip_column(1); // recent_session_columns.tip
+ recent_session_display.set_tooltip_column(1); // recent_session_columns.tip
recent_session_display.set_model (recent_session_model);
// custom sort
class SessionDialog : public ArdourDialog {
public:
- SessionDialog (bool require_new, const std::string& session_name, const std::string& session_path,
+ SessionDialog (bool require_new, const std::string& session_name, const std::string& session_path,
const std::string& template_name, bool cancel_not_quit);
SessionDialog ();
~SessionDialog ();
std::string session_name (bool& should_be_new);
std::string session_folder ();
-
+
bool use_session_template();
std::string session_template_name();
return;
}
- //create a temporary
+ //create a temporary
ARDOUR::SessionMetadata data;
data.set_state (*node, version);
init_data ( true ); //skip user data here
if (res != CURLE_ABORTED_BY_CALLBACK) {
error << string_compose (_("curl error %1 (%2)"), res, curl_easy_strerror(res)) << endmsg;
}
- remove ( (audioFileName+".part").c_str() );
+ remove ( (audioFileName+".part").c_str() );
} else {
rename ( (audioFileName+".part").c_str(), audioFileName.c_str() );
// now download the tags &c.
return (void *) res;
}
-
+
void
Mootcher::doneWithMootcher()
{
- // update the sound info pane if the selection in the list box is still us
+ // update the sound info pane if the selection in the list box is still us
sfb->refresh_display(ID, audioFileName);
delete this; // this should be OK to do as long as Progress and Finished signals are always received in the order in which they are emitted
}
static void *
-freesound_download_thread_func(void *arg)
-{
+freesound_download_thread_func(void *arg)
+{
Mootcher *thisMootcher = (Mootcher *) arg;
void *res;
// check to see if audio file already exists
FILE *testFile = g_fopen(audioFileName.c_str(), "r");
- if (testFile) {
+ if (testFile) {
fseek (testFile , 0 , SEEK_END);
if (ftell (testFile) > 256) {
fclose (testFile);
return true;
}
- // else file was small, probably an error, delete it
+ // else file was small, probably an error, delete it
fclose(testFile);
- remove( audioFileName.c_str() );
+ remove( audioFileName.c_str() );
}
return false;
}
//---------
-void
-Mootcher::updateProgress(double dlnow, double dltotal)
+void
+Mootcher::updateProgress(double dlnow, double dltotal)
{
if (dltotal > 0) {
double fraction = dlnow / dltotal;
}
}
-int
+int
Mootcher::progress_callback(void *caller, double dltotal, double dlnow, double /*ultotal*/, double /*ulnow*/)
{
// It may seem curious to pass a pointer to an instance of an object to a static
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
std::string searchText(std::string query, int page, std::string filter, enum sortMethod sort);
std::string searchSimilar(std::string id);
void * threadFunc();
- SoundFileBrowser *sfb;
+ SoundFileBrowser *sfb;
std::string audioFileName;
std::string ID;
Gtk::Button cancel_download_btn;
bool cancel_download;
- void cancelDownload() {
+ void cancelDownload() {
cancel_download = true;
progress_hbox.hide();
}
// there's a single item selected in the freesound list
//XXX make a function to be used to construct the actual file name both here and in the mootcher
Gtk::TreeIter row = freesound_list->get_iter(*rows.begin());
- std::string selected_ID = (*row)[freesound_list_columns.id];
+ std::string selected_ID = (*row)[freesound_list_columns.id];
if (ID == selected_ID) {
// the selected item in the freesound list is the item that has just finished downloading
chooser.set_filename(file);
gdk_flush();
std::string theString = mootcher.searchText(
- search_string,
+ search_string,
freesound_page,
#ifdef GTKOSX
"", // OSX eats anything incl mp3
return paths.front();
}
-SoundFileOmega::SoundFileOmega (string title, ARDOUR::Session* s,
- uint32_t selected_audio_tracks,
- uint32_t selected_midi_tracks,
+SoundFileOmega::SoundFileOmega (string title, ARDOUR::Session* s,
+ uint32_t selected_audio_tracks,
+ uint32_t selected_midi_tracks,
bool persistent,
Editing::ImportMode mode_hint)
: SoundFileBrowser (title, s, persistent)
Gtk::TreeModelColumn<bool> started;
FreesoundColumns() {
- add(id);
- add(filename);
+ add(id);
+ add(filename);
add(uri);
add(duration);
add(filesize);
{
public:
- SoundFileOmega (std::string title, ARDOUR::Session* _s,
+ SoundFileOmega (std::string title, ARDOUR::Session* _s,
uint32_t selected_audio_tracks, uint32_t selected_midi_tracks,
bool persistent,
Editing::ImportMode mode_hint = Editing::ImportAsTrack);
/* April 2013: window layering on OS X is a bit different to X Window. at present,
the "restack()" functionality in GDK will only operate on windows in the same
"level" (e.g. two normal top level windows, or two utility windows) and will not
- work across them. The splashscreen is on its own "StatusWindowLevel" so restacking
+ work across them. The splashscreen is on its own "StatusWindowLevel" so restacking
is not going to work.
So for OS X, we just hide ourselves.
Splash::on_button_release_event (GdkEventButton* ev)
{
RefPtr<Gdk::Window> window = get_window();
-
+
if (!window || ev->window != window->gobj()) {
return false;
}
-
+
hide ();
return true;
}
window->draw_layout (white, 10, pixbuf->get_height() - 30, layout);
- /* this must execute AFTER the GDK idle update mechanism
+ /* this must execute AFTER the GDK idle update mechanism
*/
-
+
if (expose_is_the_one) {
Glib::signal_idle().connect (sigc::mem_fun (this, &Splash::idle_after_expose),
GDK_PRIORITY_REDRAW+2);
if (!was_mapped) {
expose_done = false;
expose_is_the_one = false;
- }
+ }
pop_front ();
present ();
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
private:
PannerEditor* editor ();
boost::shared_ptr<ARDOUR::PannerShell> _panner_shell;
-
+
boost::shared_ptr<PBD::Controllable> position_control;
boost::shared_ptr<PBD::Controllable> width_control;
PBD::ScopedConnectionList panvalue_connections;
{
_flag = new ArdourCanvas::Flag (
parent,
- height,
+ height,
UIConfiguration::instance().color ("midi sysex outline"),
UIConfiguration::instance().color_mod ("midi sysex fill", "midi sysex fill"),
ArdourCanvas::Duple (x, y)
i = end;
i--;
- bars = (*i).bar - (*begin).bar;
+ bars = (*i).bar - (*begin).bar;
beats = distance (begin, end) - bars;
beat_density = (beats * 10.0f) / lines.canvas()->width();
void tempo_map_changed();
- void draw (const ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
+ void draw (const ARDOUR::TempoMap::BBTPointList::const_iterator& begin,
const ARDOUR::TempoMap::BBTPointList::const_iterator& end,
unsigned divisions,
ARDOUR::framecnt_t leftmost_frame,
transients_follow_front.signal_toggled().connect (sigc::mem_fun (*this, &ThemeManager::on_transients_follow_front_toggled));
icon_set_dropdown.signal_changed().connect (sigc::mem_fun (*this, &ThemeManager::on_icon_set_changed));
- Gtkmm2ext::UI::instance()->set_tip (all_dialogs,
+ Gtkmm2ext::UI::instance()->set_tip (all_dialogs,
string_compose (_("Mark all floating windows to be type \"Dialog\" rather than using \"Utility\" for some.\n"
"This may help with some window managers. This requires a restart of %1 to take effect"),
PROGRAM_NAME));
- Gtkmm2ext::UI::instance()->set_tip (transients_follow_front,
+ Gtkmm2ext::UI::instance()->set_tip (transients_follow_front,
string_compose (_("Make transient windows follow the front window when toggling between the editor and mixer.\n"
"This requires a restart of %1 to take effect"), PROGRAM_NAME));
}
/* there is no need to block signal handlers, here,
- * all elements check if the value has changed and ignore NOOPs
+ * all elements check if the value has changed and ignore NOOPs
*/
all_dialogs.set_active (UIConfiguration::instance().get_all_floating_windows_are_dialogs());
transients_follow_front.set_active (UIConfiguration::instance().get_transients_follow_front());
if ((colon = i->first.find (':')) != string::npos) {
/* this is supposed to be a child node, so find the
- * parent
+ * parent
*/
string parent = i->first.substr (0, colon);
/* these methods create and manage a canvas for use in either the
palette tab or in a separate dialog. Different behaviour is
- accomplished by changing the event handler passed into the
+ accomplished by changing the event handler passed into the
allocation handler. We do it there because we have to rebuild
the canvas on allocation events, and during the rebuild, connect
each rectangle to the event handler.
}
e.stepping_axis_view()->step_height (false);
return true;
- }
+ }
break;
case GDK_SCROLL_DOWN:
}
e.stepping_axis_view()->step_height (true);
return true;
- }
+ }
break;
default:
}
if (ending_name_edit) {
- /* already doing this, and focus out or other event has caused
+ /* already doing this, and focus out or other event has caused
us to re-enter this code.
*/
return;
if ((i != allviews.end()) && (*i != this) && !(*i)->hidden()) {
_editor.ensure_time_axis_view_is_visible (**i, false);
(*i)->begin_name_edit ();
- }
+ }
} else if (edit_prev) {
if ((i != allviews.end()) && (*i != this) && !(*i)->hidden()) {
_editor.ensure_time_axis_view_is_visible (**i, false);
(*i)->begin_name_edit ();
- }
+ }
}
}
NAME_HEIGHT = height;
- /* Config->get_show_name_highlight) == true:
+ /* Config->get_show_name_highlight) == true:
Y_OFFSET is measured from bottom of the time axis view item.
- Config->get_show_name_highlight) == false:
+ Config->get_show_name_highlight) == false:
Y_OFFSET is measured from the top of the time axis view item.
*/
}
void
-TimeAxisViewItem::init (ArdourCanvas::Item* parent, double fpp, uint32_t base_color,
- framepos_t start, framepos_t duration, Visibility vis,
+TimeAxisViewItem::init (ArdourCanvas::Item* parent, double fpp, uint32_t base_color,
+ framepos_t start, framepos_t duration, Visibility vis,
bool wide, bool high)
{
group = new ArdourCanvas::Container (parent);
}
if (visibility & ShowFrame) {
- frame = new ArdourCanvas::Rectangle (group,
- ArdourCanvas::Rect (0.0, 0.0,
- trackview.editor().sample_to_pixel(duration),
+ frame = new ArdourCanvas::Rectangle (group,
+ ArdourCanvas::Rect (0.0, 0.0,
+ trackview.editor().sample_to_pixel(duration),
trackview.current_height()));
frame->set_outline_what (ArdourCanvas::Rectangle::What (ArdourCanvas::Rectangle::LEFT|ArdourCanvas::Rectangle::RIGHT));
if (visibility & ShowNameText) {
if (UIConfiguration::instance().get_show_name_highlight()) {
- name_text->set_y_position (height - NAME_Y_OFFSET);
+ name_text->set_y_position (height - NAME_Y_OFFSET);
} else {
- name_text->set_y_position (NAME_Y_OFFSET);
+ name_text->set_y_position (NAME_Y_OFFSET);
}
}
if (frame_handle_start) {
if (pixel_width < (3 * TimeAxisViewItem::GRAB_HANDLE_WIDTH)) {
/*
- * there's less than GRAB_HANDLE_WIDTH of the region between
+ * there's less than GRAB_HANDLE_WIDTH of the region between
* the right-hand end of frame_handle_start and the left-hand
* end of frame_handle_end, so disable the handles
*/
delete selection_length;
delete selection_end;
delete selection_start;
-
+
delete punch_start;
delete punch_end;
}
punch_changed (punch);
- _session->auto_punch_location_changed.connect (_session_connections, MISSING_INVALIDATOR,
+ _session->auto_punch_location_changed.connect (_session_connections, MISSING_INVALIDATOR,
boost::bind (&TimeInfoBox::punch_location_changed, this, _1), gui_context());
}
}
{
if (loc) {
watch_punch (loc);
- }
+ }
}
void
AudioClock* selection_start;
AudioClock* selection_end;
AudioClock* selection_length;
-
+
AudioClock* punch_start;
AudioClock* punch_end;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
int pre_gui_init ();
- /** called after the GUI toolkit has been initialized.
+ /** called after the GUI toolkit has been initialized.
*/
UIConfiguration* post_gui_init ();
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
return (savergb);
}
-/** Returns a Pango::FontDescription given a string describing the font.
+/** Returns a Pango::FontDescription given a string describing the font.
*
* If the returned FontDescription does not specify a family, then
* the family is set to "Sans". This mirrors GTK's behaviour in
- * gtkstyle.c.
+ * gtkstyle.c.
*
* Some environments will force Pango to specify the family
* even if it was not specified in the string describing the font.
- * Such environments should be left unaffected by this function,
+ * Such environments should be left unaffected by this function,
* since the font family will be left alone.
*
* There may be other similar font specification enforcement
appear to be. if it ever is necessar, figure out if it should apply
to all platforms.
*/
-#if 0
+#if 0
if (Keyboard::some_magic_widget_has_focus ()) {
allow_activating = false;
}
* automatically sent through the accel groups activation
* pathway, which prevents individual widgets & canvas items
* from ever seeing it if is used by a key binding.
- *
+ *
* specifically, this hid Ctrl-down-arrow from MIDI region
* views because it is also bound to an action.
*
bool
ARDOUR_UI_UTILS::key_is_legal_for_numeric_entry (guint keyval)
{
- /* we assume that this does not change over the life of the process
+ /* we assume that this does not change over the life of the process
*/
static int comma_decimal = -1;
}
}
-string
+string
ARDOUR_UI_UTILS::rate_as_string (float r)
{
char buf[32];
double step,
double page,
bool with_numeric,
- int subw,
+ int subw,
int subh,
bool linear)
}
void
-VolumeController::dB_printer (char buf[32], const boost::shared_ptr<PBD::Controllable>& c)
+VolumeController::dB_printer (char buf[32], const boost::shared_ptr<PBD::Controllable>& c)
{
if (c) {
v = 0.0;
} else {
- /* non-linear scaling as the dB level gets low
+ /* non-linear scaling as the dB level gets low
so that we can hit -inf and get back out of
it appropriately.
*/
ActionManager::add_action_group (window_actions);
}
- info->set_action (ActionManager::register_action (window_actions, info->action_name().c_str(), info->menu_name().c_str(),
+ info->set_action (ActionManager::register_action (window_actions, info->action_name().c_str(), info->menu_name().c_str(),
sigc::bind (sigc::mem_fun (*this, &Manager::toggle_window), info)));
}
}
/* OS X has a richer concept of window layering than X does (or
* certainly, than any accepted conventions on X), and so the use of
* Manager::set_transient_for() is not necessary on that platform.
- *
+ *
* On OS X this is mostly taken care of by using the window type rather
* than explicit 1:1 transient-for relationships.
*/
, _x_off (-1)
, _y_off (-1)
, _width (-1)
- , _height (-1)
+ , _height (-1)
, vistracker (0)
{
}
, _x_off (-1)
, _y_off (-1)
, _width (-1)
- , _height (-1)
+ , _height (-1)
, vistracker (0)
{
set_state (node);
}
std::string
-ProxyBase::action_name() const
+ProxyBase::action_name() const
{
return string_compose (X_("toggle-%1"), _name);
}
void
-ProxyBase::toggle()
+ProxyBase::toggle()
{
if (!_window) {
(void) get (true);
ProxyBase (const std::string& name, const std::string& menu_name);
ProxyBase (const std::string& name, const std::string& menu_name, const XMLNode&);
virtual ~ProxyBase();
-
+
void show ();
void show_all ();
void hide ();
void present ();
void maybe_show ();
-
+
bool visible() const { return _visible; }
const std::string& name() const { return _name; }
const std::string& menu_name() const { return _menu_name; }
-
+
std::string action_name() const;
void set_action (Glib::RefPtr<Gtk::Action>);
Glib::RefPtr<Gtk::Action> action() const { return _action; };
-
+
void drop_window ();
void use_window (Gtk::Window&);
-
+
virtual Gtk::Window* get (bool create = false) = 0;
-
+
virtual void toggle ();
-
+
void set_state (const XMLNode&);
XMLNode& get_state () const;
-
+
virtual ARDOUR::SessionHandlePtr* session_handle () = 0;
operator bool() const { return _window != 0; }
-
+
protected:
std::string _name;
std::string _menu_name;
void save_pos_and_size ();
bool delete_event_handler (GdkEventAny *ev);
-
+
void setup ();
};
public:
ProxyTemporary (const std::string& name, Gtk::Window* win);
~ProxyTemporary();
-
- Gtk::Window* get (bool create = false) {
+
+ Gtk::Window* get (bool create = false) {
(void) create;
return _window;
}
-
- Gtk::Window* operator->() {
+
+ Gtk::Window* operator->() {
return _window;
}
ProxyWithConstructor (const std::string& name, const std::string& menu_name, const boost::function<T*()>& c, const XMLNode* node)
: ProxyBase (name, menu_name, *node) , creator (c) {}
- Gtk::Window* get (bool create = false) {
+ Gtk::Window* get (bool create = false) {
if (!_window) {
if (!create) {
return 0;
return _window;
}
- T* operator->() {
+ T* operator->() {
return dynamic_cast<T*> (get (true));
}
Proxy (const std::string& name, const std::string& menu_name, const XMLNode* node)
: ProxyBase (name, menu_name, *node) {}
- Gtk::Window* get (bool create = false) {
+ Gtk::Window* get (bool create = false) {
if (!_window) {
if (!create) {
return 0;
return _window;
}
- T* operator->() {
+ T* operator->() {
return dynamic_cast<T*> (get(true));
}
private:
boost::function<T*()> creator;
};
-
+
} /* namespace */
#endif /* __gtk2_ardour_window_manager_h__ */
#include "pbd/transmitter.h"
#include "pbd/receiver.h"
-class TestReceiver : public Receiver
+class TestReceiver : public Receiver
{
protected:
void receive (Transmitter::Channel chn, const char * str);
#include "CAAUParameter.h"
/*
- The ParameterMap returned by the Map() method is a map where
+ The ParameterMap returned by the Map() method is a map where
- the key is the clumpID
- the value is a ParameterList (vector<CAAUParameter>)
- If you have parameters on multiple scopes (or elements within a scope), then you should create one of these
+ If you have parameters on multiple scopes (or elements within a scope), then you should create one of these
for each scope-element pair
*/
- AUParamInfo (AudioUnit inAU,
- bool inIncludeExpert,
- bool inIncludeReadOnly,
+ AUParamInfo (AudioUnit inAU,
+ bool inIncludeExpert,
+ bool inIncludeReadOnly,
AudioUnitScope inScope = kAudioUnitScope_Global,
AudioUnitElement inElement = 0);
// some convenience methods
UInt32 NumParams () const { return mNumParams; }
- AudioUnitParameterID ParamID (UInt32 inIndex) const
- {
- if (inIndex < mNumParams) return mParamListID[inIndex];
- return 0xFFFFFFFF;
+ AudioUnitParameterID ParamID (UInt32 inIndex) const
+ {
+ if (inIndex < mNumParams) return mParamListID[inIndex];
+ return 0xFFFFFFFF;
}
-
+
UInt32 NumClumps () const { return mParams.size(); }
UInt32 NumParamsForClump (UInt32 inClump) const;
~CAAUParameter();
/*! @method operator <@ */
- bool operator < (const CAAUParameter &a) const
- {
- return memcmp(this, &a, sizeof(AudioUnitParameter)) < 0;
+ bool operator < (const CAAUParameter &a) const
+ {
+ return memcmp(this, &a, sizeof(AudioUnitParameter)) < 0;
}
/*! @method operator ==@ */
- bool operator == (const CAAUParameter &a) const
- {
- return !memcmp(this, &a, sizeof(AudioUnitParameter));
+ bool operator == (const CAAUParameter &a) const
+ {
+ return !memcmp(this, &a, sizeof(AudioUnitParameter));
}
/*! @method operator =@ */
/*! @method GetValue */
Float32 GetValue() const;
/*! @method SetValue */
- void SetValue( AUParameterListenerRef inListener,
+ void SetValue( AUParameterListenerRef inListener,
void * inObject,
Float32 inValue) const;
/*! @method GetName */
- CFStringRef GetName() const { return mParamName; }
+ CFStringRef GetName() const { return mParamName; }
// borrowed reference!
/*! @method GetStringFromValueCopy */
// or null if there is no name associated
// caller must release
/*! @method ValuesHaveStrings */
- bool ValuesHaveStrings () const
- {
- return (mParamInfo.flags & kAudioUnitParameterFlag_ValuesHaveStrings) != 0;
+ bool ValuesHaveStrings () const
+ {
+ return (mParamInfo.flags & kAudioUnitParameterFlag_ValuesHaveStrings) != 0;
}
/*! @method GetValueFromString */
/*! @method GetParamTag */
CFStringRef GetParamTag() const { return mParamTag; }
- // this may return null! -
+ // this may return null! -
// in which case there is no descriptive tag for the parameter
/*! @method GetParamName */
CFStringRef GetParamName (int inIndex) const
// this can return null if there is no name for the parameter
- {
- return (mNamedParams && inIndex < mNumIndexedParams)
+ {
+ return (mNamedParams && inIndex < mNumIndexedParams)
? (CFStringRef) CFArrayGetValueAtIndex(mNamedParams, inIndex)
- : 0;
+ : 0;
}
/*! @method GetNumIndexedParams */
bool HasNamedParams () const { return IsIndexedParam() && mNamedParams; }
/*! @method GetClumpID */
- bool GetClumpID (UInt32 &outClumpID) const
- {
+ bool GetClumpID (UInt32 &outClumpID) const
+ {
if (mParamInfo.flags & kAudioUnitParameterFlag_HasClump) {
outClumpID = mParamInfo.clumpID;
return true;
}
/*! @method HasDisplayTransformation */
- bool HasDisplayTransformation () const
- {
- return GetAudioUnitParameterDisplayType (mParamInfo.flags);
+ bool HasDisplayTransformation () const
+ {
+ return GetAudioUnitParameterDisplayType (mParamInfo.flags);
}
/*! @method IsExpert */
- bool IsExpert () const
- {
- return mParamInfo.flags & kAudioUnitParameterFlag_ExpertMode;
+ bool IsExpert () const
+ {
+ return mParamInfo.flags & kAudioUnitParameterFlag_ExpertMode;
}
#if DEBUG
void Print () const;
public:
static AudioChannelLayout* Create(UInt32 inNumberChannelDescriptions);
static void Destroy(AudioChannelLayout* inChannelLayout);
- static UInt32 CalculateByteSize(UInt32 inNumberChannelDescriptions) {
+ static UInt32 CalculateByteSize(UInt32 inNumberChannelDescriptions) {
return offsetof(AudioChannelLayout, mChannelDescriptions) + inNumberChannelDescriptions * sizeof(AudioChannelDescription);
}
static void SetAllToUnknown(AudioChannelLayout& outChannelLayout, UInt32 inNumberChannelDescriptions);
CAAudioChannelLayout (UInt32 inNumberChannels, bool inChooseSurround);
// if inChooseSurround is false, then symmetrical speaker arrangements
// are chosen in place of surround layouts if there is a choice
- // This call chooses layouts based on the expected defaults in
+ // This call chooses layouts based on the expected defaults in
// AudioUnit usage
CAAudioChannelLayout (AudioChannelLayoutTag inTag);
CAAudioChannelLayout (const CAAudioChannelLayout &c);
private:
class ACLRefCounter : public CAReferenceCounted {
public:
- ACLRefCounter (UInt32 inDataSize)
- {
+ ACLRefCounter (UInt32 inDataSize)
+ {
if (inDataSize < offsetof(AudioChannelLayout, mChannelDescriptions))
inDataSize = offsetof(AudioChannelLayout, mChannelDescriptions);
*/
/*=============================================================================
CAAudioUnit.h
-
+
=============================================================================*/
#ifndef __CAAudioUnit_h__
// The destructor will NOT automatically close the AU down
// This state should be managed by the Caller
// once closed, the unit represented by this object is no longer valid
-// it is up to the user of this object to ensure its validity is in sync
+// it is up to the user of this object to ensure its validity is in sync
// if it is removed from a graph
// methods that can significantly change the state of the AU (like its format) are
typedef ChannelTagVector::iterator ChannelTagVectorIter;
public:
- CAAudioUnit ()
+ CAAudioUnit ()
: mDataPtr(0) {}
CAAudioUnit (const AudioUnit& inUnit);
UInt32 inOffsetSampleFrame,
const MusicDeviceNoteParams * inParams)
{
- return StartNote (kMusicNoteEvent_UseGroupInstrument,
- inGroupID, outNoteInstanceID,
+ return StartNote (kMusicNoteEvent_UseGroupInstrument,
+ inGroupID, outNoteInstanceID,
inOffsetSampleFrame, inParams);
}
return CanDo (inChannelsInOut, inChannelsInOut);
}
- bool CanDo ( int inChannelsIn,
+ bool CanDo ( int inChannelsIn,
int inChannelsOut) const;
// This version does a more thorough test for ANY AU with ANY ins/outs
bool SupportsNumChannels () const;
- bool HasChannelLayouts (AudioUnitScope inScope,
+ bool HasChannelLayouts (AudioUnitScope inScope,
AudioUnitElement inEl) const;
int GetChannelInfo (AUChannelInfo** chaninfo, UInt32& cnt);
AudioUnitElement inEl,
CAAudioChannelLayout &outLayout) const;
- OSStatus SetChannelLayout (AudioUnitScope inScope,
+ OSStatus SetChannelLayout (AudioUnitScope inScope,
AudioUnitElement inEl,
CAAudioChannelLayout &inLayout);
- OSStatus SetChannelLayout (AudioUnitScope inScope,
+ OSStatus SetChannelLayout (AudioUnitScope inScope,
AudioUnitElement inEl,
AudioChannelLayout &inLayout,
UInt32 inSize);
OSStatus GetNumberChannels (AudioUnitScope inScope,
AudioUnitElement inEl,
- UInt32 &outChans) const
- {
- return NumberChannels (inScope, inEl, outChans);
+ UInt32 &outChans) const
+ {
+ return NumberChannels (inScope, inEl, outChans);
}
OSStatus SetNumberChannels (AudioUnitScope inScope,
OSStatus SetElementCount (AudioUnitScope inScope, UInt32 inCount);
// value of -1 for outTotalNumChannels indicates no restriction on num channels
- // for ex. the Matrix Mixer satisfies this (its in/out element count is writable, and can be set to
+ // for ex. the Matrix Mixer satisfies this (its in/out element count is writable, and can be set to
// any number of channels.
// outTotalNumChannels is only valid if method returns true...
bool HasDynamicInputs (SInt32 &outTotalNumChannels) const
CAAudioUnit (const CAComponent& inComp);
bool HasDynamicScope (AudioUnitScope inScope, SInt32 &outTotalNumChannels) const;
- OSStatus ConfigureDynamicScope (AudioUnitScope inScope,
- UInt32 inNumElements,
- UInt32 *inChannelsPerElement,
+ OSStatus ConfigureDynamicScope (AudioUnitScope inScope,
+ UInt32 inNumElements,
+ UInt32 *inChannelsPerElement,
Float64 inSampleRate);
- bool ValidateChannelPair (int inChannelsIn,
+ bool ValidateChannelPair (int inChannelsIn,
int inChannelsOut,
const AUChannelInfo * info,
UInt32 numChanInfo) const;
- bool ValidateDynamicScope (AudioUnitScope inScope,
- SInt32 &outTotalNumChannels,
- const AUChannelInfo * info,
+ bool ValidateDynamicScope (AudioUnitScope inScope,
+ SInt32 &outTotalNumChannels,
+ const AUChannelInfo * info,
UInt32 numInfo) const;
- bool CheckOneSide (const CAAUChanHelper &inHelper,
- bool checkOutput,
- const AUChannelInfo *info,
+ bool CheckOneSide (const CAAUChanHelper &inHelper,
+ bool checkOutput,
+ const AUChannelInfo *info,
UInt32 numInfo) const;
};
class CAAUChanHelper {
public:
- CAAUChanHelper()
- : mChans(mStaticChans), mNumEls(0), mDidAllocate(false)
+ CAAUChanHelper()
+ : mChans(mStaticChans), mNumEls(0), mDidAllocate(false)
{
memset (mChans, 0, sizeof(UInt32) * 8);
}
void DeallocateBuffers();
void UseExternalBuffer(Byte *ptr, UInt32 nBytes);
-
+
void AdvanceBufferPointers(UInt32 nBytes)
// this is for bufferlists that function simply as
// an array of pointers into another bufferlist, being advanced,
*/
/*=============================================================================
CACFDictionary.h
-
+
=============================================================================*/
#if !defined(__CACFDictionary_h__)
#define __CACFDictionary_h__
// CACFDictionary
//=============================================================================
-class CACFDictionary
+class CACFDictionary
{
// Construction/Destruction
CACFDictionary(const CFDictionaryRef inCFDictionary, bool inRelease) : mCFDictionary(const_cast<CFMutableDictionaryRef>(inCFDictionary)), mRelease(inRelease), mMutable(true) {}
CACFDictionary(const CFMutableDictionaryRef inCFDictionary, bool inRelease) : mCFDictionary(inCFDictionary), mRelease(inRelease), mMutable(true) {}
CACFDictionary(const CACFDictionary& inDictionary) : mCFDictionary(inDictionary.mCFDictionary), mRelease(inDictionary.mRelease), mMutable(inDictionary.mMutable) { if(mRelease && (mCFDictionary != NULL)) { CFRetain(mCFDictionary); } }
- CACFDictionary& operator=(const CACFDictionary& inDictionary) { mCFDictionary = inDictionary.mCFDictionary; mRelease = inDictionary.mRelease; mMutable = inDictionary.mMutable; if(mRelease && (mCFDictionary != NULL)) { CFRetain(mCFDictionary); } return *this; }
+ CACFDictionary& operator=(const CACFDictionary& inDictionary) { mCFDictionary = inDictionary.mCFDictionary; mRelease = inDictionary.mRelease; mMutable = inDictionary.mMutable; if(mRelease && (mCFDictionary != NULL)) { CFRetain(mCFDictionary); } return *this; }
~CACFDictionary() { if(mRelease && (mCFDictionary != NULL)) { CFRelease(mCFDictionary); } }
// Attributes
*/
/*=============================================================================
CAComponent.h
-
+
=============================================================================*/
#ifndef __CAComponent_h__
#include "CAComponentDescription.h"
-class CAComponent
+class CAComponent
{
public:
CAComponent ()
// if next is specifed that is used to find the next component after that one
CAComponent (const ComponentDescription& inDesc, CAComponent* next = 0);
- CAComponent (const CAComponent& y)
+ CAComponent (const CAComponent& y)
: mComp (0), mDesc(), mManuName(0), mAUName(0), mCompName(0), mCompInfo (0) { *this = y; }
CAComponent (const Component& comp);
const CAComponentDescription& Desc () const { return mDesc; }
- OSStatus Open (ComponentInstance& outInst) const
+ OSStatus Open (ComponentInstance& outInst) const
{
return OpenAComponent (Comp(), &outInst);
}
void retain() { IncrementAtomic(&mRefCount); }
- void release()
- {
+ void release()
+ {
// this returns the ORIGINAL value, not the new one.
SInt32 rc = DecrementAtomic(&mRefCount);
if (rc == 1) {
// It adds a number of convenience routines, but otherwise adds nothing
// to the footprint of the original struct.
//=============================================================================
-class CAStreamBasicDescription :
+class CAStreamBasicDescription :
public AudioStreamBasicDescription
{
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1998-2010 Paul Barton-Davis
+ Copyright (C) 1998-2010 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
void cycle_start (pframes_t nframes);
void cycle_end (pframes_t nframes);
-
+
/* called from non-RT context */
-
+
void parse (framecnt_t timestamp);
int write (const MIDI::byte *msg, size_t msglen, MIDI::timestamp_t timestamp);
int read (MIDI::byte *buf, size_t bufsize);
#define ARDOURBACKEND_API LIBARDOUR_DLL_EXPORT
#else
#define ARDOURBACKEND_API LIBARDOUR_DLL_IMPORT
-#endif
+#endif
#define ARDOURBACKEND_LOCAL LIBARDOUR_DLL_LOCAL
namespace ARDOUR {
const char* name;
/** Using arg1 and arg2, initialize this audiobackend.
- *
+ *
* Returns zero on success, non-zero otherwise.
*/
int (*instantiate) (const std::string& arg1, const std::string& arg2);
int (*deinstantiate) (void);
/** Factory method to create an AudioBackend-derived class.
- *
+ *
* Returns a valid shared_ptr to the object if successfull,
* or a "null" shared_ptr otherwise.
*/
AudioBackend (AudioEngine& e, AudioBackendInfo& i) : PortEngine (e), _info (i), engine (e) {}
virtual ~AudioBackend () {}
-
+
enum ErrorCode {
NoError = 0,
BackendInitializationError = -64,
* before any device can be selected. Return false otherwise.
*
* Intended mainly to differentiate between meta-APIs like JACK
- * which can still expose different backends (such as ALSA or CoreAudio
+ * which can still expose different backends (such as ALSA or CoreAudio
* or FFADO or netjack) and those like ASIO or CoreAudio which
* do not.
*/
virtual int set_driver (const std::string& /*drivername*/) { return 0; }
/** used to list device names along with whether or not they are currently
- * available.
+ * available.
*/
struct DeviceStatus {
std::string name;
virtual bool can_change_sample_rate_when_running () const = 0;
/* Return true if the derived class can change the buffer size of the
* device in use while the device is already being used. Return false
- * otherwise.
+ * otherwise.
*/
virtual bool can_change_buffer_size_when_running () const = 0;
/* Set the hardware parameters.
- *
+ *
* If called when the current state is stopped or paused,
* the changes will not take effect until the state changes to running.
*
* If @param yn is true, then the hardware will interleave
* samples for successive channels; otherwise, the hardware will store
* samples for a single channel contiguously.
- *
+ *
* Setting this does not change the fact that all data streams
* to and from Ports are mono (essentially, non-interleaved)
*/
/** Set the number of output channels that should be used
*/
virtual int set_output_channels (uint32_t) = 0;
- /** Set the (additional) input latency that cannot be determined via
+ /** Set the (additional) input latency that cannot be determined via
* the implementation's underlying code (e.g. latency from
* external D-A/D-A converters. Units are samples.
*/
virtual int set_systemic_input_latency (uint32_t) = 0;
- /** Set the (additional) output latency that cannot be determined via
+ /** Set the (additional) output latency that cannot be determined via
* the implementation's underlying code (e.g. latency from
* external D-A/D-A converters. Units are samples.
*/
*/
virtual std::string driver_name() const { return std::string(); }
- /** Return the name of a control application for the
+ /** Return the name of a control application for the
* selected/in-use device. If no such application exists,
* or if no device has been selected or is in-use,
* return an empty string.
virtual void launch_control_app () = 0;
/* @return a vector of strings that describe the available
- * MIDI options.
+ * MIDI options.
*
* These can be presented to the user to decide which
* MIDI drivers, options etc. can be used. The returned strings
virtual bool can_set_systemic_midi_latencies () const = 0;
/* State Control */
-
+
/** Start using the device named in the most recent call
* to set_device(), with the parameters set by various
* the most recent calls to set_sample_rate() etc. etc.
- *
+ *
* At some undetermined time after this function is successfully called,
* the backend will start calling the ::process_callback() method of
* the AudioEngine referenced by @param engine. These calls will
* this pattern, or possibly just this:
*
* http://stackoverflow.com/questions/12139786/good-pratice-default-arguments-for-pure-virtual-method
- */
+ */
int start (bool for_latency_measurement=false) {
return _start (for_latency_measurement);
}
- /** Stop using the device currently in use.
+ /** Stop using the device currently in use.
*
* If the function is successfully called, no subsequent calls to the
* process_callback() of @param engine will be made after the function
* returns, until parameters are reset and start() are called again.
- *
+ *
* The backend is considered to be un-configured after a successful
* return, and requires calls to set hardware parameters before it can be
* start()-ed again. See pause() for a way to avoid this. stop() should
- * only be used when reconfiguration is required OR when there are no
+ * only be used when reconfiguration is required OR when there are no
* plans to use the backend in the future with a reconfiguration.
*
* Return zero if successful, 1 if the device is not in use, negative values on error
*/
virtual int stop () = 0;
- /** Reset device.
+ /** Reset device.
*
* Return zero if successful, negative values on error
*/
* from 0.0 to 1.0
*
* E.g. if the buffer size represents 5msec and current processing
- * takes 1msec, the returned value should be 0.2.
- *
+ * takes 1msec, the returned value should be 0.2.
+ *
* Implementations can feel free to smooth the values returned over
* time (e.g. high pass filtering, or its equivalent).
*/
/* Transport Control (JACK is the only audio API that currently offers
the concept of shared transport control)
*/
-
- /** Attempt to change the transport state to TransportRolling.
+
+ /** Attempt to change the transport state to TransportRolling.
*/
virtual void transport_start () {}
- /** Attempt to change the transport state to TransportStopped.
+ /** Attempt to change the transport state to TransportStopped.
*/
virtual void transport_stop () {}
/** return the current transport state
* timebase, otherwise cease to be the time master for the same.
*
* Return zero on success, non-zero otherwise
- *
+ *
* JACK is the only currently known audio API with the concept of a shared
* transport timebase.
*/
virtual int usecs_per_cycle () const { return 1000000 * (buffer_size() / sample_rate()); }
virtual size_t raw_buffer_size (DataType t) = 0;
-
+
/* Process time */
-
+
/** return the time according to the sample clock in use, measured in
* samples since an arbitrary zero time in the past. The value should
* increase monotonically and linearly, without interruption from any
* source (including CPU frequency scaling).
*
* It is extremely likely that any implementation will use a DLL, since
- * this function can be called from any thread, at any time, and must be
+ * this function can be called from any thread, at any time, and must be
* able to accurately determine the correct sample time.
*
* Can be called from any thread.
/** Return the time since the current buffer process cycle started,
* in samples, according to the sample clock in use.
- *
+ *
* Can ONLY be called from within a process() callback tree (which
* implies that it can only be called by a process thread)
*/
virtual int create_process_thread (boost::function<void()> func) = 0;
/** Wait for all processing threads to exit.
- *
+ *
* Return zero on success, non-zero on failure.
*/
virtual int join_process_threads () = 0;
}
protected:
- AudioBackendInfo& _info;
+ AudioBackendInfo& _info;
AudioEngine& engine;
virtual int _start (bool for_latency_measurement) = 0;
} // namespace
#endif /* __libardour_audiobackend_h__ */
-
+
bool prep_record_enable ();
bool prep_record_disable ();
-
+
// Working buffers for do_refill (butler thread)
static void allocate_working_buffers();
static void free_working_buffers();
private:
AudioBuffer* _buffer;
- bool _buf_valid;
+ bool _buf_valid;
};
} // namespace ARDOUR
bool bounceable (boost::shared_ptr<Processor>, bool include_endpoint) const;
boost::shared_ptr<Region> bounce (InterThreadInfo&);
- boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&,
+ boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&,
boost::shared_ptr<Processor> endpoint, bool include_endpoint);
int export_stuff (BufferSet& bufs, framepos_t start_frame, framecnt_t nframes,
boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze);
ProcessThread* main_thread() const { return _main_thread; }
- /* START BACKEND PROXY API
+ /* START BACKEND PROXY API
*
* See audio_backend.h for full documentation and semantics. These wrappers
* just forward to a backend implementation.
}
framecnt_t processed_frames() const { return _processed_frames; }
-
+
void set_session (Session *);
void remove_session (); // not a replacement for SessionHandle::session_going_away()
Session* session() const { return _session; }
public:
virtual const char *what() const throw() { return "could not connect to engine backend"; }
};
-
+
void split_cycle (pframes_t offset);
-
+
int reset_timebase ();
-
+
void update_latencies ();
-
+
/* this signal is sent for every process() cycle while freewheeling.
(the regular process() call to session->process() is not made)
*/
-
+
PBD::Signal1<int, pframes_t> Freewheel;
-
+
PBD::Signal0<void> Xrun;
/** this signal is emitted if the sample rate changes */
PBD::Signal0<void> DeviceError;
/* this signal is emitted if the device list changed */
-
+
PBD::Signal0<void> DeviceListChanged;
-
+
/* this signal is sent if the backend ever disconnects us */
-
+
PBD::Signal1<void,const char*> Halted;
-
+
/* these two are emitted when the engine itself is
started and stopped
*/
-
+
PBD::Signal0<void> Running;
PBD::Signal0<void> Stopped;
/* these two are emitted when a device reset is initiated/finished
*/
-
+
PBD::Signal0<void> DeviceResetStarted;
PBD::Signal0<void> DeviceResetFinished;
static AudioEngine* instance() { return _instance; }
static void destroy();
void died ();
-
+
/* The backend will cause these at the appropriate time(s)
*/
int process_callback (pframes_t nframes);
bool speed_mismatch (float) const;
boost::shared_ptr<AudioSource> audio_source (uint32_t n=0) const;
-
+
// if several audio files associated with a region,
// information about file with MAX channel count will be provided
uint32_t get_related_audio_file_channel_count () const;
-
+
void set_scale_amplitude (gain_t);
gain_t scale_amplitude() const { return _scale_amplitude; }
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
int update_header (framepos_t when, struct tm&, time_t);
uint32_t channel_count () const { return n_channels; }
-
+
int flush_header () {return 0;};
void set_header_timeline_position () {};
bool clamped_at_unity () const { return false; }
default: return "unknown"; // reeeally shouldn't ever happen
}
}
-
+
const char* to_i18n_string () const;
inline operator uint32_t() const { return (uint32_t)_symbol; }
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 2014 Waves Audio Ltd.
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+
*/
#ifndef __gtk2_ardour__engine_state_controller__
namespace ARDOUR {
class AudioBackendInfo;
-
+
/**
* @class EngineStateController
* @brief EngineStateController class.
class EngineStateController
{
public:
-
+
// public data types:
-
- /**
+
+ /**
* @struct PortState
* Structure which represents AudioPort state
*/
struct PortState {
std::string name; ///< Audio Port name
bool active; ///< Audio Port state
-
+
PortState ()
: name("")
, active(false)
{
}
-
+
PortState (const std::string& name)
: name(name)
, active(false)
{
}
-
+
bool operator==(const PortState& rhs) {return rhs.name == name; }
-
+
};
-
+
/// @typedef Type for the list of all available audio ports
typedef std::list<PortState> PortStateList;
bool available; ///< Midi Port availability - if it is physicaly available or not
bool scene_connected; ///< Is midi port used for scene MIDI marker in/out
bool mtc_in; ///< Is midi port used as MTC in
-
+
MidiPortState(const std::string& name)
: name(name)
, active(false)
, scene_connected(false)
, mtc_in(false)
{}
-
+
bool operator==(const MidiPortState& rhs)
{
return name == rhs.name;
}
};
-
+
/// @typedef Type for the list of MidiPorts ever registered in the system
typedef std::list<MidiPortState> MidiPortStateList;
-
+
//Interfaces
-
+
/** Get an instance of EngineStateController singleton.
* @return EngineStateController instance pointer
*/
static EngineStateController* instance ();
-
+
/** Associate session with EngineStateController instance.
*/
void set_session (Session* session);
-
+
/** Remove link to the associated session.
*/
void remove_session ();
-
+
//////////////////////////////////////////////////////////////////////////////////////////////////////////
// General backend/device information methods
-
+
/** Provides names of all available backends.
*
* @param[out] available_backends - vector of available backends
*/
void available_backends (std::vector<const AudioBackendInfo*>& available_backends);
-
+
/** Provides the name of currently used backend.
*
* @return the name of currently used backend
*/
const std::string& get_current_backend_name() const;
-
+
/** Provides the name of currently used device.
*
* @return the name of currently used device
*/
const std::string& get_current_device_name () const;
-
+
/** Provides names for all available devices.
*
* @param[out] device_vector - vector of available devices
*/
void enumerate_devices (std::vector<ARDOUR::AudioBackend::DeviceStatus>& device_vector) const;
-
+
/** Get sample rate used by current device.
*
* @return current sample rate
*/
ARDOUR::framecnt_t get_current_sample_rate () const;
-
+
/** Get default sample rate for current backend.
*
* @return default sample rate for current backend
*/
ARDOUR::framecnt_t get_default_sample_rate () const;
-
+
/** Get sample rates which are supported by current device and current backend.
*
* @param[out] sample_rates - vector of supported sample rates
*/
void available_sample_rates_for_current_device (std::vector<float>& sample_rates) const;
-
+
/** Get buffer size used by current device.
*
* @return current buffer size
*/
ARDOUR::pframes_t get_current_buffer_size () const;
-
+
/** Get default buffer size for current backend.
*
* @return default buffer size for current backend
*/
ARDOUR::pframes_t get_default_buffer_size () const;
-
+
/** Get buffer sizes which are supported by current device and current backend.
*
* @param[out] buffer_sizes - vector of supported buffer_sizes
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// device state control methods
-
+
/** Get the number of all enabled Audio inputs.
*
* @return number of all enabled Audio inputs
* @return number of all enabled Audio outputs
*/
uint32_t get_available_outputs_count () const;
-
+
/** Get vector of all enabled physical Audio input port names.
*
* @param[out] port_names - vector of all enabled Audio input names
* @param[out] port_names - vector of all enabled Audio input names
*/
void get_physical_audio_outputs (std::vector<std::string>& port_names);
-
+
/** Get vector of all enabled physical MIDI input port names.
*
* @param[out] port_names - vector of all enabled MIDI input names
* @param[out] port_names - vector of all enabled MIDI output names
*/
void get_physical_midi_outputs (std::vector<std::string>& port_names);
-
+
/** Sets new state to all Audio inputs.
*
* @param[in] state - new state
* @param[in] state - new state
*/
void set_state_to_all_outputs(bool state);
-
+
/** Get vector of states for all physical Audio input ports.
*
* @param[out] channel_states - vector of input port states
* @param[out] channel_states - vector of output port states
*/
void get_physical_audio_output_states(std::vector<PortState>& channel_states);
-
+
/** Set state of the specified Audio input port.
*
* @param[in] port_name - input name
* @param[in] state - new state
*/
void set_physical_audio_output_state(const std::string& port_name, bool state);
-
+
/** Get state of the specified Audio input port.
*
* @param[in] port_name - input name
* @return output state
*/
bool get_physical_audio_output_state(const std::string& port_name);
-
+
/** Get vector of all enabled MIDI input port names.
*
* return name of ltc source port
*/
std::string get_ltc_source_port ();
-
+
/** Set ltc output port
*
* @param[in] port - name of ltc output port
* return name of ltc output port
*/
std::string get_ltc_output_port ();
-
+
/** Set state of the specified MIDI input port.
*
* @param[in] port_name - input name
* @return output state
*/
bool get_physical_midi_output_state(const std::string& port_name, bool& scene_connected);
-
+
/** Set state of Scene In connection for the specified MIDI input port.
*
* @param[in] port_name - input name
* @param[in] state - new state
*/
void set_physical_midi_scenen_out_connection_state(const std::string&, bool);
-
+
/** Disocnnect all MIDI input ports from Scene In.
*/
void set_all_midi_scene_inputs_disconnected();
/** Disocnnect all MIDI output ports from Scene Out.
*/
void set_all_midi_scene_outputs_disconnected();
-
+
/** Set MIDI TimeCode input port
* @note There is a sense to choose MIDI TimeCode input only because
* our MIDI TimeCode is propagated to all midi output ports.
*/
void set_mtc_source_port (const std::string&);
-
+
/** Check if AudioEngine setup is required
* @return true if setup is required, otherwise - false
*/
bool is_setup_required() const {return ARDOUR::AudioEngine::instance()->setup_required (); }
-
+
////////////////////////////////////////////////////////////////////////////////////////////////////
// Methods set parameters inside the controller
// the state of engine won't change untill we make a "push" of this state to the backend
// NOTE: Use push_state_to_backend() method to update backend with the most recent controller state
-
+
/** Set new sample rate for current device in EngineStateController database
* @note Use push_state_to_backend() method to update backend/device state with the most recent controller state
* @param sample_rate - new sample rate
* @param buffer_size - new buffer size
*/
bool set_new_buffer_size_in_controller(pframes_t buffer_size);
-
+
/** @brief push current controller state to backend.
* Propagate and set all current EngineStateController parameters to the backend
* @note Engine will be restarted if it's running when this method is called.
*/
bool set_new_device_as_current(const std::string& device_name);
-
+
////////////////////////////////////////////////////////////////////////////////////////////////////
// Methods to save/serialize setting states
/** Save Audio/Midi settings (entire EngineStateController database) to config persistently
*/
void save_audio_midi_settings();
-
+
////////////////////////////////////////////////////////////////////////////////////////////////////
//UPDATE SIGNALS
/** This signal is emitted if the sample rate changes */
PBD::Signal0<void> EngineStopped;
/** This signal is emitted if Engine processing is terminated */
PBD::Signal0<void> EngineHalted;
-
+
/** This signal is emitted if the AUDIO input channel configuration changes */
PBD::Signal0<void> InputConfigChanged;
/** This signal is emitted if the AUDIO output channel configuration changes */
* @note By output connection mode "Stereo Out" or "Multi Out" is meant
*/
PBD::Signal0<void> OutputConnectionModeChanged;
-
+
/** This signals is emitted if the MIDI input channel configuration changes */
PBD::Signal0<void> MIDIInputConfigChanged;
/** This signals is emitted if the MIDI output channel configuration changes */
PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneInputConnectionChanged;
/** This signals is emitted if the MIDI Scene Out connection changes */
PBD::Signal2<void, const std::vector<std::string>&, bool> MIDISceneOutputConnectionChanged;
-
+
/** This signal is emitted if the MTC Input channel is changed */
PBD::Signal1<void, const std::string&> MTCInputChanged;
-
+
/** This signal is emitted if new Audio/MIDI ports are registered or unregistered */
PBD::Signal0<void> PortRegistrationChanged;
-
+
private:
EngineStateController(); /// singleton
~EngineStateController(); /// singleton
EngineStateController(const EngineStateController& ); /// prohibited
EngineStateController& operator=(const EngineStateController&); /// prohibited
-
+
////////////////////////////////////////////////////////////////////////////////////////////
// private data structures
-
+
/** @struct Engine state
* @brief State structure.
* Contains information about single device/backend state
PortStateList multi_out_channel_states; ///< states of device Audio inputs in Multi Out mode
PortStateList stereo_out_channel_states; ///< states of device Audio inputs in Stereo Out mode
bool active; ///< was this state the most recent active one
-
+
State()
: sample_rate(0)
, buffer_size(0)
, active (false)
{
}
-
+
bool operator==(const State& rhs)
{
return (backend_name == rhs.backend_name) && (device_name == rhs.device_name);
}
-
+
/** Forms string name for the state
* @return name string
*/
std::string form_state_name() {
return std::string("State:" + backend_name + ":" + device_name);
}
-
+
/** @struct StatepPredicate
* This predicate is used to identify a state during search in the list of states
*/
: _backend_name (backend_name)
, _device_name (device_name)
{}
-
+
bool operator()(boost::shared_ptr<ARDOUR::EngineStateController::State> rhs)
{
return (_backend_name == rhs->backend_name) && (_device_name == rhs->device_name);
}
-
+
private:
std::string _backend_name;
std::string _device_name;
};
};
-
+
/// @typedef Type for the state pointer
typedef boost::shared_ptr<State> StatePtr;
/// @typedef Type for the list of states
typedef std::list<StatePtr> StateList;
-
+
////////////////////////////////////////////////////////////////////////////////////////////////////
// methods to manage setting states
-
+
/** Deserializes and loads Engine and Audio port states from the config to EngineStateController
*/
void _deserialize_and_load_engine_states();
* @param[in,out] audio_midi_settings_node - node to serialize the satets to
*/
void _serialize_midi_port_states(XMLNode* audio_midi_settings_node);
-
+
/** Provides initial state configuration.
* It loades the last active state if there is one and it is aplicable.
* Otherwise default state (None device with default sample rate and buffer size) is loaded.
*/
void _do_initial_engine_setup();
-
+
/** Loades provided state.
* @note It's possible that provided state can't be loaded
* (device disconnected or reqested parameters are not supported anymore).
* @return true on success, otherwise - false
*/
bool _apply_state(const StatePtr& state);
-
+
/** Gets available device channels from engine and updates internal controller state
*/
void _update_device_channels_state();
-
+
/** Check "Stereo Out" mode channels state configuration and make it correspond Stereo Out mode requirements
*/
void _refresh_stereo_out_channel_states();
-
+
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// internal helper functions
/** make sure that current device parameters are supported and fit session requirements
/** change ltc source port in case of the output ports list change
*/
void _update_ltc_output_port ();
-
+
/** check that port is still existed in the list of input ports
@param[in] port - port name
@return true if current port is existed, otherwise - false
*/
void _on_session_loaded();
////////////////////////////////////////
-
+
////////////////////////////////////////
// attributes
StatePtr _current_state; ///< current state pointer
// list of system states
StateList _states; ///< list of all available states
-
+
MidiPortStateList _midi_inputs; ///< midi input states
MidiPortStateList _midi_outputs; ///< midi output states
-
+
std::string _last_used_real_device; ///< last active non-default (real) device
-
+
Session* _session; ///< current session
// Engine connections stuff
};
} // namespace ARDOUR
-
+
#endif /* defined(__gtk2_ardour__engine_state_controller__) */
private:
void add_split_config (FileSpec const & config);
-
+
class Encoder {
public:
template <typename T> boost::shared_ptr<AudioGrapher::Sink<T> > init (FileSpec const & new_config);
PBD::ScopedConnection copy_files_connection;
std::string writer_filename;
-
+
// Only one of these should be available at a time
FloatWriterPtr float_writer;
IntWriterPtr int_writer;
FloatSinkPtr sink ();
void add_child (FileSpec const & new_config);
void remove_children (bool remove_out_files);
-
+
bool operator== (FileSpec const & other_config) const;
private:
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace ARDOUR {
/**
- * @return the path to the directory used to store user specific
+ * @return the path to the directory used to store user specific
* configuration files for the given @param version of the program.
* If @param version is negative, the build-time string PROGRAM_VERSION
* will be used to determine the version number.
*
* @post user_config_directory() exists IF version was negative.
*
- *
+ *
*/
LIBARDOUR_API std::string user_config_directory (int version = -1);
/**
* @return the path used to store a persistent indication
* that the given version of the program has been used before.
- *
- * @param version is the version to check for. If unspecified,
+ *
+ * @param version is the version to check for. If unspecified,
* it defaults to the current (build-time) version of the program.
*/
LIBARDOUR_API std::string been_here_before_path (int version = -1);
#define LIBARDOUR_API LIBARDOUR_DLL_EXPORT
#else
#define LIBARDOUR_API LIBARDOUR_DLL_IMPORT
- #endif
+ #endif
#define LIBARDOUR_LOCAL LIBARDOUR_DLL_LOCAL
#endif
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/******************************************************************************************/
/*VSTFX - an engine to manage native linux VST plugins - derived from FST for Windows VSTs*/
/******************************************************************************************/
-
+
LIBARDOUR_API extern void (*vstfx_error_callback)(const char *msg);
LIBARDOUR_API void vstfx_set_error_function (void (*func)(const char *));
Location (const Location& other);
Location (Session &, const XMLNode&);
Location* operator= (const Location& other);
-
+
bool operator==(const Location& other);
bool locked() const { return _locked; }
static PBD::Signal1<void,Location*> changed;
/* these are member signals for objects that care only about
- changes to this object
+ changes to this object
*/
PBD::Signal0<void> Changed;
-
+
PBD::Signal0<void> NameChanged;
PBD::Signal0<void> EndChanged;
PBD::Signal0<void> StartChanged;
PBD::Signal0<void> FlagsChanged;
PBD::Signal0<void> LockChanged;
PBD::Signal0<void> PositionLockStyleChanged;
-
+
/* CD Track / CD-Text info */
std::map<std::string, std::string> cd_info;
static PBD::Signal0<void> scene_changed; /* for use by backend scene change management, class level */
PBD::Signal0<void> SceneChangeChanged; /* for use by objects interested in this object */
-
+
private:
std::string _name;
framepos_t _start;
bool _locked;
PositionLockStyle _position_lock_style;
boost::shared_ptr<SceneChange> _scene_change;
-
+
void set_mark (bool yn);
bool set_flag_internal (bool yn, Flags flag);
void recompute_bbt_from_frames ();
void marks_either_side (framepos_t const, framepos_t &, framepos_t &) const;
void find_all_between (framepos_t start, framepos_t, LocationList&, Location::Flags);
-
+
PBD::Signal1<void,Location*> current_changed;
/* Objects that care about individual addition and removal of Locations should connect to added/removed.
bool prep_record_enable ();
bool prep_record_disable ();
-
+
MidiRingBuffer<framepos_t>* _playback_buf;
MidiRingBuffer<framepos_t>* _capture_buf;
boost::weak_ptr<MidiPort> _source_port;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 1998 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/* Ports used for control. These are read/written to outside of the
* process callback (asynchronously with respect to when data
- * actually arrives).
+ * actually arrives).
*
* More detail: we do actually read/write data for these ports
* inside the process callback, but incoming data is only parsed
* and outgoing data is only generated *outside* the process
- * callback.
+ * callback.
*/
MIDI::Port* midi_input_port () const { return _midi_input_port; }
MIDI::Port* mmc_output_port () const { return _mmc_output_port; }
MIDI::Port* scene_input_port () const { return _scene_input_port; }
MIDI::Port* scene_output_port () const { return _scene_output_port; }
-
+
boost::shared_ptr<MidiPort> mmc_in() const { return boost::dynamic_pointer_cast<MidiPort>(_mmc_in); }
boost::shared_ptr<MidiPort> mmc_out() const { return boost::dynamic_pointer_cast<MidiPort>(_mmc_out); }
boost::shared_ptr<MidiPort> mtc_output_port() const { return _mtc_output_port; }
boost::shared_ptr<MidiPort> midi_clock_input_port() const { return _midi_clock_input_port; }
boost::shared_ptr<MidiPort> midi_clock_output_port() const { return _midi_clock_output_port; }
-
+
void set_midi_port_states (const XMLNodeList&);
std::list<XMLNode*> get_midi_port_states () const;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#define ARDOURPANNER_API LIBARDOUR_DLL_EXPORT
#else
#define ARDOURPANNER_API LIBARDOUR_DLL_IMPORT
- #endif
+ #endif
#define ARDOURPANNER_LOCAL LIBARDOUR_DLL_LOCAL
namespace ARDOUR {
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
class RegionWriteLock : public Glib::Threads::RWLock::WriterLock {
public:
- RegionWriteLock (Playlist *pl, bool do_block_notify = true)
+ RegionWriteLock (Playlist *pl, bool do_block_notify = true)
: Glib::Threads::RWLock::WriterLock (pl->region_lock)
, playlist (pl)
, block_notify (do_block_notify) {
std::string unique_id;
virtual PluginPtr load (Session& session) = 0;
- virtual bool is_instrument() const;
+ virtual bool is_instrument() const;
/* NOTE: this block of virtual methods looks like the interface
to a Processor, but Plugin does not inherit from Processor.
struct PresetRecord {
PresetRecord () : number (-1), user (true) {}
PresetRecord (const std::string& u, const std::string& l, int n = -1, bool s = true) : uri (u), label (l), number (n), user (s) {}
-
+
bool operator!= (PresetRecord const & a) const {
return number != a.number || uri != a.uri || label != a.label;
}
-
+
std::string uri;
std::string label;
int number; // if <0, invalid
class PortManager;
/** PortEngine is an abstract base class that defines the functionality
- * required by Ardour.
- *
+ * required by Ardour.
+ *
* A Port is basically an endpoint for a datastream (which can either be
* continuous, like audio, or event-based, like MIDI). Ports have buffers
* associated with them into which data can be written (if they are output
* ports) and from which data can be read (if they input ports). Ports can be
* connected together so that data written to an output port can be read from
- * an input port. These connections can be 1:1, 1:N OR N:1.
+ * an input port. These connections can be 1:1, 1:N OR N:1.
*
* Ports may be associated with software only, or with hardware. Hardware
* related ports are often referred to as physical, and correspond to some
* come from the "outside world" if the terminal port is also
* physical, or will have been synthesized by the entity that
* owns the terminal port.
- *
+ *
* <b>playback latency</b>: how long until the data written to the buffer of
* port will reach a terminal port.
*
public:
PortEngine (PortManager& pm) : manager (pm) {}
virtual ~PortEngine() {}
-
+
/** Return a private, type-free pointer to any data
* that might be useful to a concrete implementation
*/
virtual void* private_handle() const = 0;
/* We use void* here so that the API can be defined for any implementation.
- *
+ *
* We could theoretically use a template (PortEngine<T>) and define
* PortHandle as T, but this complicates the desired inheritance
* pattern in which FooPortEngine handles things for the Foo API,
* rather than being a derivative of PortEngine<Foo>.
*/
-
+
typedef void* PortHandle;
/** Return the name of this process as used by the port manager
* when naming ports.
*/
virtual const std::string& my_name() const = 0;
-
+
/** Return true if the underlying mechanism/API is still available
* for us to utilize. return false if some or all of the AudioBackend
* API can no longer be effectively used.
*/
virtual bool available() const = 0;
- /** Return the maximum size of a port name
+ /** Return the maximum size of a port name
*/
virtual uint32_t port_name_size() const = 0;
*
* To avoid selecting by name, pass an empty string for @param
* port_name_pattern.
- *
+ *
* To avoid selecting by type, pass DataType::NIL as @param type.
- *
+ *
* To avoid selecting by flags, pass PortFlags (0) as @param flags.
*/
virtual int get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>& ports) const = 0;
* is connected to.
*/
virtual void unregister_port (PortHandle) = 0;
-
+
/* Connection management */
/** Ensure that data written to the port named by @param src will be
*/
virtual int connect (const std::string& src, const std::string& dst) = 0;
- /** Remove any existing connection between the ports named by @param src and
+ /** Remove any existing connection between the ports named by @param src and
* @param dst. Return zero on success, non-zero otherwise.
*/
virtual int disconnect (const std::string& src, const std::string& dst) = 0;
-
-
+
+
/** Ensure that data written to the port referenced by @param portwill be
* readable from the port named by @param dst. Return zero on success,
* non-zero otherwise.
*/
virtual int connect (PortHandle src, const std::string& dst) = 0;
- /** Remove any existing connection between the port referenced by @param src and
+ /** Remove any existing connection between the port referenced by @param src and
* the port named @param dst. Return zero on success, non-zero otherwise.
- */
+ */
virtual int disconnect (PortHandle src, const std::string& dst) = 0;
/** Remove all connections between the port referred to by @param port and
/** Retrieve a MIDI event from the data at @param port_buffer. The event
number to be retrieved is given by @param event_index (a value of zero
indicates that the first event in the port_buffer should be retrieved).
- *
+ *
* The data associated with the event will be copied into the buffer at
* @param buf and the number of bytes written will be stored in @param
- * size. The timestamp of the event (which is always relative to the start
+ * size. The timestamp of the event (which is always relative to the start
* of the current process cycle, in samples) will be stored in @param
* timestamp
*/
* port_buffer. The MIDI event will be marked with a time given by @param
* timestamp. Return zero on success, non-zero otherwise.
*
- * Events must be added monotonically to a port buffer. An attempt to
+ * Events must be added monotonically to a port buffer. An attempt to
* add a non-monotonic event (e.g. out-of-order) will cause this method
* to return a failure status.
*/
* APIs can offer it.
*/
virtual bool can_monitor_input() const = 0;
- /** Increment or decrement the number of requests to monitor the input
+ /** Increment or decrement the number of requests to monitor the input
* of the hardware channel represented by the port referred to by @param
* port.
*
* If the number of requests rises above zero, input monitoring will
* be enabled (if can_monitor_input() returns true for the implementation).
- *
+ *
* If the number of requests falls to zero, input monitoring will be
* disabled (if can_monitor_input() returns true for the implementation)
*/
/* Latency management
*/
-
+
/** Set the latency range for the port referred to by @param port to @param
* r. The playback range will be set if @param for_playback is true,
* otherwise the capture range will be set.
* schedule MIDI events within their buffers. It is a bit odd that we
* expose this here, because it is also exposed by AudioBackend, but they
* only have access to a PortEngine object, not an AudioBackend.
- *
- * Return the time according to the sample clock in use when the current
- * buffer process cycle began.
*
- * XXX to be removed after some more design cleanup.
+ * Return the time according to the sample clock in use when the current
+ * buffer process cycle began.
+ *
+ * XXX to be removed after some more design cleanup.
*/
virtual framepos_t sample_time_at_cycle_start () = 0;
class PortEngine;
class AudioBackend;
-class LIBARDOUR_API PortManager
+class LIBARDOUR_API PortManager
{
public:
typedef std::map<std::string,boost::shared_ptr<Port> > Ports;
typedef std::list<boost::shared_ptr<Port> > PortList;
-
+
PortManager ();
virtual ~PortManager() {}
std::string my_name() const;
/* Port registration */
-
+
boost::shared_ptr<Port> register_input_port (DataType, const std::string& portname, bool async = false);
boost::shared_ptr<Port> register_output_port (DataType, const std::string& portname, bool async = false);
int unregister_port (boost::shared_ptr<Port>);
-
+
/* Port connectivity */
-
+
int connect (const std::string& source, const std::string& destination);
int disconnect (const std::string& source, const std::string& destination);
int disconnect (boost::shared_ptr<Port>);
std::string get_pretty_name_by_name (const std::string& portname) const;
bool port_is_mine (const std::string& fullname) const;
bool port_name_prefix_is_unique (const std::string& first_part_of_port_name) const;
-
+
/* other Port management */
-
+
bool port_is_physical (const std::string&) const;
void get_physical_outputs (DataType type, std::vector<std::string>&);
void get_physical_inputs (DataType type, std::vector<std::string>&);
int get_ports (DataType, PortList&);
void remove_all_ports ();
-
+
/* per-Port monitoring */
-
+
bool can_request_input_monitoring () const;
void request_input_monitoring (const std::string&, bool) const;
void ensure_input_monitoring (const std::string&, bool) const;
-
+
class PortRegistrationFailure : public std::exception {
public:
PortRegistrationFailure (std::string const & why = "")
};
/* the port engine will invoke these callbacks when the time is right */
-
+
void registration_callback ();
int graph_order_callback ();
void connect_callback (const std::string&, const std::string&, bool connection);
/** Emitted if a Port is registered or unregistered */
PBD::Signal0<void> PortRegisteredOrUnregistered;
-
+
/** Emitted if a Port is connected or disconnected.
* The Port parameters are the ports being connected / disconnected, or 0 if they are not known to Ardour.
* The std::string parameters are the (long) port names.
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* IO connection */
CONFIG_VARIABLE (bool, auto_connect_standard_busses, "auto-connect-standard-busses", true)
-/* this variable is used to indicate output mode in Waves Tracks:
- "Multi Out" == AutoConnectPhysical and "Stereo Out" == AutoConnectMaster
+/* this variable is used to indicate output mode in Waves Tracks:
+ "Multi Out" == AutoConnectPhysical and "Stereo Out" == AutoConnectMaster
*/
CONFIG_VARIABLE (AutoConnectOption, output_auto_connect, "output-auto-connect", AutoConnectMaster)
CONFIG_VARIABLE (AutoConnectOption, input_auto_connect, "input-auto-connect", AutoConnectPhysical)
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* announce=false but they still need to be in the map soon after
* creation.
*/
-
+
static void map_add (boost::shared_ptr<Region>);
private:
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void protect_automation ();
- enum {
+ enum {
/* These numbers are taken from MIDI Machine Control,
which can only control up to 317 tracks without
doing sysex segmentation.
bool active () const { return _active; }
void set_active (bool);
-
+
PBD::Signal0<void> ColorChanged;
PBD::Signal0<void> ActiveChanged;
class Port;
}
-namespace ARDOUR
+namespace ARDOUR
{
class Session;
/*
- Copyright (C) 2011 Tim Mayberry
- Copyright (C) 2013 Paul Davis
+ Copyright (C) 2011 Tim Mayberry
+ Copyright (C) 2013 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*
* Argument is the snapshot name to use when saving.
*/
- PBD::Signal1<void,std::string> SaveSessionRequested;
+ PBD::Signal1<void,std::string> SaveSessionRequested;
/* emitted during a session save to allow other entities to add state, via
- * extra XML, to the session state
+ * extra XML, to the session state
*/
PBD::Signal0<void> SessionSaveUnderway;
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
const ChanCount& input, const ChanCount& output,
boost::shared_ptr<PluginInfo> instrument = boost::shared_ptr<PluginInfo>(),
- TrackMode mode = Normal,
+ TrackMode mode = Normal,
RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
);
boost::shared_ptr<MidiPort> midi_clock_input_port () const;
boost::shared_ptr<MidiPort> mtc_output_port () const;
boost::shared_ptr<MidiPort> mtc_input_port () const;
-
+
MIDI::MachineControl& mmc() { return *_mmc; }
void reconnect_midi_scene_ports (bool);
void consolidate_skips (Location*);
void sync_locations_to_skips ();
void _sync_locations_to_skips ();
-
+
PBD::ScopedConnectionList skip_update_connections;
bool _ignore_skips_updates;
/* This variable was not discussed with Ardour developers and is considered
weakly conceived. It is also poorly named, since we have "groups" already
present in libardour but this variable has nothing to do with it. There
- should have been more discussion about what was required and the best
+ should have been more discussion about what was required and the best
way to accomplish it.
*/
CONFIG_VARIABLE (bool, enable_group_edit, "enable-group-edit", false)
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
private:
- static SessionMetadata *_metadata; //singleton instance
+ static SessionMetadata *_metadata; //singleton instance
typedef std::pair<std::string, std::string> Property;
typedef std::map<std::string, std::string> PropertyMap;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
SndFileSource (Session&, const std::string& path, int chn);
/** Constructor to be called for existing in-session files during
- * session loading
+ * session loading
*/
SndFileSource (Session&, const XMLNode&);
static boost::shared_ptr<Source> createExternal
(DataType type, Session&,
- const std::string& path,
+ const std::string& path,
int chn, Source::Flag flags, bool announce = true, bool async = false);
static boost::shared_ptr<Source> createWritable
(DataType type, Session&,
- const std::string& path,
+ const std::string& path,
bool destructive, framecnt_t rate, bool announce = true, bool async = false);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the tempo section is located in. A value of 0.0 indicates that
it occurs on the first beat of the bar, a value of 0.5 indicates
that it occurs halfway through the bar and so on.
-
+
this enables us to keep the tempo change at the same relative
position within the bar if/when the meter changes.
*/
const TempoSection* tempo;
uint32_t bar;
uint32_t beat;
-
+
BBTPoint (const MeterSection& m, const TempoSection& t, framepos_t f,
uint32_t b, uint32_t e)
: frame (f), meter (&m), tempo (&t), bar (b), beat (e) {}
(obj.*method)(metrics);
}
- void get_grid (BBTPointList::const_iterator&, BBTPointList::const_iterator&,
+ void get_grid (BBTPointList::const_iterator&, BBTPointList::const_iterator&,
framepos_t start, framepos_t end);
- /* TEMPO- AND METER-SENSITIVE FUNCTIONS
+ /* TEMPO- AND METER-SENSITIVE FUNCTIONS
bbt_time(), bbt_time_rt(), frame_time() and bbt_duration_at()
are all sensitive to tempo and meter, and will give answers
that align with the grid formed by tempo and meter sections.
-
- They SHOULD NOT be used to determine the position of events
+
+ They SHOULD NOT be used to determine the position of events
whose location is canonically defined in beats.
*/
void bbt_time (framepos_t when, Timecode::BBT_Time&);
- /* realtime safe variant of ::bbt_time(), will throw
+ /* realtime safe variant of ::bbt_time(), will throw
std::logic_error if the map is not large enough
to provide an answer.
*/
framecnt_t bbt_duration_at (framepos_t, const Timecode::BBT_Time&, int dir);
/* TEMPO-SENSITIVE FUNCTIONS
-
+
These next 4 functions will all take tempo in account and should be
used to determine position (and in the last case, distance in beats)
when tempo matters but meter does not.
- They SHOULD be used to determine the position of events
+ They SHOULD be used to determine the position of events
whose location is canonically defined in beats.
*/
void extend_map (framepos_t end);
void require_map_to (framepos_t pos);
void require_map_to (const Timecode::BBT_Time&);
- void _extend_map (TempoSection* tempo, MeterSection* meter,
+ void _extend_map (TempoSection* tempo, MeterSection* meter,
Metrics::iterator next_metric,
Timecode::BBT_Time current, framepos_t current_frame, framepos_t end);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
class Position;
boost::scoped_ptr<Position> _pos;
-
+
double one_ppqn_in_frames (framepos_t transport_position);
void send_midi_clock_event (pframes_t offset, pframes_t nframes);
void send_position_event (uint32_t midi_clocks, pframes_t offset, pframes_t nframes);
};
}
- // namespace
+ // namespace
#endif /* __libardour_ticker_h__ */
*/
virtual bool bounceable (boost::shared_ptr<Processor> endpoint, bool include_endpoint) const = 0;
virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
- virtual boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&,
+ virtual boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&,
boost::shared_ptr<Processor> endpoint, bool include_endpoint) = 0;
virtual int export_stuff (BufferSet& bufs, framepos_t start_frame, framecnt_t nframes,
boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) = 0;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
AutoConnectPhysical = 0x1,
AutoConnectMaster = 0x2
};
-
+
enum TracksAutoNamingRule {
UseDefaultNames = 0x1,
NameAfterDriver = 0x2
this equality cannot be assumed.
*/
TransportStopped = 0,
- TransportRolling = 1,
- TransportLooping = 2,
+ TransportRolling = 1,
+ TransportLooping = 2,
TransportStarting = 3,
};
/* these values happen to match the constants used by JACK but
this equality cannot be assumed.
*/
- IsInput = 0x1,
+ IsInput = 0x1,
IsOutput = 0x2,
IsPhysical = 0x4,
CanMonitor = 0x8,
static inline ARDOUR::framepos_t
track_frame_to_session_frame (ARDOUR::framepos_t track_frame, double speed)
{
- /* NB - do we need a check for speed == 0 ??? */
+ /* NB - do we need a check for speed == 0 ??? */
long double result = (long double) track_frame / (long double) speed;
if (result >= (long double) ARDOUR::max_framepos) {
#ifndef OLD_GAIN_MATH
/* 5th order polynomial function fit to data from a TC Spectra console
fader (image of fader gradations).
-
+
y = a + bx1 + cx2 + dx3 + fx4 + gx5
-
+
a = -1.1945480381045521E-02
b = 1.5809476525537265E+00
c = -1.5850710838966151E+01
* aeffectx.h - simple header to allow VeSTige compilation and eventually work
*
* Copyright (c) 2006 Javier Serrano Polo <jasp00/at/users.sourceforge.net>
- *
+ *
* This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
*
* This program is free software; you can redistribute it and/or
typedef struct _VSTKey VSTKey;
-struct LIBARDOUR_API _VSTInfo
+struct LIBARDOUR_API _VSTInfo
{
char *name;
char *creator;
int UniqueID;
char *Category;
-
+
int numInputs;
int numOutputs;
int numParams;
/*
Copyright (C) 1998 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
if (ARDOUR::Port::sends_output()) {
flush_output_fifo (nframes);
- }
+ }
/* copy incoming data from the port buffer into the input FIFO
and if necessary wakeup the reader
if (timestamp == 0) {
timestamp = _last_write_timestamp;
- }
+ }
if (mb.push_back (timestamp, msglen, msg)) {
ret = msglen;
error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
return -1;
}
-
+
(*chan)->capture_buf->increment_read_ptr (to_write);
(*chan)->curr_capture_cnt += to_write;
return;
}
- /* can't rec-safe in destructive mode if transport is before start ????
+ /* can't rec-safe in destructive mode if transport is before start ????
REQUIRES REVIEW */
if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
} else {
disengage_record_safe ();
}
-
+
RecordSafeChanged (); /* EMIT SIGNAL */
}
}
continue to exist. If we do not do this, then the
Session retains a reference to it, it is not
deleted, and later attempts to create a new source
- file will use wierd naming because it already
+ file will use wierd naming because it already
exists.
XXX longer term TO-DO: do not add to session source
if (!in) {
warning << string_compose (_("Legacy crossfade involved an incoming region not present in playlist \"%1\" - crossfade discarded"),
- name())
+ name())
<< endmsg;
continue;
}
if (!out) {
warning << string_compose (_("Legacy crossfade involved an outgoing region not present in playlist \"%1\" - crossfade discarded"),
- name())
+ name())
<< endmsg;
continue;
}
if (in->layer() <= out->layer()) {
/* incoming region is below the outgoing one,
- * so apply a fade out to the outgoing one
+ * so apply a fade out to the outgoing one
*/
const XMLNodeList c = (*i)->children ();
return *_buffer;
}
-Sample*
+Sample*
AudioPort::engine_get_whole_audio_buffer ()
{
/* caller must hold process lock */
return false;
}
- /* we're including the endpoint - if we just hit it,
+ /* we're including the endpoint - if we just hit it,
then stop.
*/
return true;
}
- /* save outputs of this processor to test against inputs
+ /* save outputs of this processor to test against inputs
of the next one.
*/
unit->GetElementCount (kAudioUnitScope_Output, output_elements);
if (input_elements > 0) {
- /* setup render callback: the plugin calls this to get input data
+ /* setup render callback: the plugin calls this to get input data
*/
AURenderCallbackStruct renderCallbackInfo;
vector<pair<int,int> >& io_configs = pinfo->cache.io_configs;
- DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 has %2 IO configurations, looking for %3 in, %4 out\n",
+ DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("%1 has %2 IO configurations, looking for %3 in, %4 out\n",
name(), io_configs.size(), in, out));
//Ardour expects the plugin to tell it the output
int32_t possible_out = i->second;
if ((possible_in == audio_in) && (possible_out == audio_out)) {
- DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tCHOSEN: %1 in %2 out to match in %3 out %4\n",
+ DEBUG_TRACE (DEBUG::AudioUnits, string_compose ("\tCHOSEN: %1 in %2 out to match in %3 out %4\n",
possible_in, possible_out,
in, out));
audio_out = 2;
found = true;
} else if (possible_out == -2) {
- /* plugins shouldn't really use (0,-2) but might.
- any configuration possible, provide stereo output
+ /* plugins shouldn't really use (0,-2) but might.
+ any configuration possible, provide stereo output
*/
audio_out = 2;
found = true;
audio_out = audio_in;
found = true;
} else if (possible_out == -2) {
- /* plugins shouldn't really use (-2,-2) but might.
+ /* plugins shouldn't really use (-2,-2) but might.
interpret as (-1,-1).
*/
audio_out = audio_in;
audio_out = 2;
found = true;
} else if (possible_out == -2) {
- /* plugins shouldn't really use (<-2,-2) but might.
- interpret as (<-2,-1): any configuration possible, provide stereo output
+ /* plugins shouldn't really use (<-2,-2) but might.
+ interpret as (<-2,-1): any configuration possible, provide stereo output
*/
audio_out = 2;
found = true;
audio_out = 2;
found = true;
} else if (possible_out == -2) {
- /* plugins shouldn't really use (>0,-2) but might.
- interpret as (>0,-1):
+ /* plugins shouldn't really use (>0,-2) but might.
+ interpret as (>0,-1):
any output configuration possible, provide stereo output
*/
audio_out = 2;
buffers->mBuffers[i].mDataByteSize = nframes * sizeof (Sample);
/* setting this to 0 indicates to the AU that it can provide buffers here
if necessary. if it can process in-place, it will use the buffers provided
- as input by ::render_callback() above.
-
+ as input by ::render_callback() above.
+
a non-null values tells the plugin to render into the buffer pointed
at by the value.
*/
}
}
- /* does this really mean anything ?
+ /* does this really mean anything ?
*/
ts.mSampleTime = frames_processed;
/* on the beat */
*outDeltaSampleOffsetToNextBeat = 0;
} else {
- *outDeltaSampleOffsetToNextBeat = (UInt32)
+ *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())); // frames per beat
}
}
void
-AUPlugin::do_remove_preset (std::string)
+AUPlugin::do_remove_preset (std::string)
{
}
/* AU require a CAComponentDescription pointer provided by the OS.
* Ardour only caches port and i/o config. It can't just 'scan' without
* 'discovering' (like we do for VST).
- *
+ *
* "Scan Only" means
* "Iterate over all plugins. skip the ones where there's no io-cache".
*/
AUPlugin::create_parameter_listener (AUEventListenerProc cb, void* arg, float interval_secs)
{
#ifdef WITH_CARBON
- CFRunLoopRef run_loop = (CFRunLoopRef) GetCFRunLoopFromEventLoop(GetCurrentEventLoop());
+ CFRunLoopRef run_loop = (CFRunLoopRef) GetCFRunLoopFromEventLoop(GetCurrentEventLoop());
#else
CFRunLoopRef run_loop = CFRunLoopGetCurrent();
#endif
if (AUEventListenerAddEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) {
return -1;
- }
+ }
event.mEventType = kAudioUnitEvent_BeginParameterChangeGesture;
event.mArgument.mParameter.mAudioUnit = unit->AU();
if (AUEventListenerAddEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) {
return -1;
- }
+ }
event.mEventType = kAudioUnitEvent_EndParameterChangeGesture;
event.mArgument.mParameter.mAudioUnit = unit->AU();
if (AUEventListenerAddEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) {
return -1;
- }
+ }
return 0;
}
if (AUEventListenerRemoveEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) {
return -1;
- }
+ }
event.mEventType = kAudioUnitEvent_BeginParameterChangeGesture;
event.mArgument.mParameter.mAudioUnit = unit->AU();
if (AUEventListenerRemoveEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) {
return -1;
- }
+ }
event.mEventType = kAudioUnitEvent_EndParameterChangeGesture;
event.mArgument.mParameter.mAudioUnit = unit->AU();
if (AUEventListenerRemoveEventType (_parameter_listener, _parameter_listener_arg, &event) != noErr) {
return -1;
- }
+ }
return 0;
}
if ((i = parameter_map.find (event->mArgument.mParameter.mParameterID)) == parameter_map.end()) {
return;
}
-
+
switch (event->mEventType) {
case kAudioUnitEvent_BeginParameterChangeGesture:
StartTouch (i->second);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
return 0;
}
-int
+int
AudioEngine::buffer_size_change (pframes_t bufsiz)
{
if (_session) {
}
/* really only JACK requires this
* (other backends clear the output buffers
- * before the process_callback. it may even be
+ * before the process_callback. it may even be
* jack/alsa only). but better safe than sorry.
*/
PortManager::silence_outputs (nframes);
if (_measuring_latency == MeasureAudio && _mtdm) {
/* run a normal cycle from the perspective of the PortManager
so that we get silence on all registered ports.
-
+
we overwrite the silence on the two ports used for latency
measurement.
*/
} else if (session_removal_countdown > 0) {
/* we'll be fading audio out.
-
- if this is the last time we do this as part
+
+ if this is the last time we do this as part
of session removal, do a MIDI panic now
to get MIDI stopped. This relies on the fact
that "immediate data" (aka "out of band data") from
- MIDI tracks is *appended* after any other data,
+ MIDI tracks is *appended* after any other data,
so that it emerges after any outbound note ons, etc.
*/
AudioEngine::do_reset_backend()
{
SessionEvent::create_per_thread_pool (X_("Backend reset processing thread"), 1024);
-
+
Glib::Threads::Mutex::Lock guard (_reset_request_lock);
-
+
while (!_stop_hw_reset_processing) {
-
+
if (g_atomic_int_get (&_hw_reset_request_count) != 0 && _backend) {
-
+
_reset_request_lock.unlock();
-
+
Glib::Threads::RecMutex::Lock pl (_state_lock);
g_atomic_int_dec_and_test (&_hw_reset_request_count);
-
+
std::cout << "AudioEngine::RESET::Reset request processing. Requests left: " << _hw_reset_request_count << std::endl;
DeviceResetStarted(); // notify about device reset to be started
-
+
// backup the device name
std::string name = _backend->device_name ();
// inform about possible changes
BufferSizeChanged (_backend->buffer_size() );
DeviceResetFinished(); // notify about device reset finish
-
+
} else {
-
+
DeviceResetFinished(); // notify about device reset finish
// we've got an error
DeviceError();
std::cout << "AudioEngine::RESET::Done." << std::endl;
_reset_request_lock.lock();
-
+
} else {
-
+
_hw_reset_condition.wait (_reset_request_lock);
-
+
}
}
}
AudioEngine::do_devicelist_update()
{
SessionEvent::create_per_thread_pool (X_("Device list update processing thread"), 512);
-
+
Glib::Threads::Mutex::Lock guard (_devicelist_update_lock);
-
+
while (!_stop_hw_devicelist_processing) {
-
+
if (_hw_devicelist_update_count) {
_devicelist_update_lock.unlock();
-
+
Glib::Threads::RecMutex::Lock pl (_state_lock);
-
+
g_atomic_int_dec_and_test (&_hw_devicelist_update_count);
DeviceListChanged (); /* EMIT SIGNAL */
-
+
_devicelist_update_lock.lock();
-
+
} else {
_hw_devicelist_update_condition.wait (_devicelist_update_lock);
}
void
AudioEngine::start_hw_event_processing()
-{
+{
if (_hw_reset_event_thread == 0) {
g_atomic_int_set(&_hw_reset_request_count, 0);
g_atomic_int_set(&_stop_hw_reset_processing, 0);
_hw_reset_event_thread = Glib::Threads::Thread::create (boost::bind (&AudioEngine::do_reset_backend, this));
}
-
+
if (_hw_devicelist_update_thread == 0) {
g_atomic_int_set(&_hw_devicelist_update_count, 0);
g_atomic_int_set(&_stop_hw_devicelist_processing, 0);
_hw_reset_event_thread->join ();
_hw_reset_event_thread = 0;
}
-
+
if (_hw_devicelist_update_thread) {
g_atomic_int_set(&_stop_hw_devicelist_processing, 1);
g_atomic_int_set(&_hw_devicelist_update_count, 0);
{
if (_backend) {
return _backend->name();
- }
+ }
return string();
}
}
float
-AudioEngine::get_dsp_load() const
+AudioEngine::get_dsp_load() const
{
if (!_backend) {
return 0.0;
}
bool
-AudioEngine::is_realtime() const
+AudioEngine::is_realtime() const
{
if (!_backend) {
return false;
}
bool
-AudioEngine::connected() const
+AudioEngine::connected() const
{
if (!_backend) {
return false;
}
static void
-merge_curves (boost::shared_ptr<Evoral::ControlList> dst,
- boost::shared_ptr<const Evoral::ControlList> curve1,
+merge_curves (boost::shared_ptr<Evoral::ControlList> dst,
+ boost::shared_ptr<const Evoral::ControlList> curve1,
boost::shared_ptr<const Evoral::ControlList> curve2)
{
Evoral::ControlList::EventList::size_type size = curve1->size();
* @param chan_n Channel.
* @param frames_per_pixel Number of samples to use to generate one peak value.
*/
-
+
ARDOUR::framecnt_t
AudioRegion::read_peaks (PeakData *buf, framecnt_t npeaks, framecnt_t offset, framecnt_t cnt, uint32_t chan_n, double frames_per_pixel) const
{
if (audio_source(chan_n)->read_peaks (buf, npeaks, offset, cnt, frames_per_pixel)) {
return 0;
- }
+ }
if (_scale_amplitude != 1.0f) {
for (framecnt_t n = 0; n < npeaks; ++n) {
/* APPLY FADES TO THE DATA IN mixdown_buffer AND MIX THE RESULTS INTO
* buf. The key things to realize here: (1) the fade being applied is
- * (as of April 26th 2012) just the inverse of the fade in curve (2)
+ * (as of April 26th 2012) just the inverse of the fade in curve (2)
* "buf" contains data from lower regions already. So this operation
* fades out the existing material.
*/
reverse_curve (_inverse_fade_out.val(), _fade_out.val());
break;
- case FadeFast:
+ case FadeFast:
generate_db_fade (_fade_out.val(), len, num_steps, -60);
generate_inverse_power_curve (_inverse_fade_out.val(), _fade_out.val());
break;
- case FadeSlow:
+ case FadeSlow:
generate_db_fade (c1, len, num_steps, -1); //start off with a slow fade
generate_db_fade (c2, len, num_steps, -80); //end with a fast fade
merge_curves (_fade_out.val(), c1, c2);
{
uint32_t chan_count = 0;
for (SourceList::const_iterator i = _sources.begin(); i != _sources.end(); ++i) {
-
+
boost::shared_ptr<SndFileSource> sndf = boost::dynamic_pointer_cast<SndFileSource>(*i);
if (sndf ) {
-
+
if (sndf->channel_count() > chan_count) {
chan_count = sndf->channel_count();
}
}
#endif // HAVE_COREAUDIO
}
-
+
return chan_count;
}
*
* XXX this may not work for destructive recording, but we
* might decided to get rid of that anyway.
- *
+ *
*/
const off_t expected_file_size = (_length / (double) samples_per_file_peak) * sizeof (PeakData);
error << string_compose (_("Cannot open peakfile @ %1 for reading (%2)"), _peakpath, strerror (errno)) << endmsg;
return -1;
}
-
+
scale = npeaks/expected_peaks;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
if (mark) {
/* XXX need to mark the last added point with the
- * current time
+ * current time
*/
}
}
*/
if (_session && _session->transport_rolling() && ac->alist()->automation_write()) {
- DEBUG_TRACE (DEBUG::Automation, string_compose ("\ttransport is rolling @ %1, audible = %2so enter write pass\n",
+ DEBUG_TRACE (DEBUG::Automation, string_compose ("\ttransport is rolling @ %1, audible = %2so enter write pass\n",
_session->transport_speed(), _session->audible_frame()));
/* add a guard point since we are already moving */
ac->list()->set_in_write_pass (true, true, _session->audible_frame());
}
} else if (time != _last_time) { //transport stopped or reversed. stop the automation pass and start a new one (for bonus points, someday store the previous pass in an undo record)
for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) {
- DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport in rewind, speed %2, in write pass ? %3 writing ? %4\n",
+ DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport in rewind, speed %2, in write pass ? %3 writing ? %4\n",
(*aw)->name(), _session->transport_speed(), _session->transport_rolling(),
(*aw)->alist()->automation_write()));
(*aw)->list()->set_in_write_pass (false);
Glib::Threads::Mutex::Lock lm (automation_watch_lock);
for (AutomationWatches::iterator aw = automation_watches.begin(); aw != automation_watches.end(); ++aw) {
- DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport state changed, speed %2, in write pass ? %3 writing ? %4\n",
+ DEBUG_TRACE (DEBUG::Automation, string_compose ("%1: transport state changed, speed %2, in write pass ? %3 writing ? %4\n",
(*aw)->name(), _session->transport_speed(), rolling,
(*aw)->alist()->automation_write()));
if (rolling && (*aw)->alist()->automation_write()) {
/* https://tech.ebu.ch/docs/r/r099.pdf
* CC Country code: (2 characters) based on the ISO 3166-1 standard
- * OOO Organisation code: (3 characters) based on the EBU facility codes, Tech 3279
+ * OOO Organisation code: (3 characters) based on the EBU facility codes, Tech 3279
* NNNNNNNNNNNN Serial number: (12 characters extracted from the recorder model and serial number) This should identify the machine’s type and serial number.
* HHMMSS OriginationTime (6 characters,) from the <OriginationTime> field of the BWF.
- * RRRRRRRRR Random Number (9 characters 0-9) Generated locally by the recorder using some reasonably random algorithm.
+ * RRRRRRRRR Random Number (9 characters 0-9) Generated locally by the recorder using some reasonably random algorithm.
*/
snprintf_bounded_null_filled (info->originator_reference, sizeof (info->originator_reference), "%2s%3s%12s%02d%02d%02d%9d",
SessionMetadata::Metadata()->country().substr (0, 2).c_str(),
_count.reset();
_available.reset();
-#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT
+#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT
for (VSTBuffers::iterator i = _vst_buffers.begin(); i != _vst_buffers.end(); ++i) {
delete *i;
}
const float rate = (float)_session.frame_rate();
audio_dstream_capture_buffer_size = (uint32_t) floor (Config->get_audio_capture_buffer_seconds() * rate);
audio_dstream_playback_buffer_size = (uint32_t) floor (Config->get_audio_playback_buffer_seconds() * rate);
-
+
/* size is in bytes
* XXX: AudioEngine needs to tell us the MIDI buffer size
* (i.e. how many MIDI bytes we might see in a cycle)
//pthread_detach (thread);
have_thread = true;
-
+
// we are ready to request buffer adjustments
_session.adjust_capture_buffering ();
_session.adjust_playback_buffering ();
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
find_files_matching_pattern (cp_modules, control_protocol_search_path (),
dylib_extension_pattern);
- DEBUG_TRACE (DEBUG::ControlProtocols,
+ DEBUG_TRACE (DEBUG::ControlProtocols,
string_compose (_("looking for control protocols in %1\n"), control_protocol_search_path().to_string()));
for (vector<std::string>::iterator i = cp_modules.begin(); i != cp_modules.end(); ++i) {
control_protocol_info.push_back (cpi);
- DEBUG_TRACE (DEBUG::ControlProtocols,
+ DEBUG_TRACE (DEBUG::ControlProtocols,
string_compose(_("Control surface protocol discovered: \"%1\"\n"), cpi->name));
}
/* this object should vanish from any signal callback lists
that it is on before we get any further. The full qualification
- of the method name is not necessary, but is here to make it
+ of the method name is not necessary, but is here to make it
clear that this call is about signals, not data flow connections.
*/
{
if (_output) {
return _output->n_ports().n_audio();
- }
+ }
return _configured_output.n_audio();
}
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 2014 Waves Audio Ltd.
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
+
*/
#include "ardour/engine_state_controller.h"
using namespace PBD;
namespace {
-
+
struct DevicePredicate
{
DevicePredicate (const std::string& device_name)
: _device_name (device_name)
{}
-
+
bool operator ()(const AudioBackend::DeviceStatus& rhs)
{
return _device_name == rhs.name;
}
-
+
private:
std::string _device_name;
};
AudioEngine::instance ()->Running.connect_same_thread (running_connection, boost::bind (&EngineStateController::_on_engine_running, this));
AudioEngine::instance ()->Stopped.connect_same_thread (stopped_connection, boost::bind (&EngineStateController::_on_engine_stopped, this));
AudioEngine::instance ()->Halted.connect_same_thread (stopped_connection, boost::bind (&EngineStateController::_on_engine_stopped, this));
-
+
/* Subscribe for udpates from AudioEngine */
AudioEngine::instance ()->PortRegisteredOrUnregistered.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_ports_registration_update, this));
AudioEngine::instance ()->SampleRateChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_sample_rate_change, this, _1));
AudioEngine::instance ()->BufferSizeChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_buffer_size_change, this, _1));
AudioEngine::instance ()->DeviceListChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_device_list_change, this));
AudioEngine::instance ()->DeviceError.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_device_error, this));
-
+
/* Global configuration parameters update */
Config->ParameterChanged.connect_same_thread (update_connections, boost::bind (&EngineStateController::_on_parameter_changed, this, _1));
-
+
_deserialize_and_load_engine_states ();
_deserialize_and_load_midi_port_states ();
_do_initial_engine_setup ();
-
+
// now push the sate to the backend
push_current_state_to_backend (false);
}
XMLNode&
EngineStateController::serialize_audio_midi_settings ()
{
-
+
XMLNode* root = new XMLNode ("AudioMidiSettings");
-
+
_serialize_engine_states (root);
_serialize_midi_port_states (root);
-
+
return *root;
}
EngineStateController::_deserialize_and_load_engine_states ()
{
XMLNode* audio_midi_settings_root = ARDOUR::Config->extra_xml ("AudioMidiSettings");
-
+
if (!audio_midi_settings_root) {
return;
}
-
+
XMLNode* engine_states = audio_midi_settings_root->child ("EngineStates");
-
+
if (!engine_states) {
return;
}
-
+
XMLNodeList state_nodes_list = engine_states->children ();
XMLNodeConstIterator state_node_iter = state_nodes_list.begin ();
-
+
for (; state_node_iter != state_nodes_list.end (); ++state_node_iter) {
-
+
XMLNode* state_node = *state_node_iter;
StatePtr engine_state (new State);
XMLProperty* prop = NULL;
-
+
if ((prop = state_node->property ("backend-name")) == 0) {
continue;
}
engine_state->backend_name = prop->value ();
-
+
if ((prop = state_node->property ("device-name")) == 0) {
continue;
}
engine_state->device_name = prop->value ();
-
+
if ((prop = state_node->property ("sample-rate")) == 0) {
continue;
}
engine_state->sample_rate = atoi (prop->value ());
-
+
if ((prop = state_node->property ("buffer-size")) == 0) {
continue;
}
engine_state->buffer_size = atoi (prop->value ());
-
+
if ((prop = state_node->property ("active")) == 0) {
continue;
}
engine_state->active = string_is_affirmative (prop->value ());
-
+
XMLNodeList state_children_list = state_node->children ();
XMLNodeConstIterator state_child_iter = state_children_list.begin ();
-
+
for (; state_child_iter != state_children_list.end (); ++state_child_iter) {
XMLNode* state_child = *state_child_iter;
-
+
if (state_child->name () == "InputConfiguration") {
-
+
XMLNodeList input_states_nodes = state_child->children ();
XMLNodeConstIterator input_state_node_iter = input_states_nodes.begin ();
PortStateList& input_states = engine_state->input_channel_states;
-
+
for (; input_state_node_iter != input_states_nodes.end (); ++input_state_node_iter) {
-
+
XMLNode* input_state_node = *input_state_node_iter;
-
+
if (input_state_node->name () != "input") {
continue;
}
PortState input_state (input_state_node->name ());
-
+
if ((prop = input_state_node->property ("name")) == 0) {
continue;
}
input_state.name = prop->value ();
-
+
if ((prop = input_state_node->property ("active")) == 0) {
continue;
}
input_state.active = string_is_affirmative (prop->value ());
-
+
input_states.push_back (input_state);
}
-
+
} else if (state_child->name () == "MultiOutConfiguration") {
-
+
XMLNodeList multi_out_state_nodes = state_child->children ();
XMLNodeConstIterator multi_out_state_node_iter = multi_out_state_nodes.begin ();
PortStateList& multi_out_states = engine_state->multi_out_channel_states;
-
+
for (; multi_out_state_node_iter != multi_out_state_nodes.end (); ++multi_out_state_node_iter) {
-
+
XMLNode* multi_out_state_node = *multi_out_state_node_iter;
-
+
if (multi_out_state_node->name () != "output") {
continue;
}
PortState multi_out_state (multi_out_state_node->name ());
-
+
if ((prop = multi_out_state_node->property ("name")) == 0) {
continue;
}
multi_out_state.name = prop->value ();
-
+
if ((prop = multi_out_state_node->property ("active")) == 0) {
continue;
}
multi_out_state.active = string_is_affirmative (prop->value ());
-
+
multi_out_states.push_back (multi_out_state);
}
} else if (state_child->name () == "StereoOutConfiguration") {
-
+
XMLNodeList stereo_out_state_nodes = state_child->children ();
XMLNodeConstIterator stereo_out_state_node_iter = stereo_out_state_nodes.begin ();
PortStateList& stereo_out_states = engine_state->stereo_out_channel_states;
-
+
for (; stereo_out_state_node_iter != stereo_out_state_nodes.end (); ++stereo_out_state_node_iter) {
-
+
XMLNode* stereo_out_state_node = *stereo_out_state_node_iter;
-
+
if (stereo_out_state_node->name () != "output") {
continue;
}
PortState stereo_out_state (stereo_out_state_node->name ());
-
+
if ((prop = stereo_out_state_node->property ("name")) == 0) {
continue;
}
stereo_out_state.name = prop->value ();
-
+
if ((prop = stereo_out_state_node->property ("active")) == 0) {
continue;
- }
+ }
stereo_out_state.active = string_is_affirmative (prop->value ());
-
+
stereo_out_states.push_back (stereo_out_state);
}
}
}
-
+
_states.push_back (engine_state);
}
}
void
EngineStateController::_deserialize_and_load_midi_port_states ()
-{
+{
XMLNode* audio_midi_settings_root = ARDOUR::Config->extra_xml ("AudioMidiSettings");
-
+
if (!audio_midi_settings_root) {
return;
}
-
+
XMLNode* midi_states = audio_midi_settings_root->child ("MidiStates");
-
+
if (!midi_states) {
return;
}
-
+
XMLNodeList state_nodes_list = midi_states->children ();
XMLNodeConstIterator state_node_iter = state_nodes_list.begin ();
for (; state_node_iter != state_nodes_list.end (); ++state_node_iter) {
-
+
XMLNode* state_node = *state_node_iter;
if (state_node->name () == "MidiInputs") {
-
+
XMLNodeList input_state_nodes = state_node->children ();
XMLNodeConstIterator input_state_node_iter = input_state_nodes.begin ();
_midi_inputs.clear ();
-
+
for (; input_state_node_iter != input_state_nodes.end (); ++input_state_node_iter) {
-
+
XMLNode* input_state_node = *input_state_node_iter;
XMLProperty* prop = NULL;
-
+
if (input_state_node->name () != "input") {
continue;
}
MidiPortState input_state (input_state_node->name ());
-
+
if ((prop = input_state_node->property ("name")) == 0) {
continue;
}
input_state.name = prop->value ();
-
+
if ((prop = input_state_node->property ("active")) == 0) {
continue;
}
input_state.active = string_is_affirmative (prop->value ());
-
+
if ((prop = input_state_node->property ("scene-connected")) == 0) {
continue;
}
input_state.scene_connected = string_is_affirmative (prop->value ());
-
+
if ((prop = input_state_node->property ("mtc-in")) == 0) {
continue;
}
input_state.mtc_in = string_is_affirmative (prop->value ());
-
+
_midi_inputs.push_back (input_state);
}
-
+
} else if (state_node->name () == "MidiOutputs") {
-
+
XMLNodeList output_state_nodes = state_node->children ();
XMLNodeConstIterator output_state_node_iter = output_state_nodes.begin ();
_midi_outputs.clear ();
-
+
for (; output_state_node_iter != output_state_nodes.end (); ++output_state_node_iter) {
-
+
XMLNode* output_state_node = *output_state_node_iter;
XMLProperty* prop = NULL;
-
+
if (output_state_node->name () != "output") {
continue;
}
MidiPortState output_state (output_state_node->name ());
-
+
if ((prop = output_state_node->property ("name")) == 0) {
continue;
}
output_state.name = prop->value ();
-
+
if ((prop = output_state_node->property ("active")) == 0) {
continue;
}
output_state.active = string_is_affirmative (prop->value ());
-
+
if ((prop = output_state_node->property ("scene-connected")) == 0) {
continue;
}
output_state.scene_connected = string_is_affirmative (prop->value ());
-
+
if ((prop = output_state_node->property ("mtc-in")) == 0) {
continue;
}
output_state.mtc_in = string_is_affirmative (prop->value ());
-
+
_midi_outputs.push_back (output_state);
}
}
if (!audio_midi_settings_node) {
return;
}
-
+
// clean up state data first
audio_midi_settings_node->remove_nodes_and_delete ("EngineStates" );
-
+
XMLNode* engine_states = new XMLNode ("EngineStates" );
-
+
StateList::const_iterator state_iter = _states.begin ();
for (; state_iter != _states.end (); ++state_iter) {
-
+
StatePtr state_ptr = *state_iter;
-
+
// create new node for the state
XMLNode* state_node = new XMLNode ("State");
-
+
state_node->add_property ("backend-name", state_ptr->backend_name);
state_node->add_property ("device-name", state_ptr->device_name);
state_node->add_property ("sample-rate", state_ptr->sample_rate);
state_node->add_property ("buffer-size", state_ptr->buffer_size);
state_node->add_property ("active", state_ptr->active ? "yes" : "no");
-
+
// store channel states:
// inputs
XMLNode* input_config_node = new XMLNode ("InputConfiguration");
input_config_node->add_child_nocopy (*input_state_node);
}
state_node->add_child_nocopy (*input_config_node);
-
+
// multi out outputs
XMLNode* multi_out_config_node = new XMLNode ("MultiOutConfiguration");
PortStateList& multi_out_channels = state_ptr->multi_out_channel_states;
multi_out_config_node->add_child_nocopy (*multi_out_state_node);
}
state_node->add_child_nocopy (*multi_out_config_node);
-
+
// stereo out outputs
XMLNode* stereo_out_config_node = new XMLNode ("StereoOutConfiguration");
PortStateList& stereo_out_channels = state_ptr->stereo_out_channel_states;
stereo_out_config_node->add_child_nocopy (*stereo_out_state_node);
}
state_node->add_child_nocopy (*stereo_out_config_node);
-
+
engine_states->add_child_nocopy (*state_node);
}
if (!audio_midi_settings_node) {
return;
}
-
+
// clean up state data first
audio_midi_settings_node->remove_nodes_and_delete ("MidiStates" );
-
+
XMLNode* midi_states_node = new XMLNode ("MidiStates" );
-
+
XMLNode* midi_input_states_node = new XMLNode ("MidiInputs" );
MidiPortStateList::const_iterator midi_input_state_iter = _midi_inputs.begin ();
for (; midi_input_state_iter != _midi_inputs.end (); ++midi_input_state_iter) {
midi_input_states_node->add_child_nocopy (*midi_input_node);
}
midi_states_node->add_child_nocopy (*midi_input_states_node);
-
+
XMLNode* midi_output_states_node = new XMLNode ("MidiOutputs" );
MidiPortStateList::const_iterator midi_output_state_iter = _midi_outputs.begin ();
for (; midi_output_state_iter != _midi_outputs.end (); ++midi_output_state_iter) {
EngineStateController::_apply_state (const StatePtr& state)
{
bool applied = false;
-
+
if (set_new_backend_as_current (state->backend_name)) {
applied = set_new_device_as_current (state->device_name);
}
-
+
return applied;
}
EngineStateController::_do_initial_engine_setup ()
{
bool state_applied = false;
-
+
// if we have no saved state load default values
if (!_states.empty ()) {
-
+
// look for last active state first
StateList::const_iterator state_iter = _states.begin ();
for (; state_iter != _states.end (); ++state_iter) {
break;
}
}
-
+
// last active state was not applied
// try others
if (!state_applied) {
if (!state_applied ){
std::vector<const AudioBackendInfo*> backends = AudioEngine::instance ()->available_backends ();
-
+
if (!backends.empty ()) {
-
+
if (!set_new_backend_as_current (backends.front ()->name )) {
std::cerr << "\tfailed to set backend [" << backends.front ()->name << "]\n";
}
}
-
+
}
}
{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
// check if device parameters from the state record are still valid
// validate sample rate
std::vector<float> sample_rates = backend->available_sample_rates (_current_state->device_name);
-
+
if (sample_rates.empty ()) {
return false;
}
// check if session desired sample rate (if it's set) could be used with this device
if (_session != 0) {
-
+
if ( !set_new_sample_rate_in_controller (_session->nominal_frame_rate ())) {
if ( !set_new_sample_rate_in_controller (backend->default_sample_rate ()) ) {
if (!set_new_sample_rate_in_controller (sample_rates.front ()) ) {
}
}
}
-
+
} else {
// check if current sample rate is supported because we have no session desired sample rate value
if ( !set_new_sample_rate_in_controller (_current_state->sample_rate)) {
}
}
}
-
+
// validate buffer size
std::vector<pframes_t> buffer_sizes = backend->available_buffer_sizes (_current_state->device_name);
// check if buffer size is supported
EngineStateController::_update_ltc_source_port ()
{
// this method is called if the list of ports is changed
-
+
// check that ltc-in port from Config still exists
if (_audio_input_port_exists (get_ltc_source_port ())) {
// audio port, that was saved in Config, exists
set_ltc_source_port (_current_state->input_channel_states.front ().name);
return ;
}
-
+
// no available audio-in ports
set_ltc_source_port ("");
}
EngineStateController::_update_ltc_output_port ()
{
// this method is called if the list of ports is changed
-
+
// check that ltc-out port from Config still exists
if (_audio_output_port_exists (get_ltc_output_port ())) {
// audio port, that was saved in Config, exists
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
//otherwise set first available audio port
if (!output_states->empty ()) {
set_ltc_output_port (output_states->front ().name);
return ;
}
-
+
// no available audio-out ports
set_ltc_output_port ("");
}
-
+
bool
EngineStateController::_audio_input_port_exists (const std::string& port_name)
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::const_iterator iter = output_states->begin ();
for (; iter != output_states->end (); ++iter ) {
if (iter->name == port_name)
if (backend_name == AudioEngine::instance ()->current_backend_name ()) {
return true;
}
-
+
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->set_backend (backend_name, PROGRAM_NAME, "");
if (backend)
{
if (_current_state != NULL) {
_current_state->active = false;
}
-
+
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (backend_name, "None"));
-
+
if (found_state_iter != _states.end ()) {
// we found a record for new engine with None device - switch to it
_current_state = *found_state_iter;
_validate_current_device_state ();
_states.push_front (_current_state);
}
-
+
push_current_state_to_backend (false);
-
+
return true;
}
-
+
return false;
}
if (_current_state->device_name == device_name) {
return true;
}
-
+
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<AudioBackend::DeviceStatus> device_vector = backend->enumerate_devices ();
-
+
// validate the device
std::vector<AudioBackend::DeviceStatus>::iterator device_iter;
device_iter = std::find_if (device_vector.begin (), device_vector.end (), DevicePredicate (device_name));
-
+
// device is available
if (device_iter != device_vector.end ()) {
-
+
boost::shared_ptr<State> previous_state (_current_state);
-
+
// look through state list and find the record for this device and current engine
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (backend->name (), device_name));
-
+
if (found_state_iter != _states.end ())
{
// we found a record for current engine and provided device name - switch to it
-
+
_current_state = *found_state_iter;
-
+
if (!_validate_current_device_state ()) {
_current_state = previous_state;
return false;
}
-
+
} else {
-
+
// the record is not found, create new one
_current_state = boost::shared_ptr<State>(new State ());
-
+
_current_state->backend_name = backend->name ();
_current_state->device_name = device_name;
-
+
if (!_validate_current_device_state ()) {
_current_state = previous_state;
return false;
}
-
+
_states.push_front (_current_state);
}
-
+
if (previous_state != NULL) {
previous_state->active = false;
}
-
+
push_current_state_to_backend (false);
_last_used_real_device.clear ();
-
+
if (device_name != "None") {
_last_used_real_device = device_name;
}
-
+
return true;
}
-
+
// device is not supported by current backend
return false;
}
{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<float> sample_rates = backend->available_sample_rates (_current_state->device_name);
std::vector<float>::iterator iter = std::find (sample_rates.begin (), sample_rates.end (), (float)sample_rate);
-
+
if (iter != sample_rates.end ()) {
_current_state->sample_rate = sample_rate;
return true;
}
-
+
return false;
}
bool
EngineStateController::set_new_buffer_size_in_controller (pframes_t buffer_size)
-{
+{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<uint32_t> buffer_sizes = backend->available_buffer_sizes (_current_state->device_name);
std::vector<uint32_t>::iterator iter = std::find (buffer_sizes.begin (), buffer_sizes.end (), buffer_size);
_current_state->buffer_size = buffer_size;
return true;
}
-
+
return false;
}
EngineStateController::get_available_inputs_count () const
{
uint32_t available_channel_count = 0;
-
+
PortStateList::const_iterator iter = _current_state->input_channel_states.begin ();
-
+
for (; iter != _current_state->input_channel_states.end (); ++iter) {
if (iter->active) {
++available_channel_count;
}
}
-
+
return available_channel_count;
}
EngineStateController::get_available_outputs_count () const
{
uint32_t available_channel_count = 0;
-
+
PortStateList* output_states;
if (Config->get_output_auto_connect () & AutoConnectMaster) {
output_states = &_current_state->stereo_out_channel_states;
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::const_iterator iter = output_states->begin ();
-
+
for (; iter != output_states->end (); ++iter) {
if (iter->active) {
++available_channel_count;
}
}
-
+
return available_channel_count;
}
EngineStateController::get_physical_audio_inputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
PortStateList &input_states = _current_state->input_channel_states;
-
+
PortStateList::iterator iter = input_states.begin ();
for (; iter != input_states.end (); ++iter) {
if (iter->active) {
EngineStateController::get_physical_audio_outputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
PortStateList* output_states;
if (Config->get_output_auto_connect () & AutoConnectMaster) {
output_states = &_current_state->stereo_out_channel_states;
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::iterator iter = output_states->begin ();
for (; iter != output_states->end (); ++iter) {
if (iter->active) {
EngineStateController::get_physical_midi_inputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
MidiPortStateList::iterator iter = _midi_inputs.begin ();
for (; iter != _midi_inputs.end (); ++iter) {
if (iter->available && iter->active) {
EngineStateController::get_physical_midi_outputs (std::vector<std::string>& port_names)
{
port_names.clear ();
-
+
MidiPortStateList::iterator iter = _midi_outputs.begin ();
for (; iter != _midi_outputs.end (); ++iter) {
if (iter->available && iter->active) {
PortStateList &input_states = _current_state->input_channel_states;
PortStateList::iterator found_state_iter;
found_state_iter = std::find (input_states.begin (), input_states.end (), PortState (port_name));
-
+
if (found_state_iter != input_states.end () && found_state_iter->active != state ) {
found_state_iter->active = state;
AudioEngine::instance ()->reconnect_session_routes (true, false);
-
+
InputConfigChanged ();
}
}
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::iterator target_state_iter;
target_state_iter = std::find (output_states->begin (), output_states->end (), PortState (port_name));
-
+
if (target_state_iter != output_states->end () && target_state_iter->active != state ) {
target_state_iter->active = state;
-
+
// if StereoOut mode is used
if (Config->get_output_auto_connect () & AutoConnectMaster) {
-
+
// get next element
PortStateList::iterator next_state_iter (target_state_iter);
-
+
// loopback
if (++next_state_iter == output_states->end ()) {
next_state_iter = output_states->begin ();
}
-
-
+
+
// only two outputs should be enabled
if (output_states->size () <= 2) {
-
+
target_state_iter->active = true;
next_state_iter->active = true;
-
+
} else {
-
+
// if current was set to active - activate next and disable the rest
if (target_state_iter->active ) {
next_state_iter->active = true;
target_state_iter->active = true;
}
}
-
+
// now deactivate the rest
while (++next_state_iter != target_state_iter) {
-
+
if (next_state_iter == output_states->end ()) {
next_state_iter = output_states->begin ();
// we jumped, so additional check is required
break;
}
}
-
+
next_state_iter->active = false;
}
-
+
}
}
-
+
AudioEngine::instance ()->reconnect_session_routes (false, true);
OutputConfigChanged ();
}
EngineStateController::get_physical_audio_input_state (const std::string& port_name)
{
bool state = false;
-
+
PortStateList &input_states = _current_state->input_channel_states;
PortStateList::iterator found_state_iter;
found_state_iter = std::find (input_states.begin (), input_states.end (), PortState (port_name));
-
+
if (found_state_iter != input_states.end ()) {
state = found_state_iter->active;
}
-
+
return state;
}
EngineStateController::get_physical_audio_output_state (const std::string& port_name)
{
bool state = false;
-
+
PortStateList* output_states;
if (Config->get_output_auto_connect () & AutoConnectMaster) {
output_states = &_current_state->stereo_out_channel_states;
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
PortStateList::iterator found_state_iter;
found_state_iter = std::find (output_states->begin (), output_states->end (), PortState (port_name));
-
+
if (found_state_iter != output_states->end ()) {
state = found_state_iter->active;
}
void
EngineStateController::set_physical_midi_input_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_inputs.end () && found_state_iter->available && found_state_iter->active != state ) {
found_state_iter->active = state;
-
+
if (_session) {
// reconnect MTC inputs as well
if (found_state_iter->mtc_in) {
}
_session->reconnect_mmc_ports (true);
}
-
+
MIDIInputConfigChanged ();
}
}
void
EngineStateController::set_physical_midi_output_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_outputs.end () && found_state_iter->available && found_state_iter->active != state ) {
found_state_iter->active = state;
-
+
if (_session) {
_session->reconnect_mmc_ports (false);
}
-
+
MIDIOutputConfigChanged ();
}
}
bool
EngineStateController::get_physical_midi_input_state (const std::string& port_name, bool& scene_connected) {
-
+
bool state = false;
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_inputs.end () && found_state_iter->available) {
state = found_state_iter->active;
scene_connected = found_state_iter->scene_connected;
}
-
+
return state;
}
bool
EngineStateController::get_physical_midi_output_state (const std::string& port_name, bool& scene_connected) {
-
+
bool state = false;
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_outputs.end () && found_state_iter->available) {
state = found_state_iter->active;
scene_connected = found_state_iter->scene_connected;
}
-
+
return state;
}
void
EngineStateController::set_physical_midi_scene_in_connection_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_inputs.end () && found_state_iter->available && found_state_iter->active ) {
found_state_iter->scene_connected = state;
-
+
std::vector<std::string> ports;
ports.push_back (port_name);
MIDISceneInputConnectionChanged (ports, state);
void
EngineStateController::set_physical_midi_scenen_out_connection_state (const std::string& port_name, bool state) {
-
+
MidiPortStateList::iterator found_state_iter;
found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), MidiPortState (port_name));
-
+
if (found_state_iter != _midi_outputs.end () && found_state_iter->available && found_state_iter->active ) {
found_state_iter->scene_connected = state;
-
+
std::vector<std::string> ports;
ports.push_back (port_name);
MIDISceneOutputConnectionChanged (ports, state);
for (; iter != _midi_outputs.end (); ++iter) {
iter->scene_connected = false;
}
-
+
std::vector<std::string> ports;
MIDISceneOutputConnectionChanged (ports, false);
}
MidiPortStateList::iterator iter = _midi_inputs.begin ();
for (; iter != _midi_inputs.end (); ++iter) {
iter->mtc_in = false;
-
+
if (iter->name == port_name) {
iter->mtc_in = true;
-
+
if (_session) {
_session->reconnect_mtc_ports ();
}
}
}
-
+
if (_session && port_name.empty ()) {
_session->reconnect_mtc_ports ();
}
-
+
MTCInputChanged (port_name);
}
EngineStateController::set_state_to_all_inputs (bool state)
{
bool something_changed = false;
-
+
PortStateList::iterator iter = _current_state->input_channel_states.begin ();
for (; iter != _current_state->input_channel_states.end (); ++iter) {
if (iter->active != state) {
something_changed = true;
}
}
-
+
if (something_changed) {
AudioEngine::instance ()->reconnect_session_routes (true, false);
InputConfigChanged ();
if (Config->get_output_auto_connect () & AutoConnectMaster) {
return;
}
-
+
bool something_changed = false;
-
+
PortStateList::iterator iter = _current_state->multi_out_channel_states.begin ();
for (; iter != _current_state->multi_out_channel_states.end (); ++iter) {
if (iter->active != state) {
something_changed = true;
}
}
-
+
if (something_changed) {
AudioEngine::instance ()->reconnect_session_routes (false, true);
OutputConfigChanged ();
} else {
output_states = &_current_state->multi_out_channel_states;
}
-
+
channel_states.assign (output_states->begin (), output_states->end ());
}
EngineStateController::get_physical_midi_input_states (std::vector<MidiPortState>& channel_states)
{
channel_states.clear ();
-
+
MidiPortStateList::iterator iter = _midi_inputs.begin ();
-
+
for (; iter != _midi_inputs.end (); ++iter ) {
if (iter->available) {
MidiPortState state (iter->name);
state.mtc_in = iter->mtc_in;
channel_states.push_back (state);
}
- }
+ }
}
void
EngineStateController::get_physical_midi_output_states (std::vector<MidiPortState>& channel_states)
{
channel_states.clear ();
-
+
MidiPortStateList::iterator iter = _midi_outputs.begin ();
-
+
for (; iter != _midi_outputs.end (); ++iter ) {
if (iter->available) {
MidiPortState state (iter->name);
if (!_session) {
return;
}
-
+
AudioEngine::instance ()->reconnect_session_routes (true, true);
_session->reconnect_mtc_ports ();
_session->reconnect_mmc_ports (true);
_session->reconnect_mmc_ports (false);
-
+
// This is done during session construction
// _session->reconnect_ltc_input ();
// _session->reconnect_ltc_output ();
EngineStateController::_on_sample_rate_change (framecnt_t new_sample_rate)
{
if (_current_state->sample_rate != new_sample_rate) {
-
+
// if sample rate has been changed
framecnt_t sample_rate_to_set = new_sample_rate;
if (AudioEngine::instance ()->session ()) {
// and we have current session we should restore it back to the one tracks uses
sample_rate_to_set = AudioEngine::instance ()->session ()->frame_rate ();
}
-
+
if ( !set_new_sample_rate_in_controller (sample_rate_to_set)) {
// if sample rate can't be set
// switch to NONE device
DeviceError ();
}
}
-
+
SampleRateChanged (); // emit a signal
}
if (_current_state->buffer_size != new_buffer_size) {
_current_state->buffer_size = new_buffer_size;
}
-
+
BufferSizeChanged (); // emit a signal
}
EngineStateController::_on_device_list_change ()
{
bool current_device_disconnected = false;
-
+
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
std::vector<AudioBackend::DeviceStatus> device_vector = backend->enumerate_devices ();
-
+
// find out out if current device is still available if it's not None
if (_current_state->device_name != "None")
{
std::vector<AudioBackend::DeviceStatus>::iterator device_iter;
device_iter = std::find_if (device_vector.begin (), device_vector.end (), DevicePredicate (_current_state->device_name));
-
+
// if current device is not available any more - switch to None device
if (device_iter == device_vector.end ()) {
-
+
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (_current_state->backend_name, "None"));
-
+
if (found_state_iter != _states.end ()) {
// found the record - switch to it
_current_state = *found_state_iter;
_validate_current_device_state ();
_states.push_front (_current_state);
}
-
+
push_current_state_to_backend (true);
current_device_disconnected = true;
}
} else {
// if the device which was active before is available now - switch to it
-
+
std::vector<AudioBackend::DeviceStatus>::iterator device_iter;
device_iter = std::find_if (device_vector.begin (), device_vector.end (), DevicePredicate (_last_used_real_device));
-
+
if (device_iter != device_vector.end ()) {
StateList::iterator found_state_iter = find_if (_states.begin (), _states.end (),
State::StatePredicate (_current_state->backend_name,
_last_used_real_device));
-
+
if (found_state_iter != _states.end ()) {
-
+
boost::shared_ptr<State> previous_state (_current_state);
_current_state = *found_state_iter;
-
+
if (_validate_current_device_state ()) {
push_current_state_to_backend (false);
} else {
}
}
}
-
- DeviceListChanged (current_device_disconnected); // emit a signal
+
+ DeviceListChanged (current_device_disconnected); // emit a signal
}
{
boost::shared_ptr<AudioBackend> backend = AudioEngine::instance ()->current_backend ();
assert (backend);
-
+
// update audio input states
std::vector<std::string> phys_audio_inputs;
backend->get_physical_inputs (DataType::AUDIO, phys_audio_inputs);
-
+
PortStateList new_input_states;
PortStateList &input_states = _current_state->input_channel_states;
-
+
std::vector<std::string>::const_iterator input_iter = phys_audio_inputs.begin ();
for (; input_iter != phys_audio_inputs.end (); ++input_iter) {
-
+
PortState state (*input_iter);
state.active = true;
PortStateList::const_iterator found_state_iter = std::find (input_states.begin (), input_states.end (), state);
-
+
if (found_state_iter != input_states.end ()) {
new_input_states.push_back (*found_state_iter);
} else {
}
}
_current_state->input_channel_states = new_input_states;
-
+
// update audio output states (multi out mode)
std::vector<std::string> phys_audio_outputs;
backend->get_physical_outputs (DataType::AUDIO, phys_audio_outputs);
-
+
PortStateList new_output_states;
PortStateList &output_multi_states = _current_state->multi_out_channel_states;
-
+
std::vector<std::string>::const_iterator output_iter = phys_audio_outputs.begin ();
for (; output_iter != phys_audio_outputs.end (); ++output_iter) {
-
+
PortState state (*output_iter);
state.active = true;
PortStateList::const_iterator found_state_iter = std::find (output_multi_states.begin (), output_multi_states.end (), state);
-
+
if (found_state_iter != output_multi_states.end ()) {
new_output_states.push_back (*found_state_iter);
} else {
new_output_states.push_back (state);
}
}
-
+
_current_state->multi_out_channel_states = new_output_states;
-
+
// update audio output states (stereo out mode)
new_output_states.clear ();
PortStateList &output_stereo_states = _current_state->stereo_out_channel_states;
-
+
output_iter = phys_audio_outputs.begin ();
for (; output_iter != phys_audio_outputs.end (); ++output_iter) {
-
+
PortState state (*output_iter);
state.active = true;
PortStateList::const_iterator found_state_iter = std::find (output_stereo_states.begin (), output_stereo_states.end (), state);
-
+
if (found_state_iter != output_stereo_states.end ()) {
new_output_states.push_back (*found_state_iter);
} else {
_current_state->stereo_out_channel_states = new_output_states;
_refresh_stereo_out_channel_states ();
-
-
+
+
// update midi ports: unlike audio ports which states are saved per device
// each midi port state is saved individualy
// so get all midi ports from the backend
for (; iter != _midi_inputs.end (); ++iter) {
iter->available = false;
}
-
+
for (iter = _midi_outputs.begin (); iter != _midi_outputs.end (); ++iter) {
iter->available = false;
}
-
+
// update midi input ports
std::vector<std::string> phys_midi_inputs;
backend->get_physical_inputs (DataType::MIDI, phys_midi_inputs);
-
+
std::vector<std::string>::const_iterator midi_input_iter = phys_midi_inputs.begin ();
for (; midi_input_iter != phys_midi_inputs.end (); ++midi_input_iter) {
-
+
MidiPortState state (*midi_input_iter);
state.active = false;
state.available = true;
MidiPortStateList::iterator found_state_iter = std::find (_midi_inputs.begin (), _midi_inputs.end (), state);
-
+
if (found_state_iter != _midi_inputs.end ()) {
found_state_iter->available = true;
} else {
_midi_inputs.push_back (state);
}
}
-
+
// update midi output ports
std::vector<std::string> phys_midi_outputs;
backend->get_physical_outputs (DataType::MIDI, phys_midi_outputs);
-
+
std::vector<std::string>::const_iterator midi_output_iter = phys_midi_outputs.begin ();
for (; midi_output_iter != phys_midi_outputs.end (); ++midi_output_iter) {
-
+
MidiPortState state (*midi_output_iter);
state.active = false;
state.available = true;
MidiPortStateList::iterator found_state_iter = std::find (_midi_outputs.begin (), _midi_outputs.end (), state);
-
+
if (found_state_iter != _midi_outputs.end ()) {
found_state_iter->available = true;
} else {
break;
}
}
-
+
uint32_t pending_active_channels = 2;
PortStateList::iterator iter = output_states.begin ();
// if found active
if (++iter == output_states.end ()) {
iter = output_states.begin ();
}
-
+
(iter++)->active = true;
pending_active_channels = 0;
}
{
AudioEngine::instance ()->reconnect_session_routes (true, true);
_current_state->active = true;
-
+
EngineRunning (); // emit a signal
}
EngineStateController::_on_parameter_changed (const std::string& parameter_name)
{
if (parameter_name == "output-auto-connect") {
-
+
AudioEngine::instance ()->reconnect_session_routes (false, true);
OutputConfigChanged (); // emit a signal
OutputConnectionModeChanged (); // emit signal
EngineStateController::_on_ports_registration_update ()
{
_update_device_channels_state ();
-
+
// update MIDI connections
if (_session) {
_session->reconnect_midi_scene_ports (true);
_session->reconnect_midi_scene_ports (false);
-
+
_session->reconnect_mtc_ports ();
-
+
_session->reconnect_mmc_ports (true);
_session->reconnect_mmc_ports (false);
-
+
_session->reconnect_ltc_input ();
_session->reconnect_ltc_output ();
}
-
+
_update_ltc_source_port ();
_update_ltc_output_port ();
-
+
PortRegistrationChanged (); // emit a signal
}
if (!backend) {
return false;
}
-
+
// check if anything changed
bool state_changed = (_current_state->device_name != backend->device_name ()) ||
(_current_state->sample_rate != backend->sample_rate ()) ||
(_current_state->buffer_size != backend->buffer_size ());
-
+
bool was_running = AudioEngine::instance ()->running ();
-
+
Glib::Threads::RecMutex::Lock sl (AudioEngine::instance ()->state_lock ());
if (state_changed) {
if (was_running) {
-
+
if (_current_state->device_name != backend->device_name ()) {
// device has been changed
// the list of ports has been changed too
set_ltc_source_port ("");
set_ltc_output_port ("");
}
-
+
if (AudioEngine::instance ()->stop ()) {
return false;
}
if ((_current_state->device_name != backend->device_name ()) && (result = backend->set_device_name (_current_state->device_name))) {
error << string_compose (_("Cannot set device name to %1"), get_current_device_name ()) << endmsg;
}
-
+
if (!result ) {
std::cout << "EngineStateController::Setting device sample rate " << _current_state->sample_rate << std::endl;
result = backend->set_sample_rate (_current_state->sample_rate);
error << string_compose (_("Cannot set sample rate to %1"), get_current_sample_rate ()) << endmsg;
}
}
-
+
if (!result ) {
std::cout << "EngineStateController::Setting device buffer size " << _current_state->buffer_size << std::endl;
result = backend->set_buffer_size (_current_state->buffer_size);
}
}
}
-
+
if (result) // error during device setup
{
//switch to None device and notify about the issue
return true;
}
}
-
+
if (start || (was_running && state_changed)) {
if (AudioEngine::instance ()->start () && !AudioEngine::instance ()->is_reset_requested ()) {
//switch to None device and notify about the issue
return false;
}
}
-
+
save_audio_midi_settings ();
-
+
return true;
}
return (state_iter->name);
}
}
-
+
return "";
}
REGISTER (_RemoteModel);
/*
* EditorOrdered has been deprecated
- * since the removal of independent
+ * since the removal of independent
* editor / mixer ordering.
*/
enum_writer.add_to_hack_table ("EditorOrdered", "MixerOrdered");
REGISTER_ENUM (UseDefaultNames);
REGISTER_ENUM (NameAfterDriver);
REGISTER_BITS (_TracksAutoNamingRule);
-
+
REGISTER_ENUM (FormatFloat);
REGISTER_ENUM (FormatInt24);
REGISTER_ENUM (FormatInt16);
}
}
-RegionExportChannelFactory::RegionExportChannelFactory (Session * session, AudioRegion const & region, AudioTrack & track, Type type)
+RegionExportChannelFactory::RegionExportChannelFactory (Session * session, AudioRegion const & region, AudioTrack & track, Type type)
: region (region)
, track (track)
, type (type)
/*
- Copyright (C) 2008-2012 Paul Davis
+ Copyright (C) 2008-2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
ExportGraphBuilder::cleanup (bool remove_out_files/*=false*/)
{
ChannelConfigList::iterator iter = channel_configs.begin();
-
+
while (iter != channel_configs.end() ) {
iter->remove_children(remove_out_files);
iter = channel_configs.erase(iter);
}
}
-
+
void
ExportGraphBuilder::set_current_timespan (boost::shared_ptr<ExportTimespan> span)
{
// No duplicate channel config found, create new one
channel_configs.push_back (new ChannelConfig (*this, config, channels));
}
-
+
/* Encoder */
template <>
{
filenames.push_back (new_config.filename);
}
-
+
void
ExportGraphBuilder::Encoder::destroy_writer (bool delete_out_file)
{
if (delete_out_file ) {
-
+
if (float_writer) {
float_writer->close ();
}
-
+
if (int_writer) {
int_writer->close ();
}
-
+
if (short_writer) {
short_writer->close ();
}
std::cout << "Encoder::destroy_writer () : Error removing file: " << strerror(errno) << std::endl;
}
}
-
+
float_writer.reset ();
int_writer.reset ();
short_writer.reset ();
ExportGraphBuilder::SFC::remove_children (bool remove_out_files)
{
boost::ptr_list<Encoder>::iterator iter = children.begin ();
-
+
while (iter != children.end() ) {
-
+
if (remove_out_files) {
iter->destroy_writer(remove_out_files);
}
iter = children.erase (iter);
}
}
-
+
bool
ExportGraphBuilder::SFC::operator== (FileSpec const & other_config) const
{
ExportGraphBuilder::Normalizer::remove_children (bool remove_out_files)
{
boost::ptr_list<SFC>::iterator iter = children.begin ();
-
+
while (iter != children.end() ) {
iter->remove_children (remove_out_files);
iter = children.erase (iter);
}
}
-
+
bool
ExportGraphBuilder::Normalizer::operator== (FileSpec const & other_config) const
{
add_child_to_list (new_config, children);
}
}
-
+
void
ExportGraphBuilder::SRC::remove_children (bool remove_out_files)
{
boost::ptr_list<SFC>::iterator sfc_iter = children.begin();
-
+
while (sfc_iter != children.end() ) {
converter->remove_output (sfc_iter->sink() );
sfc_iter->remove_children (remove_out_files);
sfc_iter = children.erase (sfc_iter);
}
-
+
boost::ptr_list<Normalizer>::iterator norm_iter = normalized_children.begin();
-
+
while (norm_iter != normalized_children.end() ) {
converter->remove_output (norm_iter->sink() );
norm_iter->remove_children (remove_out_files);
children.push_back (new SRC (parent, new_config, max_frames_in));
silence_trimmer->add_output (children.back().sink());
}
-
+
void
ExportGraphBuilder::SilenceHandler::remove_children (bool remove_out_files)
{
boost::ptr_list<SRC>::iterator iter = children.begin();
-
+
while (iter != children.end() ) {
silence_trimmer->remove_output (iter->sink() );
iter->remove_children (remove_out_files);
children.push_back (new SilenceHandler (parent, new_config, max_frames_out));
chunker->add_output (children.back().sink ());
}
-
+
void
ExportGraphBuilder::ChannelConfig::remove_children (bool remove_out_files)
{
boost::ptr_list<SilenceHandler>::iterator iter = children.begin();
-
+
while(iter != children.end() ) {
-
+
chunker->remove_output (iter->sink ());
iter->remove_children (remove_out_files);
iter = children.erase(iter);
MOTOROLA = "header-less" audio (44.1 kHz, 16 Bit, big endian),
and MP3
- We try to use these file types whenever appropriate and
+ We try to use these file types whenever appropriate and
default to our own names otherwise.
*/
status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
}
// does not do much mor than UTF-8 to Latin1 translation yet, but
- // that may have to change if cue parsers in burning programs change
+ // that may have to change if cue parsers in burning programs change
out = '"' + latin1_txt + '"';
return out;
/*
- Copyright (C) 2008-2012 Paul Davis
+ Copyright (C) 2008-2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
keeppath = de_duped_hits[0];
}
-
+
} else {
keeppath = path;
}
return -1;
}
- if (Glib::file_test (oldpath.c_str(), Glib::FILE_TEST_EXISTS)) {
+ if (Glib::file_test (oldpath.c_str(), Glib::FILE_TEST_EXISTS)) {
/* rename only needed if file exists on disk */
if (::rename (oldpath.c_str(), newpath.c_str()) != 0) {
error << string_compose (_("cannot rename file %1 to %2 (%3)"), oldpath, newpath, strerror(errno)) << endmsg;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
/* ARDOUR::Profile may not be available when this is
- called, so rely on build-time detection of the
+ called, so rely on build-time detection of the
product name etc.
*/
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#ifdef check
#undef check /* stupid Apple and their un-namespaced, generic Carbon macros */
-#endif
+#endif
#include <glibmm/fileutils.h>
#include <glibmm/miscutils.h>
how many more per-thread buffer sets we need above
the h/w concurrency, but its definitely > 1 more.
*/
- BufferManager::init (hardware_concurrency() + 4);
+ BufferManager::init (hardware_concurrency() + 4);
PannerManager::instance().discover_panners();
/* it is unfortunate that we need to include reserved names here that
refer to control surfaces. But there's no way to ensure a complete
lack of collisions without doing this, since the control surface
- support may not even be active. Without adding an API to control
+ support may not even be active. Without adding an API to control
surface support that would list their port names, we do have to
list them here.
*/
}
void
-ARDOUR::cleanup ()
+ARDOUR::cleanup ()
{
if (!libardour_initialized) {
return;
#include <mach/mach_time.h>
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 0
-int
+int
clock_gettime (int /*clk_id*/, struct timespec *t)
{
static bool initialized = false;
return 0;
}
#endif
-
+
microseconds_t
ARDOUR::get_microseconds ()
{
MIDI::Name::PatchPrimaryKey patch_key (program, bank);
boost::shared_ptr<MIDI::Name::Patch> patch =
- MIDI::Name::MidiPatchManager::instance().find_patch (external_instrument_model,
+ MIDI::Name::MidiPatchManager::instance().find_patch (external_instrument_model,
external_instrument_mode, channel, patch_key);
if (patch) {
{
if (_gm_patches.empty()) {
for (int n = 0; n < 128; n++) {
- _gm_patches.push_back (boost::shared_ptr<Patch> (new Patch (general_midi_program_names[n], n)));
+ _gm_patches.push_back (boost::shared_ptr<Patch> (new Patch (general_midi_program_names[n], n)));
}
}
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
size_t len1;
size_t len2;
- /*Try and load the shared library pointed to by the path -
+ /*Try and load the shared library pointed to by the path -
NOTE: You have to give RTLD_LAZY or RTLD_NOW to dlopen or
you get some occasional failures to load - dlerror reports
invalid arguments*/
return 0;
}
- if ((vstfx->plugin = fhandle->main_entry (amc)) == 0)
+ if ((vstfx->plugin = fhandle->main_entry (amc)) == 0)
{
vstfx_error ("** ERROR ** VSTFX : %s could not be instantiated :(\n", fhandle->name);
free (vstfx);
if (vstfx->handle->plugincnt)
vstfx->handle->plugincnt--;
- /*vstfx_unload will unload the dll if the instance count allows -
+ /*vstfx_unload will unload the dll if the instance count allows -
we need to do this because some plugins keep their own instance count
and (JUCE) manages the plugin UI in its own thread. When the plugins
internal instance count reaches zero, JUCE stops the UI thread and won't
}
-bool
+bool
vstfx_save_state (VSTState* vstfx, char * filename)
{
FILE* f = g_fopen (filename, "wb");
//g_free( encoded );
}
}
- }
+ }
fprintf( f, "</plugin_state>\n" );
fclose( f );
/*Set up a call to the plugins 'dispatcher' function*/
-int vstfx_call_dispatcher (VSTState* vstfx, int opcode, int index, int val, void *ptr, float opt)
+int vstfx_call_dispatcher (VSTState* vstfx, int opcode, int index, int val, void *ptr, float opt)
{
pthread_mutex_lock (&vstfx->lock);
void
Location::set_name (const std::string& str)
-{
- _name = str;
+{
+ _name = str;
name_changed (this); /* EMIT SIGNAL */
NameChanged (); /* EMIT SIGNAL */
if (e - s < Config->get_range_location_minimum()) {
return -1;
}
-
+
if (s != _start) {
framepos_t const old = _start;
}
start_change = true;
-
+
if (is_session_range ()) {
Session::StartTimeChanged (old); /* EMIT SIGNAL */
AudioFileSource::set_header_position_offset (s);
}
}
-
-
+
+
if (e != _end) {
-
+
framepos_t const old = _end;
_end = e;
if (allow_bbt_recompute) {
recompute_bbt_from_frames ();
}
-
+
end_change = true;
if (is_session_range()) {
if (_scene_change != sc) {
_scene_change = sc;
_session.set_dirty ();
-
+
scene_changed (); /* EMIT SIGNAL */
SceneChangeChanged (); /* EMIT SIGNAL */
}
l = base.length();
if (!base.empty()) {
-
+
/* find all existing names that match "base", and store
the numeric part of them (if any) in the map "taken"
*/
for (i = locations.begin(); i != locations.end(); ++i) {
const string& temp ((*i)->name());
-
+
if (!temp.find (base,0)) {
/* grab what comes after the "base" as if it was
a number, and assuming that works OK,
was deleted.
This must start at 1, both for human-numbering reasons
- and also because the call to atoi() above would return
+ and also because the call to atoi() above would return
zero if there is no recognizable numeric suffix, causing
"base 0" not to be inserted into the "taken" map.
*/
- n = 1;
+ n = 1;
while (n < UINT32_MAX) {
if (taken.find (n) == taken.end()) {
}
++n;
}
-
+
return 0;
}
i = tmp;
}
}
-
+
changed (); /* EMIT SIGNAL */
}
if (was_removed) {
removed (loc); /* EMIT SIGNAL */
-
+
if (was_current) {
current_changed (0); /* EMIT SIGNAL */
}
if (i != locations.end()) {
/* we can re-use an old Location object */
loc = *i;
-
+
// changed locations will be updated by Locations::changed signal
loc->set_state (**niter, version);
} else {
for (LocationList::const_iterator i = locations.begin(); i != locations.end(); ++i) {
if ((*i)->is_mark()) {
- if (pos > (*i)->start()) {
+ if (pos > (*i)->start()) {
delta = pos - (*i)->start();
} else {
delta = (*i)->start() - pos;
vstfx_close (_state);
}
-PluginPtr
+PluginPtr
LXVSTPluginInfo::load (Session& session)
{
try {
#endif
if (_size + stamp_size + size >= _capacity) {
- cerr << "MidiBuffer::push_back2 failed (buffer is full; _size = " << _size << " capacity "
+ cerr << "MidiBuffer::push_back2 failed (buffer is full; _size = " << _size << " capacity "
<< _capacity << " stamp " << stamp_size << " size = " << size << ")" << endl;
PBD::stacktrace (cerr, 20);
return false;
/* two events at identical times. we need to determine
the order in which they should occur.
-
+
the rule is:
-
+
Controller messages
Program Change
Note Off
* if "sz" is non-zero, there is data to be merged from "other"
* into this buffer before we do anything else, corresponding
* to the events from "other" that we skipped while advancing
- * "them".
+ * "them".
*/
if (bytes_to_merge) {
memcpy (_data + us.offset, other._data + merge_offset, bytes_to_merge);
/* update iterator to our own events. this is a miserable hack */
us.offset += bytes_to_merge;
- }
+ }
/* if we're at the end of the other buffer, we're done */
if ((*us).time() == (*them).time()) {
- DEBUG_TRACE (DEBUG::MidiIO,
+ DEBUG_TRACE (DEBUG::MidiIO,
string_compose ("simultaneous MIDI events discovered during merge, times %1/%2 status %3/%4\n",
(*us).time(), (*them).time(),
(int) *(_data + us.offset + sizeof (TimeType)),
if (them_first) {
/* need to skip the event pointed to by 'us'
since its at the same time as 'them'
- (still), and we'll enter
+ (still), and we'll enter
*/
if (us != end()) {
_size += other._size - them.offset;
assert(_size <= _capacity);
break;
- }
+ }
}
return true;
const framecnt_t total = g_atomic_int_get(const_cast<gint*> (&_frames_pending_write));
- if (total == 0 ||
- _capture_buf->read_space() == 0 ||
+ if (total == 0 ||
+ _capture_buf->read_space() == 0 ||
(!force_flush && (total < disk_write_chunk_frames) && was_recording)) {
goto out;
}
if (_write_source->midi_write (lm, *_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
return -1;
- }
+ }
g_atomic_int_add(const_cast<gint*> (&_frames_pending_write), -to_write);
}
MidiDiskstream::playback_buffer_load () const
{
/* For MIDI it's not trivial to differentiate the following two cases:
-
+
1. The playback buffer is empty because the system has run out of time to fill it.
2. The playback buffer is empty because there is no more data on the playlist.
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
"%1 MDS pre-read read %8 @ %4..%5 from %2 write to %3, LOOPED ? %6-%7\n", _name,
- _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
+ _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes,
(loc ? loc->start() : -1), (loc ? loc->end() : -1), nframes));
// cerr << "================\n";
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #1, from %1 for %2\n",
effective_start, first));
events_read = _playback_buf->read (dst, effective_start, first);
- }
+ }
if (second) {
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #2, from %1 for %2\n",
loc->start(), second));
events_read += _playback_buf->read (dst, loc->start(), second);
}
-
+
} else {
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose ("loop read #3, adjusted start as %1 for %2\n",
effective_start, nframes));
assert (prop);
Evoral::event_id_t const id = atoi (prop->value().c_str());
- /* we need to load via an int intermediate for all properties that are
+ /* we need to load via an int intermediate for all properties that are
actually uint8_t (char/byte).
*/
<< endmsg;
continue;
}
-
+
_documents[device->first] = document;
_master_devices_by_model[device->first] = device->second;
<< _global_port_buffer_offset << " limit="
<< (_global_port_buffer_offset + _port_buffer_offset + nframes) << "\n";
}
- }
+ }
} else {
_buffer->silence (nframes);
/* resolve all notes at the start of the buffer */
resolve_notes (port_buffer, 0);
_resolve_required = false;
- }
+ }
if (_buffer->empty()) {
return;
}
}
- /* done.. the data has moved to the port buffer, mark it so
+ /* done.. the data has moved to the port buffer, mark it so
*/
_buffer->clear ();
this->increment_read_ptr (prefix_size);
uint8_t status;
- bool r = this->peek (&status, sizeof(uint8_t));
+ bool r = this->peek (&status, sizeof(uint8_t));
assert (r); // If this failed, buffer is corrupt, all hope is lost
/* lets see if we are going to be able to write this event into dst.
, last_program_message_time (-1)
, last_delivered_program (-1)
, last_delivered_bank (-1)
-
+
{
/* catch any add/remove/clear etc. for all Locations */
_session.locations()->changed.connect_same_thread (*this, boost::bind (&MIDISceneChanger::locations_changed, this));
}
/** Use the session's list of locations to collect all patch changes.
- *
+ *
* This is called whenever the locations change in anyway.
*/
void
non-RT/process context. Using zero means "deliver them as early as
possible" (practically speaking, in the next process callback).
*/
-
+
MIDIOutputActivity (); /* EMIT SIGNAL */
if ((cnt = msc->get_bank_msb_message (buf, sizeof (buf))) > 0) {
}
bool
-MIDISceneChanger::recording() const
+MIDISceneChanger::recording() const
{
return _session.transport_rolling() && _session.get_record_enabled();
}
if (!recording()) {
MIDIInputActivity (); /* EMIT SIGNAL */
-
+
int bank = -1;
if (have_seen_bank_changes) {
bank = input_port->channel (channel)->bank();
}
-
+
jump_to (bank, program);
return;
}
}
DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1 OFF %2/%3 current voices = %5 total on %4\n",
- this, (int) note, (int) chn, _on,
+ this, (int) note, (int) chn, _on,
(int) _active_notes[note+128 * chn]));
}
*/
dst.push_back (noteoff);
_active_notes[note + 128 * channel]--;
- DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1: MB-resolved note %2/%3 at %4\n",
+ DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1: MB-resolved note %2/%3 at %4\n",
this, (int) note, (int) channel, time));
}
}
*/
dst.write (time, midi_parameter_type (buf[0]), 3, buf);
_active_notes[note + 128 * channel]--;
- DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1: EVS-resolved note %2/%3 at %4\n",
+ DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1: EVS-resolved note %2/%3 at %4\n",
this, (int) note, (int) channel, time));
}
}
ev.set_note (note);
ev.set_velocity (0);
src.append_event_beats (lock, ev);
- DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1: MS-resolved note %2/%3 at %4\n",
+ DEBUG_TRACE (PBD::DEBUG::MidiTrackers, string_compose ("%1: MS-resolved note %2/%3 at %4\n",
this, (int) note, (int) channel, time));
_active_notes[note + 128 * channel]--;
/* don't stack events up at the same time */
diskstream->flush_playback (start_frame, end_frame);
- }
+ }
/* append immediate messages to the first MIDI buffer (thus sending it to the first output port) */
MonitorState ms = Track::monitoring_state();
if (ms == MonitoringSilence) {
return MonitoringInput;
- }
+ }
return ms;
}
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
if (_midi_in) {
return;
}
-
+
_midi_in = AudioEngine::instance()->register_input_port (DataType::MIDI, X_("MIDI control in"), true);
_midi_out = AudioEngine::instance()->register_output_port (DataType::MIDI, X_("MIDI control out"), true);
/* XXX nasty type conversion needed because of the mixed inheritance
* required to integrate MIDI::IPMidiPort and ARDOUR::AsyncMIDIPort.
*
- * At some point, we'll move IPMidiPort into Ardour and make it
+ * At some point, we'll move IPMidiPort into Ardour and make it
* inherit from ARDOUR::MidiPort not MIDI::Port, and then this
- * mess can go away
+ * mess can go away
*/
_midi_input_port = boost::dynamic_pointer_cast<AsyncMIDIPort>(_midi_in).get();
, _dim_all_ptr (new MPControl<bool> (false, _("monitor dim"), Controllable::Toggle))
, _cut_all_ptr (new MPControl<bool> (false, _("monitor cut"), Controllable::Toggle))
, _mono_ptr (new MPControl<bool> (false, _("monitor mono"), Controllable::Toggle))
- , _dim_level_ptr (new MPControl<volatile gain_t>
+ , _dim_level_ptr (new MPControl<volatile gain_t>
/* default is -12dB, range is -20dB to 0dB */
- (dB_to_coefficient(-12.0), _("monitor dim level"), Controllable::Flag (0),
+ (dB_to_coefficient(-12.0), _("monitor dim level"), Controllable::Flag (0),
dB_to_coefficient(-20.0), dB_to_coefficient (0.0)))
- , _solo_boost_level_ptr (new MPControl<volatile gain_t>
+ , _solo_boost_level_ptr (new MPControl<volatile gain_t>
/* default is 0dB, range is 0dB to +20dB */
- (dB_to_coefficient(0.0), _("monitor solo boost level"), Controllable::Flag (0),
+ (dB_to_coefficient(0.0), _("monitor solo boost level"), Controllable::Flag (0),
dB_to_coefficient(0.0), dB_to_coefficient(10.0)))
, _dim_all_control (_dim_all_ptr)
, _cut_all_control (_cut_all_ptr)
LIBARDOUR_API int LIBARDOUR_APICALLTYPE
symlink(const char *dest, const char *shortcut, const char *working_directory /*= NULL */)
{
-IShellLinkA *pISL = NULL;
+IShellLinkA *pISL = NULL;
IPersistFile *ppf = NULL;
int ret = (-1);
LIBARDOUR_API int LIBARDOUR_APICALLTYPE
readlink(const char *__restrict shortcut, char *__restrict buf, size_t bufsize)
{
-IShellLinkA *pISL = NULL;
+IShellLinkA *pISL = NULL;
IPersistFile *ppf = NULL;
int ret = (-1);
// Read the target information from the shortcut object
if (S_OK == (pISL->GetPath (target_path, _MAX_PATH, NULL, SLGP_UNCPRIORITY)))
{
- strncpy(buf, target_path, bufsize);
+ strncpy(buf, target_path, bufsize);
ret = ((ret = strlen(buf)) > bufsize) ? bufsize : ret;
// _set_errno(0);
}
read_current (&last);
DEBUG_TRACE (DEBUG::MTC, string_compose ("speed&pos: timestamp %1 speed %2 initstate %3 dir %4 tpos %5 now %6 last-in %7\n",
- last.timestamp,
+ last.timestamp,
last.speed,
engine_dll_initstate,
transport_direction,
last_inbound_frame));
/* re-init engine DLL here when state changed (direction, first_mtc_timestamp) */
- if (last.timestamp == 0) {
- engine_dll_initstate = 0;
+ if (last.timestamp == 0) {
+ engine_dll_initstate = 0;
} else if (engine_dll_initstate != transport_direction && last.speed != 0) {
engine_dll_initstate = transport_direction;
init_engine_dll(last.position, session.engine().samples_per_cycle());
#include "ardour/mtdm.h"
-MTDM::MTDM (int fsamp)
+MTDM::MTDM (int fsamp)
: _cnt (0)
, _inv (0)
{
_freq [2].f = 3072;
_freq [3].f = 2560;
_freq [4].f = 2304;
- _freq [5].f = 2176;
+ _freq [5].f = 2176;
_freq [6].f = 1088;
_freq [7].f = 1312;
_freq [8].f = 1552;
vip = *ip++;
for (i = 0, F = _freq; i < 13; i++, F++)
{
- a = 2 * (float) M_PI * (F->p & 65535) / 65536.0;
+ a = 2 * (float) M_PI * (F->p & 65535) / 65536.0;
F->p += F->f;
- c = cosf (a);
- s = -sinf (a);
+ c = cosf (a);
+ s = -sinf (a);
vop += (i ? 0.01f : 0.20f) * s;
F->xa += s * vip;
F->ya += c * vip;
- }
+ }
*op++ = vop;
if (++_cnt == 16)
{
k = (int)(floor (p + 0.5));
e = fabs (p - k);
if (e > _err) _err = e;
- if (e > 0.4) return 1;
+ if (e > 0.4) return 1;
d += m * (k & 1);
m *= 2;
- }
+ }
_del = 16 * d;
return 0;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
while (itimes--) {
for (RegionList::iterator i = other->regions.begin(); i != other->regions.end(); ++i) {
boost::shared_ptr<Region> copy_of_region = RegionFactory::create (*i, true);
-
+
/* put these new regions on top of all existing ones, but preserve
the ordering they had in the original playlist.
*/
-
+
add_region_internal (copy_of_region, (*i)->position() + pos);
set_layer (copy_of_region, copy_of_region->layer() + top);
}
if (_edit_mode == Splice) {
splice_locked (at, distance, exclude);
- }
+ }
}
void
new_pos = 0;
} else if (new_pos >= limit ) {
new_pos = limit;
- }
+ }
(*i)->set_position (new_pos);
}
}
mark_session_dirty ();
-
+
return save;
}
if (ac) {
ac->set_value (val);
-
+
Plugins::iterator i = _plugins.begin();
-
+
/* don't set the first plugin, just all the slaves */
-
+
if (i != _plugins.end()) {
++i;
for (; i != _plugins.end(); ++i) {
plugin->set_insert_id (this->id());
if (_plugins.empty()) {
- /* first (and probably only) plugin instance - connect to relevant signals
+ /* first (and probably only) plugin instance - connect to relevant signals
*/
plugin->ParameterChanged.connect_same_thread (*this, boost::bind (&PluginInsert::parameter_changed, this, _1, _2));
{
if (_port_handle) {
return (port_engine.connected (_port_handle) != 0);
- }
+ }
return false;
}
port_engine.disconnect_all (_port_handle);
_connections.clear ();
- /* a cheaper, less hacky way to do boost::shared_from_this() ...
+ /* a cheaper, less hacky way to do boost::shared_from_this() ...
*/
boost::shared_ptr<Port> pself = port_manager->get_port_by_name (name());
PostDisconnect (pself, boost::shared_ptr<Port>()); // emit signal
Port::connected_to (std::string const & o) const
{
if (!_port_handle) {
- return false;
+ return false;
}
if (!port_engine.available()) {
_connections.erase (other);
}
- /* a cheaper, less hacky way to do boost::shared_from_this() ...
+ /* a cheaper, less hacky way to do boost::shared_from_this() ...
*/
boost::shared_ptr<Port> pself = AudioEngine::instance()->get_port_by_name (name());
boost::shared_ptr<Port> pother = AudioEngine::instance()->get_port_by_name (other);
a check on whether this may affect anything that we
need to know about.
*/
- PostDisconnect (pself, pother); // emit signal
+ PostDisconnect (pself, pother); // emit signal
}
return r;
}
_backend->get_physical_outputs (type, s);
}
-
+
void
PortManager::get_physical_inputs (DataType type, std::vector<std::string>& s)
{
_backend->get_physical_inputs (type, s);
}
-
+
ChanCount
PortManager::n_physical_outputs () const
{
return _backend->n_physical_outputs ();
}
-
+
ChanCount
PortManager::n_physical_inputs () const
{
for (Ports::const_iterator x = pr->begin(); x != pr->end(); ++x) {
- string prefix = x->first.substr (0, len);
+ string prefix = x->first.substr (0, len);
if (strings_equal_ignore_case (prefix, first_part_of_port_name)) {
return false;
return _backend->can_monitor_input ();
}
-
+
void
PortManager::request_input_monitoring (const string& name, bool yn) const
{
_backend->request_input_monitoring (ph, yn);
}
}
-
+
void
PortManager::ensure_input_monitoring (const string& name, bool yn) const
{
* if the start grid is 1.0, the beat at 0 isn't swung,
* but the beat at 1.0 is. the beat at 2.0 isn't swung,
* but the beat at 3.0 is. and so on.
- *
+ *
* so the criterion for a position being swung is
* whether or not ((possible_grid_position / grid) % 2) != 0
*/
/* compute new start + end points WITHOUT the offset
* caused by the start of the model (see above).
- *
+ *
* these versions of new_start and new_end are
* guaranteed to precisely align with the quantize grid(s).
*/
void
Route::set_remote_control_id_internal (uint32_t id, bool notify_class_listeners)
{
- /* force IDs for master/monitor busses and prevent
+ /* force IDs for master/monitor busses and prevent
any other route from accidentally getting these IDs
(i.e. legacy sessions)
*/
/* don't allow it to collide */
- if (!is_master () && !is_monitor() &&
+ if (!is_master () && !is_monitor() &&
(id == MasterBusRemoteControlID || id == MonitorBusRemoteControlID)) {
id += MonitorBusRemoteControlID;
}
{
if (is_master()) {
return MasterBusRemoteControlID;
- }
+ }
if (is_monitor()) {
return MonitorBusRemoteControlID;
on a transition between monitoring states we get a de-clicking gain
change in the _main_outs delivery, if config.get_use_monitor_fades()
is true.
-
+
We override this in the case where we have an internal generator.
*/
bool silence = _have_internal_generator ? false : (monitoring_state () == MonitoringSilence);
return;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1: set solo => %2, src: %3 grp ? %4 currently self-soloed ? %5\n",
name(), yn, src, (src == _route_group), self_soloed()));
if (self_soloed() != yn) {
return;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-upstream by %2, current up = %3 down = %4\n",
name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
uint32_t old_sbu = _soloed_by_others_upstream;
return;
}
- DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
+ DEBUG_TRACE (DEBUG::Solo, string_compose ("%1 mod solo-by-downstream by %2, current up = %3 down = %4\n",
name(), delta, _soloed_by_others_upstream, _soloed_by_others_downstream));
if (delta < 0) {
if (!removed) {
/* what? */
return 1;
- }
+ }
if (configure_processors_unlocked (err)) {
pstate.restore ();
}
/* make sure we have sufficient scratch buffers to cope with the new processor
- configuration
+ configuration
*/
_session.ensure_buffers (n_process_buffers ());
for (i = _processors.begin(); i != _processors.end(); ++i) {
if (!full_state) {
- /* template save: do not include internal sends functioning as
+ /* template save: do not include internal sends functioning as
aux sends because the chance of the target ID
in the session where this template is used
is not very likely.
bool need_to_queue_solo_change = true;
if ((change.type & IOChange::ConfigurationChanged)) {
- /* This is called with the process lock held if change
- contains ConfigurationChanged
+ /* This is called with the process lock held if change
+ contains ConfigurationChanged
*/
need_to_queue_solo_change = false;
configure_processors (0);
}
if ((change.type & IOChange::ConfigurationChanged)) {
- /* This is called with the process lock held if change
- contains ConfigurationChanged
+ /* This is called with the process lock held if change
+ contains ConfigurationChanged
*/
need_to_queue_solo_change = false;
configure_processors (0);
/* we'll build this new list here and then use it
*
- * TODO put the ProcessorList is on the stack for RT-safety.
+ * TODO put the ProcessorList is on the stack for RT-safety.
*/
ProcessorList new_processors;
/* ignore inactive processors and obviously ignore the main
* outs since everything has them and we don't care.
*/
-
+
if ((*i)->active() && (*i) != _main_outs && (*i)->does_routing()) {
return true;;
}
size_t n_buffers;
size_t i;
- /* MIDI
- *
+ /* MIDI
+ *
* We don't currently mix MIDI input together, so we don't need the
* complex logic of the audio case.
*/
} else {
/* on subsequent times around, merge data from
- * the port with what is already there
+ * the port with what is already there
*/
if (scaling != 1.0f) {
}
void
-RouteGroup::set_monitoring (bool yn)
+RouteGroup::set_monitoring (bool yn)
{
if (is_monitoring() == yn) {
return;
}
void
-SceneChange::set_color (uint32_t c)
+SceneChange::set_color (uint32_t c)
{
_color = c;
ColorChanged (); /* EMIT SIGNAL */
/*
- Copyright (C) 2011 Tim Mayberry
- Copyright (C) 2013 Paul Davis
+ Copyright (C) 2011 Tim Mayberry
+ Copyright (C) 2013 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
const char*
vst_search_path ()
{
- DWORD dwType = REG_SZ;
+ DWORD dwType = REG_SZ;
HKEY hKey;
- DWORD dwSize = PATH_MAX;
+ DWORD dwSize = PATH_MAX;
char* p = 0;
char* user_home = 0;
char tmp[PATH_MAX+1];
return p;
}
-#else
+#else
/* Unix-like. Probably require some OS X specific breakdown if we ever add VST
* support on that platform.
Send::name_and_id_new_send (Session& s, Role r, uint32_t& bitslot, bool ignore_bitslot)
{
if (ignore_bitslot) {
- /* this happens during initial construction of sends from XML,
+ /* this happens during initial construction of sends from XML,
before they get ::set_state() called. lets not worry about
it.
*/
, loop_changing (false)
, last_loopend (0)
, _session_dir (new SessionDirectory (fullpath))
- , _current_snapshot_name (snapshot_name)
+ , _current_snapshot_name (snapshot_name)
, state_tree (0)
, state_was_pending (false)
, _state_of_the_state (StateOfTheState(CannotSave|InitialConnecting|Loading))
* of a template.
*/
- if (!mix_template.empty()) {
+ if (!mix_template.empty()) {
if (load_state (_current_snapshot_name)) {
throw SessionException (_("Failed to load template/snapshot state"));
}
list<boost::shared_ptr<AudioTrack> > tracks;
- // Track names after driver
+ // Track names after driver
if (Config->get_tracks_auto_naming() == NameAfterDriver) {
string track_name = "";
for (std::vector<string>::size_type i = 0; i < inputs.size(); ++i) {
list<boost::shared_ptr<AudioTrack> > single_track = new_audio_track (1, 1, Normal, 0, 1, track_name);
tracks.insert(tracks.begin(), single_track.front());
- }
+ }
} else { // Default track names
tracks = new_audio_track (1, 1, Normal, 0, how_many, string());
}
* know that the engine is running, but before we either create a
* session or set state for an existing one.
*/
-
+
if (how_many_dsp_threads () > 1) {
/* For now, only create the graph if we are using >1 DSP threads, as
it is a bit slower than the old code with 1 thread.
/* Hold process lock while doing this so that we don't hear bits and
* pieces of audio as we work on each route.
*/
-
+
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
/* Connect tracks to monitor section. Note that in an
}
}
}
-
+
/* take care of our stuff first */
auto_loop_changed (location);
}
sync_locations_to_skips ();
-
+
set_dirty ();
}
++l;
continue;
}
-
+
switch (Evoral::coverage ((*l)->start(), (*l)->end(), loc->start(), loc->end())) {
case Evoral::OverlapInternal:
case Evoral::OverlapExternal:
if (location->is_auto_loop()) {
set_auto_loop_location (location);
}
-
+
if (location->is_session_range()) {
/* no need for any signal handling or event setting with the session range,
because we keep a direct reference to it and use its start/end directly.
update_skips (location, true);
}
-
+
set_dirty ();
}
set_auto_loop_location (0);
set_track_loop (false);
}
-
+
if (location->is_auto_punch()) {
set_auto_punch_location (0);
}
}
if (location->is_skip()) {
-
+
update_skips (location, false);
}
void
Session::_locations_changed (const Locations::LocationList& locations)
{
- /* There was some mass-change in the Locations object.
+ /* There was some mass-change in the Locations object.
We might be re-adding a location here but it doesn't actually matter
for all the locations that the Session takes an interest in.
* routes directly or indirectly feed them. This information
* is used by the solo code.
*/
-
+
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
/* Clear out the route's list of direct or indirect feeds */
* @param instrument plugin info for the instrument to insert pre-fader, if any
*/
list<boost::shared_ptr<MidiTrack> >
-Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
+Session::new_midi_track (const ChanCount& input, const ChanCount& output, boost::shared_ptr<PluginInfo> instrument,
TrackMode mode, RouteGroup* route_group, uint32_t how_many, string name_template)
{
string track_name;
}
}
-#ifdef USE_TRACKS_CODE_FEATURES
+#ifdef USE_TRACKS_CODE_FEATURES
static bool
compare_routes_by_remote_id (const boost::shared_ptr<Route>& route1, const boost::shared_ptr<Route>& route2)
if (!IO::connecting_legal) {
return;
}
-
+
// if we are deleting routes we will call this once at the end
if (_route_deletion_in_progress) {
return;
}
-
+
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK);
-
+
if (withLock) {
lm.acquire ();
}
-
+
// We need to disconnect the route's inputs and outputs first
// basing on autoconnect configuration
bool reconnectIputs = !(Config->get_input_auto_connect() & ManualConnect) && reconnect_inputs;
bool reconnectOutputs = !(Config->get_output_auto_connect() & ManualConnect) && reconnect_outputs;
-
+
ChanCount existing_inputs;
ChanCount existing_outputs;
count_existing_track_channels (existing_inputs, existing_outputs);
-
+
//ChanCount inputs = ChanCount::ZERO;
//ChanCount outputs = ChanCount::ZERO;
-
+
RouteList existing_routes = *routes.reader ();
existing_routes.sort (compare_routes_by_remote_id);
-
+
{
PBD::Unwinder<bool> protect_ignore_changes (_reconnecting_routes_in_progress, true);
vector<string> physinputs;
vector<string> physoutputs;
-
+
EngineStateController::instance()->get_physical_audio_outputs(physoutputs);
EngineStateController::instance()->get_physical_audio_inputs(physinputs);
-
+
uint32_t input_n = 0;
uint32_t output_n = 0;
RouteList::iterator rIter = existing_routes.begin();
} else if (current_output_auto_connection == AutoConnectMaster) {
(*rIter)->amp()->activate();
}
-
+
if (reconnectIputs) {
(*rIter)->input()->disconnect (this); //GZ: check this; could be heavy
-
+
for (uint32_t route_input_n = 0; route_input_n < (*rIter)->n_inputs().get(DataType::AUDIO); ++route_input_n) {
-
+
if (current_input_auto_connection & AutoConnectPhysical) {
-
+
if ( input_n == physinputs.size() ) {
break;
}
-
+
string port = physinputs[input_n];
-
+
if (port.empty() ) {
error << "Physical Input number "<< input_n << " is unavailable and cannot be connected" << endmsg;
}
-
+
//GZ: check this; could be heavy
(*rIter)->input()->connect ((*rIter)->input()->ports().port(DataType::AUDIO, route_input_n), port, this);
++input_n;
}
}
}
-
+
if (reconnectOutputs) {
-
+
//normalize route ouptuts: reduce the amount outputs to be equal to the amount of inputs
if (current_output_auto_connection & AutoConnectPhysical) {
-
+
//GZ: check this; could be heavy
(*rIter)->output()->disconnect (this);
size_t route_inputs_count = (*rIter)->n_inputs().get(DataType::AUDIO);
-
+
//GZ: check this; could be heavy
(*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, route_inputs_count), false, this );
-
+
} else if (current_output_auto_connection & AutoConnectMaster){
-
+
if (!reconnect_master) {
continue;
}
-
+
//GZ: check this; could be heavy
(*rIter)->output()->disconnect (this);
-
+
if (_master_out) {
uint32_t master_inputs_count = _master_out->n_inputs().get(DataType::AUDIO);
(*rIter)->output()->ensure_io(ChanCount(DataType::AUDIO, master_inputs_count), false, this );
break;
}
}
-
+
for (uint32_t route_output_n = 0; route_output_n < (*rIter)->n_outputs().get(DataType::AUDIO); ++route_output_n) {
if (current_output_auto_connection & AutoConnectPhysical) {
-
+
if ( output_n == physoutputs.size() ) {
break;
}
-
+
string port = physoutputs[output_n];
-
+
if (port.empty() ) {
error << "Physical Output number "<< output_n << " is unavailable and cannot be connected" << endmsg;
}
-
+
//GZ: check this; could be heavy
(*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
++output_n;
-
+
} else if (current_output_auto_connection & AutoConnectMaster) {
-
+
if ( route_output_n == _master_out->n_inputs().get(DataType::AUDIO) ) {
break;
}
-
+
// connect to master bus
string port = _master_out->input()->ports().port(DataType::AUDIO, route_output_n)->name();
-
+
if (port.empty() ) {
error << "MasterBus Input number "<< route_output_n << " is unavailable and cannot be connected" << endmsg;
}
-
-
+
+
//GZ: check this; could be heavy
(*rIter)->output()->connect ((*rIter)->output()->ports().port(DataType::AUDIO, route_output_n), port, this);
-
+
}
}
}
-
+
//auto_connect_route (*rIter, inputs, outputs, false, reconnectIputs);
}
-
+
_master_out->output()->disconnect (this);
auto_connect_master_bus ();
}
-
+
graph_reordered ();
-
+
session_routes_reconnected (); /* EMIT SIGNAL */
}
Session::reconnect_midi_scene_ports(bool inputs)
{
if (inputs ) {
-
+
boost::shared_ptr<MidiPort> scene_in_ptr = scene_in();
if (scene_in_ptr) {
scene_in_ptr->disconnect_all ();
-
+
std::vector<EngineStateController::MidiPortState> midi_port_states;
EngineStateController::instance()->get_physical_midi_input_states (midi_port_states);
-
+
std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
-
+
for (; state_iter != midi_port_states.end(); ++state_iter) {
if (state_iter->active && state_iter->available && state_iter->scene_connected) {
scene_in_ptr->connect (state_iter->name);
}
} else {
-
+
boost::shared_ptr<MidiPort> scene_out_ptr = scene_out();
-
+
if (scene_out_ptr ) {
scene_out_ptr->disconnect_all ();
std::vector<EngineStateController::MidiPortState> midi_port_states;
EngineStateController::instance()->get_physical_midi_output_states (midi_port_states);
-
+
std::vector<EngineStateController::MidiPortState>::iterator state_iter = midi_port_states.begin();
-
+
for (; state_iter != midi_port_states.end(); ++state_iter) {
if (state_iter->active && state_iter->available && state_iter->scene_connected) {
scene_out_ptr->connect (state_iter->name);
Session::reconnect_mmc_ports(bool inputs)
{
if (inputs ) { // get all enabled midi input ports
-
+
boost::shared_ptr<MidiPort> mmc_in_ptr = _midi_ports->mmc_in();
if (mmc_in_ptr) {
mmc_in_ptr->disconnect_all ();
std::vector<std::string> enabled_midi_inputs;
EngineStateController::instance()->get_physical_midi_inputs (enabled_midi_inputs);
-
+
std::vector<std::string>::iterator port_iter = enabled_midi_inputs.begin();
-
+
for (; port_iter != enabled_midi_inputs.end(); ++port_iter) {
mmc_in_ptr->connect (*port_iter);
}
}
} else { // get all enabled midi output ports
-
+
boost::shared_ptr<MidiPort> mmc_out_ptr = _midi_ports->mmc_out();
if (mmc_out_ptr ) {
mmc_out_ptr->disconnect_all ();
std::vector<std::string> enabled_midi_outputs;
EngineStateController::instance()->get_physical_midi_outputs (enabled_midi_outputs);
-
+
std::vector<std::string>::iterator port_iter = enabled_midi_outputs.begin();
-
+
for (; port_iter != enabled_midi_outputs.end(); ++port_iter) {
mmc_out_ptr->connect (*port_iter);
}
* @param name_template string to use for the start of the name, or "" to use "Audio".
*/
list< boost::shared_ptr<AudioTrack> >
-Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
+Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group,
uint32_t how_many, string name_template)
{
string track_name;
reassign_track_numbers();
update_route_record_state ();
-
+
RouteAdded (new_routes); /* EMIT SIGNAL */
}
{ // RCU Writer scope
RCUWriter<RouteList> writer (routes);
boost::shared_ptr<RouteList> rs = writer.get_copy ();
-
-
+
+
for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
-
+
if (*iter == _master_out) {
continue;
}
-
+
(*iter)->set_solo (false, this);
-
+
rs->remove (*iter);
-
+
/* deleting the master out seems like a dumb
idea, but its more of a UI policy issue
than our concern.
*/
-
+
if (*iter == _master_out) {
_master_out = boost::shared_ptr<Route> ();
}
-
+
if (*iter == _monitor_out) {
_monitor_out.reset ();
}
// We need to disconnect the route's inputs and outputs
-
+
(*iter)->input()->disconnect (0);
(*iter)->output()->disconnect (0);
-
+
/* if the route had internal sends sending to it, remove them */
if ((*iter)->internal_return()) {
-
+
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
boost::shared_ptr<Send> s = (*i)->internal_send_for (*iter);
}
}
}
-
+
/* if the monitoring section had a pointer to this route, remove it */
if (_monitor_out && !(*iter)->is_master() && !(*iter)->is_monitor()) {
Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
PBD::Unwinder<bool> uw (ignore_route_processor_changes, true);
(*iter)->remove_aux_or_listen (_monitor_out);
}
-
+
boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (*iter);
if (mt && mt->step_editing()) {
if (_step_editors > 0) {
}
}
}
-
+
/* writer goes out of scope, forces route list update */
} // end of RCU Writer scope
-
+
update_route_solo_state ();
RouteAddedOrRemoved (false); /* EMIT SIGNAL */
update_latency_compensation ();
set_dirty();
-
+
/* Re-sort routes to remove the graph's current references to the one that is
* going away, then flush old references out of the graph.
* Wave Tracks: reconnect routes
routes.flush (); // maybe unsafe, see below.
resort_routes ();
#endif
-
+
if (_process_graph) {
_process_graph->clear_other_chain ();
}
-
+
/* get rid of it from the dead wood collection in the route list manager */
/* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
-
+
routes.flush ();
-
+
/* try to cause everyone to drop their references
* and unregister ports from the backend
*/
for (RouteList::iterator iter = routes_to_remove->begin(); iter != routes_to_remove->end(); ++iter) {
(*iter)->drop_references ();
}
-
+
Route::RemoteControlIDChange(); /* EMIT SIGNAL */
-
+
/* save the new state of the world */
-
+
if (save_state (_current_snapshot_name)) {
save_history (_current_snapshot_name);
}
string
Session::new_audio_source_path_for_embedded (const std::string& path)
{
- /* embedded source:
+ /* embedded source:
*
* we know that the filename is already unique because it exists
- * out in the filesystem.
+ * out in the filesystem.
*
* However, when we bring it into the session, we could get a
* collision.
*
* Eg. two embedded files:
- *
+ *
* /foo/bar/baz.wav
* /frob/nic/baz.wav
*
- * When merged into session, these collide.
+ * When merged into session, these collide.
*
* There will not be a conflict with in-memory sources
* because when the source was created we already picked
return newpath;
}
-/** Return true if there are no audio file sources that use @param name as
- * the filename component of their path.
+/** Return true if there are no audio file sources that use @param name as
+ * the filename component of their path.
*
* Return false otherwise.
*
- * This method MUST ONLY be used to check in-session, mono files since it
+ * This method MUST ONLY be used to check in-session, mono files since it
* hard-codes the channel of the audio file source we are looking for as zero.
- *
+ *
* If/when Ardour supports native files in non-mono formats, the logic here
* will need to be revisited.
*/
Session::create_midi_source_by_stealing_name (boost::shared_ptr<Track> track)
{
/* the caller passes in the track the source will be used in,
- so that we can keep the numbering sane.
-
+ so that we can keep the numbering sane.
+
Rationale: a track with the name "Foo" that has had N
captures carried out so far will ALREADY have a write source
named "Foo-N+1.mid" waiting to be used for the next capture.
-
+
If we call new_midi_source_name() we will get "Foo-N+2". But
there is no region corresponding to "Foo-N+1", so when
"Foo-N+2" appears in the track, the gap presents the user
with odd behaviour - why did it skip past Foo-N+1?
-
+
We could explain this to the user in some odd way, but
instead we rename "Foo-N+1.mid" as "Foo-N+2.mid", and then
use "Foo-N+1" here.
-
+
If that attempted rename fails, we get "Foo-N+2.mid" anyway.
*/
boost::shared_ptr<Region>
Session::write_one_track (Track& track, framepos_t start, framepos_t end,
bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
- InterThreadInfo& itt,
+ InterThreadInfo& itt,
boost::shared_ptr<Processor> endpoint, bool include_endpoint,
bool for_export, bool for_freeze)
{
break;
}
}
-
+
g_atomic_int_set (&_have_rec_disabled_track, i != rl->end () ? 1 : 0);
bool record_arm_state_changed = (old != g_atomic_int_get (&_have_rec_enabled_track) );
-
+
if (record_status() == Recording && record_arm_state_changed ) {
RecordArmStateChanged ();
}
return 0;
}
-uint32_t
+uint32_t
Session::next_control_id () const
{
int subtract = 0;
}
-SessionDirectory&
+SessionDirectory&
SessionDirectory::operator= (const std::string& newpath)
{
m_root_path = newpath;
SessionEvent* ev = static_cast<SessionEvent*> (p->alloc ());
DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("%1 Allocating SessionEvent from %2 ev @ %3 pool size %4 free %5 used %6\n", pthread_name(), p->name(), ev,
p->total(), p->available(), p->used()));
-
+
ev->own_pool = p;
return ev;
}
return 0;
}
-MIDI::Port*
+MIDI::Port*
Session::midi_input_port () const
{
return _midi_ports->midi_input_port ();
}
-MIDI::Port*
+MIDI::Port*
Session::midi_output_port () const
{
return _midi_ports->midi_output_port ();
}
-boost::shared_ptr<MidiPort>
+boost::shared_ptr<MidiPort>
Session::midi_clock_output_port () const
{
return _midi_ports->midi_clock_output_port ();
}
-boost::shared_ptr<MidiPort>
+boost::shared_ptr<MidiPort>
Session::midi_clock_input_port () const
{
return _midi_ports->midi_clock_input_port ();
}
-boost::shared_ptr<MidiPort>
+boost::shared_ptr<MidiPort>
Session::mtc_output_port () const
{
return _midi_ports->mtc_output_port ();
}
-boost::shared_ptr<MidiPort>
+boost::shared_ptr<MidiPort>
Session::mtc_input_port () const
{
return _midi_ports->mtc_input_port ();
if ((*i)->is_auditioner ()) { // REQUIRES REVIEW Can audiotioner be in Record Safe mode?
continue;
}
-
+
boost::shared_ptr<Track> t;
-
+
if ((t = boost::dynamic_pointer_cast<Track>(*i)) != 0) {
t->set_record_safe (yn, (group_override ? (void*) t->route_group () : (void *) this));
}
DEBUG_TRACE (DEBUG::Butler, "flush loop recording fragment to disk\n");
/* this locate might be happening while we are
- * loop recording.
+ * loop recording.
*
* Non-seamless looping will require a locate (below) that
* will reset capture buffers and throw away data.
*
- * Rather than first find all tracks and see if they
+ * Rather than first find all tracks and see if they
* have outstanding data, just do a flush anyway. It
* may be cheaper this way anyway, and is certainly
* more accurate.
/* need to get track buffers reloaded */
set_track_loop (true);
}
- }
+ }
}
}
if (!_object_selection.empty()) {
jump_to = _object_selection.from;
}
- }
+ }
if (jump_to < 0 && (autoreturn & LastLocate)) {
jump_to = _last_roll_location;
/* This (::non_realtime_stop()) gets called by main
process thread, which will lead to confusion
when calling AsyncMIDIPort::write().
-
+
Something must be done. XXX
*/
send_mmc_locate (_transport_frame);
/* set all tracks to use internal looping */
set_track_loop (true);
} else {
- /* we will do this in the locate to the start OR when we hit the end
- * of the loop for the first time
+ /* we will do this in the locate to the start OR when we hit the end
+ * of the loop for the first time
*/
}
} else {
* already have the correct data in them, and thus there is no need to
* actually tell the tracks to locate. What does need to be done,
* though, is all the housekeeping that is associated with non-linear
- * changes in the value of _transport_frame.
+ * changes in the value of _transport_frame.
*/
DEBUG_TRACE (DEBUG::Transport, string_compose ("rt-locate to %1, roll %2 flush %3 loop-enabled %4 force %5 mmc %6\n",
void
Session::set_transport_speed (double speed, framepos_t destination_frame, bool abort, bool clear_state, bool as_default)
{
- DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n",
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n",
speed, abort, clear_state, _transport_speed, _transport_frame, as_default));
if (_transport_speed == speed) {
if (actively_recording() && speed != 1.0 && speed != 0.0) {
/* no varispeed during recording */
- DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n",
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n",
_transport_speed, _transport_frame));
return;
}
DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed));
- /* throttle signal emissions.
+ /* throttle signal emissions.
* when slaved [_last]_transport_speed
* usually changes every cycle (tiny amounts due to DLL).
* Emitting a signal every cycle is overkill and unwarranted.
*
* Using _last_transport_speed is not acceptable,
- * since it allows for large changes over a long period
+ * since it allows for large changes over a long period
* of time. Hence we introduce a dedicated variable to keep track
*
* The 0.2% dead-zone is somewhat arbitrary. Main use-case
merge_event (ev);
/* request a declick at the start of the next process cycle() so that playback ceases.
- It will remain silent until we actually stop (at the StopOnce event somewhere in
+ It will remain silent until we actually stop (at the StopOnce event somewhere in
the future). The extra flag (StopPendingCapture) is set to ensure that check_declick_out()
does not stop the transport too early.
*/
DEBUG_TRACE (DEBUG::Transport, "time to actually stop\n");
/* declick was scheduled, but we've been called again, which means it is really time to stop
-
+
XXX: we should probably split this off into its own method and call it explicitly.
*/
if (init (_path, false)) {
throw failed_constructor ();
}
-
+
assert (!Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
existence_check ();
if (init (_path, true)) {
throw failed_constructor ();
}
-
+
assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
existence_check ();
/* Unlike the audio case, the MIDI file remains mutable (because we can
edit MIDI data)
*/
-
+
_flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
}
}
/** Constructor for existing external-to-session files.
- Files created this way are never writable or removable
+ Files created this way are never writable or removable
*/
SndFileSource::SndFileSource (Session& s, const string& path, int chn, Flag flags)
: Source(s, DataType::AUDIO, path, flags)
}
}
-/** This constructor is used to construct new internal-to-session files,
- not open existing ones.
+/** This constructor is used to construct new internal-to-session files,
+ not open existing ones.
*/
SndFileSource::SndFileSource (Session& s, const string& path, const string& origin,
SampleFormat sfmt, HeaderFormat hf, framecnt_t rate, Flag flags)
fmt = SF_FORMAT_RF64;
_flags = Flag (_flags & ~Broadcast);
break;
-
+
default:
fatal << string_compose (_("programming error: %1"), X_("unsupported audio header format requested")) << endmsg;
abort(); /*NOTREACHED*/
delete _broadcast_info;
_broadcast_info = 0;
_flags = Flag (_flags & ~Broadcast);
- }
+ }
/* Set the broadcast flag if the BWF info is already there. We need
* this when recovering or using existing files.
struct curl_httppost *formpost=NULL;
struct curl_httppost *lastptr=NULL;
- /* Fill in the filename field */
+ /* Fill in the filename field */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "client_id",
headerlist = curl_slist_append(headerlist, "Accept: application/xml");
curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, headerlist);
- /* what URL that receives this POST */
+ /* what URL that receives this POST */
std::string url = "https://api.soundcloud.com/oauth2/token";
curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
curl_easy_setopt(curl_handle, CURLOPT_HTTPPOST, formpost);
struct curl_httppost *lastptr=NULL;
/* Fill in the file upload field. This makes libcurl load data from
- the given file name when curl_easy_perform() is called. */
+ the given file name when curl_easy_perform() is called. */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "track[asset_data]",
CURLFORM_FILE, file_path.c_str(),
CURLFORM_END);
- /* Fill in the filename field */
+ /* Fill in the filename field */
curl_formadd(&formpost,
&lastptr,
CURLFORM_COPYNAME, "oauth_token",
/* initalize custom header list (stating that Expect: 100-continue is not
- wanted */
+ wanted */
struct curl_slist *headerlist=NULL;
static const char buf[] = "Expect:";
headerlist = curl_slist_append(headerlist, buf);
if (curl_handle && multi_handle) {
- /* what URL that receives this POST */
+ /* what URL that receives this POST */
std::string url = "https://api.soundcloud.com/tracks";
curl_easy_setopt(curl_handle, CURLOPT_URL, url.c_str());
// curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, 1L);
while(still_running) {
struct timeval timeout;
- int rc; /* select() return code */
+ int rc; /* select() return code */
fd_set fdread;
fd_set fdwrite;
FD_ZERO(&fdwrite);
FD_ZERO(&fdexcep);
- /* set a suitable timeout to play around with */
+ /* set a suitable timeout to play around with */
timeout.tv_sec = 1;
timeout.tv_usec = 0;
timeout.tv_usec = (curl_timeo % 1000) * 1000;
}
- /* get file descriptors from the transfers */
+ /* get file descriptors from the transfers */
curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
/* In a real-world program you OF COURSE check the return code of the
function calls. On success, the value of maxfd is guaranteed to be
greater or equal than -1. We call select(maxfd + 1, ...), specially in
case of (maxfd == -1), we call select(0, ...), which is basically equal
- to sleep. */
+ to sleep. */
rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
switch(rc) {
case -1:
- /* select error */
+ /* select error */
break;
case 0:
default:
- /* timeout or readable/writable sockets */
+ /* timeout or readable/writable sockets */
curl_multi_perform(multi_handle, &still_running);
break;
}
- }
+ }
- /* then cleanup the formpost chain */
+ /* then cleanup the formpost chain */
curl_formfree(formpost);
- /* free slist */
+ /* free slist */
curl_slist_free_all (headerlist);
}
}
boost::shared_ptr<Source>
-SourceFactory::createWritable (DataType type, Session& s, const std::string& path,
+SourceFactory::createWritable (DataType type, Session& s, const std::string& path,
bool destructive, framecnt_t rate, bool announce, bool defer_peaks)
{
/* this might throw failed_constructor(), which is OK */
// use 64 byte prefetch for quadruple quads:
// load each 64 bytes into cash before processing
while (nframes >= 16) {
-#if defined(COMPILER_MSVC) || defined(COMPILER_MINGW)
+#if defined(COMPILER_MSVC) || defined(COMPILER_MINGW)
_mm_prefetch(((char*)buf+64), _mm_hint(0) );
-#else
+#else
__builtin_prefetch(buf+64,0,0);
#endif
work = _mm256_load_ps(buf);
// use 64 byte prefetch for quadruple quads
while (nframes >= 16) {
-#ifdef COMPILER_MSVC
+#ifdef COMPILER_MSVC
_mm_prefetch(((char*)buf+64), 0); // A total guess! Assumed to be eqivalent to
#else // the line below but waiting to be tested !!
__builtin_prefetch(buf+64,0,0);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/***********************************************************************/
-double
+double
Meter::frames_per_grid (const Tempo& tempo, framecnt_t sr) const
{
/* This is tempo- and meter-sensitive. The number it returns
- is based on the interval between any two lines in the
+ is based on the interval between any two lines in the
grid that is constructed from tempo and meter sections.
The return value IS NOT interpretable in terms of "beats".
TempoSection::update_bar_offset_from_bbt (const Meter& m)
{
- _bar_offset = ((start().beats - 1) * BBT_Time::ticks_per_beat + start().ticks) /
+ _bar_offset = ((start().beats - 1) * BBT_Time::ticks_per_beat + start().ticks) /
(m.divisions_per_bar() * BBT_Time::ticks_per_beat);
DEBUG_TRACE (DEBUG::TempoMath, string_compose ("Tempo set bar offset to %1 from %2 w/%3\n", _bar_offset, start(), m.divisions_per_bar()));
/* remember the 1-based counting properties of beats */
new_start.beats += 1;
-
- DEBUG_TRACE (DEBUG::TempoMath, string_compose ("from bar offset %1 and dpb %2, ticks = %3->%4 beats = %5\n",
+
+ DEBUG_TRACE (DEBUG::TempoMath, string_compose ("from bar offset %1 and dpb %2, ticks = %3->%4 beats = %5\n",
_bar_offset, meter.divisions_per_bar(), ticks, new_start.ticks, new_start.beats));
set_start (new_start);
if ((prop = node.property ("beats-per-bar")) == 0) {
error << _("MeterSection XML node has no \"beats-per-bar\" or \"divisions-per-bar\" property") << endmsg;
throw failed_constructor();
- }
+ }
}
if (sscanf (prop->value().c_str(), "%lf", &_divisions_per_bar) != 1 || _divisions_per_bar < 0.0) {
assert (section->start().ticks == 0);
/* we only allow new meters to be inserted on beat 1 of an existing
- * measure.
+ * measure.
*/
if (dynamic_cast<MeterSection*>(section)) {
metrics.erase (i);
}
break;
- }
+ }
} else if (!iter_is_tempo && !insert_is_tempo) {
/* as we start, we are *guaranteed* to have m.meter and m.tempo pointing
at something, because we insert the default tempo and meter during
TempoMap construction.
-
+
now see if we can find better candidates.
*/
round the start time appropriately. remember that
`where' is based on the existing tempo map, not
the result after we insert the new meter.
-
+
*/
if (where.beats != 1) {
for (Metrics::iterator i = metrics.begin(); i != metrics.end(); ++i) {
if ((t = dynamic_cast<TempoSection*> (*i)) != 0) {
- {
+ {
Glib::Threads::RWLock::WriterLock lm (lock);
*((Tempo*) t) = newtempo;
recompute_map (false);
}
/* find the metric immediately after the tempo + meter sections for the
- * last point in the map
+ * last point in the map
*/
for (next_metric = metrics.begin(); next_metric != metrics.end(); ++next_metric) {
}
/* we cast away const here because this is the one place where we need
- * to actually modify the frame time of each metric section.
+ * to actually modify the frame time of each metric section.
*/
- _extend_map (const_cast<TempoSection*> ((*i).tempo),
+ _extend_map (const_cast<TempoSection*> ((*i).tempo),
const_cast<MeterSection*> ((*i).meter),
next_metric, BBT_Time ((*i).bar, (*i).beat, 0), (*i).frame, end);
}
void
-TempoMap::_extend_map (TempoSection* tempo, MeterSection* meter,
+TempoMap::_extend_map (TempoSection* tempo, MeterSection* meter,
Metrics::iterator next_metric,
BBT_Time current, framepos_t current_frame, framepos_t end)
{
* is within, which will be different
* from the preceding following ones
* since it takes part of its duration
- * from the preceding tempo and part
+ * from the preceding tempo and part
* from this new tempo.
*/
/* set tempo section location
* based on offset from last
- * bar start
+ * bar start
*/
- tempo->set_frame (bar_start_frame +
+ tempo->set_frame (bar_start_frame +
llrint ((ts->bar_offset() * meter->divisions_per_bar() * beat_frames)));
/* advance to the location of
beat_frames = meter->frames_per_grid (*tempo, _frame_rate);
- DEBUG_TRACE (DEBUG::TempoMath, string_compose ("New metric with beat frames = %1 dpb %2 meter %3 tempo %4\n",
+ DEBUG_TRACE (DEBUG::TempoMath, string_compose ("New metric with beat frames = %1 dpb %2 meter %3 tempo %4\n",
beat_frames, meter->divisions_per_bar(), *((Meter*)meter), *((Tempo*)tempo)));
++next_metric;
}
}
- }
+ }
if (current.beats == 1) {
DEBUG_TRACE (DEBUG::TempoMath, string_compose ("Add Bar at %1|1 @ %2\n", current.bars, current_frame));
BBTPointList::const_iterator e = bbt_before_or_at (BBT_Time (bbt.bars, bbt.beats, 0));
if (bbt.ticks != 0) {
- return ((*e).frame - (*s).frame) +
+ return ((*e).frame - (*s).frame) +
llrint ((*e).tempo->frames_per_beat (_frame_rate) * (bbt.ticks/BBT_Time::ticks_per_beat));
} else {
return ((*e).frame - (*s).frame);
}
framecnt_t
-TempoMap::bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int /*dir*/)
+TempoMap::bbt_duration_at_unlocked (const BBT_Time& when, const BBT_Time& bbt, int /*dir*/)
{
if (bbt.bars == 0 && bbt.beats == 0 && bbt.ticks == 0) {
return 0;
/* add any additional frames related to ticks in the added value */
if (bbt.ticks != 0) {
- return ((*wi).frame - (*start).frame) +
+ return ((*wi).frame - (*start).frame) +
(*wi).tempo->frames_per_beat (_frame_rate) * (bbt.ticks/BBT_Time::ticks_per_beat);
} else {
return ((*wi).frame - (*start).frame);
++i;
assert (i != _map.end());
the_beat.ticks -= BBT_Time::ticks_per_beat;
- }
+ }
} else if (dir < 0) {
assert (i != _map.end());
the_beat.ticks -= BBT_Time::ticks_per_beat;
DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("fold beat to %1\n", the_beat));
- }
+ }
} else if (rem > 0) {
}
}
- return (*i).frame + (the_beat.ticks/BBT_Time::ticks_per_beat) *
+ return (*i).frame + (the_beat.ticks/BBT_Time::ticks_per_beat) *
(*i).tempo->frames_per_beat (_frame_rate);
}
}
fi--;
}
- DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to bar: map iter at %1|%2 %3, return\n",
+ DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to bar: map iter at %1|%2 %3, return\n",
(*fi).bar, (*fi).beat, (*fi).frame));
return (*fi).frame;
}
}
- DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to bar: map iter at %1|%2 %3, return\n",
+ DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to bar: map iter at %1|%2 %3, return\n",
(*fi).bar, (*fi).beat, (*fi).frame));
return (*fi).frame;
DEBUG_TRACE (DEBUG::SnapBBT, "requested frame is on beat, step back\n");
--fi;
}
- DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to beat: map iter at %1|%2 %3, return\n",
+ DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to beat: map iter at %1|%2 %3, return\n",
(*fi).bar, (*fi).beat, (*fi).frame));
return (*fi).frame;
} else if (dir > 0) {
DEBUG_TRACE (DEBUG::SnapBBT, "requested frame is on beat, step forward\n");
++fi;
}
- DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to beat: map iter at %1|%2 %3, return\n",
+ DEBUG_TRACE (DEBUG::SnapBBT, string_compose ("rounded to beat: map iter at %1|%2 %3, return\n",
(*fi).bar, (*fi).beat, (*fi).frame));
return (*fi).frame;
} else {
}
void
-TempoMap::get_grid (TempoMap::BBTPointList::const_iterator& begin,
- TempoMap::BBTPointList::const_iterator& end,
- framepos_t lower, framepos_t upper)
+TempoMap::get_grid (TempoMap::BBTPointList::const_iterator& begin,
+ TempoMap::BBTPointList::const_iterator& end,
+ framepos_t lower, framepos_t upper)
{
- {
+ {
Glib::Threads::RWLock::WriterLock lm (lock);
if (_map.empty() || (_map.back().frame < upper)) {
recompute_map (false, upper);
if (ts->bar_offset() < 0.0) {
if (last_meter) {
ts->update_bar_offset_from_bbt (*last_meter);
- }
+ }
}
}
if (op.ticks) {
if (op.ticks >= BBT_Time::ticks_per_beat) {
pos += llrint (frames_per_beat + /* extra beat */
- (frames_per_beat * ((op.ticks % (uint32_t) BBT_Time::ticks_per_beat) /
+ (frames_per_beat * ((op.ticks % (uint32_t) BBT_Time::ticks_per_beat) /
(double) BBT_Time::ticks_per_beat)));
} else {
pos += llrint (frames_per_beat * (op.ticks / (double) BBT_Time::ticks_per_beat));
if (pos < 0) {
/* not really correct, but we should catch pos < 0 at a higher
- level
+ level
*/
return _map.begin();
}
}
TempoMap::BBTPointList::const_iterator
-TempoMap::bbt_after_or_at (framepos_t pos)
+TempoMap::bbt_after_or_at (framepos_t pos)
{
/* CALLER MUST HOLD READ LOCK */
return i;
}
-std::ostream&
+std::ostream&
operator<< (std::ostream& o, const Meter& m) {
return o << m.divisions_per_bar() << '/' << m.note_divisor();
}
-std::ostream&
+std::ostream&
operator<< (std::ostream& o, const Tempo& t) {
return o << t.beats_per_minute() << " 1/" << t.note_type() << "'s per minute";
}
-std::ostream&
+std::ostream&
operator<< (std::ostream& o, const MetricSection& section) {
o << "MetricSection @ " << section.frame() << " aka " << section.start() << ' ';
/*
120bpm at bar 1, 240bpm at bar 4
-
+
120bpm = 24e3 samples per beat
240bpm = 12e3 samples per beat
*/
/*
-
+
120bpm 240bpm
0 beats 12 beats
0 frames 288e3 frames
tempo change (which shouldn't affect anything, since we are just dealing with
beats)
*/
-
+
void
FrameposMinusBeatsTest::doubleTempoWithMeterTest ()
{
/*
120bpm at bar 1, 240bpm at bar 4
-
+
120bpm = 24e3 samples per beat
240bpm = 12e3 samples per beat
*/
/*
-
+
120bpm 240bpm
0 beats 12 beats
0 frames 288e3 frames
/*
120bpm at bar 1, 240bpm at bar 4
-
+
120bpm = 24e3 samples per beat
240bpm = 12e3 samples per beat
*/
/*
-
+
120bpm 240bpm
0 beats 12 beats
0 frames 288e3 frames
tempo change (which shouldn't affect anything, since we are just dealing with
beats)
*/
-
+
void
FrameposPlusBeatsTest::doubleTempoWithMeterTest ()
{
/*
120bpm at bar 1, 240bpm at bar 4
-
+
120bpm = 24e3 samples per beat
240bpm = 12e3 samples per beat
*/
/*
-
+
120bpm 240bpm
0 beats 12 beats
0 frames 288e3 frames
/*
120bpm at bar 1, 240bpm at bar 4
-
+
120bpm = 24e3 samples per beat
240bpm = 12e3 samples per beat
*/
/*
-
+
120bpm 240bpm
0 beats 12 beats
0 frames 288e3 frames
/*
120bpm at bar 1, 240bpm at bar 2, 160bpm at bar 3
-
+
120bpm = 24e3 samples per beat
160bpm = 18e3 samples per beat
240bpm = 12e3 samples per beat
/*
-
+
120bpm 240bpm 160bpm
0 beats 4 beats 8 beats
0 frames 96e3 frames 144e3 frames
}
/*
for (int i=0; i < NUM_SAMPLES; ++i) {
- cout << i << " " << output[i] << endl;
+ cout << i << " " << output[i] << endl;
}
*/
}
start (*parser, start_time);
update_midi_clock (*parser, start_time);
-
+
for (framecnt_t i = 1; i<= 100 * period_size; i++) {
// simulate jitter
framecnt_t input_delta = framecnt_t (one_ppqn_in_frames + 0.1 * (double(g_random_int()) / double (RAND_MAX)) * one_ppqn_in_frames);
-
+
if (i % input_delta == 0) {
update_midi_clock (*parser, start_time + i);
}
-/*
+/*
* Copyright(C) 2000-2008 Paul Davis
* Author: Hans Baier
- *
+ *
* Evoral is free software; you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or(at your option) any later
* version.
- *
+ *
* Evoral is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for details.
- *
+ *
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Meter meter;
public:
- TestSlaveSessionProxy() :
- transport_speed (1.0),
- _transport_frame (0),
+ TestSlaveSessionProxy() :
+ transport_speed (1.0),
+ _transport_frame (0),
_frame_time (1000000),
_tempo_map (0),
tempo (120),
{
_tempo_map = new TempoMap (FRAME_RATE);
_tempo_map->add_tempo (tempo, Timecode::BBT_Time(1, 1, 0));
- _tempo_map->add_meter (meter, Timecode::BBT_Time(1, 1, 0));
+ _tempo_map->add_meter (meter, Timecode::BBT_Time(1, 1, 0));
}
// Controlling the mock object
void set_period_size (framecnt_t a_size) { _period_size = a_size; }
framecnt_t period_size () const { return _period_size; }
- void next_period () {
- _transport_frame += double(_period_size) * double(transport_speed);
+ void next_period () {
+ _transport_frame += double(_period_size) * double(transport_speed);
_frame_time += _period_size;
}
pframes_t frames_since_cycle_start () const { return 0; }
framepos_t frame_time () const { return _frame_time; }
- void request_locate (framepos_t frame, bool with_roll = false) {
- _transport_frame = frame;
+ void request_locate (framepos_t frame, bool with_roll = false) {
+ _transport_frame = frame;
}
void request_transport_speed (const double speed) { transport_speed = speed; }
void setUp() {
}
-
+
void tearDown() {
}
/*
120bpm at bar 1, 240bpm at bar 4
-
+
120bpm = 24e3 samples per beat
240bpm = 12e3 samples per beat
*/
/*
-
+
120bpm 240bpm
0 beats 12 beats
0 frames 288e3 frames
Position() : speed(0.0f), frame(0), midi_beats(0) { }
~Position() { }
-
+
/** Sync timing information taken from the given Session
- * @return True if timings differed
+ * @return True if timings differed
*/
bool sync (Session* s) {
bool changed = false;
-
+
double sp = s->transport_speed();
framecnt_t fr = s->transport_frame();
-
+
if (speed != sp) {
speed = sp;
changed = true;
double mb;
/** Midi Beats in terms of Song Position Pointer is equivalent to total
- * sixteenth notes at 'time'
+ * sixteenth notes at 'time'
*/
mb = (((bars - 1) * divisions) + beats - 1);
framecnt_t frame;
double midi_beats;
double midi_clocks;
-
+
void print (std::ostream& s) {
s << "frames: " << frame << " midi beats: " << midi_beats << " speed: " << speed;
}
#ifdef USE_TRACKS_CODE_FEATURES
-/* This is the Tracks version of Track::monitoring_state().
+/* This is the Tracks version of Track::monitoring_state().
*
- * Ardour developers: try to flag or fix issues if parts of the libardour API
+ * Ardour developers: try to flag or fix issues if parts of the libardour API
* change in ways that invalidate this
*/
#else
-/* This is the Ardour/Mixbus version of Track::monitoring_state().
+/* This is the Ardour/Mixbus version of Track::monitoring_state().
*
* Tracks developers: do NOT modify this method under any circumstances.
*/
}
- return nframes;
+ return nframes;
}
void
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* version.
*/
-string
+string
ARDOUR::legalize_for_path_2X (const string& str)
{
string::size_type pos;
};
/** Class that allows optimizing out debugging code during compile time.
- * Usage: to take all advantage of this class you should wrap all
+ * Usage: to take all advantage of this class you should wrap all
* debugging statemets like this:
* \code
* if (debug_level (SomeDebugLevel) && other_optional_conditionals) {
: public ListedSource<T>
, public Throwing<>
{
- public:
+ public:
/// Constructs an interleaver \n RT safe
Interleaver()
return boost::static_pointer_cast<Sink<T> > (inputs[channel]);
}
- private:
-
+ private:
+
class Input : public Sink<T>
{
public:
};
/** Sample format converter that does dithering.
- * This class can only convert floats to either \a float, \a int32_t, \a int16_t, or \a uint8_t
+ * This class can only convert floats to either \a float, \a int32_t, \a int16_t, or \a uint8_t
*/
template <typename TOut>
class LIBAUDIOGRAPHER_API SampleFormatConverter
};
/** Class that allows optimizing out error checking during compile time.
- * Usage: to take all advantage of this class you should wrap all
+ * Usage: to take all advantage of this class you should wrap all
* throwing statemets like this:
* \code
* if (throw_level (SomeThrowLevel) && other_optional_conditionals) {
{
BOOST_STATIC_ASSERT (boost::has_trivial_destructor<T>::value);
- typedef boost::integral_constant<bool,
+ typedef boost::integral_constant<bool,
boost::is_floating_point<T>::value ||
boost::is_signed<T>::value> zero_fillable;
public:
#define LIBAUDIOGRAPHER_API LIBAUDIOGRAPHER_DLL_EXPORT
#else
#define LIBAUDIOGRAPHER_API LIBAUDIOGRAPHER_DLL_IMPORT
- #endif
+ #endif
#define LIBAUDIOGRAPHER_LOCAL LIBAUDIOGRAPHER_DLL_LOCAL
#endif
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
int err;
src_state = src_new (quality, channels, &err);
if (throw_level (ThrowObject) && !src_state) {
- throw Exception (*this, str (format
+ throw Exception (*this, str (format
("Cannot initialize sample rate converter: %1%")
% src_strerror (err)));
}
err = src_process (src_state, &src_data);
if (throw_level (ThrowProcess) && err) {
- throw Exception (*this, str (format
+ throw Exception (*this, str (format
("An error occured during sample rate conversion: %1%")
% src_strerror (err)));
}
}
if (throw_level (ThrowProcess) && src_data.output_frames_gen == 0 && leftover_frames) {
- throw Exception (*this, boost::str (boost::format
+ throw Exception (*this, boost::str (boost::format
("No output frames genereated with %1% leftover frames")
% leftover_frames));
}
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
ASIOBackend::~ASIOBackend ()
{
-#if 0
+#if 0
delete _pcmio; _pcmio = 0; // TODO
delete _midiio; _midiio = 0; // TODO
#endif
namespace ARDOUR {
typedef struct _CoreMIDIPacket {
- MIDITimeStamp timeStamp;
- UInt16 length;
- Byte data[256];
+ MIDITimeStamp timeStamp;
+ UInt16 length;
+ Byte data[256];
#if 0 // unused
_CoreMIDIPacket (MIDITimeStamp t, Byte *d, UInt16 l)
: timeStamp(t)
}
}
#endif
- _CoreMIDIPacket (const MIDIPacket *other)
+ _CoreMIDIPacket (const MIDIPacket *other)
: timeStamp(other->timeStamp)
, length (other->length)
{
return 0;
}
-static int
+static int
deinstantiate ()
{
backend.reset ();
}
string
-JACKAudioBackend::name() const
+JACKAudioBackend::name() const
{
return X_("JACK");
}
all_devices.insert (make_pair (_target_driver, std::set<string>()));
}
- /* store every device we've found, by driver name.
+ /* store every device we've found, by driver name.
*
* This is so we do not confuse ALSA, FFADO, netjack etc. devices
* with each other.
return f;
}
- /* if JACK is not already running, just list a bunch of reasonable
+ /* if JACK is not already running, just list a bunch of reasonable
values and let the future sort it all out.
*/
if (!_jack_connection->in_control()) {
return "???"; // JACK has no way (as of fall 2013) to return
// the device name
- }
+ }
return _target_device;
}
return _target_systemic_output_latency;
}
-size_t
+size_t
JACKAudioBackend::raw_buffer_size(DataType t)
{
std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
if (!available()) {
if (_jack_connection->in_control()) {
- /* we will be starting JACK, so set up the
+ /* we will be starting JACK, so set up the
command that JACK will use when it (auto-)starts
*/
setup_jack_startup_command (for_latency_measurement);
jack_sample_rate_callback (jack_get_sample_rate (_priv_jack));
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
- /* Now that we have buffer size and sample rate established, the engine
+ /* Now that we have buffer size and sample rate established, the engine
can go ahead and do its stuff
*/
jack_transport_locate (_priv_jack, where);
}
-framepos_t
-JACKAudioBackend::transport_frame () const
+framepos_t
+JACKAudioBackend::transport_frame () const
{
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
return jack_get_current_transport_frame (_priv_jack);
}
}
-float
-JACKAudioBackend::dsp_load() const
+float
+JACKAudioBackend::dsp_load() const
{
GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
return jack_cpu_load (_priv_jack);
jack_transport_state_t state;
bool starting;
- /* this won't be called if the port engine in use is not JACK, so we do
+ /* this won't be called if the port engine in use is not JACK, so we do
not have to worry about the type of PortEngine::private_handle()
*/
public:
JACKAudioBackend (AudioEngine& e, AudioBackendInfo& info, boost::shared_ptr<JackConnection>);
~JACKAudioBackend ();
-
+
/* AUDIOBACKEND API */
std::string name() const;
void update_latencies ();
static bool already_configured();
-
+
/* PORTENGINE API */
const std::string& my_name() const;
int disconnect_all (PortHandle);
int connect (const std::string& src, const std::string& dst);
int disconnect (const std::string& src, const std::string& dst);
-
+
/* MIDI */
std::vector<std::string> enumerate_midi_options () const;
/* Latency management
*/
-
+
void set_latency_range (PortHandle, bool for_playback, LatencyRange);
LatencyRange get_latency_range (PortHandle, bool for_playback);
static void _freewheel_callback (int , void *arg);
static void _latency_callback (jack_latency_callback_mode_t, void*);
static void _session_callback (jack_session_event_t *event, void *arg);
-
+
void jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int);
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
int jack_bufsize_callback (pframes_t);
void set_jack_callbacks ();
int reconnect_to_jack ();
-
+
struct ThreadData {
JACKAudioBackend* engine;
boost::function<void()> f;
ThreadData (JACKAudioBackend* e, boost::function<void()> fp, size_t stacksz)
: engine (e) , f (fp) , stacksize (stacksz) {}
};
-
+
void* process_thread ();
static void* _start_process_thread (void*);
typedef std::set<std::string> DeviceList;
typedef std::map<std::string,DeviceList> DriverDeviceMap;
-
+
mutable DriverDeviceMap all_devices;
PBD::ScopedConnection disconnect_connection;
void when_connected_to_jack ();
PBD::ScopedConnection jack_connection_connection;
- /* Object to manage interactions with Session in a way that
+ /* Object to manage interactions with Session in a way that
keeps JACK out of libardour directly
*/
} // namespace
#endif /* __ardour_audiobackend_h__ */
-
+
, _probed_buffer_size (0)
, _probed_sample_rate (0)
{
- /* See if the server is already up
+ /* See if the server is already up
*/
EnvironmentalProtectionAgency* global_epa = EnvironmentalProtectionAgency::get_global_epa ();
uint32_t _probed_sample_rate; // when not in control
};
-} // namespace
+} // namespace
#endif /* __libardour_jack_connection_h__ */
GET_PRIVATE_JACK_POINTER_RET (_priv_jack,0);
- const char** ports = jack_get_ports (_priv_jack, port_name_pattern.c_str(),
- ardour_data_type_to_jack_port_type (type),
+ const char** ports = jack_get_ports (_priv_jack, port_name_pattern.c_str(),
+ ardour_data_type_to_jack_port_type (type),
ardour_port_flags_to_jack_flags (flags));
if (ports == 0) {
JACKAudioBackend::register_port (const std::string& shortname, ARDOUR::DataType type, ARDOUR::PortFlags flags)
{
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
- return jack_port_register (_priv_jack, shortname.c_str(),
+ return jack_port_register (_priv_jack, shortname.c_str(),
ardour_data_type_to_jack_port_type (type),
ardour_port_flags_to_jack_flags (flags),
0);
}
}
- /* this won't be called if the port engine in use is not JACK, so we do
+ /* this won't be called if the port engine in use is not JACK, so we do
not have to worry about the type of PortEngine::private_handle()
*/
public:
JACKSession (ARDOUR::Session* s);
~JACKSession ();
-
+
void session_event (jack_session_event_t* event);
void timebase_callback (jack_transport_state_t /*state*/,
ARDOUR::pframes_t /*nframes*/,
#ifdef PLATFORM_WINDOWS
// N.B. The #define (immediately below) can be safely removed once we know that this code builds okay with mingw
#ifdef COMPILER_MSVC
- IShellLinkA *pISL = NULL;
+ IShellLinkA *pISL = NULL;
IPersistFile *ppf = NULL;
// Mixbus creates a Windows shortcut giving the location of its
}
vector<string>
-ARDOUR::enumerate_midi_options ()
+ARDOUR::enumerate_midi_options ()
{
if (midi_options.empty()) {
#ifdef HAVE_ALSA
-/* pmutil.h -- some helpful utilities for building midi
- applications that use PortMidi
+/* pmutil.h -- some helpful utilities for building midi
+ applications that use PortMidi
*/
#ifdef __cplusplus
This queue implementation uses the "light pipe" algorithm which
operates correctly even with multi-processors and out-of-order
memory writes. (see Alexander Dokumentov, "Lock-free Interprocess
- Communication," Dr. Dobbs Portal, http://www.ddj.com/,
+ Communication," Dr. Dobbs Portal, http://www.ddj.com/,
articleID=189401457, June 15, 2006. This algorithm requires
that messages be translated to a form where no words contain
zeros. Each word becomes its own "data valid" tag. Because of
- this translation, we cannot return a pointer to data still in
- the queue when the "peek" method is called. Instead, a buffer
- is preallocated so that data can be copied there. Pm_QueuePeek()
- dequeues a message into this buffer and returns a pointer to
+ this translation, we cannot return a pointer to data still in
+ the queue when the "peek" method is called. Instead, a buffer
+ is preallocated so that data can be copied there. Pm_QueuePeek()
+ dequeues a message into this buffer and returns a pointer to
it. A subsequent Pm_Dequeue() will copy from this buffer.
This implementation does not try to keep reader/writer data in
- separate cache lines or prevent thrashing on cache lines.
+ separate cache lines or prevent thrashing on cache lines.
However, this algorithm differs by doing inserts/removals in
units of messages rather than units of machine words. Some
performance improvement might be obtained by not clearing data
an overflow, the sender writes the current tail position to a field.
The receiver must acknowlege receipt by zeroing the field. The sender
will not send more until the field is zeroed.
-
+
Pm_QueueDestroy() destroys the queue and frees its storage.
*/
PMEXPORT PmQueue *Pm_QueueCreate(long num_msgs, int32_t bytes_per_msg);
PMEXPORT PmError Pm_QueueDestroy(PmQueue *queue);
-/*
+/*
Pm_Dequeue() removes one item from the queue, copying it into msg.
Returns 1 if successful, and 0 if the queue is empty.
Returns pmBufferOverflow if what would have been the next thing
in the queue was dropped due to overflow. (So when overflow occurs,
the receiver can receive a queue full of messages before getting the
- overflow report. This protocol ensures that the reader will be
+ overflow report. This protocol ensures that the reader will be
notified when data is lost due to overflow.
*/
PMEXPORT PmError Pm_Dequeue(PmQueue *queue, void *msg);
/*
Pm_Enqueue() inserts one item into the queue, copying it from msg.
- Returns pmNoError if successful and pmBufferOverflow if the queue was
+ Returns pmNoError if successful and pmBufferOverflow if the queue was
already full. If pmBufferOverflow is returned, the overflow flag is set.
*/
PMEXPORT PmError Pm_Enqueue(PmQueue *queue, void *msg);
Either condition may change immediately because a parallel
enqueue or dequeue operation could be in progress. Furthermore,
- Pm_QueueEmpty() is optimistic: it may say false, when due to
+ Pm_QueueEmpty() is optimistic: it may say false, when due to
out-of-order writes, the full message has not arrived. Therefore,
Pm_Dequeue() could still return 0 after Pm_QueueEmpty() returns
false. On the other hand, Pm_QueueFull() is pessimistic: if it
- returns false, then Pm_Enqueue() is guaranteed to succeed.
+ returns false, then Pm_Enqueue() is guaranteed to succeed.
Error conditions: Pm_QueueFull() returns pmBadPtr if queue is NULL.
Pm_QueueEmpty() returns FALSE if queue is NULL.
or NULL if the queue is empty. The item is not removed from the queue.
Pm_QueuePeek() will not indicate when an overflow occurs. If you want
to get and check pmBufferOverflow messages, use the return value of
- Pm_QueuePeek() *only* as an indication that you should call
+ Pm_QueuePeek() *only* as an indication that you should call
Pm_Dequeue(). At the point where a direct call to Pm_Dequeue() would
return pmBufferOverflow, Pm_QueuePeek() will return NULL but internally
clear the pmBufferOverflow flag, enabling Pm_Enqueue() to resume
enqueuing messages. A subsequent call to Pm_QueuePeek()
- will return a pointer to the first message *after* the overflow.
+ will return a pointer to the first message *after* the overflow.
Using this as an indication to call Pm_Dequeue(), the first call
to Pm_Dequeue() will return pmBufferOverflow. The second call will
return success, copying the same message pointed to by the previous
data to decide who should be called to receive it. (2) when you need
to know a message is ready but cannot accept the message.
- Note that Pm_QueuePeek() is not a fast check, so if possible, you
+ Note that Pm_QueuePeek() is not a fast check, so if possible, you
might as well just call Pm_Dequeue() and accept the data if it is there.
*/
PMEXPORT void *Pm_QueuePeek(PmQueue *queue);
/*
Pm_SetOverflow() allows the writer (enqueuer) to signal an overflow
- condition to the reader (dequeuer). E.g. when transfering data from
+ condition to the reader (dequeuer). E.g. when transfering data from
the OS to an application, if the OS indicates a buffer overrun,
Pm_SetOverflow() can be used to insure that the reader receives a
pmBufferOverflow result from Pm_Dequeue(). Returns pmBadPtr if queue
*/
/*
- * The text above constitutes the entire PortMidi license; however,
+ * The text above constitutes the entire PortMidi license; however,
* the PortMusic community also makes the following non-binding requests:
*
* Any person wishing to distribute modifications to the Software is
* requested to send the modifications to the original developer so that
* they can be incorporated into the canonical version. It is also
- * requested that these non-binding requests be included along with the
+ * requested that these non-binding requests be included along with the
* license above.
*/
/* CHANGELOG FOR PORTMIDI
* (see ../CHANGELOG.txt)
*
- * NOTES ON HOST ERROR REPORTING:
+ * NOTES ON HOST ERROR REPORTING:
*
* PortMidi errors (of type PmError) are generic, system-independent errors.
* When an error does not map to one of the more specific PmErrors, the
* retained a more specific system-dependent error code. The caller can
* get more information by calling Pm_HasHostError() to test if there is
* a pending host error, and Pm_GetHostErrorText() to get a text string
- * describing the error. Host errors are reported on a per-device basis
- * because only after you open a device does PortMidi have a place to
- * record the host error code. I.e. only
- * those routines that receive a (PortMidiStream *) argument check and
- * report errors. One exception to this is that Pm_OpenInput() and
+ * describing the error. Host errors are reported on a per-device basis
+ * because only after you open a device does PortMidi have a place to
+ * record the host error code. I.e. only
+ * those routines that receive a (PortMidiStream *) argument check and
+ * report errors. One exception to this is that Pm_OpenInput() and
* Pm_OpenOutput() can report errors even though when an error occurs,
* there is no PortMidiStream* to hold the error. Fortunately, both
* of these functions return any error immediately, so we do not really
* need per-device error memory. Instead, any host error code is stored
- * in a global, pmHostError is returned, and the user can call
+ * in a global, pmHostError is returned, and the user can call
* Pm_GetHostErrorText() to get the error message (and the invalid stream
- * parameter will be ignored.) The functions
+ * parameter will be ignored.) The functions
* pm_init and pm_term do not fail or raise
* errors. The job of pm_init is to locate all available devices so that
* the caller can get information via PmDeviceInfo(). If an error occurs,
* the device is simply not listed as available.
*
* Host errors come in two flavors:
- * a) host error
+ * a) host error
* b) host error during callback
- * These can occur w/midi input or output devices. (b) can only happen
+ * These can occur w/midi input or output devices. (b) can only happen
* asynchronously (during callback routines), whereas (a) only occurs while
* synchronously running PortMidi and any resulting system dependent calls.
* Both (a) and (b) are reported by the next read or write call. You can
* NOTES ON COMPILE-TIME SWITCHES
*
* DEBUG assumes stdio and a console. Use this if you want automatic, simple
- * error reporting, e.g. for prototyping. If you are using MFC or some
+ * error reporting, e.g. for prototyping. If you are using MFC or some
* other graphical interface with no console, DEBUG probably should be
* undefined.
* PM_CHECK_ERRORS more-or-less takes over error checking for return values,
#include <stdint.h>
#else
#ifndef INT32_DEFINED
-// rather than having users install a special .h file for windows,
+// rather than having users install a special .h file for windows,
// just put the required definitions inline here. porttime.h uses
// these too, so the definitions are (unfortunately) duplicated there
typedef int int32_t;
#ifdef _WINDLL
#define PMEXPORT __declspec(dllexport)
#else
-#define PMEXPORT
+#define PMEXPORT
#endif
#ifndef FALSE
pmNoData = 0, /**< A "no error" return that also indicates no data avail. */
pmGotData = 1, /**< A "no error" return that also indicates data available */
pmHostError = -10000,
- pmInvalidDeviceId, /** out of range or
- * output device when input is requested or
+ pmInvalidDeviceId, /** out of range or
+ * output device when input is requested or
* input device when output is requested or
- * device is already opened
+ * device is already opened
*/
pmInsufficientMemory,
pmBufferTooSmall,
asynchronously where the client does not
explicitly call a function, and therefore cannot receive an error code.
The client can test for a pending error using Pm_HasHostError(). If true,
- the error can be accessed and cleared by calling Pm_GetErrorText().
+ the error can be accessed and cleared by calling Pm_GetErrorText().
Errors are also cleared by calling other functions that can return
errors, e.g. Pm_OpenInput(), Pm_OpenOutput(), Pm_Read(), Pm_Write(). The
client does not need to call Pm_HasHostError(). Any pending error will be
- reported the next time the client performs an explicit function call on
+ reported the next time the client performs an explicit function call on
the stream, e.g. an input or output operation. Until the error is cleared,
no new error codes will be obtained, even for a different stream.
*/
/** Translate portmidi error number into human readable message.
- These strings are constants (set at compile time) so client has
+ These strings are constants (set at compile time) so client has
no need to allocate storage
*/
PMEXPORT const char *Pm_GetErrorText( PmError errnum );
/** Translate portmidi host error into human readable message.
These strings are computed at run time, so client has to allocate storage.
- After this routine executes, the host error is cleared.
+ After this routine executes, the host error is cleared.
*/
PMEXPORT void Pm_GetHostErrorText(char * msg, unsigned int len);
#define HDRLENGTH 50
-#define PM_HOST_ERROR_MSG_LEN 256u /* any host error msg will occupy less
+#define PM_HOST_ERROR_MSG_LEN 256u /* any host error msg will occupy less
than this number of characters */
/**
typedef int PmDeviceID;
#define pmNoDevice -1
typedef struct {
- int structVersion; /**< this internal structure version */
+ int structVersion; /**< this internal structure version */
const char *interf; /**< underlying MIDI API, e.g. MMSystem or DirectX */
const char *name; /**< device name, e.g. USB MidiSport 1x1 */
int input; /**< true iff input is available */
Return the default device ID or pmNoDevice if there are no devices.
The result (but not pmNoDevice) can be passed to Pm_OpenMidi().
-
+
The default device can be specified using a small application
named pmdefaults that is part of the PortMidi distribution. This
program in turn uses the Java Preferences object created by
java.util.prefs.Preferences.userRoot().node("/PortMidi"); the
- preference is set by calling
+ preference is set by calling
prefs.put("PM_RECOMMENDED_OUTPUT_DEVICE", prefName);
or prefs.put("PM_RECOMMENDED_INPUT_DEVICE", prefName);
-
+
In the statements above, prefName is a string describing the
MIDI device in the form "interf, name" where interf identifies
the underlying software system or API used by PortMdi to access
- devices and name is the name of the device. These correspond to
+ devices and name is the name of the device. These correspond to
the interf and name fields of a PmDeviceInfo. (Currently supported
- interfaces are "MMSystem" for Win32, "ALSA" for Linux, and
+ interfaces are "MMSystem" for Win32, "ALSA" for Linux, and
"CoreMIDI" for OS X, so in fact, there is no choice of interface.)
- In "interf, name", the strings are actually substrings of
- the full interface and name strings. For example, the preference
+ In "interf, name", the strings are actually substrings of
+ the full interface and name strings. For example, the preference
"Core, Sport" will match a device with interface "CoreMIDI"
and name "In USB MidiSport 1x1". It will also match "CoreMIDI"
and "In USB MidiSport 2x2". The devices are enumerated in device
the entire preference string is interpreted as a name, and the
interface part is the empty string, which matches anything.
- On the MAC, preferences are stored in
+ On the MAC, preferences are stored in
/Users/$NAME/Library/Preferences/com.apple.java.util.prefs.plist
which is a binary file. In addition to the pmdefaults program,
there are utilities that can read and edit this preference file.
- On the PC,
+ On the PC,
- On Linux,
+ On Linux,
*/
PMEXPORT PmDeviceID Pm_GetDefaultInputDeviceID( void );
/** TRUE if t1 before t2 */
#define PmBefore(t1,t2) ((t1-t2) < 0)
-/**
+/**
\defgroup grp_device Input/Output Devices Handling
@{
*/
outputDriverInfo is never required for correct operation. If not used
outputDriverInfo should be NULL.
- For input, the buffersize specifies the number of input events to be
- buffered waiting to be read using Pm_Read(). For output, buffersize
- specifies the number of output events to be buffered waiting for output.
+ For input, the buffersize specifies the number of input events to be
+ buffered waiting to be read using Pm_Read(). For output, buffersize
+ specifies the number of output events to be buffered waiting for output.
(In some cases -- see below -- PortMidi does not buffer output at all
and merely passes data to a lower-level API, in which case buffersize
is ignored.)
-
- latency is the delay in milliseconds applied to timestamps to determine
- when the output should actually occur. (If latency is < 0, 0 is assumed.)
+
+ latency is the delay in milliseconds applied to timestamps to determine
+ when the output should actually occur. (If latency is < 0, 0 is assumed.)
If latency is zero, timestamps are ignored and all output is delivered
immediately. If latency is greater than zero, output is delayed until the
- message timestamp plus the latency. (NOTE: the time is measured relative
+ message timestamp plus the latency. (NOTE: the time is measured relative
to the time source indicated by time_proc. Timestamps are absolute,
not relative delays or offsets.) In some cases, PortMidi can obtain
better timing than your application by passing timestamps along to the
data to audio data by matching midi latency to the audio buffer latency.
time_proc is a pointer to a procedure that returns time in milliseconds. It
- may be NULL, in which case a default millisecond timebase (PortTime) is
+ may be NULL, in which case a default millisecond timebase (PortTime) is
used. If the application wants to use PortTime, it should start the timer
(call Pt_Start) before calling Pm_OpenInput or Pm_OpenOutput. If the
application tries to start the timer *after* Pm_OpenInput or Pm_OpenOutput,
Or you may be using a sequencer or drum-machine for MIDI clock information but want to
exclude any notes it may play.
*/
-
+
/* Filter bit-mask definitions */
/** filter active sensing messages (0xFE): */
#define PM_FILT_ACTIVE (1 << 0x0E)
Multiple channels should be OR'd together, like
Pm_SetChannelMask(Pm_Channel(10) | Pm_Channel(11))
- Note that channels are numbered 0 to 15 (not 1 to 16). Most
+ Note that channels are numbered 0 to 15 (not 1 to 16). Most
synthesizer and interfaces number channels starting at 1, but
PortMidi numbers channels starting at 0.
any time.
*/
PMEXPORT PmError Pm_Abort( PortMidiStream* stream );
-
+
/**
Pm_Close() closes a midi stream, flushing any pending buffers.
- (PortMidi attempts to close open streams when the application
+ (PortMidi attempts to close open streams when the application
exits -- this is particularly difficult under Windows.)
*/
PMEXPORT PmError Pm_Close( PortMidiStream* stream );
time_proc passed when the stream was opened. Typically, this
is used when the stream must be opened before the time_proc
reference is actually advancing. In this case, message timing
- may be erratic, but since timestamps of zero mean
+ may be erratic, but since timestamps of zero mean
"send immediately," initialization messages with zero timestamps
can be written without a functioning time reference and without
problems. Before the first MIDI message with a non-zero
timestamp is written to the stream, the time reference must
begin to advance (for example, if the time_proc computes time
- based on audio samples, time might begin to advance when an
+ based on audio samples, time might begin to advance when an
audio stream becomes active). After time_proc return values
- become valid, and BEFORE writing the first non-zero timestamped
+ become valid, and BEFORE writing the first non-zero timestamped
MIDI message, call Pm_Synchronize() so that PortMidi can observe
the difference between the current time_proc value and its
- MIDI stream time.
-
- In the more normal case where time_proc
- values advance continuously, there is no need to call
- Pm_Synchronize. PortMidi will always synchronize at the
+ MIDI stream time.
+
+ In the more normal case where time_proc
+ values advance continuously, there is no need to call
+ Pm_Synchronize. PortMidi will always synchronize at the
first output message and periodically thereafter.
*/
PmError Pm_Synchronize( PortMidiStream* stream );
Pm_Message() encodes a short Midi message into a 32-bit word. If data1
and/or data2 are not present, use zero.
- Pm_MessageStatus(), Pm_MessageData1(), and
+ Pm_MessageStatus(), Pm_MessageData1(), and
Pm_MessageData2() extract fields from a 32-bit midi message.
*/
#define Pm_Message(status, data1, data2) \
structure carrying 4 bytes of the message, i.e. only the first
PmEvent carries the status byte.
- Note that MIDI allows nested messages: the so-called "real-time" MIDI
- messages can be inserted into the MIDI byte stream at any location,
+ Note that MIDI allows nested messages: the so-called "real-time" MIDI
+ messages can be inserted into the MIDI byte stream at any location,
including within a sysex message. MIDI real-time messages are one-byte
- messages used mainly for timing (see the MIDI spec). PortMidi retains
- the order of non-real-time MIDI messages on both input and output, but
+ messages used mainly for timing (see the MIDI spec). PortMidi retains
+ the order of non-real-time MIDI messages on both input and output, but
it does not specify exactly how real-time messages are processed. This
- is particulary problematic for MIDI input, because the input parser
- must either prepare to buffer an unlimited number of sysex message
- bytes or to buffer an unlimited number of real-time messages that
+ is particulary problematic for MIDI input, because the input parser
+ must either prepare to buffer an unlimited number of sysex message
+ bytes or to buffer an unlimited number of real-time messages that
arrive embedded in a long sysex message. To simplify things, the input
- parser is allowed to pass real-time MIDI messages embedded within a
- sysex message, and it is up to the client to detect, process, and
+ parser is allowed to pass real-time MIDI messages embedded within a
+ sysex message, and it is up to the client to detect, process, and
remove these messages as they arrive.
When receiving sysex messages, the sysex message is terminated
by either an EOX status byte (anywhere in the 4 byte messages) or
by a non-real-time status byte in the low order byte of the message.
- If you get a non-real-time status byte but there was no EOX byte, it
+ If you get a non-real-time status byte but there was no EOX byte, it
means the sysex message was somehow truncated. This is not
considered an error; e.g., a missing EOX can result from the user
disconnecting a MIDI cable during sysex transmission.
- A real-time message can occur within a sysex message. A real-time
- message will always occupy a full PmEvent with the status byte in
+ A real-time message can occur within a sysex message. A real-time
+ message will always occupy a full PmEvent with the status byte in
the low-order byte of the PmEvent message field. (This implies that
the byte-order of sysex bytes and real-time message bytes may not
be preserved -- for example, if a real-time message arrives after
3 bytes of a sysex message, the real-time message will be delivered
first. The first word of the sysex message will be delivered only
after the 4th byte arrives, filling the 4-byte PmEvent message field.
-
+
The timestamp field is observed when the output port is opened with
a non-zero latency. A timestamp of zero means "use the current time",
which in turn means to deliver the message with a delay of
latency (the latency parameter used when opening the output port.)
- Do not expect PortMidi to sort data according to timestamps --
- messages should be sent in the correct order, and timestamps MUST
+ Do not expect PortMidi to sort data according to timestamps --
+ messages should be sent in the correct order, and timestamps MUST
be non-decreasing. See also "Example" for Pm_OpenOutput() above.
- A sysex message will generally fill many PmEvent structures. On
+ A sysex message will generally fill many PmEvent structures. On
output to a PortMidiStream with non-zero latency, the first timestamp
- on sysex message data will determine the time to begin sending the
- message. PortMidi implementations may ignore timestamps for the
- remainder of the sysex message.
-
- On input, the timestamp ideally denotes the arrival time of the
- status byte of the message. The first timestamp on sysex message
- data will be valid. Subsequent timestamps may denote
- when message bytes were actually received, or they may be simply
+ on sysex message data will determine the time to begin sending the
+ message. PortMidi implementations may ignore timestamps for the
+ remainder of the sysex message.
+
+ On input, the timestamp ideally denotes the arrival time of the
+ status byte of the message. The first timestamp on sysex message
+ data will be valid. Subsequent timestamps may denote
+ when message bytes were actually received, or they may be simply
copies of the first timestamp.
- Timestamps for nested messages: If a real-time message arrives in
- the middle of some other message, it is enqueued immediately with
- the timestamp corresponding to its arrival time. The interrupted
- non-real-time message or 4-byte packet of sysex data will be enqueued
+ Timestamps for nested messages: If a real-time message arrives in
+ the middle of some other message, it is enqueued immediately with
+ the timestamp corresponding to its arrival time. The interrupted
+ non-real-time message or 4-byte packet of sysex data will be enqueued
later. The timestamp of interrupted data will be equal to that of
the interrupting real-time message to insure that timestamps are
non-decreasing.
PmTimestamp timestamp;
} PmEvent;
-/**
+/**
@}
*/
/** \defgroup grp_io Reading and Writing Midi Messages
*/
/**
Pm_Read() retrieves midi data into a buffer, and returns the number
- of events read. Result is a non-negative number unless an error occurs,
+ of events read. Result is a non-negative number unless an error occurs,
in which case a PmError value will be returned.
Buffer Overflow
- The problem: if an input overflow occurs, data will be lost, ultimately
- because there is no flow control all the way back to the data source.
- When data is lost, the receiver should be notified and some sort of
- graceful recovery should take place, e.g. you shouldn't resume receiving
+ The problem: if an input overflow occurs, data will be lost, ultimately
+ because there is no flow control all the way back to the data source.
+ When data is lost, the receiver should be notified and some sort of
+ graceful recovery should take place, e.g. you shouldn't resume receiving
in the middle of a long sysex message.
- With a lock-free fifo, which is pretty much what we're stuck with to
- enable portability to the Mac, it's tricky for the producer and consumer
+ With a lock-free fifo, which is pretty much what we're stuck with to
+ enable portability to the Mac, it's tricky for the producer and consumer
to synchronously reset the buffer and resume normal operation.
Solution: the buffer managed by PortMidi will be flushed when an overflow
PMEXPORT int Pm_Read( PortMidiStream *stream, PmEvent *buffer, int32_t length );
/**
- Pm_Poll() tests whether input is available,
+ Pm_Poll() tests whether input is available,
returning TRUE, FALSE, or an error value.
*/
PMEXPORT PmError Pm_Poll( PortMidiStream *stream);
-/**
+/**
Pm_Write() writes midi data from a buffer. This may contain:
- - short messages
- or
+ - short messages
+ or
- sysex messages that are converted into a sequence of PmEvent
structures, e.g. sending data from a file or forwarding them
from midi input.
- Use Pm_WriteSysEx() to write a sysex message stored as a contiguous
+ Use Pm_WriteSysEx() to write a sysex message stored as a contiguous
array of bytes.
Sysex data may contain embedded real-time messages.
/**
Pm_WriteShort() writes a timestamped non-system-exclusive midi message.
- Messages are delivered in order as received, and timestamps must be
+ Messages are delivered in order as received, and timestamps must be
non-decreasing. (But timestamps are ignored if the stream was opened
with latency = 0.)
*/
#ifdef WIN32
#ifndef INT32_DEFINED
-// rather than having users install a special .h file for windows,
+// rather than having users install a special .h file for windows,
// just put the required definitions inline here. portmidi.h uses
// these too, so the definitions are (unfortunately) duplicated there
typedef int int32_t;
#ifdef _WINDLL
#define PMEXPORT __declspec(dllexport)
#else
-#define PMEXPORT
+#define PMEXPORT
#endif
#endif
*/
PMEXPORT int Pt_Started();
-/*
+/*
Pt_Time() returns the current time in ms.
*/
PMEXPORT PtTimestamp Pt_Time();
/*
Pt_Sleep() pauses, allowing other threads to run.
- duration is the length of the pause in ms. The true duration
+ duration is the length of the pause in ms. The true duration
of the pause may be rounded to the nearest or next clock tick
as determined by resolution in Pt_Start().
*/
/* if an error occurs while opening or closing a midi stream, set these: */
extern int pm_hosterror;
extern char pm_hosterror_text[PM_HOST_ERROR_MSG_LEN];
-
+
struct pm_internal_struct;
/* these do not use PmInternal because it is not defined yet... */
-typedef PmError (*pm_write_short_fn)(struct pm_internal_struct *midi,
+typedef PmError (*pm_write_short_fn)(struct pm_internal_struct *midi,
PmEvent *buffer);
typedef PmError (*pm_begin_sysex_fn)(struct pm_internal_struct *midi,
PmTimestamp timestamp);
pm_abort_fn abort; /* abort */
pm_close_fn close; /* close device */
pm_poll_fn poll; /* read pending midi events into portmidi buffer */
- pm_has_host_error_fn has_host_error; /* true when device has had host
+ pm_has_host_error_fn has_host_error; /* true when device has had host
error message */
pm_host_error_fn host_error; /* provide text readable host error message
for device (clears and resets) */
PmDeviceInfo pub; /* some portmidi state also saved in here (for autmatic
device closing (see PmDeviceInfo struct) */
void *descriptor; /* ID number passed to win32 multimedia API open */
- void *internalDescriptor; /* points to PmInternal device, allows automatic
+ void *internalDescriptor; /* points to PmInternal device, allows automatic
device closing */
pm_fns_type dictionary;
} descriptor_node, *descriptor_type;
typedef struct pm_internal_struct {
int device_id; /* which device is open (index to descriptors) */
short write_flag; /* MIDI_IN, or MIDI_OUT */
-
+
PmTimeProcPtr time_proc; /* where to get the time */
void *time_info; /* pass this to get_time() */
int32_t buffer_len; /* how big is the buffer or queue? */
/* set to zero to get immediate, simple blocking output */
/* if latency is zero, timestamps will be ignored; */
/* if midi input device, this field ignored */
-
+
int sysex_in_progress; /* when sysex status is seen, this flag becomes
* true until EOX is seen. When true, new data is appended to the
- * stream of outgoing bytes. When overflow occurs, sysex data is
+ * stream of outgoing bytes. When overflow occurs, sysex data is
* dropped (until an EOX or non-real-timei status byte is seen) so
- * that, if the overflow condition is cleared, we don't start
+ * that, if the overflow condition is cleared, we don't start
* sending data from the middle of a sysex message. If a sysex
* message is filtered, sysex_in_progress is false, causing the
* message to be dropped. */
/* defined by system specific implementation, e.g. pmwinmm, used by PortMidi */
-void pm_init(void);
-void pm_term(void);
+void pm_init(void);
+void pm_term(void);
/* defined by portMidi, used by pmwinmm */
PmError none_write_short(PmInternal *midi, PmEvent *buffer);
-PmError none_write_byte(PmInternal *midi, unsigned char byte,
+PmError none_write_byte(PmInternal *midi, unsigned char byte,
PmTimestamp timestamp);
PmTimestamp none_synchronize(PmInternal *midi);
PMEXPORT PmQueue *Pm_QueueCreate(long num_msgs, int32_t bytes_per_msg)
{
- int32_t int32s_per_msg =
+ int32_t int32s_per_msg =
(int32_t) (((bytes_per_msg + sizeof(int32_t) - 1) &
~(sizeof(int32_t) - 1)) / sizeof(int32_t));
PmQueueRep *queue = (PmQueueRep *) pm_alloc(sizeof(PmQueueRep));
PMEXPORT PmError Pm_QueueDestroy(PmQueue *q)
{
PmQueueRep *queue = (PmQueueRep *) q;
-
+
/* arg checking */
- if (!queue || !queue->buffer || !queue->peek)
+ if (!queue || !queue->buffer || !queue->peek)
return pmBadPtr;
-
+
pm_free(queue->peek);
pm_free(queue->buffer);
pm_free(queue);
head = queue->head;
/* if writer overflows, it writes queue->overflow = tail+1 so that
- * when the reader gets to that position in the buffer, it can
+ * when the reader gets to that position in the buffer, it can
* return the overflow condition to the reader. The problem is that
* at overflow, things have wrapped around, so tail == head, and the
* reader will detect overflow immediately instead of waiting until
* point where tail == head. So the condition also checks that
* queue->buffer[head] is zero -- if so, then the buffer is now
* empty, and we're at the point in the msg stream where overflow
- * occurred. It's time to signal overflow to the reader. If
+ * occurred. It's time to signal overflow to the reader. If
* queue->buffer[head] is non-zero, there's a message there and we
* should read all the way around the buffer before signalling overflow.
* There is a write-order dependency here, but to fail, the overflow
- * field would have to be written while an entire buffer full of
+ * field would have to be written while an entire buffer full of
* writes are still pending. I'm assuming out-of-order writes are
* possible, but not that many.
*/
/* test to see if there is data in the queue -- test from back
* to front so if writer is simultaneously writing, we don't
- * waste time discovering the write is not finished
+ * waste time discovering the write is not finished
*/
for (i = queue->msg_size - 1; i >= 0; i--) {
if (!queue->buffer[head + i]) {
return pmNoData;
}
}
- memcpy(msg, (char *) &queue->buffer[head + 1],
+ memcpy(msg, (char *) &queue->buffer[head + 1],
sizeof(int32_t) * (queue->msg_size - 1));
/* fix up zeros */
i = queue->buffer[head];
int32_t *ptr;
int32_t *dest;
int rslt;
- if (!queue)
+ if (!queue)
return pmBadPtr;
/* no more enqueue until receiver acknowledges overflow */
if (queue->overflow) return pmBufferOverflow;
PMEXPORT int Pm_QueueFull(PmQueue *q)
{
long tail;
- int i;
+ int i;
PmQueueRep *queue = (PmQueueRep *) q;
/* arg checking */
if (!queue)
if (queue->peek_flag) {
return queue->peek;
}
- /* this is ugly: if peek_overflow is set, then Pm_Dequeue()
+ /* this is ugly: if peek_overflow is set, then Pm_Dequeue()
* returns immediately with pmBufferOverflow, but here, we
* want Pm_Dequeue() to really check for data. If data is
* there, we can return it
queue->peek_flag = TRUE;
return queue->peek;
} else if (rslt == pmBufferOverflow) {
- /* when overflow is indicated, the queue is empty and the
+ /* when overflow is indicated, the queue is empty and the
* first message that was dropped by Enqueue (signalling
* pmBufferOverflow to its caller) would have been the next
* message in the queue. Pm_QueuePeek will return NULL, but
int pm_descriptor_index = 0;
descriptor_type descriptors = NULL;
-/* pm_add_device -- describe interface/device pair to library
+/* pm_add_device -- describe interface/device pair to library
*
- * This is called at intialization time, once for each
+ * This is called at intialization time, once for each
* interface (e.g. DirectSound) and device (e.g. SoundBlaster 1)
* The strings are retained but NOT COPIED, so do not destroy them!
*
* returns pmInvalidDeviceId if device memory is exceeded
* otherwise returns pmNoError
*/
-PmError pm_add_device(char *interf, char *name, int input,
+PmError pm_add_device(char *interf, char *name, int input,
void *descriptor, pm_fns_type dictionary) {
if (pm_descriptor_index >= pm_descriptor_max) {
// expand descriptors
- descriptor_type new_descriptors = (descriptor_type)
+ descriptor_type new_descriptors = (descriptor_type)
pm_alloc(sizeof(descriptor_node) * (pm_descriptor_max + 32));
if (!new_descriptors) return pmInsufficientMemory;
if (descriptors) {
- memcpy(new_descriptors, descriptors,
+ memcpy(new_descriptors, descriptors,
sizeof(descriptor_node) * pm_descriptor_max);
free(descriptors);
}
/* ID number passed to win32 multimedia API open */
descriptors[pm_descriptor_index].descriptor = descriptor;
-
+
/* points to PmInternal, allows automatic device closing */
descriptors[pm_descriptor_index].internalDescriptor = NULL;
descriptors[pm_descriptor_index].dictionary = dictionary;
-
+
pm_descriptor_index++;
-
+
return pmNoError;
}
-/* utility to look up device, given a pattern,
+/* utility to look up device, given a pattern,
note: pattern is modified
*/
int pm_find_default_device(char *pattern, int is_input)
id = i;
break;
}
- }
+ }
return id;
}
return pmBadPtr;
}
-PmError none_write_byte(PmInternal *midi, unsigned char byte,
+PmError none_write_byte(PmInternal *midi, unsigned char byte,
PmTimestamp timestamp) {
return pmBadPtr;
}
none_write_flush,
none_synchronize,
none_open,
- none_abort,
+ none_abort,
none_close,
none_poll,
none_has_host_error,
- none_get_host_error
+ none_get_host_error
};
switch(errnum)
{
- case pmNoError:
- msg = "";
+ case pmNoError:
+ msg = "";
break;
- case pmHostError:
- msg = "PortMidi: `Host error'";
+ case pmHostError:
+ msg = "PortMidi: `Host error'";
break;
- case pmInvalidDeviceId:
- msg = "PortMidi: `Invalid device ID'";
+ case pmInvalidDeviceId:
+ msg = "PortMidi: `Invalid device ID'";
break;
- case pmInsufficientMemory:
- msg = "PortMidi: `Insufficient memory'";
+ case pmInsufficientMemory:
+ msg = "PortMidi: `Insufficient memory'";
break;
- case pmBufferTooSmall:
- msg = "PortMidi: `Buffer too small'";
+ case pmBufferTooSmall:
+ msg = "PortMidi: `Buffer too small'";
break;
- case pmBadPtr:
- msg = "PortMidi: `Bad pointer'";
+ case pmBadPtr:
+ msg = "PortMidi: `Bad pointer'";
break;
- case pmInternalError:
- msg = "PortMidi: `Internal PortMidi Error'";
+ case pmInternalError:
+ msg = "PortMidi: `Internal PortMidi Error'";
break;
case pmBufferOverflow:
msg = "PortMidi: `Buffer overflow'";
case pmBufferMaxSize:
msg = "PortMidi: `Buffer cannot be made larger'";
break;
- default:
- msg = "PortMidi: `Illegal error number'";
+ default:
+ msg = "PortMidi: `Illegal error number'";
break;
}
return msg;
PmInternal * midi = (PmInternal *) stream;
pm_hosterror = (*midi->dictionary->has_host_error)(midi);
if (pm_hosterror) {
- midi->dictionary->host_error(midi, pm_hosterror_text,
+ midi->dictionary->host_error(midi, pm_hosterror_text,
PM_HOST_ERROR_MSG_LEN);
/* now error message is global */
return TRUE;
else if(!descriptors[midi->device_id].pub.opened)
err = pmBadPtr;
else if(!descriptors[midi->device_id].pub.input)
- err = pmBadPtr;
+ err = pmBadPtr;
/* First poll for data in the buffer...
* This either simply checks for data, or attempts first to fill the buffer
* with data from the MIDI hardware; this depends on the implementation.
if (err != pmNoError) {
if (err == pmHostError) {
- midi->dictionary->host_error(midi, pm_hosterror_text,
+ midi->dictionary->host_error(midi, pm_hosterror_text,
PM_HOST_ERROR_MSG_LEN);
pm_hosterror = TRUE;
}
if (err != pmNoError) {
if (err == pmHostError) {
- midi->dictionary->host_error(midi, pm_hosterror_text,
+ midi->dictionary->host_error(midi, pm_hosterror_text,
PM_HOST_ERROR_MSG_LEN);
pm_hosterror = TRUE;
}
/* this is called from Pm_Write and Pm_WriteSysEx to issue a
- * call to the system-dependent end_sysex function and handle
+ * call to the system-dependent end_sysex function and handle
* the error return
*/
static PmError pm_end_sysex(PmInternal *midi)
PmError err = (*midi->dictionary->end_sysex)(midi, 0);
midi->sysex_in_progress = FALSE;
if (err == pmHostError) {
- midi->dictionary->host_error(midi, pm_hosterror_text,
+ midi->dictionary->host_error(midi, pm_hosterror_text,
PM_HOST_ERROR_MSG_LEN);
pm_hosterror = TRUE;
}
PmError err = pmNoError;
int i;
int bits;
-
+
pm_hosterror = FALSE;
/* arg checking */
if(midi == NULL)
err = pmBadPtr;
else
err = pmNoError;
-
+
if (err != pmNoError) goto pm_write_error;
-
+
if (midi->latency == 0) {
midi->now = 0;
} else {
* dictionary->begin_sysex() followed by calls to
* dictionary->write_byte() and dictionary->write_realtime()
* until an end-of-sysex is detected, when we call
- * dictionary->end_sysex(). After an error occurs,
+ * dictionary->end_sysex(). After an error occurs,
* Pm_Write() continues to call functions. For example,
* it will continue to call write_byte() even after
* an error sending a sysex message, and end_sysex() will be
* called when an EOX or non-real-time status is found.
- * When errors are detected, Pm_Write() returns immediately,
+ * When errors are detected, Pm_Write() returns immediately,
* so it is possible that this will drop data and leave
* sysex messages in a partially transmitted state.
*/
goto pm_write_error;
}
midi->sysex_in_progress = TRUE;
- if ((err = (*midi->dictionary->begin_sysex)(midi,
+ if ((err = (*midi->dictionary->begin_sysex)(midi,
buffer[i].timestamp)) != pmNoError)
goto pm_write_error;
if ((err = (*midi->dictionary->write_byte)(midi, MIDI_SYSEX,
- buffer[i].timestamp)) != pmNoError)
+ buffer[i].timestamp)) != pmNoError)
goto pm_write_error;
bits = 8;
/* fall through to continue sysex processing */
- } else if ((msg & MIDI_STATUS_MASK) &&
+ } else if ((msg & MIDI_STATUS_MASK) &&
(Pm_MessageStatus(msg) != MIDI_EOX)) {
/* a non-sysex message */
if (midi->sysex_in_progress) {
/* this should be a realtime message */
if (is_real_time(msg)) {
- if ((err = (*midi->dictionary->write_realtime)(midi,
+ if ((err = (*midi->dictionary->write_realtime)(midi,
&(buffer[i]))) != pmNoError)
goto pm_write_error;
} else {
goto pm_write_error;
}
} else { /* regular short midi message */
- if ((err = (*midi->dictionary->write_short)(midi,
+ if ((err = (*midi->dictionary->write_short)(midi,
&(buffer[i]))) != pmNoError)
goto pm_write_error;
continue;
(*midi->fill_offset_ptr) + 4 <= midi->fill_length &&
(msg & 0x80808080) == 0) { /* all data */
/* copy 4 bytes from msg to fill_base + fill_offset */
- unsigned char *ptr = midi->fill_base +
+ unsigned char *ptr = midi->fill_base +
*(midi->fill_offset_ptr);
- ptr[0] = msg; ptr[1] = msg >> 8;
+ ptr[0] = msg; ptr[1] = msg >> 8;
ptr[2] = msg >> 16; ptr[3] = msg >> 24;
(*midi->fill_offset_ptr) += 4;
continue;
/* no acceleration, so do byte-by-byte copying */
while (bits < 32) {
unsigned char midi_byte = (unsigned char) (msg >> bits);
- if ((err = (*midi->dictionary->write_byte)(midi, midi_byte,
+ if ((err = (*midi->dictionary->write_byte)(midi, midi_byte,
buffer[i].timestamp)) != pmNoError)
goto pm_write_error;
if (midi_byte == MIDI_EOX) {
err = (*midi->dictionary->write_flush)(midi, 0);
pm_write_error:
if (err == pmHostError) {
- midi->dictionary->host_error(midi, pm_hosterror_text,
+ midi->dictionary->host_error(midi, pm_hosterror_text,
PM_HOST_ERROR_MSG_LEN);
pm_hosterror = TRUE;
}
PMEXPORT PmError Pm_WriteShort(PortMidiStream *stream, PmTimestamp when, PmMessage msg)
{
PmEvent event;
-
+
event.timestamp = when;
event.message = msg;
return Pm_Write(stream, &event, 1);
}
-PMEXPORT PmError Pm_WriteSysEx(PortMidiStream *stream, PmTimestamp when,
+PMEXPORT PmError Pm_WriteSysEx(PortMidiStream *stream, PmTimestamp when,
unsigned char *msg)
{
/* allocate buffer space for PM_DEFAULT_SYSEX_BUFFER_SIZE bytes */
}
/* I thought that I could do a pm_Write here and
* change this if to a loop, avoiding calls in Pm_Write
- * to the slower write_byte, but since
+ * to the slower write_byte, but since
* sysex_in_progress is true, this will not flush
* the buffer, and we'll infinite loop: */
/* err = Pm_Write(stream, buffer, 0);
}
buffer[bufx].message = 0;
buffer[bufx].timestamp = when;
- }
+ }
/* keep inserting bytes until you find MIDI_EOX */
}
end_of_sysex:
PmError err = pmNoError;
pm_hosterror = FALSE;
*stream = NULL;
-
+
/* arg checking */
- if (inputDevice < 0 || inputDevice >= pm_descriptor_index)
+ if (inputDevice < 0 || inputDevice >= pm_descriptor_index)
err = pmInvalidDeviceId;
- else if (!descriptors[inputDevice].pub.input)
+ else if (!descriptors[inputDevice].pub.input)
err = pmInvalidDeviceId;
else if(descriptors[inputDevice].pub.opened)
err = pmInvalidDeviceId;
-
- if (err != pmNoError)
+
+ if (err != pmNoError)
goto error_return;
/* create portMidi internal data */
- midi = (PmInternal *) pm_alloc(sizeof(PmInternal));
+ midi = (PmInternal *) pm_alloc(sizeof(PmInternal));
*stream = midi;
if (!midi) {
err = pmInsufficientMemory;
if (!midi->queue) {
/* free portMidi data */
*stream = NULL;
- pm_free(midi);
+ pm_free(midi);
err = pmInsufficientMemory;
goto error_return;
}
midi->buffer_len = bufferSize; /* portMidi input storage */
midi->latency = 0; /* not used */
midi->sysex_in_progress = FALSE;
- midi->sysex_message = 0;
- midi->sysex_message_count = 0;
+ midi->sysex_message = 0;
+ midi->sysex_message_count = 0;
midi->filters = PM_FILT_ACTIVE;
midi->channel_mask = 0xFFFF;
midi->sync_time = 0;
int32_t bufferSize,
PmTimeProcPtr time_proc,
void *time_info,
- int32_t latency )
+ int32_t latency )
{
PmInternal *midi;
PmError err = pmNoError;
pm_hosterror = FALSE;
*stream = NULL;
-
+
/* arg checking */
if (outputDevice < 0 || outputDevice >= pm_descriptor_index)
err = pmInvalidDeviceId;
- else if (!descriptors[outputDevice].pub.output)
+ else if (!descriptors[outputDevice].pub.output)
err = pmInvalidDeviceId;
else if (descriptors[outputDevice].pub.opened)
err = pmInvalidDeviceId;
- if (err != pmNoError)
+ if (err != pmNoError)
goto error_return;
/* create portMidi internal data */
- midi = (PmInternal *) pm_alloc(sizeof(PmInternal));
- *stream = midi;
+ midi = (PmInternal *) pm_alloc(sizeof(PmInternal));
+ *stream = midi;
if (!midi) {
err = pmInsufficientMemory;
goto error_return;
/* if latency > 0, we need a time reference. If none is provided,
use PortTime library */
if (time_proc == NULL && latency != 0) {
- if (!Pt_Started())
+ if (!Pt_Started())
Pt_Start(1, 0, 0);
/* time_get does not take a parameter, so coerce */
midi->time_proc = (PmTimeProcPtr) Pt_Time;
*stream = NULL;
descriptors[outputDevice].internalDescriptor = NULL;
/* free portMidi data */
- pm_free(midi);
+ pm_free(midi);
} else {
/* portMidi input open successful */
descriptors[outputDevice].pub.opened = TRUE;
/* and the device should be in the opened state */
else if (!descriptors[midi->device_id].pub.opened)
err = pmBadPtr;
-
- if (err != pmNoError)
+
+ if (err != pmNoError)
goto error_return;
/* close the device */
descriptors[midi->device_id].internalDescriptor = NULL;
descriptors[midi->device_id].pub.opened = FALSE;
if (midi->queue) Pm_QueueDestroy(midi->queue);
- pm_free(midi);
+ pm_free(midi);
error_return:
/* system dependent code must set pm_hosterror and
* pm_hosterror_text if a pmHostError occurs.
err = (*midi->dictionary->abort)(midi);
if (err == pmHostError) {
- midi->dictionary->host_error(midi, pm_hosterror_text,
+ midi->dictionary->host_error(midi, pm_hosterror_text,
PM_HOST_ERROR_MSG_LEN);
pm_hosterror = TRUE;
}
static void pm_flush_sysex(PmInternal *midi, PmTimestamp timestamp)
{
PmEvent event;
-
+
/* there may be nothing in the buffer */
if (midi->sysex_message_count == 0) return; /* nothing to flush */
-
+
event.message = midi->sysex_message;
event.timestamp = timestamp;
/* copied from pm_read_short, avoids filtering */
1) all short input messages must be sent to pm_read_short, which
enqueues them to a FIFO for the application.
2) each buffer of sysex bytes should be reported by calling pm_read_bytes
- (which sets midi->sysex_in_progress). After the eox byte,
+ (which sets midi->sysex_in_progress). After the eox byte,
pm_read_bytes will clear sysex_in_progress
*/
-/* pm_read_short is the place where all input messages arrive from
+/* pm_read_short is the place where all input messages arrive from
system-dependent code such as pmwinmm.c. Here, the messages
- are entered into the PortMidi input buffer.
+ are entered into the PortMidi input buffer.
*/
void pm_read_short(PmInternal *midi, PmEvent *event)
-{
+{
int status;
/* arg checking */
assert(midi != NULL);
/* midi filtering is applied here */
status = Pm_MessageStatus(event->message);
if (!pm_status_filtered(status, midi->filters)
- && (!is_real_time(status) ||
+ && (!is_real_time(status) ||
!pm_realtime_filtered(status, midi->filters))
&& !pm_channel_filtered(status, midi->channel_mask)) {
/* if sysex is in progress and we get a status byte, it had
* embedded in a sysex message
*/
if (is_real_time(status)) {
- midi->sysex_message |=
+ midi->sysex_message |=
(status << (8 * midi->sysex_message_count++));
if (midi->sysex_message_count == 4) {
pm_flush_sysex(midi, event->timestamp);
/*
* returns how many bytes processed
*/
-unsigned int pm_read_bytes(PmInternal *midi, const unsigned char *data,
+unsigned int pm_read_bytes(PmInternal *midi, const unsigned char *data,
int len, PmTimestamp timestamp)
{
int i = 0; /* index into data, must not be unsigned (!) */
}
/* Now, i<len implies sysex_in_progress. If sysex_in_progress
* becomes false in the loop, there must have been an overflow
- * and we can just drop all remaining bytes
+ * and we can just drop all remaining bytes
*/
while (i < len && midi->sysex_in_progress) {
if (midi->sysex_message_count == 0 && i <= len - 4 &&
- ((event.message = (((PmMessage) data[i]) |
+ ((event.message = (((PmMessage) data[i]) |
(((PmMessage) data[i+1]) << 8) |
(((PmMessage) data[i+2]) << 16) |
(((PmMessage) data[i+3]) << 24))) &
- 0x80808080) == 0) { /* all data, no status */
+ 0x80808080) == 0) { /* all data, no status */
if (Pm_Enqueue(midi->queue, &event) == pmBufferOverflow) {
midi->sysex_in_progress = FALSE;
}
while (i < len) {
/* send one byte at a time */
unsigned char byte = data[i++];
- if (is_real_time(byte) &&
+ if (is_real_time(byte) &&
pm_realtime_filtered(byte, midi->filters)) {
continue; /* real-time data is filtered, so omit */
}
- midi->sysex_message |=
+ midi->sysex_message |=
(byte << (8 * midi->sysex_message_count++));
if (byte == MIDI_EOX) {
midi->sysex_in_progress = FALSE;
/* pmmac.c -- PortMidi os-dependent code */
/* This file only needs to implement:
-pm_init(), which calls various routines to register the
+pm_init(), which calls various routines to register the
available midi devices,
Pm_GetDefaultInputDeviceID(), and
Pm_GetDefaultOutputDeviceID().
pm_initialized = TRUE;
if (!err) {
pm_default_input_device_id = find_default_device(
- "/PortMidi/PM_RECOMMENDED_INPUT_DEVICE", TRUE,
+ "/PortMidi/PM_RECOMMENDED_INPUT_DEVICE", TRUE,
pm_default_input_device_id);
pm_default_output_device_id = find_default_device(
- "/PortMidi/PM_RECOMMENDED_OUTPUT_DEVICE", FALSE,
+ "/PortMidi/PM_RECOMMENDED_OUTPUT_DEVICE", FALSE,
pm_default_output_device_id);
}
}
/*
* Platform interface to the MacOS X CoreMIDI framework
- *
+ *
* Jon Parise <jparise at cmu.edu>
* and subsequent work by Andrew Zeldis and Zico Kolter
* and Roger B. Dannenberg
*
* $Id: pmmacosx.c,v 1.17 2002/01/27 02:40:40 jon Exp $
*/
-
+
/* Notes:
since the input and output streams are represented by MIDIEndpointRef
values and almost no other state, we store the MIDIEndpointRef on
the error text. We use a structure with two kinds of
host error: "error" and "callback_error". That way, asynchronous callbacks
do not interfere with other error information.
-
+
OS X does not seem to have an error-code-to-text function, so we will
just use text messages instead of error codes.
*/
#define MAX_BYTES_PER_S 14000
/* Apple reports that packets are dropped when the MIDI bytes/sec
- exceeds 15000. This is computed by "tracking the number of MIDI
+ exceeds 15000. This is computed by "tracking the number of MIDI
bytes scheduled into 1-second buckets over the last six seconds
- and averaging these counts."
+ and averaging these counts."
- This is apparently based on timestamps, not on real time, so
+ This is apparently based on timestamps, not on real time, so
we have to avoid constructing packets that schedule high speed
output even if the actual writes are delayed (which was my first
solution).
- The LIMIT_RATE symbol, if defined, enables code to modify
+ The LIMIT_RATE symbol, if defined, enables code to modify
timestamps as follows:
After each packet is formed, the next allowable timestamp is
computed as this_packet_time + this_packet_len * delay_per_byte
- This is the minimum timestamp allowed in the next packet.
+ This is the minimum timestamp allowed in the next packet.
Note that this distorts accurate timestamps somewhat.
*/
Byte sysex_buffer[SYSEX_BUFFER_SIZE]; /* temp storage for sysex data */
MIDITimeStamp sysex_timestamp; /* timestamp to use with sysex data */
/* allow for running status (is running status possible here? -rbd): -cpr */
- unsigned char last_command;
+ unsigned char last_command;
int32_t last_msg_length;
/* limit midi data rate (a CoreMidi requirement): */
UInt64 min_next_time; /* when can the next send take place? */
static PmTimestamp midi_synchronize(PmInternal *midi)
{
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
- UInt64 pm_stream_time_2 =
+ UInt64 pm_stream_time_2 =
AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
PmTimestamp real_time;
UInt64 pm_stream_time;
- /* if latency is zero and this is an output, there is no
+ /* if latency is zero and this is an output, there is no
time reference and midi_synchronize should never be called */
assert(midi->time_proc);
assert(!(midi->write_flag && midi->latency == 0));
static void
-process_packet(MIDIPacket *packet, PmEvent *event,
+process_packet(MIDIPacket *packet, PmEvent *event,
PmInternal *midi, midi_macosxcm_type m)
{
/* handle a packet of MIDI messages from CoreMIDI */
(m->last_command == 0 &&
!(cur_packet_data[0] & MIDI_STATUS_MASK))) {
m->last_command = 0; /* no running status */
- unsigned int amt = pm_read_bytes(midi, cur_packet_data,
- remaining_length,
+ unsigned int amt = pm_read_bytes(midi, cur_packet_data,
+ remaining_length,
event->timestamp);
remaining_length -= amt;
cur_packet_data += amt;
switch (cur_message_length) {
case 1:
event->message = Pm_Message(cur_packet_data[0], 0, 0);
- break;
+ break;
case 2:
- event->message = Pm_Message(cur_packet_data[0],
+ event->message = Pm_Message(cur_packet_data[0],
cur_packet_data[1], 0);
break;
case 3:
event->message = Pm_Message(cur_packet_data[0],
- cur_packet_data[1],
+ cur_packet_data[1],
cur_packet_data[2]);
break;
default:
event->message = Pm_Message(m->last_command, 0, 0);
break;
case 2:
- event->message = Pm_Message(m->last_command,
+ event->message = Pm_Message(m->last_command,
cur_packet_data[0], 0);
break;
case 3:
- event->message = Pm_Message(m->last_command,
- cur_packet_data[0],
+ event->message = Pm_Message(m->last_command,
+ cur_packet_data[0],
cur_packet_data[1]);
break;
default:
unsigned int packetIndex;
uint32_t now;
unsigned int status;
-
+
#ifdef CM_DEBUG
printf("readProc: numPackets %d: ", newPackets->numPackets);
#endif
midi = (PmInternal *) connRefCon;
m = (midi_macosxcm_type) midi->descriptor;
assert(m);
-
+
/* synchronize time references every 100ms */
now = (*midi->time_proc)(midi->time_info);
- if (m->first_message || m->sync_time + 100 /*ms*/ < now) {
+ if (m->first_message || m->sync_time + 100 /*ms*/ < now) {
/* time to resync */
now = midi_synchronize(midi);
m->first_message = FALSE;
}
-
+
packet = (MIDIPacket *) &newPackets->packet[0];
- /* printf("readproc packet status %x length %d\n", packet->data[0],
+ /* printf("readproc packet status %x length %d\n", packet->data[0],
packet->length); */
for (packetIndex = 0; packetIndex < newPackets->numPackets; packetIndex++) {
/* Set the timestamp and dispatch this message */
event.timestamp = (PmTimestamp) /* explicit conversion */ (
- (AudioConvertHostTimeToNanos(packet->timeStamp) - m->delta) /
+ (AudioConvertHostTimeToNanos(packet->timeStamp) - m->delta) /
(UInt64) 1000000);
status = packet->data[0];
/* process packet as sysex data if it begins with MIDI_SYSEX, or
#ifdef CM_DEBUG
printf(" %d", packet->length);
#endif
- if (status == MIDI_SYSEX || status == MIDI_EOX ||
+ if (status == MIDI_SYSEX || status == MIDI_EOX ||
((!(status & MIDI_STATUS_MASK)) && !m->last_command)) {
/* previously was: !(status & MIDI_STATUS_MASK)) {
* but this could mistake running status for sysex data
MIDIEndpointRef endpoint;
midi_macosxcm_type m;
OSStatus macHostError;
-
+
/* insure that we have a time_proc for timing */
if (midi->time_proc == NULL) {
- if (!Pt_Started())
+ if (!Pt_Started())
Pt_Start(1, 0, 0);
/* time_get does not take a parameter, so coerce */
midi->time_proc = (PmTimeProcPtr) Pt_Time;
macHostError = MIDIPortConnectSource(portIn, endpoint, midi);
if (macHostError != noErr) {
pm_hosterror = macHostError;
- sprintf(pm_hosterror_text,
+ sprintf(pm_hosterror_text,
"Host error %ld: MIDIPortConnectSource() in midi_in_open()",
(long) macHostError);
midi->descriptor = NULL;
pm_free(m);
return pmHostError;
}
-
+
return pmNoError;
}
MIDIEndpointRef endpoint;
OSStatus macHostError;
PmError err = pmNoError;
-
+
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
-
+
if (!m) return pmBadPtr;
endpoint = (MIDIEndpointRef) (long) descriptors[midi->device_id].descriptor;
if (endpoint == NULL_REF) {
pm_hosterror = pmBadPtr;
}
-
+
/* shut off the incoming messages before freeing data structures */
macHostError = MIDIPortDisconnectSource(portIn, endpoint);
if (macHostError != noErr) {
pm_hosterror = macHostError;
- sprintf(pm_hosterror_text,
+ sprintf(pm_hosterror_text,
"Host error %ld: MIDIPortDisconnectSource() in midi_in_close()",
(long) macHostError);
err = pmHostError;
}
-
+
midi->descriptor = NULL;
pm_free(midi->descriptor);
-
+
return err;
}
m->min_next_time = 0;
m->byte_count = 0;
m->us_per_host_tick = 1000000.0 / AudioGetHostClockFrequency();
- m->host_ticks_per_byte = (UInt64) (1000000.0 /
+ m->host_ticks_per_byte = (UInt64) (1000000.0 /
(m->us_per_host_tick * MAX_BYTES_PER_S));
return pmNoError;
}
{
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
if (!m) return pmBadPtr;
-
+
midi->descriptor = NULL;
pm_free(midi->descriptor);
-
+
return pmNoError;
}
{
OSStatus macHostError;
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
- MIDIEndpointRef endpoint =
+ MIDIEndpointRef endpoint =
(MIDIEndpointRef) (long) descriptors[midi->device_id].descriptor;
assert(m);
assert(endpoint);
* 15KB/s. */
UInt64 now = AudioGetCurrentHostTime();
if (now < m->min_next_time) {
- usleep((useconds_t)
+ usleep((useconds_t)
((m->min_next_time - now) * m->us_per_host_tick));
}
macHostError = MIDISend(portOut, endpoint, m->packetList);
if (macHostError != noErr) goto send_packet_error;
}
return pmNoError;
-
+
send_packet_error:
pm_hosterror = macHostError;
- sprintf(pm_hosterror_text,
+ sprintf(pm_hosterror_text,
"Host error %ld: MIDISend() in midi_write()",
(long) macHostError);
return pmHostError;
static PmError
-send_packet(PmInternal *midi, Byte *message, unsigned int messageLength,
+send_packet(PmInternal *midi, Byte *message, unsigned int messageLength,
MIDITimeStamp timestamp)
{
PmError err;
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
assert(m);
-
+
/* printf("add %d to packet %p len %d\n", message[0], m->packet, messageLength); */
- m->packet = MIDIPacketListAdd(m->packetList, sizeof(m->packetBuffer),
- m->packet, timestamp, messageLength,
+ m->packet = MIDIPacketListAdd(m->packetList, sizeof(m->packetBuffer),
+ m->packet, timestamp, messageLength,
message);
m->byte_count += messageLength;
if (m->packet == NULL) {
/* out of space, send the buffer and start refilling it */
/* make midi->packet non-null to fool midi_write_flush into sending */
- m->packet = (MIDIPacket *) 4;
+ m->packet = (MIDIPacket *) 4;
/* timestamp is 0 because midi_write_flush ignores timestamp since
* timestamps are already in packets. The timestamp parameter is here
- * because other API's need it. midi_write_flush can be called
+ * because other API's need it. midi_write_flush can be called
* from system-independent code that must be cross-API.
*/
if ((err = midi_write_flush(midi, 0)) != pmNoError) return err;
m->packet = MIDIPacketListInit(m->packetList);
assert(m->packet); /* if this fails, it's a programming error */
m->packet = MIDIPacketListAdd(m->packetList, sizeof(m->packetBuffer),
- m->packet, timestamp, messageLength,
+ m->packet, timestamp, messageLength,
message);
- assert(m->packet); /* can't run out of space on first message */
+ assert(m->packet); /* can't run out of space on first message */
}
return pmNoError;
-}
+}
static PmError
if (m->packet == NULL) {
m->packet = MIDIPacketListInit(m->packetList);
- /* this can never fail, right? failure would indicate something
+ /* this can never fail, right? failure would indicate something
unrecoverable */
assert(m->packet);
}
-
+
/* compute timestamp */
if (when == 0) when = midi->now;
/* if latency == 0, midi->now is not valid. We will just set it to zero */
message[1] = Pm_MessageData1(what);
message[2] = Pm_MessageData2(what);
messageLength = midi_length(what);
-
+
/* make sure we go foreward in time */
if (timestamp < m->min_next_time) timestamp = m->min_next_time;
}
-static PmError
+static PmError
midi_begin_sysex(PmInternal *midi, PmTimestamp when)
{
UInt64 when_ns;
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
assert(m);
m->sysex_byte_count = 0;
-
+
/* compute timestamp */
if (when == 0) when = midi->now;
/* if latency == 0, midi->now is not valid. We will just set it to zero */
if (m->packet == NULL) {
m->packet = MIDIPacketListInit(m->packetList);
- /* this can never fail, right? failure would indicate something
+ /* this can never fail, right? failure would indicate something
unrecoverable */
assert(m->packet);
}
PmError err;
midi_macosxcm_type m = (midi_macosxcm_type) midi->descriptor;
assert(m);
-
+
/* make sure we go foreward in time */
- if (m->sysex_timestamp < m->min_next_time)
+ if (m->sysex_timestamp < m->min_next_time)
m->sysex_timestamp = m->min_next_time;
#ifdef LIMIT_RATE
- if (m->sysex_timestamp < m->last_time)
+ if (m->sysex_timestamp < m->last_time)
m->sysex_timestamp = m->last_time;
m->last_time = m->sysex_timestamp + m->sysex_byte_count *
m->host_ticks_per_byte;
#endif
-
+
/* now send what's in the buffer */
err = send_packet(midi, m->sysex_buffer, m->sysex_byte_count,
m->sysex_timestamp);
{
CFMutableStringRef result = CFStringCreateMutable(NULL, 0);
CFStringRef str;
-
+
// begin with the endpoint's name
str = NULL;
MIDIObjectGetStringProperty(endpoint, kMIDIPropertyName, &str);
CFStringAppend(result, str);
CFRelease(str);
}
-
+
MIDIEntityRef entity = NULL_REF;
MIDIEndpointGetEntity(endpoint, &entity);
if (entity == NULL_REF)
// probably virtual
return result;
-
+
if (CFStringGetLength(result) == 0) {
// endpoint name has zero length -- try the entity
str = NULL;
MIDIEntityGetDevice(entity, &device);
if (device == NULL_REF)
return result;
-
+
str = NULL;
MIDIObjectGetStringProperty(device, kMIDIPropertyName, &str);
if (CFStringGetLength(result) == 0) {
CFStringRef str;
OSStatus err;
long i;
-
+
// Does the endpoint have connections?
CFDataRef connections = NULL;
long nConnected = 0;
}
if (anyStrings)
return result;
-
+
// Here, either the endpoint had no connections, or we failed to obtain names for any of them.
return EndpointName(endpoint, false);
}
defaultEncoding = CFStringGetSystemEncoding();
fullName = ConnectedEndpointName(endpoint);
-
+
#ifdef OLDCODE
/* get the entity and device info */
MIDIEndpointGetEntity(endpoint, &entity);
} else {
fullName = endpointName;
}
-#endif
+#endif
/* copy the string into our buffer */
if (fullName) {
newName = (char *) malloc(CFStringGetLength(fullName) + 1);
} else {
newName = NULL;
}
-
+
/* clean up */
#ifdef OLDCODE
if (endpointName) CFRelease(endpointName);
return newName;
}
-
+
pm_fns_node pm_macosx_in_dictionary = {
none_write_short,
error_text = "MIDIInputPortCreate() in pm_macosxcm_init()";
goto error_return;
}
-
+
/* Create the output port */
macHostError = MIDIOutputPortCreate(client, CFSTR("Output port"), &portOut);
if (macHostError != noErr) {
/* set the first input we see to the default */
if (pm_default_input_device_id == -1)
pm_default_input_device_id = pm_descriptor_index;
-
+
/* Register this device with PortMidi */
char* full_endpoint_name = cm_get_full_endpoint_name(endpoint);
if (full_endpoint_name != NULL) {
}
}
return pmNoError;
-
+
error_return:
pm_hosterror = macHostError;
- sprintf(pm_hosterror_text, "Host error %ld: %s\n", (long) macHostError,
+ sprintf(pm_hosterror_text, "Host error %ld: %s\n", (long) macHostError,
error_text);
pm_macosxcm_term(); /* clear out any opened ports */
return pmHostError;
to allocate memory from blocks of 1024 bytes and keep the blocks in a
list associated with but private to this module. So the user should
access this module by calling:
- bplist_read_file() or bplist_read_user_pref() or
+ bplist_read_file() or bplist_read_user_pref() or
bplist_read_system_pref()
which returns a value. When you are done with the value, call
bplist_free_data()
/* there are 2 levels of error logging/printing:
* BPLIST_LOG and BPLIST_LOG_VERBOSE
* either or both can be set to non-zero to turn on
- * If BPLIST_LOG_VERBOSE is true, then BPLIST_LOG
+ * If BPLIST_LOG_VERBOSE is true, then BPLIST_LOG
* is also true.
- *
+ *
* In the code, logging is done by calling either
* bplist_log() or bplist_log_verbose(), which take
* parameters like printf but might be a no-op.
*/
-
+
/* #define BPLIST_LOG_VERBOSE 1 */
#if BPLIST_LOG_VERBOSE
bplist_log("Bad binary plist: too short or invalid header.\n");
return NULL;
}
-
+
// read trailer
ptr = (uint8_t *) (data->data + data->len - kTRAILER_SIZE);
bplist.offset_int_size = ptr[6];
bplist.object_count = convert_uint64(ptr + 8);
top_level_object = convert_uint64(ptr + 16);
bplist.offset_table_offset = convert_uint64(ptr + 24);
-
+
// Basic sanity checks
if (bplist.offset_int_size < 1 || bplist.offset_int_size > 8 ||
bplist.object_ref_size < 1 || bplist.object_ref_size > 8 ||
bplist.offset_table_offset < kHEADER_SIZE) {
bplist_log("Bad binary plist: trailer declared insane.\n");
- return NULL;
+ return NULL;
}
-
+
// Ensure offset table is inside file
uint64_t offsetTableSize = bplist.offset_int_size * bplist.object_count;
- if (offsetTableSize + bplist.offset_table_offset + kTRAILER_SIZE >
+ if (offsetTableSize + bplist.offset_table_offset + kTRAILER_SIZE >
data->len) {
bplist_log("Bad binary plist: offset table overlaps end of container.\n");
return NULL;
}
-
+
bplist.data_bytes = data->data;
bplist.length = data->len;
bplist.cache = NULL; /* dictionary is empty */
- bplist_log_verbose("Got a sane bplist with %llu items, offset_int_size: %u, object_ref_size: %u\n",
- bplist.object_count, bplist.offset_int_size,
+ bplist_log_verbose("Got a sane bplist with %llu items, offset_int_size: %u, object_ref_size: %u\n",
+ bplist.object_count, bplist.offset_int_size,
bplist.object_ref_size);
/* at this point, we are ready to do some parsing which allocates
memory for the result data structure. If memory allocation (using
uint64_t offset;
value_ptr result = NULL;
uint8_t objectTag;
-
+
if (objectRef >= bplist->object_count) {
// Out-of-range object reference.
bplist_log("Bad binary plist: object index is out of range.\n");
return NULL;
}
-
+
// Use cached object if it exists
result = cache_lookup(bplist->cache, objectRef);
if (result != NULL) return result;
-
+
// Otherwise, find object in file.
offset = read_offset(bplist, objectRef);
if (offset > bplist->length) {
case kTAG_SIMPLE:
result = extract_simple(bplist, offset);
break;
-
+
case kTAG_INT:
result = extract_int(bplist, offset);
break;
-
+
case kTAG_REAL:
result = extract_real(bplist, offset);
break;
-
+
case kTAG_DATE:
result = extract_date(bplist, offset);
break;
-
+
case kTAG_DATA:
result = extract_data(bplist, offset);
break;
-
+
case kTAG_ASCIISTRING:
result = extract_ascii_string(bplist, offset);
break;
-
+
case kTAG_UNICODESTRING:
result = extract_unicode_string(bplist, offset);
break;
-
+
case kTAG_UID:
result = extract_uid(bplist, offset);
break;
-
+
case kTAG_ARRAY:
result = extract_array(bplist, offset);
break;
-
+
case kTAG_DICTIONARY:
result = extract_dictionary(bplist, offset);
break;
-
+
default:
// Unknown tag.
- bplist_log("Bad binary plist: unknown tag 0x%X.\n",
+ bplist_log("Bad binary plist: unknown tag 0x%X.\n",
(objectTag & 0x0F) >> 4);
result = NULL;
}
-
+
// Cache and return result.
- if (result != NULL)
+ if (result != NULL)
cache_insert(&bplist->cache, objectRef, result);
return result;
}
-static uint64_t read_sized_int(bplist_info_ptr bplist, uint64_t offset,
+static uint64_t read_sized_int(bplist_info_ptr bplist, uint64_t offset,
uint8_t size)
{
- assert(bplist->data_bytes != NULL && size >= 1 && size <= 8 &&
+ assert(bplist->data_bytes != NULL && size >= 1 && size <= 8 &&
offset + size <= bplist->length);
-
+
uint64_t result = 0;
const uint8_t *byte = bplist->data_bytes + offset;
-
+
do {
// note that ints seem to be high-order first
result = (result << 8) | *byte++;
} while (--size);
-
+
return result;
}
static uint64_t read_offset(bplist_info_ptr bplist, uint64_t index)
{
assert(index < bplist->object_count);
-
- return read_sized_int(bplist,
- bplist->offset_table_offset + bplist->offset_int_size * index,
+
+ return read_sized_int(bplist,
+ bplist->offset_table_offset + bplist->offset_int_size * index,
bplist->offset_int_size);
}
-static BOOL read_self_sized_int(bplist_info_ptr bplist, uint64_t offset,
+static BOOL read_self_sized_int(bplist_info_ptr bplist, uint64_t offset,
uint64_t *outValue, size_t *outSize)
{
uint32_t size;
int64_t value;
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
+
size = 1 << (bplist->data_bytes[offset] & 0x0F);
if (size > 8) {
// Maximum allowable size in this implementation is 1<<3 = 8 bytes.
// This also happens to be the biggest we can handle.
return NO;
}
-
+
if (offset + 1 + size > bplist->length) {
// Out of range.
return NO;
}
-
+
value = read_sized_int(bplist, offset + 1, size);
-
+
if (outValue != NULL) *outValue = value;
if (outSize != NULL) *outSize = size + 1; // +1 for tag byte.
return YES;
{
assert(bplist->data_bytes != NULL && offset < bplist->length);
value_ptr value = value_create();
-
+
switch (bplist->data_bytes[offset]) {
case kVALUE_NULL:
value->tag = kVALUE_NULL;
return value;
-
+
case kVALUE_TRUE:
value->tag = kVALUE_TRUE;
return value;
-
+
case kVALUE_FALSE:
value->tag = kVALUE_FALSE;
return value;
}
-
+
// Note: kVALUE_FILLER is treated as invalid, because it, er, is.
bplist_log("Bad binary plist: invalid atom.\n");
free(value);
if (!read_self_sized_int(bplist, offset, &value->uinteger, NULL)) {
bplist_log("Bad binary plist: invalid integer object.\n");
}
-
+
/* NOTE: originally, I sign-extended here. This was the wrong thing; it
turns out that negative ints are always stored as 64-bit, and smaller
ints are unsigned.
{
value_ptr value = value_create();
uint32_t size;
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
+
size = 1 << (bplist->data_bytes[offset] & 0x0F);
-
+
// FIXME: what to do if faced with other sizes for float/double?
- assert (sizeof (float) == sizeof (uint32_t) &&
+ assert (sizeof (float) == sizeof (uint32_t) &&
sizeof (double) == sizeof (uint64_t));
-
+
if (offset + 1 + size > bplist->length) {
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"floating-point number");
free(value);
return NULL;
}
-
+
if (size == sizeof (float)) {
// cast is ok because we know size is 4 bytes
- uint32_t i = (uint32_t) read_sized_int(bplist, offset + 1, size);
+ uint32_t i = (uint32_t) read_sized_int(bplist, offset + 1, size);
// Note that this handles byte swapping.
value_set_real(value, *(float *)&i);
return value;
{
value_ptr value;
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
+
// Data has size code like int and real, but only 3 (meaning 8 bytes) is valid.
if (bplist->data_bytes[offset] != kVALUE_FULLDATETAG) {
bplist_log("Bad binary plist: invalid size for date object.\n");
return NULL;
}
-
+
if (offset + 1 + sizeof (double) > bplist->length) {
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"date");
return NULL;
}
-
+
// FIXME: what to do if faced with other sizes for double?
assert (sizeof (double) == sizeof (uint64_t));
-
+
uint64_t date = read_sized_int(bplist, offset + 1, sizeof(double));
// Note that this handles byte swapping.
value = value_create();
}
-uint64_t bplist_get_a_size(bplist_info_ptr bplist,
+uint64_t bplist_get_a_size(bplist_info_ptr bplist,
uint64_t *offset_ptr, char *msg)
{
uint64_t size = bplist->data_bytes[*offset_ptr] & 0x0F;
(*offset_ptr)++;
if (size == 0x0F) {
- // 0x0F means separate int size follows.
+ // 0x0F means separate int size follows.
// Smaller values are used for short data.
size_t extra; // the length of the data size we are about to read
if ((bplist->data_bytes[*offset_ptr] & 0xF0) != kTAG_INT) {
msg);
return UINT64_MAX; // error
}
-
+
// read integer data as size, extra tells how many bytes to skip
if (!read_self_sized_int(bplist, *offset_ptr, &size, &extra)) {
- bplist_log("Bad binary plist: invalid %s object size tag.\n",
+ bplist_log("Bad binary plist: invalid %s object size tag.\n",
"data");
return UINT64_MAX; // error
}
}
if (*offset_ptr + size > bplist->length) {
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"data");
return UINT64_MAX; // error
}
{
uint64_t size;
value_ptr value;
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
- if ((size = bplist_get_a_size(bplist, &offset, "data")) == UINT64_MAX)
+
+ if ((size = bplist_get_a_size(bplist, &offset, "data")) == UINT64_MAX)
return NULL;
-
+
value = value_create();
// cast is ok because we only allow files up to 100MB:
value_set_data(value, bplist->data_bytes + (size_t) offset, (size_t) size);
{
uint64_t size;
value_ptr value; // return value
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
+
if ((size = bplist_get_a_size(bplist, &offset, "ascii string")) ==
- UINT64_MAX)
+ UINT64_MAX)
return NULL;
value = value_create();
// cast is ok because we only allow 100MB files
- value_set_ascii_string(value, bplist->data_bytes + (size_t) offset,
+ value_set_ascii_string(value, bplist->data_bytes + (size_t) offset,
(size_t) size);
return value;
}
{
uint64_t size;
value_ptr value;
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
- if ((size = bplist_get_a_size(bplist, &offset, "unicode string")) ==
+
+ if ((size = bplist_get_a_size(bplist, &offset, "unicode string")) ==
UINT64_MAX)
return NULL;
-
+
value = value_create();
// cast is ok because we only allow 100MB files
- value_set_unicode_string(value, bplist->data_bytes + (size_t) offset,
+ value_set_unicode_string(value, bplist->data_bytes + (size_t) offset,
(size_t) size);
return value;
}
introspectable CF objects. In fact, it even seems to convert the CF$UID
dictionaries from XML plists on the fly.
*/
-
+
value_ptr value;
uint64_t uid;
-
+
if (!read_self_sized_int(bplist, offset, &uid, NULL)) {
bplist_log("Bad binary plist: invalid UID object.\n");
return NULL;
}
-
+
// assert(NO); // original code suggests using a string for a key
// but our dictionaries all use big ints for keys, so I don't know
// what to do here
-
+
// In practice, I believe this code is never executed by PortMidi.
// I changed it to do something and not raise compiler warnings, but
// not sure what the code should do.
value = value_create();
value_set_uid(value, uid);
// return [NSDictionary dictionaryWithObject:
- // [NSNumber numberWithUnsignedLongLong:value]
+ // [NSNumber numberWithUnsignedLongLong:value]
// forKey:"CF$UID"];
return value;
}
value_ptr *array = NULL;
value_ptr value = NULL;
BOOL ok = YES;
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
+
if ((count = bplist_get_a_size(bplist, &offset, "array")) == UINT64_MAX)
return NULL;
-
+
if (count > UINT64_MAX / bplist->object_ref_size - offset) {
// Offset overflow.
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"array");
return NULL;
}
-
+
size = bplist->object_ref_size * count;
if (size + offset > bplist->length) {
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"array");
return NULL;
}
-
+
// got count, the number of array elements
value = value_create();
value_set_array(value, array, (size_t) count);
return value;
}
-
+
array = allocate(sizeof(value_ptr) * (size_t) count);
-
+
for (i = 0; i != count; ++i) {
bplist_log_verbose("[%u]\n", i);
- elementID = read_sized_int(bplist, offset + i * bplist->object_ref_size,
+ elementID = read_sized_int(bplist, offset + i * bplist->object_ref_size,
bplist->object_ref_size);
element = extract_object(bplist, elementID);
if (element != NULL) {
value_ptr value = NULL;
dict_ptr dict = NULL;
BOOL ok = YES;
-
+
assert(bplist->data_bytes != NULL && offset < bplist->length);
-
-
+
+
if ((count = bplist_get_a_size(bplist, &offset, "array")) == UINT64_MAX)
return NULL;
if (count > UINT64_MAX / (bplist->object_ref_size * 2) - offset) {
// Offset overflow.
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"dictionary");
return NULL;
}
-
+
size = bplist->object_ref_size * count * 2;
if (size + offset > bplist->length) {
- bplist_log("Bad binary plist: %s object overlaps end of container.\n",
+ bplist_log("Bad binary plist: %s object overlaps end of container.\n",
"dictionary");
return NULL;
}
-
+
value = value_create();
if (count == 0) {
value_set_dict(value, NULL);
for (i = 0; i != count; ++i) {
value_ptr key;
value_ptr val;
- elementID = read_sized_int(bplist, offset + i * bplist->object_ref_size,
+ elementID = read_sized_int(bplist, offset + i * bplist->object_ref_size,
bplist->object_ref_size);
key = extract_object(bplist, elementID);
if (key != NULL) {
ok = NO;
break;
}
-
- elementID = read_sized_int(bplist,
- offset + (i + count) * bplist->object_ref_size,
+
+ elementID = read_sized_int(bplist,
+ offset + (i + count) * bplist->object_ref_size,
bplist->object_ref_size);
val = extract_object(bplist, elementID);
if (val != NULL) {
if (ok) {
value_set_dict(value, dict);
}
-
+
return value;
}
}
return v;
}
-
+
/*************** functions for debugging ***************/
switch (v->tag & 0xF0) {
case kTAG_SIMPLE:
switch (v->tag) {
- case kVALUE_NULL:
+ case kVALUE_NULL:
printf("NULL@%p", v); break;
- case kVALUE_FALSE:
+ case kVALUE_FALSE:
printf("FALSE@%p", v); break;
case kVALUE_TRUE:
printf("TRUE@%p", v); break;
}
}
-
+
kTAG_UID = 0x80,
kTAG_ARRAY = 0xA0,
kTAG_DICTIONARY = 0xD0,
-
+
// "simple" object values
kVALUE_NULL = 0x00,
kVALUE_FALSE = 0x08,
kVALUE_TRUE = 0x09,
kVALUE_FILLER = 0x0F,
-
+
kVALUE_FULLDATETAG = 0x33 // Dates are tagged with a whole byte.
};
/* pmwin.c -- PortMidi os-dependent code */
/* This file only needs to implement:
- pm_init(), which calls various routines to register the
+ pm_init(), which calls various routines to register the
available midi devices,
Pm_GetDefaultInputDeviceID(), and
Pm_GetDefaultOutputDeviceID().
}
}
/* Look in registry for a default device name pattern. */
- if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ, &hkey) !=
+ if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ, &hkey) !=
ERROR_SUCCESS) {
return id;
}
ERROR_SUCCESS) {
return id;
}
- if (RegQueryValueEx(hkey, key, NULL, &dwType, (LPBYTE)pattern, (LPDWORD)&pattern_max) !=
+ if (RegQueryValueEx(hkey, key, NULL, &dwType, (LPBYTE)pattern, (LPDWORD)&pattern_max) !=
ERROR_SUCCESS) {
return id;
}
PmDeviceID Pm_GetDefaultInputDeviceID() {
- return pm_get_default_device_id(TRUE,
+ return pm_get_default_device_id(TRUE,
"/P/M_/R/E/C/O/M/M/E/N/D/E/D_/I/N/P/U/T_/D/E/V/I/C/E");
}
}
-#include "stdio.h"
+#include "stdio.h"
void *pm_alloc(size_t s) {
- return malloc(s);
+ return malloc(s);
}
-void pm_free(void *ptr) {
- free(ptr);
+void pm_free(void *ptr) {
+ free(ptr);
}
#endif
#ifndef _WIN32_WINNT
- /* without this define, InitializeCriticalSectionAndSpinCount is
- * undefined. This version level means "Windows 2000 and higher"
+ /* without this define, InitializeCriticalSectionAndSpinCount is
+ * undefined. This version level means "Windows 2000 and higher"
*/
#define _WIN32_WINNT 0x0500
#endif
/* callback routines */
static void CALLBACK winmm_in_callback(HMIDIIN hMidiIn,
- WORD wMsg, DWORD dwInstance,
+ WORD wMsg, DWORD dwInstance,
DWORD dwParam1, DWORD dwParam2);
static void CALLBACK winmm_streamout_callback(HMIDIOUT hmo, UINT wMsg,
- DWORD dwInstance, DWORD dwParam1,
+ DWORD dwInstance, DWORD dwParam1,
DWORD dwParam2);
#ifdef USE_SYSEX_BUFFERS
static void CALLBACK winmm_out_callback(HMIDIOUT hmo, UINT wMsg,
- DWORD dwInstance, DWORD dwParam1,
+ DWORD dwInstance, DWORD dwParam1,
DWORD dwParam2);
#endif
A note about buffers: WinMM seems to hold onto buffers longer than
one would expect, e.g. when I tried using 2 small buffers to send
long sysex messages, at some point WinMM held both buffers. This problem
-was fixed by making buffers bigger. Therefore, it seems that there should
-be enough buffer space to hold a whole sysex message.
+was fixed by making buffers bigger. Therefore, it seems that there should
+be enough buffer space to hold a whole sysex message.
The bufferSize passed into Pm_OpenInput (passed into here as buffer_len)
will be used to estimate the largest sysex message (= buffer_len * 4 bytes).
For stream output, there will already be enough space in very short
buffers, so use them, but make sure there are at least 16.
-For input, use many small buffers rather than 2 large ones so that when
+For input, use many small buffers rather than 2 large ones so that when
there are short sysex messages arriving frequently (as in control surfaces)
there will be more free buffers to fill. Use max_sysex_len / 64 buffers,
but at least 16, of size 64 bytes each.
UINT i;
WORD wRtn;
midi_num_inputs = midiInGetNumDevs();
- midi_in_caps = (MIDIINCAPS *) pm_alloc(sizeof(MIDIINCAPS) *
+ midi_in_caps = (MIDIINCAPS *) pm_alloc(sizeof(MIDIINCAPS) *
midi_num_inputs);
if (midi_in_caps == NULL) {
/* if you can't open a particular system-level midi interface
capabilities) then you still should retrieve some formof
setup info. */
wRtn = midiInGetDevCaps((UINT) MIDIMAPPER,
- (LPMIDIINCAPS) & midi_in_mapper_caps,
+ (LPMIDIINCAPS) & midi_in_mapper_caps,
sizeof(MIDIINCAPS));
if (wRtn == MMSYSERR_NOERROR) {
pm_add_device("MMSystem", midi_in_mapper_caps.szPname, TRUE,
#ifdef USE_SYSEX_BUFFERS
static MIDIHDR *allocate_sysex_buffer(long data_size)
{
- /* we're actually allocating more than data_size because the buffer
- * will include the MIDIEVENT header in addition to the data
+ /* we're actually allocating more than data_size because the buffer
+ * will include the MIDIEVENT header in addition to the data
*/
LPMIDIHDR hdr = (LPMIDIHDR) pm_alloc(MIDIHDR_SYSEX_SIZE(data_size));
MIDIEVENT *evt;
#ifdef DEBUG
printf("PortMidi warning: get_free_output_buffer() wait timed out after 1000ms\n");
#endif
- /* if we're trying to send a sysex message, maybe the
+ /* if we're trying to send a sysex message, maybe the
* message is too big and we need more message buffers.
* Expand the buffer pool by 128KB using 1024-byte buffers.
*/
/* first, expand the buffers array if necessary */
if (!m->buffers_expanded) {
LPMIDIHDR *new_buffers = (LPMIDIHDR *) pm_alloc(
- (m->num_buffers + NUM_EXPANSION_BUFFERS) *
+ (m->num_buffers + NUM_EXPANSION_BUFFERS) *
sizeof(LPMIDIHDR));
/* if no memory, we could return a no-memory error, but user
* probably will be unprepared to deal with it. Maybe the
*/
if (!new_buffers) continue;
/* copy buffers to new_buffers and replace buffers */
- memcpy(new_buffers, m->buffers,
+ memcpy(new_buffers, m->buffers,
m->num_buffers * sizeof(LPMIDIHDR));
pm_free(m->buffers);
m->buffers = new_buffers;
/* next, add one buffer and return it */
if (m->num_buffers < m->max_buffers) {
r = allocate_buffer(EXPANSION_BUFFER_LEN);
- /* again, if there's no memory, we may not really be
+ /* again, if there's no memory, we may not really be
* dead -- maybe the system is temporarily hung and
* we can just wait longer for a message buffer */
if (!r) continue;
m->next_buffer = 0; /* not used for input */
m->buffer_signal = 0; /* not used for input */
#ifdef USE_SYSEX_BUFFERS
- for (i = 0; i < NUM_SYSEX_BUFFERS; i++)
+ for (i = 0; i < NUM_SYSEX_BUFFERS; i++)
m->sysex_buffers[i] = NULL; /* not used for input */
m->next_sysex_buffer = 0; /* not used for input */
#endif
switch (wMsg) {
case MIM_DATA: {
- /* if this callback is reentered with data, we're in trouble.
- * It's hard to imagine that Microsoft would allow callbacks
- * to be reentrant -- isn't the model that this is like a
- * hardware interrupt? -- but I've seen reentrant behavior
+ /* if this callback is reentered with data, we're in trouble.
+ * It's hard to imagine that Microsoft would allow callbacks
+ * to be reentrant -- isn't the model that this is like a
+ * hardware interrupt? -- but I've seen reentrant behavior
* using a debugger, so it happens.
*/
long new_driver_time;
int remaining = lpMidiHdr->dwBytesRecorded;
EnterCriticalSection(&m->lock);
- /* printf("midi_in_callback -- lpMidiHdr %x, %d bytes, %2x...\n",
+ /* printf("midi_in_callback -- lpMidiHdr %x, %d bytes, %2x...\n",
lpMidiHdr, lpMidiHdr->dwBytesRecorded, *data); */
if (midi->time_proc)
dwParam2 = (*midi->time_proc)(midi->time_info);
/* can there be more than one message in one buffer? */
/* assume yes and iterate through them */
while (remaining > 0) {
- unsigned int amt = pm_read_bytes(midi, data + processed,
+ unsigned int amt = pm_read_bytes(midi, data + processed,
remaining, dwParam2);
remaining -= amt;
processed += amt;
if (pm_hosterror) goto close_device;
}
/* allocate buffers */
- if (allocate_buffers(m, output_buffer_len, num_buffers))
+ if (allocate_buffers(m, output_buffer_len, num_buffers))
goto free_buffers;
/* start device */
if (midi->latency != 0) {
midiwinmm_type m = (midiwinmm_type) midi->descriptor;
assert(m);
if (m->hdr) {
- m->error = midiOutPrepareHeader(m->handle.out, m->hdr,
+ m->error = midiOutPrepareHeader(m->handle.out, m->hdr,
sizeof(MIDIHDR));
if (m->error) {
/* do not send message */
} else if (midi->latency == 0) {
/* As pointed out by Nigel Brown, 20Sep06, dwBytesRecorded
- * should be zero. This is set in get_free_sysex_buffer().
+ * should be zero. This is set in get_free_sysex_buffer().
* The msg length goes in dwBufferLength in spite of what
* Microsoft documentation says (or doesn't say). */
m->hdr->dwBufferLength = m->hdr->dwBytesRecorded;
m->hdr->dwBytesRecorded = 0;
m->error = midiOutLongMsg(m->handle.out, m->hdr, sizeof(MIDIHDR));
} else {
- m->error = midiStreamOut(m->handle.stream, m->hdr,
+ m->error = midiStreamOut(m->handle.stream, m->hdr,
sizeof(MIDIHDR));
}
midi->fill_base = NULL;
PmError rslt = pmNoError;
LPMIDIHDR hdr = m->hdr;
if (!hdr) return rslt; /* something bad happened earlier,
- do not report an error because it would have been
+ do not report an error because it would have been
reported (at least) once already */
/* a(n old) version of MIDI YOKE requires a zero byte after
* the sysex message, but do not increment dwBytesRecorded: */
/* when buffer fills, Pm_WriteSysEx will revert to calling
* pmwin_write_byte, which expect to have space, so leave
* one byte free for pmwin_write_byte. Leave another byte
- * of space for zero after message to make early version of
+ * of space for zero after message to make early version of
* MIDI YOKE driver happy -- therefore dwBufferLength - 2 */
midi->fill_length = hdr->dwBufferLength - 2;
if (midi->latency != 0) {
/* see if buffer is full, leave one byte extra for pad */
if (hdr->dwBytesRecorded >= hdr->dwBufferLength - 1) {
/* write what we've got and continue */
- rslt = winmm_end_sysex(midi, timestamp);
+ rslt = winmm_end_sysex(midi, timestamp);
}
return rslt;
}
note: this code is here as an aid in case you want sysex buffers
to expand to hold large messages completely. If so, you
will want to change SYSEX_BYTES_PER_BUFFER above to some
- variable that remembers the buffer size. A good place to
+ variable that remembers the buffer size. A good place to
put this value would be in the hdr->dwUser field.
- rslt = resize_sysex_buffer(midi, m->sysex_byte_count,
+ rslt = resize_sysex_buffer(midi, m->sysex_byte_count,
m->sysex_byte_count * 2);
if (rslt == pmBufferMaxSize) /* if the buffer can't be resized */
#ifdef USE_SYSEX_BUFFERS
/* winmm_out_callback -- recycle sysex buffers */
static void CALLBACK winmm_out_callback(HMIDIOUT hmo, UINT wMsg,
- DWORD dwInstance, DWORD dwParam1,
+ DWORD dwInstance, DWORD dwParam1,
DWORD dwParam2)
{
PmInternal *midi = (PmInternal *) dwInstance;
we leave them prepared
*/
/*
- printf("out_callback: hdr %x, wMsg %x, MOM_DONE %x\n",
+ printf("out_callback: hdr %x, wMsg %x, MOM_DONE %x\n",
hdr, wMsg, MOM_DONE);
*/
if (wMsg == MOM_DONE) {
- MMRESULT ret = midiOutUnprepareHeader(m->handle.out, hdr,
+ MMRESULT ret = midiOutUnprepareHeader(m->handle.out, hdr,
sizeof(MIDIHDR));
assert(ret == MMSYSERR_NOERROR);
}
/* Even if an error is pending, I think we should unprepare msgs and
signal their arrival
*/
- /* printf("streamout_callback: hdr %x, wMsg %x, MOM_DONE %x\n",
+ /* printf("streamout_callback: hdr %x, wMsg %x, MOM_DONE %x\n",
hdr, wMsg, MOM_DONE); */
if (wMsg == MOM_DONE) {
- MMRESULT ret = midiOutUnprepareHeader(m->handle.out, hdr,
+ MMRESULT ret = midiOutUnprepareHeader(m->handle.out, hdr,
sizeof(MIDIHDR));
assert(ret == MMSYSERR_NOERROR);
}
if (error != KERN_SUCCESS) {
mach_error("Couldn't set thread precedence policy", error);
}
-
-
+
+
/* to kill a process, just increment the pt_callback_proc_id */
/* printf("pt_callback_proc_id %d, id %d\n", pt_callback_proc_id, parameters->id); */
while (pt_callback_proc_id == parameters->id) {
{
if (time_started_flag) return ptAlreadyStarted;
start_time = AudioGetCurrentHostTime();
-
+
if (callback) {
int res;
pt_callback_parameters *parms;
res = pthread_create(&pt_thread_pid, NULL, Pt_CallbackProc, parms);
if (res != 0) return ptHostError;
}
-
+
time_started_flag = TRUE;
return ptNoError;
}
static MMRESULT timer_id;
static PtCallback *time_callback;
-void CALLBACK winmm_time_callback(UINT uID, UINT uMsg, DWORD_PTR dwUser,
+void CALLBACK winmm_time_callback(UINT uID, UINT uMsg, DWORD_PTR dwUser,
DWORD_PTR dw1, DWORD_PTR dw2)
{
(*time_callback)(Pt_Time(), (void *) dwUser);
}
-
+
PMEXPORT PtError Pt_Start(int resolution, PtCallback *callback, void *userData)
{
time_started_flag = TRUE;
time_callback = callback;
if (callback) {
- timer_id = timeSetEvent(resolution, 1, winmm_time_callback,
+ timer_id = timeSetEvent(resolution, 1, winmm_time_callback,
(DWORD_PTR) userData, TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
if (!timer_id) return ptHostError;
}
);
}
break;
-
+
default:
break;
};
WavesAudioBackend::~WavesAudioBackend ()
{
-
+
}
std::string
}
-bool
+bool
WavesAudioBackend::requires_driver_selection () const
-{
- return false;
+{
+ return false;
}
-std::vector<std::string>
+std::vector<std::string>
WavesAudioBackend::enumerate_drivers () const
-{
+{
// this backend does not suppose driver selection
assert (false);
- return std::vector<std::string> ();
+ return std::vector<std::string> ();
}
-int
+int
WavesAudioBackend::set_driver (const std::string& /*drivername*/)
{
//Waves audio backend does not suppose driver selection
assert (false);
- return -1;
+ return -1;
}
-std::vector<AudioBackend::DeviceStatus>
+std::vector<AudioBackend::DeviceStatus>
WavesAudioBackend::enumerate_devices () const
-{
+{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::enumerate_devices (): " << std::endl;
std::vector<DeviceStatus> devicesStatus;
- const DeviceInfoVec& deviceInfoList = _audio_device_manager.DeviceInfoList();
+ const DeviceInfoVec& deviceInfoList = _audio_device_manager.DeviceInfoList();
for (DeviceInfoVecConstIter deviceInfoIter = deviceInfoList.begin (); deviceInfoIter != deviceInfoList.end (); ++deviceInfoIter) {
// COMMENTED DBG LOGS */ std::cout << "\t Device found: " << (*deviceInfoIter)->m_DeviceName << std::endl;
devicesStatus.push_back (DeviceStatus ((*deviceInfoIter)->m_DeviceName, true));
}
-
+
return devicesStatus;
-}
+}
-std::vector<float>
+std::vector<float>
WavesAudioBackend::available_sample_rates (const std::string& device_name) const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::available_sample_rates (): [" << device_name << "]" << std::endl;
std::vector<int> sr;
-
+
WTErr retVal = _audio_device_manager.GetDeviceSampleRates(device_name, sr);
-
+
if (eNoErr != retVal) {
std::cerr << "WavesAudioBackend::available_sample_rates (): Failed to find device [" << device_name << "]" << std::endl;
return std::vector<float> ();
// COMMENTED DBG LOGS */ std::cout << "\tFound " << devInfo.m_AvailableSampleRates.size () << " sample rates for " << device_name << ":";
std::vector<float> sample_rates (sr.begin (), sr.end ());
-
+
// COMMENTED DBG LOGS */ for (std::vector<float>::iterator i = sample_rates.begin (); i != sample_rates.end (); ++i) std::cout << " " << *i; std::cout << std::endl;
return sample_rates;
}
-float WavesAudioBackend::default_sample_rate () const
-{
+float WavesAudioBackend::default_sample_rate () const
+{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::default_sample_rate (): " << AudioBackend::default_sample_rate () << std::endl;
- return AudioBackend::default_sample_rate ();
+ return AudioBackend::default_sample_rate ();
}
-std::vector<uint32_t>
+std::vector<uint32_t>
WavesAudioBackend::available_buffer_sizes (const std::string& device_name) const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::available_buffer_sizes (): [" << device_name << "]" << std::endl;
}
-uint32_t
+uint32_t
WavesAudioBackend::available_input_channel_count (const std::string& device_name) const
{
DeviceInfo devInfo;
WTErr err = _audio_device_manager.GetDeviceInfoByName(device_name, devInfo);
-
+
if (eNoErr != err) {
std::cerr << "WavesAudioBackend::available_input_channel_count (): Failed to find device [" << device_name << "]" << std::endl;
return 0;
}
-uint32_t
+uint32_t
WavesAudioBackend::available_output_channel_count (const std::string& device_name) const
{
DeviceInfo devInfo;
WTErr err = _audio_device_manager.GetDeviceInfoByName(device_name, devInfo);
-
+
if (eNoErr != err) {
std::cerr << "WavesAudioBackend::available_output_channel_count (): Failed to find device [" << device_name << "]" << std::endl;
return 0;
WavesAudioBackend::set_device_name (const std::string& device_name)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_device_name (): " << device_name << std::endl;
-
+
if (_ports.size ()) {
std::cerr << "WavesAudioBackend::set_device_name (): There are unregistered ports left after [" << (_device ? _device->DeviceName () : std::string ("<NULL>")) << "]!" << std::endl;
for (size_t i = 0; i < _ports.size (); ++i) {
}
-int
+int
WavesAudioBackend::set_sample_rate (float sample_rate)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_sample_rate (): " << sample_rate << std::endl;
-
+
WTErr retVal = eNoErr;
if (!_device) {
return -1;
}
-
+
bool device_needs_restart = _device->Streaming ();
-
+
if (device_needs_restart) {
retVal = _device->SetStreaming (false);
// COMMENTED DBG LOGS */ std::cout << "\t\t[" << _device->DeviceName() << "]->_device->SetStreaming (false);"<< std::endl;
return -1;
}
}
-
+
retVal = _device->SetCurrentSamplingRate ((int)sample_rate);
-
+
if (retVal != eNoErr) {
std::cerr << "WavesAudioBackend::set_sample_rate (): [" << _device->DeviceName() << "]->SetCurrentSamplingRate ((int)" << sample_rate << ") failed (" << retVal << ") !" << std::endl;
return -1;
// this means we are driven by device for buffer size
sample_rate = _device->CurrentSamplingRate ();
_sample_rate_change(sample_rate);
-
+
if (device_needs_restart) {
// COMMENTED DBG LOGS */ std::cout << "\t\t[" << _device->DeviceName() << "]->SetStreaming (true);"<< std::endl;
retVal = _device->SetStreaming (true);
}
-int
+int
WavesAudioBackend::set_buffer_size (uint32_t buffer_size)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_buffer_size (" << buffer_size << "):"<< std::endl;
}
bool device_needs_restart = _device->Streaming ();
-
+
if (device_needs_restart) {
retVal = _device->SetStreaming (false);
// COMMENTED DBG LOGS */ std::cout << "\t\t[" << _device->DeviceName() << "]->SetStreaming (false);"<< std::endl;
return -1;
}
}
-
+
retVal = _device->SetCurrentBufferSize (buffer_size);
-
+
if (retVal != eNoErr) {
std::cerr << "WavesAudioBackend::set_buffer_size (): [" << _device->DeviceName() << "]->SetCurrentBufferSize (" << buffer_size << ") failed (" << retVal << ") !" << std::endl;
return -1;
}
-
+
// if call to set buffer is successful but device buffer size differs from the value we tried to set
// this means we are driven by device for buffer size
buffer_size = _device->CurrentBufferSize ();
_buffer_size_change(buffer_size);
-
+
if (device_needs_restart) {
// COMMENTED DBG LOGS */ std::cout << "\t\t[" << _device->DeviceName() << "]->SetStreaming (true);"<< std::endl;
retVal = _device->SetStreaming (true);
return -1;
}
}
-
+
return 0;
}
-int
+int
WavesAudioBackend::set_sample_format (SampleFormat sample_format)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_sample_format (): " << sample_format << std::endl;
return 0;
}
-int
+int
WavesAudioBackend::reset_device ()
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::_reset_device ():" << std::endl;
}
-int
+int
WavesAudioBackend::_buffer_size_change (uint32_t new_buffer_size)
{
_buffer_size = new_buffer_size;
}
-int
+int
WavesAudioBackend::_sample_rate_change (float new_sample_rate)
{
_sample_rate = new_sample_rate;
}
-int
+int
WavesAudioBackend::set_interleaved (bool yn)
{
/*you can ignore them totally*/
}
-int
+int
WavesAudioBackend::set_input_channels (uint32_t input_channels)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_input_channels (): " << input_channels << std::endl;
}
-int
+int
WavesAudioBackend::set_output_channels (uint32_t output_channels)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_output_channels (): " << output_channels << std::endl;
}
-std::string
+std::string
WavesAudioBackend::device_name () const
{
if (!_device) {
return "";
}
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::device_name (): " << _device->DeviceName () << std::endl;
-
+
return _device->DeviceName ();
}
-float
+float
WavesAudioBackend::sample_rate () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::sample_rate (): " << std::endl;
}
-uint32_t
+uint32_t
WavesAudioBackend::buffer_size () const
{
}
int size = _device->CurrentBufferSize ();
-
+
// COMMENTED DBG LOGS */ std::cout << "\t[" << _device->DeviceName () << "]->CurrentBufferSize () returned " << size << std::endl;
return (uint32_t)size;
}
-SampleFormat
+SampleFormat
WavesAudioBackend::sample_format () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::sample_format ()" << std::endl;
}
-bool
+bool
WavesAudioBackend::interleaved () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::interleaved ()" << std::endl;
}
-uint32_t
+uint32_t
WavesAudioBackend::input_channels () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::input_channels ()" << std::endl;
}
-uint32_t
+uint32_t
WavesAudioBackend::output_channels () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::output_channels ()" << std::endl;
}
-std::string
+std::string
WavesAudioBackend::control_app_name () const
{
- std::string app_name = "";
+ std::string app_name = "";
if (_device && !dynamic_cast<WCMRNativeAudioNoneDevice*> (_device)) {
app_name = "PortAudioMayKnowIt";
}
- return app_name;
+ return app_name;
}
std::cerr << "WavesAudioBackend::launch_control_app (): No device is set!" << std::endl;
return;
}
-
+
WTErr err = _device->ShowConfigPanel (NULL);
-
+
if (eNoErr != err) {
std::cerr << "WavesAudioBackend::launch_control_app (): [" << _device->DeviceName () << "]->ShowConfigPanel () failed (" << err << ")!" << std::endl;
}
void
-WavesAudioBackend::_audio_device_callback (const float* input_buffer,
- float* output_buffer,
+WavesAudioBackend::_audio_device_callback (const float* input_buffer,
+ float* output_buffer,
unsigned long nframes,
framepos_t sample_time,
uint64_t cycle_start_time_nanos)
if (_call_thread_init_callback) {
_call_thread_init_callback = false;
// COMMENTED DBG LOGS */ std::cout << "\tAudioEngine::thread_init_callback() invoked for " << std::hex << pthread_self() << std::dec << " !" << std::endl;
-
+
/* There is the possibility that the thread this runs in may change from
* callback to callback, so do it every time.
*/
_main_thread = pthread_self ();
-
+
AudioEngine::thread_init_callback (this);
}
if ( !engine.thread_initialised_for_audio_processing () ) {
std::cerr << "\tWavesAudioBackend::_audio_device_callback (): It's an attempt to call process callback from the thread which didn't initialize it " << std::endl;
-
+
AudioEngine::thread_init_callback (this);
}
-
+
if (pthread_equal (_main_thread, pthread_self()) == 0) {
#ifdef PTW32_VERSION
std::cerr << "Process thread ID has changed. Expected thread: " << _main_thread.p << " current thread: " << pthread_self().p << std::dec << " !" << std::endl;
}
engine.process_callback (nframes);
-
+
_write_audio_data_to_device (output_buffer, nframes);
_write_midi_data_to_devices (nframes);
-
+
uint64_t dsp_end_time_nanos = __get_time_nanos();
-
+
_dsp_load_accumulator -= *_dsp_load_history.begin();
_dsp_load_history.pop_front();
uint64_t dsp_load_nanos = dsp_end_time_nanos - dsp_start_time_nanos;
}
_call_thread_init_callback = true;
_freewheel_thread ();
-
+
while (!engine.freewheeling()) {
sleep(0);
}
-
+
// freewheel thread was not activated successfully
if (_freewheel_thread_active == false) {
engine.freewheel_callback(false);
}
else {
_freewheel_thread_active = false; // stop _freewheel_thread ()
-
+
while (engine.freewheeling()) {
sleep(0);
}
-
+
_call_thread_init_callback = true;
WTErr retval = _device->SetStreaming (true);
if (retval != eNoErr) {
}
-void
+void
WavesAudioBackend::_freewheel_thread ()
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::_freewheel_thread ():" << std::endl;
if (!_freewheel_thread_active) { // Lets create it
-
+
// COMMENTED DBG LOGS */ std::cout << "\tCreating the thread _freewheel_thread () . . ." << std::endl;
pthread_attr_t attributes;
pthread_t thread_id;
std::cerr << "WavesAudioBackend::freewheel_thread (): pthread_attr_init () failed!" << std::endl;
return;
}
-
+
if (pthread_attr_setstacksize (&attributes, __thread_stack_size ())) {
std::cerr << "WavesAudioBackend::freewheel_thread (): pthread_attr_setstacksize () failed!" << std::endl;
return;
_freewheel_thread_active = true;
if ((pthread_create (&thread_id, &attributes, __start_process_thread, thread_data))) {
_freewheel_thread_active = false;
-
+
// release invoking thread
engine.freewheel_callback(true);
-
+
std::cerr << "WavesAudioBackend::freewheel_thread (): pthread_create () failed!" << std::endl;
return;
}
// COMMENTED DBG LOGS */ std::cout << "\t. . . _freewheel_thread () complete." << std::endl;
return;
}
-
+
// notify angine that freewheeling is started
engine.freewheel_callback(true);
-
+
if (_call_thread_init_callback) {
_call_thread_init_callback = false;
AudioEngine::thread_init_callback (this);
while (_freewheel_thread_active) {
engine.process_callback (_buffer_size);
}
-
+
// notify angine that freewheeling is stopped
engine.freewheel_callback(false);
-
+
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::_freewheel_thread (): FINISHED" << std::endl;
return;
}
}
float average_dsp_load = (float)_dsp_load_accumulator/_dsp_load_history_length;
-
+
return ( average_dsp_load / _audio_cycle_period_nanos)*100.0;
}
if((_sample_rate <= 0.0) || (_buffer_size <= 0.0)) {
return;
}
-
+
_audio_cycle_period_nanos = ((uint64_t)1000000000L * _buffer_size) / _sample_rate;
-
+
_dsp_load_accumulator = 0;
-
+
_dsp_load_history_length = (_sample_rate + _buffer_size - 1) / _buffer_size;
// COMMENTED DBG LOGS */ std::cout << "\t\t_dsp_load_history_length = " << _dsp_load_history_length << std::endl;
_dsp_load_history = std::list<uint64_t>(_dsp_load_history_length, 0);
void
-WavesAudioBackend::transport_stop ()
+WavesAudioBackend::transport_stop ()
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::transport_stop (): " << std::endl;
}
WavesAudioBackend::transport_state () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::transport_state (): " << std::endl;
- return TransportStopped;
+ return TransportStopped;
}
framepos_t
WavesAudioBackend::transport_frame () const
-{
+{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::transport_frame (): " << std::endl;
- return 0;
+ return 0;
}
int
WavesAudioBackend::set_time_master (bool yn)
-{
+{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_time_master (): " << yn << std::endl;
- return 0;
+ return 0;
}
{
// WARNING: This is approximate calculation. Implementation of accurate calculation is pending.
// http://kokkinizita.linuxaudio.org/papers/usingdll.pdf
-
+
return _sample_time_at_cycle_start + ((__get_time_nanos () - _cycle_start_time_nanos)*_sample_rate)/1000000000L;
}
// the API should be a part of WCMRCoreAudioDeviceManager to give a chance of being tied to the
// audio device transport timeß.
return AudioConvertHostTimeToNanos (AudioGetCurrentHostTime ());
-
+
#elif PLATFORM_WINDOWS
LARGE_INTEGER Count;
QueryPerformanceCounter (&Count);
pframes_t
WavesAudioBackend::samples_since_cycle_start ()
{
- pframes_t diff_sample_time;
+ pframes_t diff_sample_time;
diff_sample_time = sample_time () - _sample_time_at_cycle_start;
// COMMENTED DBG LOGS */ std::cout << "samples_since_cycle_start: " << diff_sample_time << std::endl;
bool
WavesAudioBackend::get_sync_offset (pframes_t& /*offset*/) const
-{
+{
// COMMENTED DBG LOGS */ std::cout << "get_sync_offset: false" << std::endl;
- return false;
+ return false;
}
std::cerr << "Cannot set thread attr init res = " << retVal << endmsg;
return -1;
}
-
+
if ((retVal = pthread_attr_setstacksize (&attributes, stacksize_aligned))) {
std::cerr << "Cannot set thread stack size (" << stacksize_aligned << ") res = " << retVal << endmsg;
return -1;
++i) {
// COMMENTED DBG LOGS */ std::cout << "\t\t\tstopping thread " << std::hex << *i << std::dec << "...\n";
- void* status;
+ void* status;
if (pthread_join (*i, &status) != 0) {
std::cerr << "AudioEngine: cannot stop process thread !" << std::endl;
ret += -1;
}
-bool
+bool
WavesAudioBackend::in_process_thread ()
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::in_process_thread ()" << std::endl;
}
-uint32_t
+uint32_t
WavesAudioBackend::process_thread_count ()
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::process_thread_count (): returns " << _backend_threads.size () << std::endl;
#endif
-int
+int
WavesAudioBackend::__instantiate (const std::string& arg1, const std::string& arg2)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::__instantiate ():" << "[" << arg1 << "], [" << arg2 << "]" << std::endl;
}
-int
+int
WavesAudioBackend::__deinstantiate ()
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::__deinstantiate ():" << std::endl;
#define __libardour_waves_audiobackend_h__
#include <string>
-#include <vector>
+#include <vector>
#include <list>
#include <stdint.h>
/* AUDIOBACKEND API */
virtual std::string name () const;
-
+
virtual bool is_realtime () const;
-
+
virtual bool requires_driver_selection () const;
-
+
virtual std::vector<std::string> enumerate_drivers () const;
-
+
virtual int set_driver (const std::string& /*drivername*/);
-
+
virtual std::vector<DeviceStatus> enumerate_devices () const;
-
+
virtual std::vector<float> available_sample_rates (const std::string& device) const;
virtual float default_sample_rate () const;
virtual int set_sample_format (SampleFormat);
virtual int set_interleaved (bool yn);
-
+
virtual int set_input_channels (uint32_t);
-
+
virtual int set_output_channels (uint32_t);
virtual int set_systemic_input_latency (uint32_t);
virtual int reset_device ();
virtual std::string device_name () const;
-
+
virtual float sample_rate () const;
-
+
virtual uint32_t buffer_size () const;
-
+
virtual SampleFormat sample_format () const;
-
+
virtual bool interleaved () const;
-
+
virtual uint32_t input_channels () const;
-
+
virtual uint32_t output_channels () const;
-
+
virtual uint32_t systemic_input_latency () const;
-
+
virtual uint32_t systemic_output_latency () const;
uint32_t systemic_midi_input_latency (std::string const) const { return 0; }
virtual int usecs_per_cycle () const;
virtual size_t raw_buffer_size (DataType data_type);
-
+
virtual framepos_t sample_time ();
virtual framepos_t sample_time_at_cycle_start ();
/* PORTENGINE API */
virtual void* private_handle () const;
-
+
virtual const std::string& my_name () const;
-
+
virtual bool available () const;
virtual uint32_t port_name_size () const;
virtual int connect (const std::string& src, const std::string& dst);
virtual int disconnect (const std::string& src, const std::string& dst);
-
+
virtual int connect (PortHandle port_handle, const std::string& port_name);
virtual int disconnect (PortHandle port_handle, const std::string& port_name);
virtual int get_connections (PortHandle port_handle, std::vector<std::string>&, bool process_callback_safe);
virtual int midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
-
+
virtual int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
-
+
virtual uint32_t get_midi_event_count (void* port_buffer);
-
+
virtual void midi_clear (void* port_buffer);
virtual bool can_monitor_input () const;
-
+
virtual int request_input_monitoring (PortHandle port_handle, bool);
-
+
virtual int ensure_input_monitoring (PortHandle port_handle, bool);
-
+
virtual bool monitoring_input (PortHandle port_handle);
virtual void set_latency_range (PortHandle port_handle, bool for_playback, LatencyRange);
-
+
virtual LatencyRange get_latency_range (PortHandle port_handle, bool for_playback);
virtual bool port_is_physical (PortHandle port_handle) const;
WavesAudioBackend* engine;
boost::function<void ()> f;
size_t stacksize;
-
+
ThreadData (WavesAudioBackend* e, boost::function<void ()> fp, size_t stacksz)
: engine (e) , f (fp) , stacksize (stacksz) {}
};
static void* __start_process_thread (void*);
static uint64_t __get_time_nanos ();
-
+
static size_t __thread_stack_size ();
- void _audio_device_callback (const float* input_audio_buffer,
- float* output_buffer,
+ void _audio_device_callback (const float* input_audio_buffer,
+ float* output_buffer,
unsigned long nframes,
framepos_t sample_time,
uint64_t cycle_start_time_nanos);
// DO change sample rate and buffer size
int _buffer_size_change(uint32_t new_buffer_size);
int _sample_rate_change(float new_sample_rate);
-
+
int _register_system_audio_ports ();
int _register_system_midi_ports ();
{
return std::find (_ports.begin (), _ports.end (), (WavesDataPort*)port_handle) != _ports.end ();
}
-
+
WavesDataPort* _find_port (const std::string& port_name) const;
void _freewheel_thread ();
bool _freewheel_thread_active;
friend class WavesMidiDeviceManager;
-
+
std::list<uint64_t> _dsp_load_history;
size_t _dsp_load_history_length;
uint64_t _dsp_load_accumulator;
} // namespace
#endif /* __libardour_waves_audiobackend_h__ */
-
+
using namespace ARDOUR;
-int
+int
WavesAudioBackend::set_systemic_input_latency (uint32_t systemic_input_latency)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_systemic_input_latency (): " << systemic_input_latency << std::endl;
}
-int
+int
WavesAudioBackend::set_systemic_output_latency (uint32_t systemic_output_latency)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_systemic_output_latency (): " << systemic_output_latency << std::endl;
return 0;
}
-uint32_t
+uint32_t
WavesAudioBackend::systemic_input_latency () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::systemic_input_latency ()" << std::endl;
}
-uint32_t
+uint32_t
WavesAudioBackend::systemic_output_latency () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::systemic_output_latency ()" << std::endl;
std::cerr << "WavesAudioBackend::get_latency_range (): Failed to find port [" << std::hex << port_handle << std::dec << "]!" << std::endl;
LatencyRange lr = {0,0};
return lr;
- }
+ }
return ((WavesDataPort*)port_handle)->latency_range (for_playback);
}
#endif
-std::vector<std::string>
+std::vector<std::string>
WavesAudioBackend::enumerate_midi_options () const
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::enumerate_midi_options ()" << std::endl;
}
-int
+int
WavesAudioBackend::set_midi_option (const std::string& option)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_midi_option ( " << option << " )" << std::endl;
WavesAudioBackend::get_midi_event_count (void* port_buffer)
{
// COMMENTED FREQUENT DBG LOGS */ std::cout << "WavesAudioBackend::get_midi_event_count (): " << std::endl;
-
+
if (port_buffer == NULL) {
std::cerr << "WavesAudioBackend::get_midi_event_count () : NULL in the 'port_buffer' argument!\n";
return -1;
std::cerr << "WavesAudioBackend::_changed_midi_devices (): _register_system_midi_ports () failed!" << std::endl;
return;
}
-
+
manager.registration_callback ();
if (_midi_device_manager.stream (true)) {
std::string port_name = "system_midi:" + (*it)->name () + " capture";
WavesDataPort* port = _find_port (port_name);
WavesMidiPort* midi_port = dynamic_cast<WavesMidiPort*> (port);
- if (midi_port && (midi_port->type () != DataType::MIDI ||
- midi_port->midi_device () != *it ||
- !midi_port->is_output () ||
+ if (midi_port && (midi_port->type () != DataType::MIDI ||
+ midi_port->midi_device () != *it ||
+ !midi_port->is_output () ||
!midi_port->is_physical () ||
!midi_port->is_terminal ())) {
std::cerr << "WavesAudioBackend::_register_system_midi_ports (): the port [" << midi_port->name () << "] is inconsystently constructed!" << std::endl;
}
((WavesMidiPort*)port)->set_midi_device (*it);
}
- port->set_latency_range (lr, false);
+ port->set_latency_range (lr, false);
}
if ((*it)->is_output ()) {
std::string port_name = "system_midi:" + (*it)->name () + " playback";
WavesDataPort* port = _find_port (port_name);
WavesMidiPort* midi_port = dynamic_cast<WavesMidiPort*> (port);
- if (midi_port && (midi_port->type () != DataType::MIDI ||
- midi_port->midi_device () != *it ||
- !midi_port->is_input () ||
+ if (midi_port && (midi_port->type () != DataType::MIDI ||
+ midi_port->midi_device () != *it ||
+ !midi_port->is_input () ||
!midi_port->is_physical () ||
!midi_port->is_terminal ())) {
std::cerr << "WavesAudioBackend::_register_system_midi_ports (): the port [" << midi_port->name () << "] is inconsystently constructed!" << std::endl;
port->set_latency_range (lr, true);
}
}
-
+
return 0;
}
// COMMENTED FREQUENT DBG LOGS */ std::cout << "WavesAudioBackend::_read_midi_data_from_devices ():" << std::endl;
if (!_midi_device_manager.is_streaming ())
return 0;
-
+
_midi_device_manager.do_read ();
for (std::vector<WavesMidiPort*>::iterator it = _physical_midi_inputs.begin (); it != _physical_midi_inputs.end (); ++it) {
WavesMidiDevice* midi_device = (*it)->midi_device ();
-
+
WavesMidiBuffer& waves_midi_buffer = (*it)->buffer ();
waves_midi_buffer.clear ();
-
+
while (WavesMidiEvent *waves_midi_event = midi_device->dequeue_input_waves_midi_event ()) {
int32_t timestamp_st = _buffer_size - (_sample_time_at_cycle_start - waves_midi_event->timestamp ());
-
+
if (timestamp_st < 0) {
timestamp_st = 0;
} else if (timestamp_st >= (int32_t)_buffer_size) {
{
if (!_midi_device_manager.is_streaming ())
return 0;
-
+
for (std::vector<WavesMidiPort*>::iterator it = _physical_midi_outputs.begin (); it != _physical_midi_outputs.end (); ++it) {
- WavesMidiDevice* midi_device = (*it)->midi_device ();
+ WavesMidiDevice* midi_device = (*it)->midi_device ();
WavesMidiBuffer &waves_midi_buffer = * (WavesMidiBuffer*) (*it)->get_buffer (nframes);
for (WavesMidiBufferIterator it = waves_midi_buffer.begin (); it != waves_midi_buffer.end ();) {
WavesMidiEvent* waves_midi_event = *it;
-
+
waves_midi_buffer.erase (it);
-
+
waves_midi_event->set_timestamp (_sample_time_at_cycle_start + waves_midi_event->timestamp () + nframes);
midi_device->enqueue_output_waves_midi_event (waves_midi_event);
}
WavesAudioBackend::set_port_name (PortHandle port_handle, const std::string& port_name)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::set_port_name (): [" << std::hex << port_handle << std::dec << "], [" << port_name << "]" << std::endl;
-
+
if (!_registered (port_handle)) {
std::cerr << "WavesAudioBackend::set_port_name (): Failed to find port [" << std::hex << port_handle << std::dec << "]!" << std::endl;
return -1;
}
-WavesDataPort*
+WavesDataPort*
WavesAudioBackend::_find_port (const std::string& port_name) const
{
for (std::vector<WavesDataPort*>::const_iterator it = _ports.begin (); it != _ports.end (); ++it) {
int
WavesAudioBackend::get_ports (const std::string& port_name_pattern, DataType type, PortFlags flags, std::vector<std::string>& port_names) const
{
-
+
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::get_ports (): \n\tPattern: [" << port_name_pattern << "]\n\tType: " << type << "\n\tFlags: " << flags << endl;
-
+
unsigned found_ports =0;
-
+
for (size_t i = 0; i < _ports.size (); ++i) {
WavesDataPort* port = _ports[i];
-
+
if ((port->type () == type) && flags == (port->flags () & flags)) {
port_names.push_back (port->name ());
found_ports++;
std::cerr << "WavesAudioBackend::port_data_type (): Failed to find port [" << std::hex << port_handle << std::dec << "]!" << std::endl;
return DataType::NIL;
}
-
+
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::port_data_type: " << endl;
-
+
return ((WavesAudioPort*)port_handle)->type ();
}
std::cerr << "WavesAudioBackend::register_port () : Invalid data type (" << (uint32_t)type << ") applied to port [" << port_name << "]!" << std::endl;
return NULL;
}
-
+
_ports.push_back (port);
return port;
std::cerr << "WavesAudioBackend::connect: Failed to find source port " << src_port_name << " !" << std::endl;
return -1;
}
-
+
WavesDataPort* dst_port = _find_port (dst_port_name);
if (dst_port == NULL) {
std::cerr << "WavesAudioBackend::connect: Failed to find destination port " << dst_port_name << " !" << std::endl;
std::cerr << "WavesAudioBackend::disconnect (): Failed to find source port [" << std::hex << src_port_handle << std::dec << "]!" << std::endl;
return -1;
}
-
+
// COMMENTED DBG LOGS */ std::cout << "\t[" << std::hex << src_port_handle << std::dec << "]" << std::endl;
// COMMENTED DBG LOGS */ std::cout << "\t[" << dst_port_name << "]" << std::endl;
std::cerr << "WavesAudioBackend::disconnect : Failed to find source port!\n";
return -1;
}
-
+
WavesDataPort* dst_port = _find_port (dst_port_name);
if (dst_port == NULL) {
std::cerr << "WavesAudioBackend::disconnect : Failed to find destination port!\n";
std::cerr << "WavesAudioBackend::connected (): Failed to find port [" << std::hex << port_handle << std::dec << "]!" << std::endl;
return false;
}
-
+
return ((WavesDataPort*)port_handle)->is_connected ();
}
WavesAudioBackend::get_connections (PortHandle port_handle, std::vector<std::string>& names, bool process_callback_safe)
{
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::get_connections ()" << std::endl;
-
+
if (!_registered (port_handle)) {
std::cerr << "WavesAudioBackend::get_connections (): Failed to find port [" << std::hex << port_handle << std::dec << "]!" << std::endl;
return -1;
std::cerr << "WavesAudioBackend::get_connections () : Parameter 'names' is not empty!\n";
return -1;
}
-
+
const std::vector<WavesDataPort*>& connected_ports = ((WavesDataPort*)port_handle)->get_connections ();
for (std::vector<WavesDataPort*>::const_iterator it = connected_ports.begin (); it != connected_ports.end (); ++it) {
bool
WavesAudioBackend::port_is_physical (PortHandle port_handle) const
{
-
+
if (!_registered (port_handle)) {
std::cerr << "WavesAudioBackend::port_is_physical (): Failed to find port [" << std::hex << port_handle << std::dec << "]!" << std::endl;
return -1;
}
-
+
return (((WavesAudioPort*)port_handle)->flags () & IsPhysical) != 0;
}
WavesAudioBackend::get_physical_outputs (DataType type, std::vector<std::string>& names)
{
names.clear();
-
+
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::get_physical_outputs ():" << std::endl << "\tdatatype = " << type << std::endl;
switch (type) {
WavesAudioBackend::get_physical_inputs (DataType type, std::vector<std::string>& names)
{
names.clear();
-
+
// COMMENTED DBG LOGS */ std::cout << "WavesAudioBackend::get_physical_inputs ():" << std::endl << "\tdatatype = " << type << std::endl;
switch (type) {
case ARDOUR::DataType::AUDIO: {
if (port_handle == NULL) {
std::cerr << "WavesAudioBackend::get_buffer : Invalid port handler <NULL>!" << std::endl;
return NULL;
- }
-
+ }
+
return ((WavesAudioPort*)port_handle)->get_buffer (nframes);
}
std::cerr << "WavesAudioBackend::_register_system_audio_ports (): No device is set!" << std::endl;
return -1;
}
-
+
std::vector<std::string> input_channels = _device->InputChannels ();
_max_input_channels = input_channels.size ();
-
+
uint32_t channels = (_input_channels ? _input_channels : input_channels.size ());
uint32_t port_number = 0;
// Get latency for capture
lr.min = lr.max = _device->GetLatency (false) + _device->CurrentBufferSize () + _systemic_input_latency;
- for (std::vector<std::string>::iterator it = input_channels.begin ();
+ for (std::vector<std::string>::iterator it = input_channels.begin ();
(port_number < channels) && (it != input_channels.end ());
++it) {
-
+
std::ostringstream port_name(*it);
WavesDataPort* port = _register_port ("system:capture:" + port_name.str (), DataType::AUDIO ,
static_cast<PortFlags> (IsOutput | IsPhysical | IsTerminal));
-
+
if (port == NULL) {
std::cerr << "WavesAudioBackend::_create_system_audio_ports (): Failed registering port [" << port_name << "] for [" << _device->DeviceName () << "]" << std::endl;
return-1;
}
set_latency_range (port, false, lr);
}
-
+
std::vector<std::string> output_channels = _device->OutputChannels ();
_max_output_channels = output_channels.size ();
channels = (_output_channels ? _output_channels : _max_output_channels);
port_number = 0;
-
+
// Get latency for playback
lr.min = lr.max = _device->GetLatency (true) + _device->CurrentBufferSize () + _systemic_output_latency;
for (std::vector<std::string>::iterator it = output_channels.begin ();
(port_number < channels) && (it != output_channels.end ());
++it) {
-
+
std::ostringstream port_name(*it);
WavesDataPort* port = _register_port ("system:playback:" + port_name.str (), DataType::AUDIO ,
static_cast<PortFlags> (IsInput| IsPhysical | IsTerminal));
-
+
if (port == NULL) {
std::cerr << "WavesAudioBackend::_create_system_audio_ports (): Failed registering port ]" << port_name << "] for [" << _device->DeviceName () << "]" << std::endl;
return-1;
}
set_latency_range (port, true, lr);
}
-
+
return 0;
}
{
std::vector<WavesAudioPort*> physical_audio_ports = _physical_audio_inputs;
physical_audio_ports.insert (physical_audio_ports.begin (), _physical_audio_outputs.begin (), _physical_audio_outputs.end ());
-
+
for (std::vector<WavesAudioPort*>::const_iterator it = physical_audio_ports.begin (); it != physical_audio_ports.end (); ++it) {
std::vector<WavesDataPort*>::iterator port_iterator = std::find (_ports.begin (), _ports.end (), *it);
if (port_iterator == _ports.end ()) {
using namespace ARDOUR;
WavesAudioPort::WavesAudioPort (const std::string& port_name, PortFlags flags)
- : WavesDataPort (port_name, flags)
+ : WavesDataPort (port_name, flags)
{
aligned_malloc ((void**)&_buffer, MAX_BUFFER_SIZE_BYTES, 32 /*32 byte alignment*/);
memset (_buffer, 0, MAX_BUFFER_SIZE_BYTES);
void* WavesAudioPort::get_buffer (pframes_t nframes)
{
if (is_input ()) {
-
+
std::vector<WavesDataPort*>::const_iterator it = get_connections ().begin ();
-
+
if (it != get_connections ().end ()) {
/* In fact, the static casting to (const WavesAudioPort*) is not that safe.
* However, mixing the buffers is assumed in the time critical conditions.
// use optimized function to fill the buffer intialy
ARDOUR::copy_vector (_buffer, ((const WavesAudioPort*)*it)->const_buffer (), nframes);
++it;
-
+
// mix the rest
for (; it != get_connections ().end (); ++it) {
Sample* tgt = buffer ();
#include "memory.h"
#include "waves_dataport.h"
-
+
namespace ARDOUR {
class WavesAudioPort : public WavesDataPort {
} // namespace
#endif /* __libardour_waves_audioport_h__ */
-
+
: _name (inport_name)
, _flags (inflags)
{
- _capture_latency_range.min =
- _capture_latency_range.max =
- _playback_latency_range.min =
+ _capture_latency_range.min =
+ _capture_latency_range.max =
+ _playback_latency_range.min =
_playback_latency_range.max = 0;
}
if (this == port) {
std::cerr << "WavesDataPort::connect (): attempt to connect port to itself!" << std::endl;
- return -1;
+ return -1;
}
if (is_connected (port)) {
void WavesDataPort::_disconnect (WavesDataPort *port, bool api_call)
{
std::vector<WavesDataPort*>::iterator it = std::find (_connections.begin (), _connections.end (), port);
-
+
if (it != _connections.end ()) { // actually, it's supposed to be always true.
_connections.erase (it);
}
void WavesDataPort::disconnect_all ()
{
_disconnect_all ();
-
+
if (is_input()) {
_wipe_buffer();
}
#include "ardour/types.h"
#include "memory.h"
-
+
namespace ARDOUR {
class WavesDataPort {
{
return _name;
}
-
+
int set_name (const std::string &name)
{
_name = name;
}
int connect (WavesDataPort *port);
-
+
int disconnect (WavesDataPort *port);
-
+
void disconnect_all ();
bool inline is_connected (const WavesDataPort *port) const
} // namespace
#endif /* __libardour_waves_dataport_h__ */
-
+
std::cerr << "WavesMidiDevice::open (): _input_queue = Pm_QueueCreate () failed for " << _pm_input_id << "-[" << name () << "]!" << std::endl;
return -1;
}
- }
+ }
// create stream
// COMMENTED DBG LOGS */ std::cout << " going to Pm_OpenInput : " << std::endl;
- if (pmNoError != Pm_OpenInput (&_input_pm_stream,
+ if (pmNoError != Pm_OpenInput (&_input_pm_stream,
_pm_input_id,
NULL,
1024,
return -1;
}
// COMMENTED DBG LOGS */ std::cout << " DONE : " << std::endl;
- }
- }
-
+ }
+ }
+
if (is_output () ) {
// COMMENTED DBG LOGS */ std::cout << "WavesMidiDevice::open (): OUTPUT" << _pm_output_id << "-[" << name () << "]" << std::endl;
}
// create stream
// COMMENTED DBG LOGS */ std::cout << " going to Pm_OpenOutput : " << std::endl;
- if (pmNoError != Pm_OpenOutput (&_output_pm_stream,
- _pm_output_id,
+ if (pmNoError != Pm_OpenOutput (&_output_pm_stream,
+ _pm_output_id,
NULL,
1024,
time_proc,
if (NULL == _input_pm_stream) {
return;
}
-
+
while (Pm_Poll (_input_pm_stream) > 0) {
PmEvent pm_event; // just one message at a time
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ("WavesMidiDevice::_read_midi (): [%1] new incomplete_waves_midi_event\n", name()));
_incomplete_waves_midi_event = new WavesMidiEvent (pm_event.timestamp);
}
-
+
WavesMidiEvent *nested_pm_event = _incomplete_waves_midi_event->append_data (pm_event);
if (nested_pm_event) {
Pm_Enqueue (_input_queue, &nested_pm_event);
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ("WavesMidiDevice::_read_midi (): [%1] : Pm_Enqueue (_input_queue, nested_pm_event)\n", name()));
}
-
+
switch ( _incomplete_waves_midi_event->state ()) {
case WavesMidiEvent::BROKEN:
delete _incomplete_waves_midi_event;
PmError err;
WavesMidiEvent *waves_midi_event;
-
+
while (1 == Pm_Dequeue (_output_queue, &waves_midi_event)) {
if (waves_midi_event->sysex ()) {
// LATENCY compensation
return;
}
-
+
int
WavesMidiDevice::enqueue_output_waves_midi_event (const WavesMidiEvent* waves_midi_event)
{
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ("WavesMidiDevice::enqueue_output_waves_midi_event () [%1]\n", name()));
-
+
if (waves_midi_event == NULL) {
error << "WavesMidiDevice::put_event_to_callback (): 'waves_midi_event' is NULL!" << endmsg;
return -1;
}
-
+
PmError err = Pm_Enqueue (_output_queue, &waves_midi_event);
-
+
if (0 > err) {
error << "WavesMidiDevice::put_event_to_callback (): Pm_Enqueue () failed (" << err << ")!" << endmsg;
return -1;
};
-
+
return 0;
}
-WavesMidiEvent*
+WavesMidiEvent*
WavesMidiDevice::dequeue_input_waves_midi_event ()
{
WavesMidiEvent* waves_midi_event;
} // namespace
#endif /* __libardour_waves_midi_device_h__ */
-
+
if ( _active == false ) {
return 0;
}
-
+
stream (false);
_delete_devices ();
return 0;
}
-void
+void
WavesMidiDeviceManager::__portmidi_callback (PtTimestamp timestamp, void * userData)
{
// COMMENTED FREQUENT DBG LOGS */ std::cout << "WavesMidiDeviceManager::__portmidi_callback ():" << std::endl;
WavesMidiDeviceManager *dm = (WavesMidiDeviceManager *)userData;
-
+
if (dm == NULL) {
return;
}
-
+
dm->_portmidi_callback (timestamp);
}
PmTimestamp
WavesMidiDeviceManager::__get_time_ms (void *time_info)
-{
+{
return ((WavesAudioBackend*)time_info)->sample_time ();
}
WavesMidiDeviceManager (WavesAudioBackend& audiobackend);
~WavesMidiDeviceManager ();
- inline const std::vector<WavesMidiDevice *>& devices () const
+ inline const std::vector<WavesMidiDevice *>& devices () const
{
return _devices;
}
void _portmidi_callback (PtTimestamp timestamp);
/** __get_time_ms is given to Pm_Open functions (see WavesMidiDevice.cc)
* to provide the time in milliseconds using the time of audio
- * transport.
+ * transport.
* time_info is a pointer on the backend instance, which agregates the
* audio and miditransports. It's not checked for correctness to consume
- * no time.
+ * no time.
*/
static PmTimestamp __get_time_ms (void *time_info);
} // namespace
#endif /* __libardour_waves_midi_device_manager_h__ */
-
+
: _size (0)
, _timestamp (timestamp)
, _data (NULL)
- , _state (INCOMPLETE)
+ , _state (INCOMPLETE)
{
}
: _size (datalen)
, _timestamp (timestamp)
, _data (data && datalen ? new uint8_t[ (datalen < sizeof (PmMessage)) ? sizeof (PmMessage) : datalen] : NULL)
- , _state (data && datalen ? COMPLETE : BROKEN)
+ , _state (data && datalen ? COMPLETE : BROKEN)
{
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ( "WavesMidiEvent::WavesMidiEvent (const WavesMidiEvent& source) : Size=%1---%2\n", _size, datalen));
if (_state == COMPLETE) {
: _size (source.size ())
, _timestamp (source.timestamp ())
, _data ((source.size () && source.const_data ()) ? new uint8_t[ (source.size () < sizeof (PmMessage)) ? sizeof (PmMessage) : source.size ()] : NULL)
- , _state (source.state () )
+ , _state (source.state () )
{
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ( "WavesMidiEvent::WavesMidiEvent (const WavesMidiEvent& source) : Size=%1---%2\n", _size, source.size ()));
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ( "\t\t\t Allocated Size=%1\n", ((source.size () < sizeof (PmMessage)) ? sizeof (PmMessage) : source.size ())));
WavesMidiEvent *WavesMidiEvent::append_data (const PmEvent &midi_event)
{
switch ( _state ) {
- case INCOMPLETE:
+ case INCOMPLETE:
break;
default:
DEBUG_TRACE (DEBUG::WavesMIDI, "WavesMidiEvent::append_data (): NO case INCOMPLETE\n");
_state = BROKEN;
return NULL;
}
-
+
size_t message_size = _midi_message_size (midi_event.message);
uint8_t message_status = Pm_MessageStatus (midi_event.message);
-
+
if (_data == NULL) { // This is a first event to add
bool sysex = (message_status == SYSEX);
_data = new unsigned char [sysex ? PM_DEFAULT_SYSEX_BUFFER_SIZE : sizeof (PmMessage)];
if (!sysex)
{
DEBUG_TRACE (DEBUG::WavesMIDI, "WavesMidiEvent::append_data (): SHORT MSG\n");
- * (PmMessage*)_data = 0;
+ * (PmMessage*)_data = 0;
switch (message_size) {
case 1:
case 2:
DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ( "WavesMidiEvent::append_data (): size = %1\n", _size));
break;
default:
- DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ( "WavesMidiEvent::append_data (): WRONG MESSAGE SIZE (%1 not %2) %3 [%4 %5 %6 %7] %8\n",
+ DEBUG_TRACE (DEBUG::WavesMIDI, string_compose ( "WavesMidiEvent::append_data (): WRONG MESSAGE SIZE (%1 not %2) %3 [%4 %5 %6 %7] %8\n",
message_size,
std::hex,
(int) ((unsigned char*)&midi_event)[0],
return NULL;
}
}
-
+
// Now let's parse to sysex msg
if (message_status >= REAL_TIME_FIRST) { // Nested Real Time MIDI event
WavesMidiEvent *waves_midi_message = new WavesMidiEvent (midi_event.timestamp);
waves_midi_message->append_data (midi_event);
return waves_midi_message;
}
-
+
if (message_status >= STATUS_FIRST && (message_status != EOX) && _size) { // Certainly it's a broken SYSEX case
WavesMidiEvent *waves_midi_message = new WavesMidiEvent (midi_event.timestamp);
waves_midi_message->append_data (midi_event);
}
const uint8_t* source_data ((uint8_t*)&midi_event.message);
-
+
for (size_t i = 0; i < sizeof (midi_event.message); ++i) {
_data[_size] = source_data[i];
_size++;
-
+
if (source_data[i] == EOX) { // Ended SYSEX message
_state = COMPLETE;
return NULL;
WavesMidiEvent (PmTimestamp timestamp, const uint8_t* data, size_t datalen);
WavesMidiEvent (const WavesMidiEvent& source);
~WavesMidiEvent ();
-
+
WavesMidiEvent *append_data (const PmEvent &midi_event);
inline State state () const { return _state; };
: WavesDataPort (port_name, flags)
, _midi_device (NULL)
, _waves_midi_buffer (port_name)
-{
+{
}
struct MidiEventSorter {
}
};
-void*
+void*
WavesMidiPort::get_buffer (pframes_t nframes)
{
if (is_input ()) {
} // namespace
#endif /* __libardour_waves_midiport_h__ */
-
+
class WCFourCC
{
private:
- template<class _iter>
+ template<class _iter>
static WTFourCharCode stored_from_iter(_iter& i)
{
return s_stored_byte_order==wvNS::wvBO::byte_order_big_endian ? FOURCC_BIG(i[0], i[1], i[2], i[3]) : FOURCC_LITTLE(i[0], i[1], i[2], i[3]);
// change this line will change the byte order in which WCFourCC keeps the four char code
static const wvNS::wvBO::byte_order_type s_stored_byte_order = wvNS::wvBO::compiler_byte_order;
- WCFourCC(const char a, const char b, const char c, const char d) :
+ WCFourCC(const char a, const char b, const char c, const char d) :
m_stored_value(s_stored_byte_order==wvNS::wvBO::compiler_byte_order ? FOURCC_BIG(a,b,c,d) : FOURCC_LITTLE(a,b,c,d))
{
#if kEnableWCFourCCDebug == 1
{
return reinterpret_cast<char*>(&m_stored_value)[s_stored_byte_order==wvNS::wvBO::byte_order_little_endian ? 3-in_character_index : in_character_index];
}
-
+
static size_t size()
{
return sizeof(WTFourCharCode);
{
return size();
}
-
+
static size_t capacity()
{
return size();
}
-
+
WCFixedString4 GetString() const
{
WCFixedString4 retVal;
#define _BYTEORDER_BIG_ENDIAN 0
#endif // big/little switch
#else // if the compiler proparly has NOT set either __BIG_ENDIAN__ or __LITTLE_ENDIAN__
-// http://msdn.microsoft.com/en-us/library/b0084kay.aspx for all preprocessor defs. _M_X64: 64 bit. _M_IA64: Itanium 64bit
+// http://msdn.microsoft.com/en-us/library/b0084kay.aspx for all preprocessor defs. _M_X64: 64 bit. _M_IA64: Itanium 64bit
#if defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(__INTEL__) || defined(__x86_64__) || defined(_M_X64) || defined(_M_IA64)
#define _BYTEORDER_BIG_ENDIAN 0
#elif defined(_M_PPC) || defined(__POWERPC__ ) || defined(__ppc__)
// We try to use this static const rather than preprocessor symbols in our code wherever possible.
#if _BYTEORDER_BIG_ENDIAN == 1
static const byte_order_type compiler_byte_order = byte_order_big_endian;
-#else
+#else
static const byte_order_type compiler_byte_order = byte_order_little_endian;
#endif
return x;
}
inline uint64_t swap64(uint64_t x) // TODO: To be replaced
- {
- return
+ {
+ return
((x>>7*8)&0xFF)<<0*8 | ((x>>6*8)&0xFF)<<1*8 | ((x>>5*8)&0xFF)<<2*8 | ((x>>4*8)&0xFF)<<3*8 |
((x>>3*8)&0xFF)<<4*8 | ((x>>2*8)&0xFF)<<5*8 | ((x>>1*8)&0xFF)<<6*8 | ((x>>0*8)&0xFF)<<7*8 ;
}
// TODO
#endif // _BYTEORDER_ASM_GNUC_PPC
-#if _BYTEORDER_ASM_NONE
+#if _BYTEORDER_ASM_NONE
inline uint16_t swap16(uint16_t x) { return (x>>8) | ((x&0xFF)<<8); }
inline uint32_t swap32(uint32_t x) { return (x&0xFF)<<24 | (x&0xFF00)<<8 | (x&0xFF0000)>>8 | (x&0xFF000000)>>24; }
inline uint64_t swap64(uint64_t x)
- {
- return
+ {
+ return
((x>>7*8)&0xFF)<<0*8 | ((x>>6*8)&0xFF)<<1*8 | ((x>>5*8)&0xFF)<<2*8 | ((x>>4*8)&0xFF)<<3*8 |
((x>>3*8)&0xFF)<<4*8 | ((x>>2*8)&0xFF)<<5*8 | ((x>>1*8)&0xFF)<<6*8 | ((x>>0*8)&0xFF)<<7*8 ;
}
//---------------------------------------------------------------------------------
// order conversion functions
- // may want to overload for float and double as well.
+ // may want to overload for float and double as well.
// overload for signed ints is ambiguous and should be done only if no other choice exists.
// - - - - - - - - - - - - - - - - - - - -
inline uint16_t compiler_to_big_16(uint16_t x)
#include "WavesPublicAPI/wstdint.h"
-typedef int32_t wvComPtr[2];
+typedef int32_t wvComPtr[2];
// ConvertDPtr has the exact format of a vfp callback function, but it is a local function, native only.
// It converts a pointer in either 32 bits or 64 bits to a place-holder of 64 bits in coefs/states/external memory.
//////////////////////////////////////////////////////////////////////////
inline uint32_t DSP_to_ComPtr( const char* pDataStruct, intptr_t *ThePtr)
// pDataStruct is pointing to wvComPtr in the Coefs/States
-// the function reconstruct the pointer into ThePtr
+// the function reconstruct the pointer into ThePtr
{
*ThePtr = UnpackComPtr(*(reinterpret_cast<const wvComPtr *>(pDataStruct)));
// When changing wvNS value also do the same change in Objective_C_MangledNames.h
// because CWSAUCocoaViewFactoryAsString is hard coded there
-#define wvNS wvWavesV9_3
+#define wvNS wvWavesV9_3
#ifdef __APPLE__
#define ObjCNameSpace(__className__) wvWavesV9_3_ ## __className__
#endif
#ifdef INSIDE_NETSHELL
#define DllExport
#else
- #define DllExport WPAPI_DllExport
+ #define DllExport WPAPI_DllExport
#endif
#define __CDECL __WPAPI_CDECL
#define WIN_ONLY(__Something_only_for_windows__)
#define MAC_ONLY(__Something_only_for_mac__) __Something_only_for_mac__
-
+
#if defined(i386) || defined(__i386) || defined(__i386__)
#define kNumArchBits 32
#endif
#if defined(__x86_64) || defined(__x86_64__)
#define kNumArchBits 64
- #endif
+ #endif
#if (__i386 || __x86_64) && !defined(__LITTLE_ENDIAN__)
- #define __LITTLE_ENDIAN__
+ #define __LITTLE_ENDIAN__
#endif
#if !(__i386 || __x86_64) && !defined(__BIG_ENDIAN__)
#define __BIG_ENDIAN__
#endif
#ifdef __GNUC__
#define STD_EXCEPT_WIN std
- #define FAR
- #define PASCAL
+ #define FAR
+ #define PASCAL
// #define HINSTANCE void*
#define WINAPI
-
+
#else
-
+
#define DllExport_WinOnly
#define STD_EXCEPT_WIN std
- #define FAR
+ #define FAR
#define PASCAL // windows' pascal
#define HINSTANCE void*
#define WINAPI
#define WUNUSED_PARAM_ON_MAC(__SOME_UNUSED_PARAM__)
#define WUNUSED_PARAM_ON_WIN(__SOME_UNUSED_PARAM__) WUNUSED_PARAM(__SOME_UNUSED_PARAM__)
-#endif
+#endif
#ifdef __linux__
const char* const OS_NAME = "Linux";
#define DllExport_WinOnly
#define STD_EXCEPT_WIN std
- #define FAR
- #define PASCAL
+ #define FAR
+ #define PASCAL
// #define HINSTANCE void*
#define WINAPI
#if __i386 && !defined(__LITTLE_ENDIAN__)
- #define __LITTLE_ENDIAN__
+ #define __LITTLE_ENDIAN__
#endif
#if !__i386 && !defined(__BIG_ENDIAN__)
#define __BIG_ENDIAN__
#endif
#define THROW_SPEC(THROW_OBJ) throw (THROW_OBJ)
-
+
#if defined(__x86_64) || defined(__LP64__)
#error "64 bit not suported yet on linux"
#else
#endif
#ifndef _WU_DECL
- #define _WU_DECL __CDECL // the default is calling model is cdecl, but you can also set this macro from the outside to something different
+ #define _WU_DECL __CDECL // the default is calling model is cdecl, but you can also set this macro from the outside to something different
#endif
#ifndef _XML_DECL
- #define _XML_DECL __CDECL // the default is calling model is cdecl, but you can also set this macro from the outside to something different
+ #define _XML_DECL __CDECL // the default is calling model is cdecl, but you can also set this macro from the outside to something different
#endif
#ifndef kNumArchBits
Atoms
*********************************************************************************/
-#define WTSInt64 "WTSInt64 is obsolete, please use int64_t instead";
-#define WTUInt64 "WTUInt64 is obsolete, please use uint64_t instead";
-#define WTSInt32 "WTSInt32 is obsolete, please use int32_t instead";
-#define WTUInt32 "WTUInt32 is obsolete, please use uint32_t instead";
-#define WTSInt16 "WTSInt16 is obsolete, please use int16_t instead";
-#define WTUInt16 "WTUInt16 is obsolete, please use uint16_t instead";
-#define WTSInt8 "WTSInt8 is obsolete, please use int8_t instead";
-#define WTUInt8 "WTUInt8 is obsolete, please use uint8_t instead";
-#define WTFloat32 "WTFloat32 is obsolete, please use float instead";
-#define WTByte "WTByte is obsolete, please use uint8_t instead";
+#define WTSInt64 "WTSInt64 is obsolete, please use int64_t instead";
+#define WTUInt64 "WTUInt64 is obsolete, please use uint64_t instead";
+#define WTSInt32 "WTSInt32 is obsolete, please use int32_t instead";
+#define WTUInt32 "WTUInt32 is obsolete, please use uint32_t instead";
+#define WTSInt16 "WTSInt16 is obsolete, please use int16_t instead";
+#define WTUInt16 "WTUInt16 is obsolete, please use uint16_t instead";
+#define WTSInt8 "WTSInt8 is obsolete, please use int8_t instead";
+#define WTUInt8 "WTUInt8 is obsolete, please use uint8_t instead";
+#define WTFloat32 "WTFloat32 is obsolete, please use float instead";
+#define WTByte "WTByte is obsolete, please use uint8_t instead";
/********************************************************************************
Consts
eCurrentFolder,
eRootFolder,
eLibrariesFolder,
- eAudioComponentsFolder, // MacOS only
+ eAudioComponentsFolder, // MacOS only
eCacheFolder,
eWavesCacheFolder,
eAppDataFolder,
//********************************************************************************
// Files
-const uint32_t kMaxPathLength = 1023; // maximum length of a path
+const uint32_t kMaxPathLength = 1023; // maximum length of a path
const uint32_t kMaxFileNameLength = 255; // maximum length of a file name including extension
typedef WCFixedString<kMaxPathLength> WTPathString;
typedef WCFixedString<kMaxFileNameLength> WTFileNameString;
const WCPluginViewRef kIllegalPluginViewRef = 0;
const WCMenuRef kIllegalWCMenuRef = 0;
-const intptr_t kIllegalTexturesMaster = -1;
+const intptr_t kIllegalTexturesMaster = -1;
typedef unsigned int WTTextureRef;
#include <math.h>
#ifndef __GNUC__
-#define __abs(x) abs(x)
+#define __abs(x) abs(x)
#define __labs(x) labs(x)
#define __fabs(x) fabs(x)
#endif
// log2: on Windows there's no proper definition for log2, whereas on other platform there is.
#ifndef WUlog2
#if defined(PLATFORM_WINDOWS)
- #define WUlog2(x) (kdOneOverLog2 * log10((x)))
- #else
+ #define WUlog2(x) (kdOneOverLog2 * log10((x)))
+ #else
#define WUlog2(x) log2(x)
#endif
#endif
#include "BasicTypes/WUDefines.h"
#include "BasicTypes/WUTypes.h"
-namespace wvNS {
+namespace wvNS {
// a wraper for Microseconds function from Timer.h
class DllExport UMicroseconds
{
UMicroseconds& operator+=(const TimeKeeper in_timeToAdd) {theTime += in_timeToAdd; return *this;}
UMicroseconds& ReadTime();
-
+
TimeKeeper GetNativeTime() const {return theTime;}
operator uint64_t () {return static_cast<uint64_t>(theTime);}
operator double () const {return static_cast<const double>(theTime);}
} while ((now.MicroSeconds() - than.MicroSeconds()) < amt);
}
-} // namespace wvNS {
+} // namespace wvNS {
#endif //#ifndef __UMicroseconds_h__
if (in_index < m_MaxFixedStringLength)
return m_begin[in_index];
else
- return m_begin[m_MaxFixedStringLength]; // in_index was too big
+ return m_begin[m_MaxFixedStringLength]; // in_index was too big
}
char& operator[](const pos_t in_index)
if (in_index < m_MaxFixedStringLength)
return m_begin[in_index];
else
- return m_begin[m_MaxFixedStringLength]; // in_index was too big
+ return m_begin[m_MaxFixedStringLength]; // in_index was too big
}
inline size_t resize(const size_t in_newSize)
*m_end++ = *curr_char++;
#if kEnableDebug == 1
- if (curr_char < in_chars_end) // if there wasn't enough room for some appended chars
+ if (curr_char < in_chars_end) // if there wasn't enough room for some appended chars
{
m_begin[0] = '@'; // mark the string as overflowed
}
*m_end = '\0';
}
- // append from a char* in_count chars, (no \0 is required to terminate the input string)
+ // append from a char* in_count chars, (no \0 is required to terminate the input string)
inline void append(const char* in_chars_begin, const size_t in_count)
{
append(in_chars_begin, in_chars_begin + in_count);
}
- // assign from a char* in_count chars, (no \0 is required to terminate the input string)
+ // assign from a char* in_count chars, (no \0 is required to terminate the input string)
inline void assign(const char* in_chars_begin, const size_t in_count)
{
clear();
append(in_chars_begin, in_chars_begin + in_count);
}
- // assign from a char* , (a \0 is required to terminate the input string)
+ // assign from a char* , (a \0 is required to terminate the input string)
inline void assign(const char* in_chars_ptr)
{
clear();
*m_end++ = *pSource++;
#if kEnableDebug == 1
- if (*pSource != '\0') // if there wasn't enough room for some appended chars
+ if (*pSource != '\0') // if there wasn't enough room for some appended chars
{
m_begin[0] = '@'; // mark the string as overflowed
}
WCFixedStringBase& operator<<(const size_t in_uint) {
return operator<<(static_cast<unsigned long long>(in_uint));
}
-#endif
+#endif
// WCFixedStringBase& operator<<(const unsigned char in_uint) {
// return operator<<(static_cast<const unsigned long long>(in_uint));
// }
WCFixedStringBase& operator<<(const unsigned int in_uint) {
return operator<<(static_cast<uint64_t>(in_uint));
}
-#endif
+#endif
//
#if defined(PLATFORM_WINDOWS) || defined(__linux__) // both 32 & 64 bit
WCFixedStringBase& operator<<(const unsigned long in_uint) {
return operator<<(static_cast<uint64_t>(in_uint));
}
-#endif
+#endif
WCFixedStringBase& operator<<(const long long in_int)
{
pos_t retVal = npos;
const char* pCurrChar = m_end;
- while (pCurrChar != m_begin)
+ while (pCurrChar != m_begin)
{
--pCurrChar;
if (*pCurrChar == in_char_to_find)
break;
}
}
-
+
return retVal;
}
-
+
pos_t find(const char* in_chars_to_find, const pos_t in_start_from = 0) const
{
pos_t retVal = npos;
size_t to_find_size = ::strlen(in_chars_to_find);
-
+
if (to_find_size > 0 && to_find_size <= size() && in_start_from < size())
{
const char* pCurrChar = m_begin + in_start_from;
retVal = (pCurrChar - m_begin);
break;
}
-
+
++pCurrChar;
}
}
-
+
return retVal;
}
-
+
pos_t rfind(const char* in_chars_to_find) const
{
pos_t retVal = npos;
size_t to_find_size = ::strlen(in_chars_to_find);
-
+
if (to_find_size > 0 && to_find_size <= size())
{
const char* pCurrChar = m_end - to_find_size;
retVal = (pCurrChar - m_begin);
break;
}
-
+
--pCurrChar;
}
}
-
+
return retVal;
}
-
+
pos_t find_case_insensitive(const char* in_chars_to_find, const pos_t in_start_from = 0) const
{
pos_t retVal = npos;
size_t to_find_size = ::strlen(in_chars_to_find);
-
+
if (to_find_size > 0 && to_find_size <= size() && in_start_from < size())
{
const char* pCurrChar = m_begin + in_start_from;
if (tolower(*(pCurrChar+i)) != tolower(in_chars_to_find[i]))
break;
}
-
+
if (i == to_find_size)
{
retVal = (pCurrChar - m_begin);
break;
}
-
+
++pCurrChar;
}
}
-
+
return retVal;
}
-
+
pos_t find_first_of(const char* in_possibe_chars_to_find, const pos_t in_start_from = 0) const
{
pos_t retVal = npos;
bool retVal = ((size() - strlen(in_end_text)) == where) || (0 == ::strlen(in_end_text));
return retVal;
}
-
+
size_t replace(const char in_look_for, const char in_replace_with)
{
size_t retVal = 0;
const char* end_buffer = out_buffer + (WUMin<size_t>(in_buffer_size - 1, m_end - m_begin));
while (cur_buffer < end_buffer)
*cur_buffer++ = *cur_fixed++;
-
+
*cur_buffer = '\0';
}
}
-
+
protected:
~WCFixedStringBase() {}
{
public:
- inline WCFixedString() :
+ inline WCFixedString() :
WCFixedStringBase(m_fixedString, kMaxFixedStringLength)
{
}
typedef WCFixedString<1023> WCFixedString1023;
typedef WCFixedString<2047> WCFixedString2047;
-template<size_t kSizeOfFirst, size_t kSizeOfSecond>
+template<size_t kSizeOfFirst, size_t kSizeOfSecond>
class WCFixedStringPair : public std::pair< WCFixedString<kSizeOfFirst>, WCFixedString<kSizeOfSecond> >
{
public:
const WTErr eNegativeNumber = -14; //!< expected a positive number and found a negative
const WTErr eTimeOut = -15; //!< something timed out
const WTErr eCoreAudioFailed = -16; //!< Error in a core audio call
-const WTErr eSomeThingInitailzedTwice = -17;
-const WTErr eGenerateHelpInfo = -18;
-const WTErr eOutOfRangeNumber = -19;
-const WTErr eMacOnlyCode = -20;
-const WTErr eWinOnlyCode = -21;
+const WTErr eSomeThingInitailzedTwice = -17;
+const WTErr eGenerateHelpInfo = -18;
+const WTErr eOutOfRangeNumber = -19;
+const WTErr eMacOnlyCode = -20;
+const WTErr eWinOnlyCode = -21;
const WTErr eAppLaunchFailed = -22; //!< failed to launch an application
const WTErr eAppTerminateFailed = -23; //!< failed to terminate an application
const WTErr eAppReturnedError = -24; //!< Non zero exit code from application
const WTErr eAsioFailed = -27;
// File Manager errors
-const WTErr eFMNoSuchVolume = -1001;
+const WTErr eFMNoSuchVolume = -1001;
const WTErr eFMFileNotFound = -1002;
const WTErr eFMFileAllreadyExists = -1003;
const WTErr eFMAllreadyOpenWithWritePerm = -1004;
const WTErr eFMIllegalPathRef = -1012;
const WTErr eFMFileNotOpened = -1013;
const WTErr eFMFileSizeTooBig = -1014;
-const WTErr eFMNoSuchDomain = -1015;
-const WTErr eFMNoSuchSystemFolder = -1016;
+const WTErr eFMNoSuchDomain = -1015;
+const WTErr eFMNoSuchSystemFolder = -1016;
const WTErr eFMWrongParameters = -1017;
const WTErr eFMIsNotAFolder = -1018;
const WTErr eFMIsAFolder = -1019;
// Resource Manager errors
const WTErr eRMResNotFound = -3000;
-const WTErr eRMResExists = -3001; //!< a resource exist even though it's not expected to
+const WTErr eRMResExists = -3001; //!< a resource exist even though it's not expected to
const WTErr eRMContainerNotFound = -3002; //!< The container was not found in the list of containers
const WTErr eRMResRefNotFound = -3003; //!< The resRef was not found in container's resource list
const WTErr eRMInvalidResRef = -3004;
const WTErr eMemBuffTooShort = -4005; //!< the buffer in question did not have enough space for the operation
const WTErr eInstanciationFailed = -4006;
const WTErr eMemAddressSpaceError = -4007; //!< memory falls outside the legal address space
-const WTErr eMemBadPointer = -4008;
-const WTErr eMemOutOfMemory = -4009;
+const WTErr eMemBadPointer = -4008;
+const WTErr eMemOutOfMemory = -4009;
// XML Errors
const WTErr eXMLParserFailed = -6001;
const WTErr eXMLAttribMissing = -6007;
// Preset errors
-const WTErr ePresetFileProblem = -7860;
-const WTErr eInvalidFileFormatProblem = -7861;
-const WTErr ePresetLockedProblem = -7862;
-const WTErr ePresetInfoNotFound = -7863;
-const WTErr eDuplicatePluginSpecificTag = -7959;
-const WTErr ePluginSpecifcNotExisting = -7960;
-const WTErr eBuffSizeToSmall = -7961;
-const WTErr eCreatingPopupWhereAnItemExists = -7962;
-const WTErr eDeletePluginSpecifcFailed = -7963;
-const WTErr eFactoryPresetNumOutOfRange = -7964;
-const WTErr eNoFactoryPresets = -7965;
-const WTErr eLoadPresetToPlugin_vec_empty = -7966;
-const WTErr eFactoryPresetNotFound = -7967;
-const WTErr eCantCreateUserPrefFile = -7968;
-const WTErr eDataFormatNotSupported = -7969;
-const WTErr eCantLoadProcessFunction = -7970;
-const WTErr eIllegalChunkIndex = -7971;
-const WTErr eIllegalChunkID = -7972;
+const WTErr ePresetFileProblem = -7860;
+const WTErr eInvalidFileFormatProblem = -7861;
+const WTErr ePresetLockedProblem = -7862;
+const WTErr ePresetInfoNotFound = -7863;
+const WTErr eDuplicatePluginSpecificTag = -7959;
+const WTErr ePluginSpecifcNotExisting = -7960;
+const WTErr eBuffSizeToSmall = -7961;
+const WTErr eCreatingPopupWhereAnItemExists = -7962;
+const WTErr eDeletePluginSpecifcFailed = -7963;
+const WTErr eFactoryPresetNumOutOfRange = -7964;
+const WTErr eNoFactoryPresets = -7965;
+const WTErr eLoadPresetToPlugin_vec_empty = -7966;
+const WTErr eFactoryPresetNotFound = -7967;
+const WTErr eCantCreateUserPrefFile = -7968;
+const WTErr eDataFormatNotSupported = -7969;
+const WTErr eCantLoadProcessFunction = -7970;
+const WTErr eIllegalChunkIndex = -7971;
+const WTErr eIllegalChunkID = -7972;
const WTErr eIllegalChunkVersion = -7973;
/*
- Copyright (C) 2014 John Emmas
+ Copyright (C) 2014 John Emmas
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace wvThread
{
//#include "BasicTypes/WavesAPISetAligment.h"
- //Packing affects the layout of classes, and commonly, if packing changes across header files, there can be problems.
+ //Packing affects the layout of classes, and commonly, if packing changes across header files, there can be problems.
#ifdef PLATFORM_WINDOWS
#pragma pack(push)
#pragma pack(8)
public:
static const ThreadHandle Invalid;
protected:
- ThreadHandle(uintptr_t n) : m_oshandle(n) {}
+ ThreadHandle(uintptr_t n) : m_oshandle(n) {}
public:
ThreadHandle() : m_oshandle(Invalid.m_oshandle) {}
bool is_invalid() const { return !m_oshandle || m_oshandle==Invalid.m_oshandle; }
-
+
//--------------------------------------------------------
class DllExport noncopyableobject
{
//--------------------------------------------------------
// Thread Mutex class that is automatically initialized
- class ThreadMutex : public ThreadMutexInited
+ class ThreadMutex : public ThreadMutexInited
{
public:
ThreadMutex() {init();}
protected:
uintptr_t m_osThreadRef;
- WCThreadRef(uintptr_t n) : m_osThreadRef(n) {}
+ WCThreadRef(uintptr_t n) : m_osThreadRef(n) {}
friend DllExport bool operator==(const WCThreadRef& first, const WCThreadRef& second);
friend DllExport bool operator!=(const WCThreadRef& first, const WCThreadRef& second);
class DllExport WCAtomicLock
{
- public:
+ public:
WCAtomicLock() : m_the_lock(0) {}
bool obtain(const uint32_t in_num_trys = 1);
void release();
class WCStThreadMutexLocker
{
public:
- WCStThreadMutexLocker(wvNS::wvThread::ThreadMutexInited& in_mutex) :
+ WCStThreadMutexLocker(wvNS::wvThread::ThreadMutexInited& in_mutex) :
m_mutex(in_mutex)
{
m_mutex.obtain();
}
-
+
~WCStThreadMutexLocker()
{
m_mutex.release();
WCStThreadMutexLocker(const WCStThreadMutexLocker&);
WCStThreadMutexLocker& operator=(const WCStThreadMutexLocker&);
};
-
+
} // namespace wvThread
#define WPAPI_DllExport __attribute__ ((visibility("default")))
#define __WPAPI_CDECL
#define __WPAPI_STDCALL
-
+
#else
-
+
#define WPAPI_DllExport __declspec(export)
#define __WPAPI_CDECL
#define __WPAPI_STDCALL
#define WPAPI_DllExport __declspec(dllexport)
#define __WPAPI_CDECL __cdecl
#define __WPAPI_STDCALL __stdcall
-#endif
+#endif
#ifdef __linux__
#endif
#ifdef __linux__
#if ! defined(__STDC_LIMIT_MACROS)
- #define __STDC_LIMIT_MACROS
+ #define __STDC_LIMIT_MACROS
#endif
#include <stddef.h>
#include <winsock2.h>
#include <windows.h>
#include <objbase.h>
-#endif // #if PLATFORM_WINDOWS
+#endif // #if PLATFORM_WINDOWS
#endif // #ifndef __IncludeWindows_h__
DeviceInfo():
m_DeviceId(-1), m_DeviceName("Unknown"), m_MaxInputChannels(0), m_MaxOutputChannels(0)
{};
-
+
DeviceInfo(unsigned int deviceID, const std::string & deviceName):
m_DeviceId(deviceID), m_DeviceName(deviceName), m_MaxInputChannels(0), m_MaxOutputChannels(0)
{};
virtual WTErr ShowConfigPanel (void *pParam);///< Show Control Panel - in case of ASIO this will work only with Active device!
virtual WTErr SendCustomCommand (int customCommand, void *pCommandParam); ///< Send a custom command to the audiodevice...
-
+
virtual uint32_t GetLatency (bool isInput); ///Get latency.
virtual WTErr UpdateDeviceInfo () = 0;
-
+
protected:
WCMRAudioDeviceManager *m_pMyManager; ///< The manager who's managing this device, can be used for sending notifications!
class WCMRAudioDeviceManager : public WCRefManager
{
public://< Public functions for the class.
-
+
WCMRAudioDeviceManager(WCMRAudioDeviceManagerClient *pTheClient, eAudioDeviceFilter eCurAudioDeviceFilter); ///< constructor
virtual ~WCMRAudioDeviceManager(void); ///< Destructor
void NotifyClient (WCMRAudioDeviceManagerClient::NotificationReason forReason, void *pParam = NULL);
protected:
-
+
mutable wvNS::wvThread::ThreadMutex m_AudioDeviceInfoVecMutex; // mutex to lock device info list
DeviceInfoVec m_DeviceInfoVec;
virtual WTErr getDeviceBufferSizesImpl(const std::string & deviceName, std::vector<int>& bufferSizes) const = 0;
virtual WTErr generateDeviceListImpl() = 0;
virtual WTErr updateDeviceListImpl() = 0;
-
+
WCMRAudioDeviceManagerClient *m_pTheClient; ///< The device manager's client, used to send notifications.
};
#include <mach/mach.h>
-#include <CoreAudio/CoreAudio.h>
+#include <CoreAudio/CoreAudio.h>
//forward decl.
class WCMRCoreAudioDeviceManager;
// This enum is for choosing filter for audio devices scan
typedef enum eCABS_Method
{
- eCABS_Simple = 0,
+ eCABS_Simple = 0,
eCABS_DestructiveCache,
- eCABS_CacheOnDeviceSet,
+ eCABS_CacheOnDeviceSet,
eCABS_MethodNum // Must be last
} eCABS_Method;
virtual const std::string& DeviceName() const;///<Name?
virtual const std::vector<std::string>& InputChannels();///<Current Input Channel List? - note that this may change with change in sampling rate.
virtual const std::vector<std::string>& OutputChannels();///<Current Output Channel List? - note that this may change with change in sampling rate.
-
-
+
+
virtual const std::vector<int>& SamplingRates();///<Supported Sampling Rate List?
virtual int CurrentSamplingRate(); ///<Current Sampling rate.?
virtual WTErr SetCurrentSamplingRate(int newRate);///<Change Current Sampling Rate : This is a requset, might not be successful at run time!
virtual int AudioCallback (float *pOutputBuffer, unsigned long framesPerBuffer, int64_t inSampleTime, uint64_t inCycleStartTime);
AudioDeviceID DeviceID () {return m_DeviceID;}
-
+
virtual uint32_t GetLatency (bool isInput); ///< Get latency.
virtual OSStatus GetStreamLatency(AudioDeviceID deviceID, bool isInput, std::vector<int>& latencies);
-
+
protected:
AudioDeviceID m_DeviceID; ///< The CoreAudio device id
protected:
static OSStatus HardwarePropertyChangeCallback (AudioHardwarePropertyID inPropertyID, void* inClientData);
-
+
virtual WCMRAudioDevice* initNewCurrentDeviceImpl(const std::string & deviceName);
virtual void destroyCurrentDeviceImpl();
virtual WTErr generateDeviceListImpl();
virtual WTErr updateDeviceListImpl();
virtual WTErr getDeviceSampleRatesImpl(const std::string & deviceName, std::vector<int>& sampleRates) const;
virtual WTErr getDeviceBufferSizesImpl(const std::string & deviceName, std::vector<int>& bufferSizes) const;
-
+
bool m_UseMultithreading; ///< Flag indicates whether to use multi-threading for audio processing.
bool m_bNoCopyAudioBuffer;
-
+
private:
// helper functions for this class only
WTErr getDeviceAvailableSampleRates(DeviceID deviceId, std::vector<int>& sampleRates);
WTErr getDeviceMaxInputChannels(DeviceID deviceId, unsigned int& inputChannels);
WTErr getDeviceMaxOutputChannels(DeviceID deviceId, unsigned int& outputChannels);
-
+
WCMRAudioDevice* m_NoneDevice;
};
PaError testStateValidness(int sampleRate, int bufferSize);
///////////////////////////////////////////////////////////
- static int TheCallback (const void *pInputBuffer, void *pOutputBuffer, unsigned long framesPerBuffer,
+ static int TheCallback (const void *pInputBuffer, void *pOutputBuffer, unsigned long framesPerBuffer,
const PaStreamCallbackTimeInfo* /*pTimeInfo*/, PaStreamCallbackFlags /*statusFlags*/, void *pUserData );
unsigned int m_DeviceID; ///< The PA device id
double angle_degs = atan (p.y/p.x) * 2.0 * M_PI;
double radius = sqrt (p.x * p.x + p.y * p.y);
- return (angle_degs >= _start_degrees) &&
- (angle_degs <= (_start_degrees + _arc_degrees)) &&
+ return (angle_degs >= _start_degrees) &&
+ (angle_degs <= (_start_degrees + _arc_degrees)) &&
(radius < _radius);
}
(*i)->scroll_to (Duple (x, y));
}
- pick_current_item (0); // no current mouse position
+ pick_current_item (0); // no current mouse position
}
void
std::string
Canvas::indent() const
-{
+{
string s;
for (int n = 0; n < ArdourCanvas::dump_depth; ++n) {
std::string
Canvas::render_indent() const
-{
+{
string s;
for (int n = 0; n < ArdourCanvas::render_depth; ++n) {
/* XXX January 22nd 2015: leaving this in place for now
* but I think it fixes a bug that really should be
* fixed in a different way (and will be) by my next
- * commit. But it may still be relevant.
+ * commit. But it may still be relevant.
*/
/* If scroll groups overlap, choose the one with the highest sensitivity,
that is, choose an HV scroll group over an H or V
- only group.
+ only group.
*/
if (!best_group || sg->sensitivity() > best_group->sensitivity()) {
best_group = sg;
* added or removed, so we have no coordinates to work from as is the
* case with a motion event. Find out where the mouse is and use that.
*/
-
+
Glib::RefPtr<const Gdk::Window> pointer_window = Gdk::Display::get_default()->get_window_at_pointer (x, y);
if (pointer_window != get_window()) {
enter_detail = GDK_NOTIFY_UNKNOWN;
/* no current item, so also send virtual enter events to the
- * entire heirarchy for the new item
+ * entire heirarchy for the new item
*/
for (i = _new_current_item->parent(); i ; i = i->parent()) {
} else if (_current_item->is_descendant_of (*_new_current_item)) {
/* move from descendant to ancestor (X: "_current_item is an
- * inferior ("child") of _new_current_item")
+ * inferior ("child") of _new_current_item")
*
* Deliver "virtual" leave notifications to all items in the
* heirarchy between current and new_current.
Item* parent = item->parent ();
- if (!item->ignore_events () &&
+ if (!item->ignore_events () &&
item->Event (event)) {
/* this item has just handled the event */
DEBUG_TRACE (
}
if (_current_item == item) {
- /* no need to send a leave event to this item, since it is going away
+ /* no need to send a leave event to this item, since it is going away
*/
_current_item = 0;
pick_current_item (0); // no mouse state
}
Cairo::RefPtr<Cairo::Context> draw_context = Cairo::Context::create (canvas_image);
Cairo::RefPtr<Cairo::Context> window_context = get_window()->create_cairo_context ();
-#else
+#else
Cairo::RefPtr<Cairo::Context> draw_context = get_window()->create_cairo_context ();
#endif
/* draw background color */
-
+
draw_context->rectangle (ev->area.x, ev->area.y, ev->area.width, ev->area.height);
draw_context->clip_preserve ();
set_source_rgba (draw_context, _bg_color);
draw_context->fill ();
-
+
/* render canvas */
if ( _single_exposure ) {
copy.motion.x = where.x;
copy.motion.y = where.y;
- /* Coordinates in "copy" will be canvas coordinates,
+ /* Coordinates in "copy" will be canvas coordinates,
*/
DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas motion @ %1, %2 canvas @ %3, %4\n", ev->x, ev->y, copy.motion.x, copy.motion.y));
GtkCanvasViewport::on_size_request (Gtk::Requisition* req)
{
/* force the canvas to size itself */
- // _canvas.root()->bounding_box();
+ // _canvas.root()->bounding_box();
req->width = 16;
req->height = 16;
void set_arc (double degrees);
void set_start (double degrees);
- Duple center() const {
+ Duple center() const {
return _center;
}
Coord radius () const {
void scroll_to (Coord x, Coord y);
void add_scroller (ScrollGroup& i);
-
+
virtual Rect visible_area () const = 0;
virtual Coord width () const = 0;
virtual Coord height () const = 0;
Duple clamp_to_window (Duple const& winpos, Duple border = Duple());
void zoomed();
-
+
std::string indent() const;
std::string render_indent() const;
void dump (std::ostream&) const;
bool motion_notify_handler (GdkEventMotion *);
bool deliver_event (GdkEvent *);
void deliver_enter_leave (Duple const & point, int state);
-
+
void pick_current_item (int state);
void pick_current_item (Duple const &, int state);
};
/** A GTK::Alignment with a GtkCanvas inside it plus some Gtk::Adjustments for
- * scrolling.
+ * scrolling.
*
* This provides a GtkCanvas that can be scrolled. It does NOT implement the
* Gtk::Scrollable interface.
#include "canvas/visibility.h"
#include "canvas/types.h"
-namespace ArdourCanvas
+namespace ArdourCanvas
{
struct LIBCANVAS_API HSV;
-/**
- * @file colorspace.h
+/**
+ * @file colorspace.h
* @author Pascal Getreuer 2005-2010 <getreuer@gmail.com>
*/
/** The render() method is likely to be identical in all containers
* (just call Item::render_children()). It can be overridden as necessary.
- */
+ */
void render (Rect const & area, Cairo::RefPtr<Cairo::Context> context) const;
};
public:
Image (Canvas *, Cairo::Format, int width, int height);
Image (Item*, Cairo::Format, int width, int height);
-
+
struct Data {
Data (uint8_t *d, int w, int h, int s, Cairo::Format fmt)
: data (d)
void* destroy_arg;
};
- /**
- * Returns a shared_ptr to a Data object that can be used to
+ /**
+ * Returns a shared_ptr to a Data object that can be used to
* write image data to. The Data object will contain a pointer
* to the buffer, along with image properties that may be
* useful during the data writing.
- *
+ *
* Can be called from any thread BUT ..
*
* ... to avoid collisions with Image deletion, some synchronization method
/** Adds one or more items to the vector @param items based on their
* covering @param point which is in **window** coordinates
*
- * Note that Item::add_items_at_window_point() is only intended to be
+ * Note that Item::add_items_at_window_point() is only intended to be
* called on items already looked up in a LookupTable (i.e. by a
* parent) and thus known to cover @param point already.
*
virtual void add_items_at_point (Duple /*point*/, std::vector<Item const *>& items) const;
/** Return true if the item covers @param point, false otherwise.
- *
- * The point is in window coordinates
+ *
+ * The point is in window coordinates
*/
virtual bool covers (Duple const &) const;
Item* parent () const {
return _parent;
}
-
+
uint32_t depth() const;
const Item* closest_ancestor_with (const Item& other) const;
bool common_ancestor_within (uint32_t, const Item& other) const;
/** returns true if this item is an ancestor of @param candidate,
- * and false otherwise.
+ * and false otherwise.
*/
bool is_ancestor_of (const Item& candidate) const {
return candidate.is_descendant_of (*this);
}
/** returns true if this Item is a descendant of @param candidate,
- * and false otherwise.
+ * and false otherwise.
*/
bool is_descendant_of (const Item& candidate) const;
Duple window_to_item (Duple const&) const;
Rect item_to_window (Rect const&, bool rounded = true) const;
Rect window_to_item (Rect const&) const;
-
+
void raise_to_top ();
void raise (int);
void lower_to_bottom ();
public:
LookupTable (Item const &);
virtual ~LookupTable ();
-
+
virtual std::vector<Item*> get (Rect const &) = 0;
virtual std::vector<Item*> items_at_point (Duple const &) const = 0;
virtual bool has_item_at_point (Duple const & point) const = 0;
{
public:
DumbLookupTable (Item const &);
-
+
std::vector<Item*> get (Rect const &);
std::vector<Item*> items_at_point (Duple const &) const;
bool has_item_at_point (Duple const & point) const;
std::vector<Item*> get (Rect const &);
std::vector<Item*> items_at_point (Duple const &) const;
bool has_item_at_point (Duple const & point) const;
-
+
static int default_items_per_cell;
-
+
private:
-
+
void area_to_indices (Rect const &, int &, int &, int &, int &) const;
void point_to_indices (Duple, int &, int &) const;
-
+
friend class ::OptimizingLookupTableTest;
-
+
typedef std::vector<Item*> Cell;
int _items_per_cell;
int _dimension;
mutable float* multiple;
mutable float* constant;
mutable Points::size_type cached_size;
-
+
void cache_shape_computation () const;
};
/** return @param y as a floating point fraction of the overall
* height of the rectangle. @param y is in canvas coordinate space.
- *
+ *
* A value of zero indicates that y is at the bottom of the
* rectangle; a value of 1 indicates that y is at the top.
*
public:
ImageHandle image;
};
-
+
typedef std::vector<State> States;
public:
double _text_y;
int load_states (const XMLNode&);
-
+
typedef std::map<std::string,Cairo::RefPtr<Cairo::ImageSurface> > ImageCache;
static ImageCache _image_cache;
static PBD::Searchpath _image_search_path;
mutable bool _need_redraw;
mutable double _width_correction;
double _clamped_width;
-
+
void _redraw () const;
};
: x (x_)
, y (y_)
{}
-
+
Coord x;
Coord y;
#define LIBCANVAS_API LIBCANVAS_DLL_EXPORT
#else
#define LIBCANVAS_API LIBCANVAS_DLL_IMPORT
- #endif
+ #endif
#define LIBCANVAS_LOCAL LIBCANVAS_DLL_LOCAL
#endif
Cancel,
Draw
};
-
+
WaveViewThreadRequest () : stop (0) {}
bool should_stop () const { return (bool) g_atomic_int_get (const_cast<gint*>(&stop)); }
uint64_t timestamp;
Entry (int chan, Coord hght, float amp, Color fcl, double spp, framepos_t strt, framepos_t ed,
- Cairo::RefPtr<Cairo::ImageSurface> img)
+ Cairo::RefPtr<Cairo::ImageSurface> img)
: channel (chan)
, height (hght)
, amplitude (amp)
*/
typedef std::pair<boost::shared_ptr<ARDOUR::AudioSource>,boost::shared_ptr<Entry> > ListEntry;
typedef std::vector<ListEntry> CacheList;
-
+
struct SortByTimestamp {
bool operator() (const WaveViewCache::ListEntry& a, const WaveViewCache::ListEntry& b) {
return a.second->timestamp < b.second->timestamp;
}
};
friend struct SortByTimestamp;
-
+
uint64_t image_cache_size;
uint64_t _image_cache_threshold;
{
public:
- enum Shape {
+ enum Shape {
Normal,
Rectified
};
x = 0 in the waveview corresponds to the first waveform datum taken
from region->start() samples into the source data.
-
- x = N in the waveview corresponds to the (N * spp)'th sample
+
+ x = N in the waveview corresponds to the (N * spp)'th sample
measured from region->start() into the source data.
-
+
when drawing, we will map the zeroth-pixel of the waveview
- into a window.
-
+ into a window.
+
The waveview itself contains a set of pre-rendered Cairo::ImageSurfaces
that cache sections of the display. This is filled on-demand and
never cleared until something explicitly marks the cache invalid
void render (Rect const & area, Cairo::RefPtr<Cairo::Context>) const;
void compute_bounding_box () const;
-
+
void set_samples_per_pixel (double);
void set_height (Distance);
void set_channel (int);
void set_shape (Shape);
void set_always_get_image_in_thread (bool yn);
-
+
/* currently missing because we don't need them (yet):
set_shape_independent();
set_logscaled_independent()
static void set_global_logscaled (bool);
static void set_global_shape (Shape);
static void set_global_show_waveform_clipping (bool);
-
+
static double global_gradient_depth() { return _global_gradient_depth; }
static bool global_logscaled() { return _global_logscaled; }
static Shape global_shape() { return _global_shape; }
mutable bool get_image_in_thread;
/** If true, calls to get_image() will render a missing wave image
- in the calling thread. Set true for waveviews we expect to
+ in the calling thread. Set true for waveviews we expect to
keep updating (e.g. while recording)
*/
bool always_get_image_in_thread;
double spread;
bool clip_max;
bool clip_min;
-
+
LineTips() : top (0.0), bot (0.0), clip_max (false), clip_min (false) {}
};
void queue_get_image (boost::shared_ptr<const ARDOUR::Region> region, framepos_t start, framepos_t end) const;
void generate_image (boost::shared_ptr<WaveViewThreadRequest>, bool in_render_thread) const;
boost::shared_ptr<WaveViewCache::Entry> cache_request_result (boost::shared_ptr<WaveViewThreadRequest> req) const;
-
+
void image_ready ();
-
+
mutable boost::shared_ptr<WaveViewCache::Entry> _current_image;
-
+
mutable boost::shared_ptr<WaveViewThreadRequest> current_request;
static WaveViewCache* images;
void set_fade_position (XFadePosition xfp) { _xfadeposition = xfp; }
void set_show_background_fade (bool show) { show_background_fade = show; }
-
+
void compute_bounding_box () const;
void render (Rect const & area, Cairo::RefPtr<Cairo::Context>) const;
Color _fill_color;
bool show_background_fade;
-
+
void interpolate ();
};
if (cmax == 0) {
// r = g = b == 0 ... v is undefined, s = 0
- s = 0.0;
+ s = 0.0;
h = 0.0;
return;
}
return rgba_to_color (x + m, m, c + m, a);
} else if (h >= 300.0 && h < 360.0) {
return rgba_to_color (c + m, m, x + m, a);
- }
+ }
return rgba_to_color (m, m, m, a);
}
}
// Inverse of sRGB "gamma" function.
-static inline double
-inv_gam_sRGB (double c)
+static inline double
+inv_gam_sRGB (double c)
{
if (c <= 0.04045) {
return c/12.92;
}
// sRGB "gamma" function
-static inline int
-gam_sRGB(double v)
+static inline int
+gam_sRGB(double v)
{
if (v <= 0.0031308) {
v *= 12.92;
return int (v*255+.5);
}
-static double
+static double
luminance (uint32_t c)
{
// sRGB luminance(Y) values
double r, g, b, a;
ArdourCanvas::color_to_rgba (c, r, g, b, a);
-
+
return (gam_sRGB (rY*inv_gam_sRGB(r) + gY*inv_gam_sRGB(g) + bY*inv_gam_sRGB(b))) / 255.0;
-}
+}
uint32_t
ArdourCanvas::contrasting_text_color (uint32_t c)
: h (0.0)
, s (1.0)
, v (1.0)
- , a (1.0)
+ , a (1.0)
{
}
: h (hh)
, s (ss)
, v (vv)
- , a (aa)
+ , a (aa)
{
if (h < 0.0) {
/* normalize negative hue values into positive range */
/* algorithm derived from a google palette website
and analysis of their color palettes.
- basic rule: to make a color darker, increase its saturation
- until it reaches 88%, but then additionally reduce value/lightness
+ basic rule: to make a color darker, increase its saturation
+ until it reaches 88%, but then additionally reduce value/lightness
by a larger amount.
invert rule to make a color lighter.
if (factor > 1.0) {
if (s < 88) {
hsv.v += (hsv.v * (factor * 10.0));
- }
+ }
hsv.s *= factor;
} else {
if (s < 88) {
hsv.v -= (hsv.v * (factor * 10.0));
- }
+ }
hsv.s *= factor;
}
if (is_gray() && other.is_gray()) {
/* human color perception of achromatics generates about 450
distinct colors. By contrast, CIE94 could give a maximal
- perceptual distance of sqrt ((360^2) + 1 + 1) = 360. The 450
+ perceptual distance of sqrt ((360^2) + 1 + 1) = 360. The 450
are not evenly spread (Webers Law), so lets use 360 as an
approximation of the number of distinct achromatics.
-
+
So, scale up the achromatic difference to give about
a maximal distance between v = 1.0 and v = 0.0 of 360.
-
+
A difference of about 0.0055 will generate a return value of
2, which is roughly the limit of human perceptual
discrimination for chromatics.
double sL, sA, sB;
double oL, oA, oB;
double r, g, b, alpha; // Careful, "a" is a field of this
- Color c;
+ Color c;
c = hsva_to_color (h, s, v, a);
color_to_rgba (c, r, g, b, alpha);
const double whtL = 1.0;
const double whtC = 1.0;
- const double whtH = 1.0;
+ const double whtH = 1.0;
const double xC1 = sqrt ((sA * sA) + (sB * oB));
const double xC2 = sqrt ((oA * oA) + (oB * oB));
*
* == Summary ==
* This file implements routines for color transformations between the spaces
- * sRGB, Y'UV, Y'CbCr, Y'PbPr, Y'DbDr, Y'IQ, HSV, HSL, HSI, CIEXYZ, CIELAB,
+ * sRGB, Y'UV, Y'CbCr, Y'PbPr, Y'DbDr, Y'IQ, HSV, HSL, HSI, CIEXYZ, CIELAB,
* CIELUV, CIELCH, and CIECAT02 LMS.
*
* == Usage ==
double S[3] = {173, 0.8, 0.5};
double D[3];
colortransform Trans;
-
+
if(!(GetColorTransform(&Trans, "HSI -> Lab")))
{
printf("Invalid syntax or unknown color space\n");
return;
- }
-
+ }
+
ApplyColorTransform(Trans, &D[0], &D[1], &D[2], S[0], S[1], S[2]);
@endcode
* "num" is a typedef defined at the beginning of colorspace.h that may be set
Lab2Rgb(&R, &G, &B, L, a, b);
@endcode
* Generally, the calling syntax is
-@code
+@code
Foo2Bar(&B0, &B1, &B2, F0, F1, F2);
-@endcode
+@endcode
* where (F0,F1,F2) are the coordinates of a color in space "Foo" and
- * (B0,B1,B2) are the transformed coordinates in space "Bar." For any
+ * (B0,B1,B2) are the transformed coordinates in space "Bar." For any
* transformation routine, its inverse has the sytax
-@code
+@code
Bar2Foo(&F0, &F1, &F2, B0, B1, B2);
-@endcode
+@endcode
*
* The conversion routines are consistently named with the first letter of a
* color space capitalized with following letters in lower case and omitting
* any transformation routine Foo2Bar, its inverse is Bar2Foo.
*
* All transformations assume a two degree observer angle and a D65 illuminant.
- * The white point can be changed by modifying the WHITEPOINT_X, WHITEPOINT_Y,
+ * The white point can be changed by modifying the WHITEPOINT_X, WHITEPOINT_Y,
* WHITEPOINT_Z definitions at the beginning of colorspace.h.
*
* == List of transformation routines ==
* - Xyz2Lab(double *L, double *a, double *b, double X, double Y, double Z)
* - Xyz2Luv(double *L, double *u, double *v, double X, double Y, double Z)
* - Xyz2Lch(double *L, double *C, double *h, double X, double Y, double Z)
- * - Xyz2Cat02lms(double *L, double *M, double *S, double X, double Y, double Z)
+ * - Xyz2Cat02lms(double *L, double *M, double *S, double X, double Y, double Z)
* - Rgb2Lab(double *L, double *a, double *b, double R, double G, double B)
* - Rgb2Luv(double *L, double *u, double *v, double R, double G, double B)
* - Rgb2Lch(double *L, double *C, double *h, double R, double G, double B)
- * - Rgb2Cat02lms(double *L, double *M, double *S, double R, double G, double B)
+ * - Rgb2Cat02lms(double *L, double *M, double *S, double R, double G, double B)
* (Similarly for the inverse transformations.)
*
* It is possible to transform between two arbitrary color spaces by first
* transforming from the source space to sRGB and then transforming from
* sRGB to the desired destination space. For transformations between CIE
* color spaces, it is convenient to use XYZ as the intermediate space. This
- * is the strategy used by GetColorTransform and ApplyColorTransform.
+ * is the strategy used by GetColorTransform and ApplyColorTransform.
*
* == References ==
* The definitions of these spaces and the many of the transformation formulas
- * can be found in
+ * can be found in
*
* Poynton, "Frequently Asked Questions About Gamma"
* http://www.poynton.com/notes/colour_and_gamma/GammaFAQ.html
* == License (BSD) ==
* Copyright (c) 2005-2010, Pascal Getreuer
* All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
+ *
+ * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
- *
- * - Redistributions of source code must retain the above copyright
+ *
+ * - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
- * - Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the distribution.
- *
+ *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#define M_PI 3.14159265358979323846264338327950288
#endif
-/**
+/**
* @brief sRGB gamma correction, transforms R to R'
* http://en.wikipedia.org/wiki/SRGB
*/
(((t) <= 0.0031306684425005883) ? \
(12.92*(t)) : (1.055*pow((t), 0.416666666666666667) - 0.055))
-/**
- * @brief Inverse sRGB gamma correction, transforms R' to R
+/**
+ * @brief Inverse sRGB gamma correction, transforms R' to R
*/
#define INVGAMMACORRECTION(t) \
(((t) <= 0.0404482362771076) ? \
((t)/12.92) : pow(((t) + 0.055)/1.055, 2.4))
-/**
+/**
* @brief CIE L*a*b* f function (used to convert XYZ to L*a*b*)
* http://en.wikipedia.org/wiki/Lab_color_space
*/
((t >= 8.85645167903563082e-3) ? \
pow(t,0.333333333333333) : (841.0/108.0)*(t) + (4.0/29.0))
-/**
- * @brief CIE L*a*b* inverse f function
+/**
+ * @brief CIE L*a*b* inverse f function
* http://en.wikipedia.org/wiki/Lab_color_space
*/
#define LABINVF(t) \
/*
* == Linear color transformations ==
- *
+ *
* The following routines implement transformations between sRGB and
* the linearly-related color spaces Y'UV, Y'PbPr, Y'DbDr, and Y'IQ.
*/
/*
* == Hue Saturation Value/Lightness/Intensity color transformations ==
- *
+ *
* The following routines implement transformations between sRGB and
* color spaces HSV, HSL, and HSI.
*/
-/**
+/**
* @brief Convert an sRGB color to Hue-Saturation-Value (HSV)
- *
+ *
* @param H, S, V pointers to hold the result
* @param R, G, B the input sRGB values scaled in [0,1]
*
}
-/**
+/**
* @brief Convert a Hue-Saturation-Value (HSV) color to sRGB
- *
+ *
* @param R, G, B pointers to hold the result
* @param H, S, V the input HSV values
*
- * The input values are assumed to be scaled as
+ * The input values are assumed to be scaled as
* 0 <= H < 360,
* 0 <= S <= 1,
- * 0 <= V <= 1.
+ * 0 <= V <= 1.
* The output sRGB values are scaled between 0 and 1. This is the inverse
* transformation of Rgb2Hsv.
*
}
-/**
+/**
* @brief Convert an sRGB color to Hue-Saturation-Lightness (HSL)
- *
+ *
* @param H, S, L pointers to hold the result
* @param R, G, B the input sRGB values scaled in [0,1]
*
}
-/**
+/**
* @brief Convert a Hue-Saturation-Lightness (HSL) color to sRGB
- *
+ *
* @param R, G, B pointers to hold the result
* @param H, S, L the input HSL values
*
- * The input values are assumed to be scaled as
+ * The input values are assumed to be scaled as
* 0 <= H < 360,
* 0 <= S <= 1,
- * 0 <= L <= 1.
+ * 0 <= L <= 1.
* The output sRGB values are scaled between 0 and 1. This is the inverse
* transformation of Rgb2Hsl.
*
}
-/**
+/**
* @brief Convert an sRGB color to Hue-Saturation-Intensity (HSI)
- *
+ *
* @param H, S, I pointers to hold the result
* @param R, G, B the input sRGB values scaled in [0,1]
*
}
-/**
+/**
* @brief Convert a Hue-Saturation-Intesity (HSI) color to sRGB
- *
+ *
* @param R, G, B pointers to hold the result
* @param H, S, I the input HSI values
*
- * The input values are assumed to be scaled as
+ * The input values are assumed to be scaled as
* 0 <= H < 360,
* 0 <= S <= 1,
- * 0 <= I <= 1.
+ * 0 <= I <= 1.
* The output sRGB values are scaled between 0 and 1. This is the inverse
* transformation of Rgb2Hsi.
*
/*
* == CIE color transformations ==
- *
+ *
* The following routines implement transformations between sRGB and
- * the CIE color spaces XYZ, L*a*b, L*u*v*, and L*C*H*. These
+ * the CIE color spaces XYZ, L*a*b, L*u*v*, and L*C*H*. These
* transforms assume a 2 degree observer angle and a D65 illuminant.
*/
* @param X, Y, Z pointers to hold the result
* @param R, G, B the input sRGB values
*
- * Poynton, "Frequently Asked Questions About Color," page 10
+ * Poynton, "Frequently Asked Questions About Color," page 10
* Wikipedia: http://en.wikipedia.org/wiki/SRGB
* Wikipedia: http://en.wikipedia.org/wiki/CIE_1931_color_space
*/
* @param X, Y, Z pointers to hold the result
* @param L, a, b the input L*a*b* values
*
- * Wikipedia: http://en.wikipedia.org/wiki/Lab_color_space
+ * Wikipedia: http://en.wikipedia.org/wiki/Lab_color_space
*/
void Lab2Xyz(double *X, double *Y, double *Z, double L, double a, double b)
{
}
-/*
+/*
* == Glue functions for multi-stage transforms ==
*/
using namespace ArdourCanvas;
-Container::Container (Canvas* canvas)
+Container::Container (Canvas* canvas)
: Item (canvas)
{
}
-Container::Container (Item* parent)
+Container::Container (Item* parent)
: Item (parent)
{
}
-Container::Container (Item* parent, Duple const & p)
+Container::Container (Item* parent, Duple const & p)
: Item (parent, p)
{
}
setup (height, position);
}
-void
+void
Flag::setup (Distance height, Duple position)
{
_text = new Text (this);
{
if (_rectangle) {
return _rectangle->covers (point);
- }
+ }
return false;
}
DataReady.connect (data_connections, MISSING_INVALIDATOR, boost::bind (&Image::accept_data, this), gui_context());
}
-void
+void
Image::render (Rect const& area, Cairo::RefPtr<Cairo::Context> context) const
{
if (_need_render && _pending) {
}
void
-Image::accept_data ()
+Image::accept_data ()
{
/* must be executed in gui thread */
begin_change ();
_need_render = true;
end_change (); // notify canvas that we need redrawing
-}
+}
}
Duple
-Item::window_origin () const
+Item::window_origin () const
{
- /* This is slightly subtle. Our _position is in the coordinate space of
+ /* This is slightly subtle. Our _position is in the coordinate space of
our parent. So to find out where that is in window coordinates, we
have to ask our parent.
*/
{
if (_scroll_parent) {
return _scroll_parent->scroll_offset();
- }
+ }
return Duple (0,0);
}
}
Coord
-Item::height () const
+Item::height () const
{
boost::optional<ArdourCanvas::Rect> bb = bounding_box();
}
Coord
-Item::width () const
+Item::width () const
{
boost::optional<ArdourCanvas::Rect> bb = bounding_box();
}
std::string
-Item::whatami () const
+Item::whatami () const
{
std::string type = demangle (typeid (*this).name());
return type.substr (type.find_last_of (':') + 1);
#ifdef CANVAS_DEBUG
if (DEBUG_ENABLED(PBD::DEBUG::CanvasRender)) {
- cerr << string_compose ("%1%7 %2 @ %7 render %5 @ %6 %3 items out of %4\n",
+ cerr << string_compose ("%1%7 %2 @ %7 render %5 @ %6 %3 items out of %4\n",
_canvas->render_indent(), (name.empty() ? string ("[unnamed]") : name), items.size(), _items.size(), area, _position, this,
whatami());
}
if (DEBUG_ENABLED(PBD::DEBUG::CanvasRender)) {
if (dynamic_cast<Container*>(*i) == 0) {
cerr << _canvas->render_indent() << "render "
- << ' '
+ << ' '
<< (*i)
<< ' '
<< (*i)->whatami()
<< (*i)->name
<< " item "
<< item_bbox.get()
- << " window = "
+ << " window = "
<< item
<< " intersect = "
<< draw
- << " @ "
+ << " @ "
<< _position
<< endl;
}
c = item_to_window (Duple (p->x, p->y));
- context->curve_to (c1.x + pixel_adjust,
- c1.y + pixel_adjust,
- c2.x + pixel_adjust,
- c2.y + pixel_adjust,
- c.x + pixel_adjust,
+ context->curve_to (c1.x + pixel_adjust,
+ c1.y + pixel_adjust,
+ c2.x + pixel_adjust,
+ c2.y + pixel_adjust,
+ c.x + pixel_adjust,
c.y + pixel_adjust);
++cp1;
}
}
-void
+void
Polygon::cache_shape_computation () const
{
Points::size_type npoints = _points.size();
for (i = 0; i < npoints; i++) {
if (_points[j].y == _points[i].y) {
constant[i] = _points[i].x;
- multiple[i] = 0;
+ multiple[i] = 0;
} else {
constant[i] = _points[i].x-(_points[i].y*_points[j].x)/(_points[j].y-_points[i].y)+(_points[i].y*_points[i].x)/(_points[j].y-_points[i].y);
- multiple[i] = (_points[j].x-_points[i].x)/(_points[j].y-_points[i].y);
+ multiple[i] = (_points[j].x-_points[i].x)/(_points[j].y-_points[i].y);
}
- j = i;
+ j = i;
}
}
-bool
+bool
Polygon::covers (Duple const & point) const
{
Duple p = window_to_item (point);
for (i = 0; i < npoints; i++) {
if (((_points[i].y < p.y && _points[j].y >= p.y) || (_points[j].y < p.y && _points[i].y >= p.y))) {
- oddNodes ^= (p.y * multiple[i] + constant[i] < p.x);
+ oddNodes ^= (p.y * multiple[i] + constant[i] < p.x);
}
- j = i;
+ j = i;
}
- return oddNodes;
-}
+ return oddNodes;
+}
void
Polygon::compute_bounding_box () const
context->rectangle (draw.x0, draw.y0, draw.width(), draw.height());
context->fill ();
- }
+ }
if (_outline) {
* to be colored are actually "at" 0.5 and 10.5 (midway
* between the integer coordinates).
*
- * See the Cairo FAQ on single pixel lines for more
+ * See the Cairo FAQ on single pixel lines for more
* detail.
*/
bounding box is 1.0 pixels outside the stated
corners of the rectangle (so that the middle
of the 2 pixel wide border passes through
- the corners, alternatively described as 1 row
+ the corners, alternatively described as 1 row
of pixels outside of the corners, and 1 row
inside).
}
if (_divide_height >= 0.0) {
-
+
cr->set_line_width (1.0);
set_source_rgba (cr, _divider_color_top);
to consider the position of the bounding box
within the canvas.
*/
-
+
return r->translate (position()).contains (d);
}
/* Bounding box is in item coordinates, but we need
to consider the position of the bounding box
- within the canvas.
+ within the canvas.
*/
-
+
return r->translate (position()).contains (d);
}
}
layout->set_alignment (_alignment);
-
+
int w;
int h;
}
/* text has now been rendered in _image and is ready for blit in
- * ::render
+ * ::render
*/
_need_redraw = false;
if (_need_redraw) {
redraw ();
}
-
+
return _width;
}
if (!was_visible) {
/* move to current pointer location. do this after show() so that
- * _visible is true, and thus ::pointer_motion() will do
+ * _visible is true, and thus ::pointer_motion() will do
* something.
*/
Duple winpos;
at = p1;
t = 0.0;
return ((dp1x * dp1x) + (dp1y * dp1y));
- }
+ }
// Project a line from p to the segment [p1,p2]. By considering the line
// extending the segment, parameterized as p1 + (t * (p2 - p1)),
- // we find projection of point p onto the line.
+ // we find projection of point p onto the line.
// It falls where t = [(p - p1) . (p2 - p1)] / |p2 - p1|^2
t = ((dp1x * dx) + (dp1y * dy)) / segLenSquared;
{
const double effective_height = _height;
- /* remember: canvas (and cairo) coordinate space puts the origin at the upper left.
-
+ /* remember: canvas (and cairo) coordinate space puts the origin at the upper left.
+
So, a sample value of 1.0 (0dbFS) will be computed as:
(1.0 - 1.0) * 0.5 * effective_height
}
}
- /* zero line, show only if there is enough spread
+ /* zero line, show only if there is enough spread
or the waveform line does not cross zero line */
if (show_zero_line() && ((tips[i].spread >= 5.0) || (tips[i].top > height_zero ) || (tips[i].bot < height_zero)) ) {
* while we're here.
*/
- DEBUG_TRACE (DEBUG::WaveView, string_compose ("%1 CR %2 stop? %3 image %4\n", this, current_request,
- (current_request ? current_request->should_stop() : false),
+ DEBUG_TRACE (DEBUG::WaveView, string_compose ("%1 CR %2 stop? %3 image %4\n", this, current_request,
+ (current_request ? current_request->should_stop() : false),
(current_request ? current_request->image : 0)));
if (current_request && !current_request->should_stop() && current_request->image) {
if (!ret || !full_image) {
if ((rendered && get_image_in_thread) || always_get_image_in_thread) {
-
+
DEBUG_TRACE (DEBUG::WaveView, string_compose ("%1: generating image in caller thread\n", name));
boost::shared_ptr<WaveViewThreadRequest> req (new WaveViewThreadRequest);
framecnt_t
WaveView::desired_image_width () const
{
- /* compute how wide the image should be, in samples.
+ /* compute how wide the image should be, in samples.
*
- * We want at least 1 canvas width's worth, but if that
+ * We want at least 1 canvas width's worth, but if that
* represents less than 1/10th of a second, use 1/10th of
* a second instead.
*/
-
+
framecnt_t canvas_width_samples = _canvas->visible_area().width() * _samples_per_pixel;
const framecnt_t one_tenth_of_second = _region->session().frame_rate() / 10;
if (canvas_width_samples > one_tenth_of_second) {
return canvas_width_samples;
- }
+ }
return one_tenth_of_second;
}
if (!req->should_stop()) {
/* sample position is canonical here, and we want to generate
- * an image that spans about 3x the canvas width. We get to that
+ * an image that spans about 3x the canvas width. We get to that
* width by using an image sample count of the screen width added
* on each side of the desired image center.
*/
offset into the Region's **SOURCE**, rather than an offset into
the Region itself.
*/
-
+
framecnt_t peaks_read = _region->read_peaks (peaks.get(), n_peaks,
sample_start, sample_end - sample_start,
req->channel,
// cerr << "Image/WV space: " << image_start << " .. " << image_end << endl;
- /* sample coordinates - note, these are not subject to rounding error
+ /* sample coordinates - note, these are not subject to rounding error
*
* "sample_start = N" means "the first sample we need to represent is N
* samples after the first sample of the region"
*/
-
+
framepos_t sample_start = _region_start + (image_start * _samples_per_pixel);
framepos_t sample_end = _region_start + (image_end * _samples_per_pixel);
}
/* compute the first pixel of the image that should be used when we
- * render the specified range.
+ * render the specified range.
*/
image_origin_in_self_coordinates = (image_to_draw->start - _region_start) / _samples_per_pixel;
if (_start_shift && (sample_start == _region_start) && (self.x0 == draw.x0)) {
- /* we are going to draw the first pixel for this region, but
+ /* we are going to draw the first pixel for this region, but
we may not want this to overlap a border around the
waveform. If so, _start_shift will be set.
*/
}
DEBUG_TRACE (DEBUG::WaveView, string_compose ("cache shrunk to %1\n", image_cache_size));
}
-
+
/* Remove from the linear list, even if we didn't find it in
* the actual cache_mao
*/
if (IS_START || show_background_fade) {
set_source_rgba (context, IS_START ? _outline_color : outline_shaded);
context->set_line_width (IS_START ? 1.0 : .5);
-
+
context->begin_new_path ();
context->append_path (*path_in);
context->stroke();
/***********************************************
* ge_hsb_from_color -
- *
+ *
* Get HSB values from RGB values.
*
* Modified from Smooth but originated in GTK+
***********************************************/
void
-ge_hsb_from_color (const CairoColor *color,
- gdouble *hue,
+ge_hsb_from_color (const CairoColor *color,
+ gdouble *hue,
gdouble *saturation,
- gdouble *brightness)
+ gdouble *brightness)
{
gdouble min, max, delta;
gdouble red, green, blue;
red = color->r;
green = color->g;
blue = color->b;
-
+
if (red > green)
{
max = MAX(red, blue);
max = MAX(green, blue);
min = MIN(red, blue);
}
-
+
*brightness = (max + min) / 2;
if (fabs(max - min) < 0.0001)
*saturation = (max - min) / (max + min);
else
*saturation = (max - min) / (2 - max - min);
-
+
delta = max -min;
-
+
if (red == max)
*hue = (green - blue) / delta;
else if (green == max)
*hue = 2 + (blue - red) / delta;
else if (blue == max)
*hue = 4 + (red - green) / delta;
-
+
*hue *= 60;
if (*hue < 0.0)
*hue += 360;
}
}
-
+
/***********************************************
* ge_color_from_hsb -
- *
+ *
* Get RGB values from HSB values.
*
* Modified from Smooth but originated in GTK+
***********************************************/
#define MODULA(number, divisor) (((gint)number % divisor) + (number - (gint)number))
void
-ge_color_from_hsb (gdouble hue,
+ge_color_from_hsb (gdouble hue,
gdouble saturation,
- gdouble brightness,
+ gdouble brightness,
CairoColor *color)
{
gint i;
gdouble m1, m2, m3;
if (!color) return;
-
+
if (brightness <= 0.5)
m2 = brightness * (1 + saturation);
else
m2 = brightness + saturation - brightness * saturation;
-
+
m1 = 2 * brightness - m2;
-
+
hue_shift[0] = hue + 120;
hue_shift[1] = hue;
hue_shift[2] = hue - 120;
-
+
color_shift[0] = color_shift[1] = color_shift[2] = brightness;
-
+
i = (saturation == 0)?3:0;
-
+
for (; i < 3; i++)
{
m3 = hue_shift[i];
-
+
if (m3 > 360)
m3 = MODULA(m3, 360);
else if (m3 < 0)
m3 = 360 - MODULA(ABS(m3), 360);
-
+
if (m3 < 60)
color_shift[i] = m1 + (m2 - m1) * m3 / 60;
else if (m3 < 180)
else
color_shift[i] = m1;
}
-
+
color->r = color_shift[0];
color->g = color_shift[1];
color->b = color_shift[2];
c->blue = b;
}
-void
+void
ge_gtk_style_to_cairo_color_cube (GtkStyle * style, CairoColorCube *cube)
{
int i;
g_return_if_fail (style && cube);
for (i = 0; i < 5; i++)
- {
+ {
ge_gdk_color_to_cairo (&style->bg[i], &cube->bg[i]);
ge_gdk_color_to_cairo (&style->fg[i], &cube->fg[i]);
gdouble hue = 0;
gdouble saturation = 0;
gdouble brightness = 0;
-
+
g_return_if_fail (base && composite);
ge_hsb_from_color (base, &hue, &saturation, &brightness);
-
+
brightness = MIN(brightness*shade_ratio, 1.0);
brightness = MAX(brightness, 0.0);
-
+
saturation = MIN(saturation*shade_ratio, 1.0);
saturation = MAX(saturation, 0.0);
-
+
ge_color_from_hsb (hue, saturation, brightness, composite);
composite->a = base->a;
}
gdouble hue = 0;
gdouble saturation = 0;
gdouble brightness = 0;
-
+
g_return_if_fail (base && composite);
ge_hsb_from_color (base, &hue, &saturation, &brightness);
}
void
-ge_mix_color (const CairoColor *color1, const CairoColor *color2,
+ge_mix_color (const CairoColor *color1, const CairoColor *color2,
gdouble mix_factor, CairoColor *composite)
{
g_return_if_fail (color1 && color2 && composite);
composite->a = 1.0;
}
-cairo_t *
+cairo_t *
ge_gdk_drawable_to_cairo (GdkDrawable *window, GdkRectangle *area)
{
cairo_t *cr;
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
- if (area)
+ if (area)
{
cairo_rectangle (cr, area->x, area->y, area->width, area->height);
cairo_clip_preserve (cr);
return cr;
}
-void
+void
ge_cairo_set_color (cairo_t *cr, const CairoColor *color)
{
g_return_if_fail (cr && color);
alpha);
}
-void
-ge_cairo_pattern_add_color_stop_color (cairo_pattern_t *pattern,
- gfloat offset,
+void
+ge_cairo_pattern_add_color_stop_color (cairo_pattern_t *pattern,
+ gfloat offset,
const CairoColor *color)
{
g_return_if_fail (pattern && color);
}
void
-ge_cairo_pattern_add_color_stop_shade(cairo_pattern_t *pattern,
- gdouble offset,
- const CairoColor *color,
+ge_cairo_pattern_add_color_stop_shade(cairo_pattern_t *pattern,
+ gdouble offset,
+ const CairoColor *color,
gdouble shade)
{
CairoColor shaded;
/***********************************************
* ge_cairo_simple_border -
- *
+ *
* A simple routine to draw thin squared
* borders with a topleft and bottomright color.
- *
+ *
* It originated in Smooth-Engine.
***********************************************/
void
ge_cairo_simple_border (cairo_t *cr,
const CairoColor * tl, const CairoColor * br,
- gint x, gint y, gint width, gint height,
+ gint x, gint y, gint width, gint height,
gboolean topleft_overlap)
{
gboolean solid_color;
cairo_stroke (cr);
}
-
+
ge_cairo_set_color(cr, tl);
cairo_move_to(cr, x + 0.5, y + height - 0.5);
for (i = 1; i < npoints; i++)
{
if (!((points[i].x == points[i + 1].x) &&
- (points[i].y == points[i + 1].y)))
+ (points[i].y == points[i + 1].y)))
{
cairo_line_to(cr, points[i].x, points[i].y);
}
gint y1,
gint x2,
gint y2)
-{
+{
cairo_save(cr);
ge_cairo_set_color(cr, color);
/***********************************************
* ge_cairo_pattern_fill -
- *
+ *
* Fill an area with some pattern
* Scaling or tiling if needed
***********************************************/
-void
+void
ge_cairo_pattern_fill(cairo_t *canvas,
CairoPattern *pattern,
gint x,
/***********************************************
* ge_cairo_color_pattern -
- *
+ *
* Create A Solid Color Pattern
***********************************************/
CairoPattern*
result->scale = GE_DIRECTION_NONE;
result->translate = GE_DIRECTION_NONE;
- result->handle = cairo_pattern_create_rgba(base->r,
- base->g,
- base->b,
+ result->handle = cairo_pattern_create_rgba(base->r,
+ base->g,
+ base->b,
base->a);
result->operator = CAIRO_OPERATOR_SOURCE;
/***********************************************
* ge_cairo_pixbuf_pattern -
- *
+ *
* Create A Tiled Pixbuf Pattern
***********************************************/
CairoPattern*
/***********************************************
* ge_cairo_pixmap_pattern -
- *
+ *
* Create A Tiled Pixmap Pattern
***********************************************/
CairoPattern*
gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height);
- pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (pixmap),
- gdk_drawable_get_colormap(GDK_DRAWABLE (pixmap)),
+ pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE (pixmap),
+ gdk_drawable_get_colormap(GDK_DRAWABLE (pixmap)),
0, 0, 0, 0, width, height);
result = ge_cairo_pixbuf_pattern(pixbuf);
}
/***********************************************
- * ge_cairo_linear_shade_gradient_pattern -
- *
+ * ge_cairo_linear_shade_gradient_pattern -
+ *
* Create A Linear Shade Gradient Pattern
* Aka Smooth Shade Gradient, from/to gradient
* With End points defined as shades of the
* base color
***********************************************/
CairoPattern *
-ge_cairo_linear_shade_gradient_pattern(CairoColor *base,
- gdouble shade1,
- gdouble shade2,
+ge_cairo_linear_shade_gradient_pattern(CairoColor *base,
+ gdouble shade1,
+ gdouble shade2,
gboolean vertical)
{
CairoPattern * result = g_new0(CairoPattern, 1);
int x, int y, int width, int height);
static void
-clearlooks_draw_inset (cairo_t *cr,
- const CairoColor *bg_color,
- double x, double y, double w, double h,
+clearlooks_draw_inset (cairo_t *cr,
+ const CairoColor *bg_color,
+ double x, double y, double w, double h,
double radius, uint8 corners)
{
CairoColor shadow;
static void
clearlooks_draw_shadow (cairo_t *cr, const ClearlooksColors *colors, gfloat radius, int width, int height)
{
- CairoColor shadow;
+ CairoColor shadow;
ge_shade_color (&colors->shade[6], 0.92, &shadow);
cairo_set_line_width (cr, 1.0);
const WidgetParameters *params,
int width, int height, gdouble radius)
{
- CairoColor hilight;
+ CairoColor hilight;
double light_top = params->ythickness-1,
light_bottom = height - params->ythickness - 1,
ge_shade_color (dark, 1.5, &hilight);
- for ( i = 0; i < xr; i++ )
+ for ( i = 0; i < xr; i++ )
{
for ( j = 0; j < yr; j++ )
{
xoff = x -(xr * 3 / 2) + 3 * i;
- yoff = y -(yr * 3 / 2) + 3 * j;
+ yoff = y -(yr * 3 / 2) + 3 * j;
cairo_rectangle (cr, width/2+0.5+xoff, height/2+0.5+yoff, 2, 2);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.8+contrast);
ge_cairo_set_color (cr, border_disabled);
else
if (!params->active)
- clearlooks_set_border_gradient (cr, border_normal, 1.32, 0, height);
+ clearlooks_set_border_gradient (cr, border_normal, 1.32, 0, height);
else
ge_cairo_set_color (cr, border_normal);
}
else
{
- CairoColor shadow;
+ CairoColor shadow;
ge_shade_color (&border, 0.925, &shadow);
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, params->disabled ? 0.05 : 0.1);
if (params->focus || params->disabled)
ge_cairo_set_color (cr, &border);
else
- clearlooks_set_border_gradient (cr, &border, 1.32, 0, height);
+ clearlooks_set_border_gradient (cr, &border, 1.32, 0, height);
cairo_stroke (cr);
}
int x, int y, int width, int height)
{
const CairoColor *border = &colors->shade[!params->disabled ? 5 : 3];
- CairoColor hilight;
+ CairoColor hilight;
params->style_functions->draw_button (cr, colors, params, x, y, width, height);
{
cairo_pattern_t *pattern;
double radius = MIN (params->radius, MIN ((width - 4.0) / 2.0, (height - 4.0) / 2.0));
- CairoColor shadow;
+ CairoColor shadow;
ge_shade_color (&colors->bg[GTK_STATE_NORMAL], 0.8, &shadow);
cairo_translate (cr, x+1, y+1);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, spot->r, spot->g, spot->b);
cairo_set_source (cr, pattern);
}
- else
+ else
{
- CairoColor hilight;
+ CairoColor hilight;
ge_shade_color (fill, 1.5, &hilight);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
}
if (params->prelight || params->disabled)
ge_cairo_set_color (cr, border);
else
- clearlooks_set_border_gradient (cr, border, 1.2, 0, height);
+ clearlooks_set_border_gradient (cr, border, 1.2, 0, height);
cairo_stroke (cr);
/* Draw handle lines */
static menubar_draw_proto clearlooks_menubar_draw[3] =
-{
- clearlooks_draw_menubar0,
+{
+ clearlooks_draw_menubar0,
clearlooks_draw_menubar1,
- clearlooks_draw_menubar2
+ clearlooks_draw_menubar2
};
static void
}
static void
-clearlooks_get_frame_gap_clip (int x, int y, int width, int height,
+clearlooks_get_frame_gap_clip (int x, int y, int width, int height,
const FrameParameters *frame,
ClearlooksRectangle *bevel,
ClearlooksRectangle *border)
width += 3.0;
strip_size = 2.0/width;
- if (tab->gap_side == CL_GAP_LEFT)
+ if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
ge_shade_color (fill, 0.92, &shadow);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0/height, hilight.r, hilight.g, hilight.b, 0.4);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0/height, hilight.r, hilight.g, hilight.b, 0.4);
cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, fill->r,fill->g,fill->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, shadow.r,shadow.g,shadow.b);
cairo_set_source (cr, pattern);
{
const CairoColor *border = &colors->shade[5];
cairo_pattern_t *pattern;
- CairoColor hilight;
+ CairoColor hilight;
CairoColor shadow;
ge_shade_color (border, 1.5, &hilight);
ge_cairo_set_color (cr, fill);
cairo_paint (cr);
- if (!toolbar->topmost)
+ if (!toolbar->topmost)
{
/* Draw highlight */
cairo_move_to (cr, 0, 0.5);
s2 = colors->bg[widget->state_type];
ge_shade_color(&s2, 1.06, &s1);
- ge_shade_color(&s2, 0.98, &s3);
- ge_shade_color(&s2, 0.94, &s4);
+ ge_shade_color(&s2, 0.98, &s3);
+ ge_shade_color(&s2, 0.94, &s4);
cairo_pattern_add_color_stop_rgb(pattern, 0, s1.r, s1.g, s1.b);
cairo_pattern_add_color_stop_rgb(pattern, 0.5, s2.r, s2.g, s2.b);
cairo_translate (cr, -0.5, -0.5);
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
- clearlooks_set_border_gradient (cr, &border, 1.2, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
+ clearlooks_set_border_gradient (cr, &border, 1.2, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
cairo_stroke (cr);
cairo_translate (cr, 0.5, 0.5);
s2 = colors->bg[widget->state_type];
ge_shade_color(&s2, 1.06, &s1);
- ge_shade_color(&s2, 0.98, &s3);
- ge_shade_color(&s2, 0.94, &s4);
+ ge_shade_color(&s2, 0.98, &s3);
+ ge_shade_color(&s2, 0.94, &s4);
pattern = cairo_pattern_create_linear(1, 1, 1, height-1);
cairo_pattern_add_color_stop_rgb(pattern, 0, s1.r, s1.g, s1.b);
cairo_fill(cr);
cairo_pattern_destroy(pattern);
- clearlooks_set_border_gradient (cr, &border, 1.2, 0, height);
+ clearlooks_set_border_gradient (cr, &border, 1.2, 0, height);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
cairo_move_to (cr, 1.5, height-1.5);
}
static void
-clearlooks_set_mixed_color (cairo_t *cr,
- const CairoColor *color1,
- const CairoColor *color2,
+clearlooks_set_mixed_color (cairo_t *cr,
+ const CairoColor *color1,
+ const CairoColor *color2,
gdouble mix_factor)
{
CairoColor composite;
}
static void
-clearlooks_glossy_draw_inset (cairo_t *cr,
+clearlooks_glossy_draw_inset (cairo_t *cr,
const CairoColor *bg_color,
double x, double y, double w, double h,
double radius, uint8 corners)
}
static void
-clearlooks_glossy_draw_light_inset (cairo_t *cr,
- const CairoColor *bg_color,
- double x, double y, double w, double h,
+clearlooks_glossy_draw_light_inset (cairo_t *cr,
+ const CairoColor *bg_color,
+ double x, double y, double w, double h,
double radius, uint8 corners)
{
CairoColor shadow;
}
static void
-clearlooks_glossy_draw_highlight_and_shade (cairo_t *cr,
+clearlooks_glossy_draw_highlight_and_shade (cairo_t *cr,
const CairoColor *bg_color,
const ShadowParameters *params,
int width, int height, gdouble radius)
cairo_translate (cr, -0.5, -0.5);
}
- clearlooks_draw_glossy_gradient (cr, xoffset+1, yoffset+1,
- width-(xoffset*2)-2, height-(yoffset*2)-2,
+ clearlooks_draw_glossy_gradient (cr, xoffset+1, yoffset+1,
+ width-(xoffset*2)-2, height-(yoffset*2)-2,
&fill, params->disabled, radius, params->corners);
/* Pressed button shadow */
{
width += 3.0;
- if (tab->gap_side == CL_GAP_LEFT)
+ if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
cairo_fill (cr);
cairo_pattern_destroy (pattern);
- if (scrollbar->has_color)
+ if (scrollbar->has_color)
{
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
ge_cairo_stroke_rectangle (cr, 1.5, 1.5, width-3, height-3);
}
}
-static void
+static void
clearlooks_glossy_draw_toolbar (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
cairo_translate (cr, x, y);
if (toolbar->style == 1) /* Enable Extra features */
- {
+ {
cairo_pattern_t *pattern;
CairoColor shade1, shade2, shade3;
cairo_pattern_destroy (pattern);
}
else /* Flat */
- {
+ {
ge_cairo_set_color (cr, fill);
cairo_paint (cr);
- if (!toolbar->topmost)
+ if (!toolbar->topmost)
{
/* Draw highlight */
cairo_move_to (cr, 0, 0.5);
int x, int y, int width, int height)
{
const CairoColor *border;
- const CairoColor *dot;
+ const CairoColor *dot;
gboolean inconsistent = FALSE;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
if (widget->xthickness > 2 && widget->ythickness > 2)
{
- widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5,
+ widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5,
width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
/* Draw the rectangle for the checkbox itself */
- ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
+ ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
else
{
/* Draw the rectangle for the checkbox itself */
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
}
static void
-clearlooks_set_mixed_color (cairo_t *cr,
- const CairoColor *color1,
- const CairoColor *color2,
+clearlooks_set_mixed_color (cairo_t *cr,
+ const CairoColor *color1,
+ const CairoColor *color2,
gdouble mix_factor)
{
CairoColor composite;
}
static void
-clearlooks_gummy_draw_highlight_and_shade (cairo_t *cr,
+clearlooks_gummy_draw_highlight_and_shade (cairo_t *cr,
const CairoColor *bg_color,
const ShadowParameters *params,
int width, int height, gdouble radius)
const WidgetParameters *params,
int width, int height, gdouble radius)
{
- CairoColor hilight;
+ CairoColor hilight;
double light_top = params->ythickness-1,
light_bottom = height - params->ythickness - 1,
cairo_translate (cr, -0.5, -0.5);
}
- clearlooks_draw_gummy_gradient (cr, xoffset+1, yoffset+1,
- width-(xoffset*2)-2, height-(yoffset*2)-2,
+ clearlooks_draw_gummy_gradient (cr, xoffset+1, yoffset+1,
+ width-(xoffset*2)-2, height-(yoffset*2)-2,
&fill, params->disabled, radius, params->corners);
/* Pressed button shadow */
cairo_save (cr);
- ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, height, radius,
+ ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, height, radius,
params->corners & (CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMLEFT));
cairo_clip (cr);
cairo_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, 3);
}
else
{
- CairoColor shadow;
+ CairoColor shadow;
ge_shade_color (&border, 0.92, &shadow);
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, params->disabled ? 0.09 : 0.18);
cairo_translate (cr, 1, 1);
if (!slider->lower && !slider->fill_level)
- clearlooks_gummy_scale_draw_gradient (cr,
+ clearlooks_gummy_scale_draw_gradient (cr,
&colors->shade[2], /* bottom */
&colors->shade[6], /* border */
0, 0, trough_width, trough_height,
slider->horizontal, TRUE);
else if (!slider->fill_level)
- clearlooks_gummy_scale_draw_gradient (cr,
+ clearlooks_gummy_scale_draw_gradient (cr,
&colors->spot[1], /* bottom */
&colors->spot[2], /* border */
0, 0, trough_width, trough_height,
c1.a = 0.25;
c2.a = 0.25;
- clearlooks_gummy_scale_draw_gradient (cr,
+ clearlooks_gummy_scale_draw_gradient (cr,
&c1, /* bottom */
&c2, /* border */
0, 0, trough_width, trough_height,
{
width += 3.0;
- if (tab->gap_side == CL_GAP_LEFT)
+ if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
fill = colors->bg[widget->state_type];
ge_shade_color(&fill, SHADE_TOP, &shade1);
- ge_shade_color(&fill, SHADE_CENTER_TOP, &shade2);
- ge_shade_color(&fill, SHADE_BOTTOM, &shade3);
+ ge_shade_color(&fill, SHADE_CENTER_TOP, &shade2);
+ ge_shade_color(&fill, SHADE_BOTTOM, &shade3);
cairo_pattern_add_color_stop_rgb(pattern, 0, shade1.r, shade1.g, shade1.b);
cairo_pattern_add_color_stop_rgb(pattern, 0.5, shade2.r, shade2.g, shade2.b);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
- if (scrollbar->has_color)
+ if (scrollbar->has_color)
{
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.2);
ge_cairo_stroke_rectangle (cr, 1.5, 1.5, width-3, height-3);
int x, int y, int width, int height)
{
const CairoColor *border;
- const CairoColor *dot;
+ const CairoColor *dot;
gboolean inconsistent = FALSE;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
if (widget->xthickness > 2 && widget->ythickness > 2)
{
- widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5,
+ widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5,
width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
/* Draw the rectangle for the checkbox itself */
- ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
+ ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
else
{
/* Draw the rectangle for the checkbox itself */
- ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
+ ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
const WidgetParameters *params,
int width, int height, gdouble radius)
{
- CairoColor hilight;
+ CairoColor hilight;
double light_top = params->ythickness-1,
light_bottom = height - params->ythickness - 1,
ge_cairo_set_color (cr, border_disabled);
else
if (!params->active)
- clearlooks_set_border_gradient (cr, &border_normal, 1.32, 0, height);
+ clearlooks_set_border_gradient (cr, &border_normal, 1.32, 0, height);
else
ge_cairo_set_color (cr, &border_normal);
width += 3.0;
strip_size = 2.0/width;
- if (tab->gap_side == CL_GAP_LEFT)
+ if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
ge_shade_color (fill, 0.92, &shadow);
- cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
- cairo_pattern_add_color_stop_rgba (pattern, 1.0/height, hilight.r, hilight.g, hilight.b, 0.4);
+ cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
+ cairo_pattern_add_color_stop_rgba (pattern, 1.0/height, hilight.r, hilight.g, hilight.b, 0.4);
cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, fill->r,fill->g,fill->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, shadow.r,shadow.g,shadow.b);
cairo_set_source (cr, pattern);
cairo_set_source (cr, pattern);
}
else {
- CairoColor hilight;
+ CairoColor hilight;
ge_shade_color (fill, 1.5, &hilight);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
}
pattern = cairo_pattern_create_linear (0, 0, width, 0);
s1 = colors->bg[widget->state_type];
- ge_shade_color(&s1, 0.95, &s2);
- ge_shade_color(&s1, 1.05, &s3);
+ ge_shade_color(&s1, 0.95, &s2);
+ ge_shade_color(&s1, 1.05, &s3);
cairo_pattern_add_color_stop_rgb(pattern, 0, s2.r, s2.g, s2.b);
cairo_pattern_add_color_stop_rgb(pattern, 1.0, s3.r, s3.g, s3.b);
clearlooks_draw_top_left_highlight (cr, &s1, widget, width, height, radius);
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
- clearlooks_set_border_gradient (cr, &border, 1.2, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
+ clearlooks_set_border_gradient (cr, &border, 1.2, (scrollbar->horizontal ? 0 : width), (scrollbar->horizontal ? height: 0));
cairo_stroke (cr);
cairo_translate (cr, 0.5, 0.5);
pattern = cairo_pattern_create_linear(1, 1, 1, height-1);
s1 = colors->bg[widget->state_type];
- ge_shade_color(&s1, 0.95, &s2);
- ge_shade_color(&s1, 1.05, &s3);
+ ge_shade_color(&s1, 0.95, &s2);
+ ge_shade_color(&s1, 1.05, &s3);
cairo_pattern_add_color_stop_rgb(pattern, 0, s2.r, s2.g, s2.b);
cairo_pattern_add_color_stop_rgb(pattern, 1.0, s3.r, s3.g, s3.b);
{ "contrast", TOKEN_CONTRAST },
{ "sunkenmenubar", TOKEN_SUNKENMENU },
{ "progressbarstyle", TOKEN_PROGRESSBARSTYLE },
- { "menubarstyle", TOKEN_MENUBARSTYLE },
+ { "menubarstyle", TOKEN_MENUBARSTYLE },
{ "toolbarstyle", TOKEN_TOOLBARSTYLE },
{ "menuitemstyle", TOKEN_MENUITEMSTYLE },
{ "listviewitemstyle", TOKEN_LISTVIEWITEMSTYLE },
return G_TOKEN_EQUAL_SIGN;
token = g_scanner_get_next_token (scanner);
-
+
switch (token)
{
case TOKEN_CLASSIC:
clearlooks_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
-
+
{
static GQuark scope_id = 0;
ClearlooksRcStyle *clearlooks_style = CLEARLOOKS_RC_STYLE (rc_style);
cairo_destroy (cr);
}
-static void
+static void
clearlooks_style_draw_box_gap (DRAW_ARGS,
GtkPositionType gap_side,
gint gap_x,
cairo_destroy (cr);
}
-static void
+static void
clearlooks_style_draw_handle (DRAW_ARGS, GtkOrientation orientation)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
- STYLE_FUNCTION(draw_progressbar_trough) (cr, colors, ¶ms,
+ STYLE_FUNCTION(draw_progressbar_trough) (cr, colors, ¶ms,
x, y, width, height);
}
else if (DETAIL ("trough") && widget && (GE_IS_VSCROLLBAR (widget) || GE_IS_HSCROLLBAR (widget)))
cairo_destroy (cr);
}
-static void
+static void
clearlooks_style_draw_shadow_gap (DRAW_ARGS,
GtkPositionType gap_side,
gint gap_x,
{
ClearlooksColors *colors;
WidgetParameters params;
- ArrowParameters arrow;
+ ArrowParameters arrow;
cairo_t *cr;
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
arrow.type = CL_ARROW_COMBO;
- arrow.direction = CL_DIRECTION_DOWN;
+ arrow.direction = CL_DIRECTION_DOWN;
STYLE_FUNCTION(draw_arrow) (cr, colors, ¶ms, &arrow, x, y, width, height);
for (x = 0; x < width; x++) {
/* The "4" is the number of chars per pixel, in this case, RGBA,
the 3 means "skip to the alpha" */
- current = data + (y * rowstride) + (x * 4) + 3;
+ current = data + (y * rowstride) + (x * 4) + 3;
*(current) = (guchar) (*(current) * alpha_percent);
}
}
g_warning ("Using the default screen for gtk_default_render_icon()"));
}
-
+
if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
g_warning (G_STRLOC ": invalid icon size '%d'", size);
return NULL;
g_object_unref (scaled);
} else if (state == GTK_STATE_PRELIGHT) {
- stated = gdk_pixbuf_copy (scaled);
+ stated = gdk_pixbuf_copy (scaled);
gdk_pixbuf_saturate_and_pixelate (scaled, stated,
1.2, FALSE);
}
else
stated = scaled;
-
+
return stated;
}
GE_EXPORT GtkRcStyle *
theme_create_rc_style (void)
{
- return GTK_RC_STYLE (g_object_new (CLEARLOOKS_TYPE_RC_STYLE, NULL));
+ return GTK_RC_STYLE (g_object_new (CLEARLOOKS_TYPE_RC_STYLE, NULL));
}
CL_WINDOW_EDGE_EAST,
CL_WINDOW_EDGE_SOUTH_WEST,
CL_WINDOW_EDGE_SOUTH,
- CL_WINDOW_EDGE_SOUTH_EAST
+ CL_WINDOW_EDGE_SOUTH_EAST
} ClearlooksWindowEdge;
typedef struct
typedef struct
{
ClearlooksHandleType type;
- boolean horizontal;
+ boolean horizontal;
} HandleParameters;
typedef struct
const WidgetParameters *widget,
const OptionMenuParameters *optionmenu,
int x, int y, int width, int height);
-
+
void (*draw_inset) (cairo_t *cr,
const CairoColor *bg_color,
double x, double y, double w, double h,
const WidgetParameters *widget,
const ArrowParameters *arrow,
int x, int y, int width, int height);
-
+
void (*draw_checkbox) (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
# undef GE_INTERNAL
# define GE_EXPORT __global
# define GE_INTERNAL __hidden
-#endif
+#endif
#include <string.h>
/* Widget Type Lookups/Macros
-
+
Based on/modified from functions in
Smooth-Engine.
-*/
+*/
gboolean
ge_object_is_a (const GObject * object, const gchar * type_name)
{
gboolean result = FALSE;
-
+
if ((object))
{
GType tmp = g_type_from_name (type_name);
if (tmp)
result = g_type_check_instance_is_a ((GTypeInstance *) object, tmp);
}
-
+
return result;
}
-
+
gboolean
ge_is_combo_box_entry (GtkWidget * widget)
{
gboolean result = FALSE;
-
+
if ((widget) && (widget->parent))
{
if (GE_IS_COMBO_BOX_ENTRY (widget->parent))
}
return result;
}
-
+
static gboolean
ge_combo_box_is_using_list (GtkWidget * widget)
{
gboolean result = FALSE;
-
+
if (GE_IS_COMBO_BOX (widget))
{
gboolean *tmp = NULL;
-
+
gtk_widget_style_get (widget, "appears-as-list", &result, NULL);
if (tmp)
result = *tmp;
}
-
+
return result;
}
-
+
gboolean
ge_is_combo_box (GtkWidget * widget, gboolean as_list)
{
gboolean result = FALSE;
-
+
if ((widget) && (widget->parent))
{
if (GE_IS_COMBO_BOX (widget->parent))
}
return result;
}
-
+
gboolean
ge_is_combo (GtkWidget * widget)
{
gboolean result = FALSE;
-
+
if ((widget) && (widget->parent))
{
if (GE_IS_COMBO (widget->parent))
}
return result;
}
-
+
gboolean
ge_is_in_combo_box (GtkWidget * widget)
{
return ((ge_is_combo (widget) || ge_is_combo_box (widget, TRUE) || ge_is_combo_box_entry (widget)));
}
-
+
gboolean
ge_is_toolbar_item (GtkWidget * widget)
{
gboolean result = FALSE;
-
+
if ((widget) && (widget->parent)) {
if ((GE_IS_BONOBO_TOOLBAR (widget->parent))
|| (GE_IS_BONOBO_DOCK_ITEM (widget->parent))
}
return result;
}
-
+
gboolean
ge_is_panel_widget_item (GtkWidget * widget)
{
gboolean result = FALSE;
-
+
if ((widget) && (widget->parent))
{
if (GE_IS_PANEL_WIDGET (widget->parent))
}
return result;
}
-
-gboolean
+
+gboolean
ge_is_bonobo_dock_item (GtkWidget * widget)
{
gboolean result = FALSE;
-
+
if ((widget))
{
if (GE_IS_BONOBO_DOCK_ITEM(widget) || GE_IS_BONOBO_DOCK_ITEM (widget->parent))
{
GtkContainer *box = GE_IS_BOX(widget)?GTK_CONTAINER(widget):GTK_CONTAINER(widget->parent);
GList *children = NULL, *child = NULL;
-
+
children = gtk_container_get_children(box);
-
+
for (child = g_list_first(children); child; child = g_list_next(child))
{
if (GE_IS_BONOBO_DOCK_ITEM_GRIP(child->data))
result = TRUE;
child = NULL;
}
- }
-
- if (children)
+ }
+
+ if (children)
g_list_free(children);
}
}
ge_find_combo_box_widget (GtkWidget * widget, gboolean as_list)
{
GtkWidget *result = NULL;
-
+
if (widget)
{
if (GE_IS_COMBO_BOX (widget))
}
return result;
}
-
+
static GtkWidget *
ge_find_combo_widget (GtkWidget * widget)
{
GtkWidget *result = NULL;
-
+
if (widget)
{
if (GE_IS_COMBO (widget))
ge_find_combo_box_widget_parent (GtkWidget * widget)
{
GtkWidget *result = NULL;
-
+
if (!result)
result = ge_find_combo_widget(widget);
-
+
if (!result)
result = ge_find_combo_box_widget(widget, TRUE);
/***********************************************
* option_menu_get_props -
- *
+ *
* Find Option Menu Size and Spacing
*
* Taken from Smooth
- ***********************************************/
+ ***********************************************/
void
ge_option_menu_get_props (GtkWidget * widget,
GtkRequisition * indicator_size,
GtkBorder default_spacing = { 7, 5, 2, 2 };
GtkRequisition *tmp_size = NULL;
GtkBorder *tmp_spacing = NULL;
-
+
if ((widget) && GE_IS_OPTION_MENU(widget))
gtk_widget_style_get (widget,
"indicator_size", &tmp_size,
"indicator_spacing", &tmp_spacing, NULL);
-
+
if (tmp_size)
{
*indicator_size = *tmp_size;
}
else
*indicator_size = default_size;
-
+
if (tmp_spacing)
{
*indicator_spacing = *tmp_spacing;
}
void
-ge_button_get_default_border (GtkWidget *widget,
+ge_button_get_default_border (GtkWidget *widget,
GtkBorder *border)
{
GtkBorder default_border = {1, 1, 1, 1};
/* Object Type Lookups/Macros
-
+
Based on/modified from functions in
Smooth-Engine.
-*/
+*/
#define GE_IS_WIDGET(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkWidget"))
#define GE_IS_CONTAINER(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkContainer"))
#define GE_IS_BIN(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkBin"))
#define GE_IS_SEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkSeparator"))
#define GE_IS_VSEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVSeparator"))
#define GE_IS_HSEPARATOR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHSeparator"))
-
+
#define GE_IS_HANDLE_BOX(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHandleBox"))
#define GE_IS_HANDLE_BOX_ITEM(object) ((object) && GE_IS_HANDLE_BOX(object->parent))
#define GE_IS_BONOBO_DOCK_ITEM(object) ((object) && ge_object_is_a ((GObject*)(object), "BonoboDockItem"))
#define GE_IS_COMBO_BOX(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkComboBox"))
#define GE_IS_COMBO(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkCombo"))
#define GE_IS_OPTION_MENU(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkOptionMenu"))
-
+
#define GE_IS_TOGGLE_BUTTON(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkToggleButton"))
#define GE_IS_CHECK_BUTTON(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkCheckButton"))
#define GE_IS_SPIN_BUTTON(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkSpinButton"))
-
+
#define GE_IS_STATUSBAR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkStatusbar"))
#define GE_IS_PROGRESS_BAR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkProgressBar"))
-
+
#define GE_IS_MENU_SHELL(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkMenuShell"))
#define GE_IS_MENU(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkMenu"))
#define GE_IS_MENU_BAR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkMenuBar"))
#define GE_IS_CHECK_MENU_ITEM(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkCheckMenuItem"))
#define GE_IS_RANGE(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkRange"))
-
+
#define GE_IS_SCROLLBAR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkScrollbar"))
#define GE_IS_VSCROLLBAR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVScrollbar"))
#define GE_IS_HSCROLLBAR(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHScrollbar"))
-
+
#define GE_IS_SCALE(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkScale"))
#define GE_IS_VSCALE(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVScale"))
#define GE_IS_HSCALE(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHScale"))
-
+
#define GE_IS_PANED(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkPaned"))
#define GE_IS_VPANED(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVPaned"))
#define GE_IS_HPANED(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHPaned"))
-
+
#define GE_IS_BOX(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkBox"))
#define GE_IS_VBOX(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkVBox"))
#define GE_IS_HBOX(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkHBox"))
#define GE_IS_ENTRY(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkEntry"))
#define GE_IS_BUTTON(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkButton"))
#define GE_IS_FIXED(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkFixed"))
-
+
#define TOGGLE_BUTTON(object) (GE_IS_TOGGLE_BUTTON(object)?(GtkToggleButton *)object:NULL)
-
+
#define GE_IS_NOTEBOOK(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkNotebook"))
#define GE_IS_CELL_RENDERER_TOGGLE(object) ((object) && ge_object_is_a ((GObject*)(object), "GtkCellRendererToggle"))
#define GE_WIDGET_HAS_DEFAULT(object) ((object) && GE_IS_WIDGET(object) && GTK_WIDGET_HAS_DEFAULT(object))
GE_INTERNAL gboolean ge_object_is_a (const GObject * object, const gchar * type_name);
-
+
GE_INTERNAL gboolean ge_is_combo_box_entry (GtkWidget * widget);
GE_INTERNAL gboolean ge_is_combo_box (GtkWidget * widget, gboolean as_list);
GE_INTERNAL gboolean ge_is_combo (GtkWidget * widget);
GE_INTERNAL gboolean ge_is_in_combo_box (GtkWidget * widget);
-
+
GE_INTERNAL gboolean ge_is_toolbar_item (GtkWidget * widget);
-
+
GE_INTERNAL gboolean ge_is_panel_widget_item (GtkWidget * widget);
-
+
GE_INTERNAL gboolean ge_is_bonobo_dock_item (GtkWidget * widget);
GE_INTERNAL GtkWidget *ge_find_combo_box_widget_parent (GtkWidget * widget);
-GE_INTERNAL void ge_option_menu_get_props (GtkWidget * widget,
- GtkRequisition * indicator_size,
+GE_INTERNAL void ge_option_menu_get_props (GtkWidget * widget,
+ GtkRequisition * indicator_size,
GtkBorder * indicator_spacing);
-GE_INTERNAL void ge_button_get_default_border (GtkWidget *widget,
+GE_INTERNAL void ge_button_get_default_border (GtkWidget *widget,
GtkBorder *border);
GE_INTERNAL gboolean ge_widget_is_ltr (GtkWidget *widget);
static void cl_draw_line (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x1, int y1, int x2, int y2, CLBorderType border,
CLRectangle *r);
-
+
static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height,
CLRectangle *r, CLCornerSide corner);
-
+
static void cl_draw_fill (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r);
CL_CORNER_ROUND, CL_CORNER_ROUND);
}
-static void cl_progressbar_points_transform (GdkPoint *points, int npoints,
+static void cl_progressbar_points_transform (GdkPoint *points, int npoints,
int offset, gboolean is_horizontal)
{
int i;
else
draw_vgradient (tmp, style->black_gc, style, 0, 0, width, height,
&tmp_color, &clearlooks_style->spot2); /* TODO: swap for RTL */
-
- if (orientation == GTK_PROGRESS_RIGHT_TO_LEFT ||
+
+ if (orientation == GTK_PROGRESS_RIGHT_TO_LEFT ||
orientation == GTK_PROGRESS_BOTTOM_TO_TOP)
{
offset = -offset;
points[2] = (GdkPoint){0, xdir*(stripe_width - topright_div_2)}; /* bottomright */
points[3] = (GdkPoint){0, xdir*(-topright_div_2)}; /* bottomleft */
}
-
+
shift = (stripe_width*2)/(double)10;
cl_progressbar_points_transform (points, 4, (offset*shift), is_horizontal);
g_object_unref (tile);
}
-GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
+GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
GdkColor *from, gfloat s)
{
GdkColor tmp_color;
&clwindowstyle->inset_light[windowstate]);
}
cl_rectangle_set_clip_rectangle (&r, area);
- cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
+ cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
-/* Draw a normal (toggle)button. Not spinbuttons.*/
+/* Draw a normal (toggle)button. Not spinbuttons.*/
void cl_draw_button(GtkStyle *style, GdkWindow *window,
GtkStateType state_type, GtkShadowType shadow_type,
GdkRectangle *area,
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
- if (!is_active)
+ if (!is_active)
{
int tmp_height = (float)height*0.25;
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
- cl_draw_shadow (window, widget, style, x, y, width, height, &r);
+ cl_draw_shadow (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
- cl_draw_shadow (window, widget, style, x, y, width, height, &r);
+ cl_draw_shadow (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
void cl_draw_menuitem_button (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
- GdkRectangle *area, GtkStateType state_type,
+ GdkRectangle *area, GtkStateType state_type,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
}
void cl_draw_menuitem_flat (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
- GdkRectangle *area, GtkStateType state_type,
+ GdkRectangle *area, GtkStateType state_type,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
}
void cl_draw_menuitem_gradient (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
- GdkRectangle *area, GtkStateType state_type,
+ GdkRectangle *area, GtkStateType state_type,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
cl_rectangle_set_corners (r, CL_CORNER_NARROW, CL_CORNER_NARROW,
CL_CORNER_NARROW, CL_CORNER_NARROW);
-
+
cl_rectangle_set_gradient (&r->fill_gradient,
&style->base[GTK_STATE_SELECTED], &lower_color);
if (resizable || (column_index != columns-1))
{
- gdk_draw_line (window, clearlooks_style->shade_gc[4], x+width-2, y+4, x+width-2, y+height-5);
- gdk_draw_line (window, clearlooks_style->shade_gc[0], x+width-1, y+4, x+width-1, y+height-5);
+ gdk_draw_line (window, clearlooks_style->shade_gc[4], x+width-2, y+4, x+width-2, y+height-5);
+ gdk_draw_line (window, clearlooks_style->shade_gc[0], x+width-1, y+4, x+width-1, y+height-5);
}
/* left light line */
#include <gtk/gtk.h>
#include <gdk/gdk.h>
-typedef struct
+typedef struct
{
GdkColor *from;
GdkColor *to;
GtkStyle *style, GdkGC *gc,
gint x, gint y, gint width, gint height,
guint8 offset, GdkRectangle *area);
-
-GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
+
+GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
GdkColor *from, gfloat s);
void cl_draw_spinbutton(GtkStyle *style, GdkWindow *window,
GdkRectangle *area,
GtkWidget *widget, const gchar *detail,
gint x, gint y, gint width, gint height);
-
+
void cl_draw_menuitem_button (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
- GdkRectangle *area, GtkStateType state_type,
+ GdkRectangle *area, GtkStateType state_type,
int x, int y, int wiidth, int height, CLRectangle *r);
void cl_draw_menuitem_flat (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
- GdkRectangle *area, GtkStateType state_type,
+ GdkRectangle *area, GtkStateType state_type,
int x, int y, int wiidth, int height, CLRectangle *r);
-
+
void cl_draw_menuitem_gradient (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
- GdkRectangle *area, GtkStateType state_type,
+ GdkRectangle *area, GtkStateType state_type,
int x, int y, int wiidth, int height, CLRectangle *r);
-
+
void cl_draw_treeview_header (GtkStyle *style, GdkWindow *window,
GtkStateType state_type, GtkShadowType shadow_type,
GdkRectangle *area,
GtkWidget *widget, const gchar *detail,
gint x, gint y, gint width, gint height);
-
+
#endif /* CLEARLOOKS_DRAW_H */
(GInstanceInitFunc) clearlooks_rc_style_init,
NULL
};
-
+
clearlooks_type_rc_style = g_type_module_register_type (module,
GTK_TYPE_RC_STYLE,
"ClearlooksRcStyle",
return G_TOKEN_FLOAT;
*contrast = scanner->value.v_float;
-
+
return G_TOKEN_NONE;
}
return G_TOKEN_INT;
*sunken = scanner->value.v_int;
-
+
return G_TOKEN_NONE;
}
return G_TOKEN_INT;
*progressbarstyle = scanner->value.v_int;
-
+
return G_TOKEN_NONE;
}
return G_TOKEN_INT;
*menubarstyle = scanner->value.v_int;
-
+
return G_TOKEN_NONE;
}
return G_TOKEN_INT;
*menuitemstyle = scanner->value.v_int;
-
+
return G_TOKEN_NONE;
}
theme_parse_listviewitemstyle(GtkSettings *settings,
GScanner *scanner,
guint8 *listviewitemstyle)
-{
+{
guint token;
-
+
token = g_scanner_get_next_token(scanner);
-
+
token = g_scanner_get_next_token(scanner);
if (token != G_TOKEN_EQUAL_SIGN)
return G_TOKEN_EQUAL_SIGN;
-
+
token = g_scanner_get_next_token(scanner);
if (token != G_TOKEN_INT)
return G_TOKEN_INT;
-
+
*listviewitemstyle = scanner->value.v_int;
-
+
return G_TOKEN_NONE;
-}
+}
static guint
clearlooks_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
-
+
{
static GQuark scope_id = 0;
ClearlooksRcStyle *clearlooks_style = CLEARLOOKS_RC_STYLE (rc_style);
guint old_scope;
guint token;
guint i;
-
+
/* Set up a new scope in this scanner. */
if (!scope_id)
height = 7;
}
- /* Compensate arrow position for "sunken" look */
+ /* Compensate arrow position for "sunken" look */
if (DETAIL ("spinbutton") && arrow_type == GTK_ARROW_DOWN &&
style->xthickness > 2 && style->ythickness > 2)
y -= 1;
sanitize_size (window, &width, &height);
if (detail &&
- clearlooks_style->listviewitemstyle == 1 &&
+ clearlooks_style->listviewitemstyle == 1 &&
state_type == GTK_STATE_SELECTED && (
!strncmp ("cell_even", detail, strlen ("cell_even")) ||
!strncmp ("cell_odd", detail, strlen ("cell_odd"))))
{
gtk_style_apply_default_background (style, window,widget && !GTK_WIDGET_NO_WINDOW (widget),
state_type, area, x, y, width, height);
-
+
if (area)
{
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
rect.height = d;
-static void
+static void
draw_box_gap (DRAW_ARGS,
GtkPositionType gap_side,
gint gap_x,
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
- cl_draw_shadow (window, widget, style, x, y, width, height, &r);
+ cl_draw_shadow (window, widget, style, x, y, width, height, &r);
gdk_gc_set_clip_region (r.bordergc, NULL);
gdk_gc_set_clip_region (r.topleft, NULL);
gap_side);
}
}
-
+
/**************************************************************************/
-static void
+static void
draw_handle (DRAW_ARGS, GtkOrientation orientation)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
gdk_gc_set_clip_rectangle (light_gc, area);
gdk_gc_set_clip_rectangle (dark_gc, area);
}
-
+
if (area)
{
gdk_gc_set_clip_rectangle (light_gc, NULL);
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
}
-
+
gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y, x + width, y);
gdk_draw_line (window, clearlooks_style->shade_gc[3], x, y + height - 1, x + width, y + height - 1);
GtkOrientation orientation = GTK_RANGE (widget)->orientation;
- gint fill_size = (orientation ? height : width) *
- (1 / ((adjustment->upper - adjustment->lower) /
+ gint fill_size = (orientation ? height : width) *
+ (1 / ((adjustment->upper - adjustment->lower) /
(adjustment->value - adjustment->lower)));
if (orientation == GTK_ORIENTATION_HORIZONTAL)
shadow = clearlooks_style->shade_gc[3];
}
- cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
+ cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
CL_CORNER_NONE, CL_CORNER_NONE );
r.topleft = shadow;
GdkGC *inner = clearlooks_style->shade_gc[3],
*outer = clearlooks_style->shade_gc[5];
- cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
+ cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
CL_CORNER_NONE, CL_CORNER_NONE );
if (GTK_RANGE (widget)->orientation == GTK_ORIENTATION_VERTICAL)
state_type, area, x, y, width, height);
/* we only want the borders on horizontal toolbars */
- if ( DETAIL ("menubar") || height < 2*width ) {
+ if ( DETAIL ("menubar") || height < 2*width ) {
if (!DETAIL ("menubar"))
gdk_draw_line (window, clearlooks_style->shade_gc[0],
x, y, x + width, y); /* top */
gdk_pixbuf_composite (base, composite,
0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1.0, 1.0, GDK_INTERP_NEAREST, 255);
-
+
gdk_pixbuf_composite (inconsistent, composite,
0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1.0, 1.0, GDK_INTERP_NEAREST, 255);
gdk_pixbuf_composite (outline, composite,
0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1.0, 1.0, GDK_INTERP_NEAREST, 255);
-
+
gdk_pixbuf_composite (circle, composite,
0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1.0, 1.0, GDK_INTERP_NEAREST, 255);
/**************************************************************************/
-static void
+static void
draw_shadow_gap (DRAW_ARGS,
GtkPositionType gap_side,
gint gap_x,
/* I need to improve this function. */
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
CLRectangle r;
- GdkRegion *area_region = NULL,
+ GdkRegion *area_region = NULL,
*gap_region = NULL;
#if DEBUG
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
g_return_if_fail (GTK_IS_STYLE (style));
g_return_if_fail (window != NULL);
-
+
if (area)
{
gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
/* Clear background */
gtk_style_apply_default_background (style, window, FALSE,
state_type, area,
- x, y, width, height);
+ x, y, width, height);
switch (edge)
{
xi -= 3;
yi -= 3;
-
+
}
}
break;
gdk_draw_line (window,
style->light_gc[state_type],
xi, y,
- x + width, yi);
+ x + width, yi);
++xi;
--yi;
-
+
gdk_draw_line (window,
clearlooks_style->shade_gc[4],
xi, y,
xi -= 3;
yi += 3;
-
+
}
}
break;
-
+
case GDK_WINDOW_EDGE_SOUTH_EAST:
{
gint xi, yi;
gdk_draw_line (window,
style->light_gc[state_type],
xi, y + height,
- x + width, yi);
+ x + width, yi);
++xi;
++yi;
-
+
gdk_draw_line (window,
clearlooks_style->shade_gc[4],
xi, y + height,
- x + width, yi);
-
+ x + width, yi);
+
xi += 3;
yi += 3;
}
g_assert_not_reached ();
break;
}
-
+
if (area)
{
gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
for (x = 0; x < width; x++) {
/* The "4" is the number of chars per pixel, in this case, RGBA,
the 3 means "skip to the alpha" */
- current = data + (y * rowstride) + (x * 4) + 3;
+ current = data + (y * rowstride) + (x * 4) + 3;
*(current) = (guchar) (*(current) * alpha_percent);
}
}
g_warning ("Using the default screen for gtk_default_render_icon()"));
}
-
+
if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
g_warning (G_STRLOC ": invalid icon size '%d'", size);
return NULL;
g_object_unref (scaled);
} else if (state == GTK_STATE_PRELIGHT) {
- stated = gdk_pixbuf_copy (scaled);
+ stated = gdk_pixbuf_copy (scaled);
gdk_pixbuf_saturate_and_pixelate (scaled, stated,
1.2, FALSE);
}
else
stated = scaled;
-
+
return stated;
}
G_MODULE_EXPORT GtkRcStyle *
theme_create_rc_style (void)
{
- return GTK_RC_STYLE (g_object_new (CLEARLOOKS_TYPE_RC_STYLE, NULL));
+ return GTK_RC_STYLE (g_object_new (CLEARLOOKS_TYPE_RC_STYLE, NULL));
}
/* The following function will be called by GTK+ when the module
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
style->depth);
-
+
gdk_drawable_set_colormap (pixmap, style->colormap);
tmp_gc = gdk_gc_new (pixmap);
internel_image_buffer_free_pixels, NULL);
}
-static void
-internal_color_get_as_uchars(GdkColor *color,
- guchar *red,
- guchar *green,
+static void
+internal_color_get_as_uchars(GdkColor *color,
+ guchar *red,
+ guchar *green,
guchar *blue)
{
*red = (guchar) (color->red / 256.0);
internal_create_horizontal_gradient_image_buffer (gint width, gint height,
GdkColor *from,
GdkColor *to)
-{
+{
int i;
long r, g, b, dr, dg, db;
GdkPixbuf* buffer;
if (buffer == NULL)
return NULL;
-
+
pixels = gdk_pixbuf_get_pixels (buffer);
ptr = pixels;
rowstride = gdk_pixbuf_get_rowstride (buffer);
-
+
internal_color_get_as_uchars(from, &r0, &g0, &b0);
internal_color_get_as_uchars(to, &rf, &gf, &bf);
-
+
r = r0 << 16;
g = g0 << 16;
b = b0 << 16;
-
+
dr = ((rf-r0)<<16)/width;
dg = ((gf-g0)<<16)/width;
db = ((bf-b0)<<16)/width;
{
memcpy (&(pixels[i*rowstride]), pixels, rowstride);
}
-
+
return buffer;
}
gint rowstride;
guchar *pixels;
-
+
buffer = internal_image_buffer_new (width, height);
if (buffer == NULL)
return NULL;
-
+
pixels = gdk_pixbuf_get_pixels (buffer);
rowstride = gdk_pixbuf_get_rowstride (buffer);
-
+
internal_color_get_as_uchars(from, &r0, &g0, &b0);
internal_color_get_as_uchars(to, &rf, &gf, &bf);
for (i=0; i < height; i++)
{
ptr = pixels + i * rowstride;
-
+
ptr[0] = r>>16;
ptr[1] = g>>16;
ptr[2] = b>>16;
gint *y,
gint *width,
gint *height);
-
+
GtkWidget *special_get_ancestor(GtkWidget * widget,
GType widget_type);
-
+
void blend (GdkColormap *colormap,
GdkColor *a, GdkColor *b, GdkColor *c, int alpha);
#else
#define LIBEVORAL_API LIBEVORAL_DLL_IMPORT
#define LIBEVORAL_TEMPLATE_API LIBEVORAL_TEMPLATE_DLL_IMPORT
- #endif
+ #endif
#define LIBEVORAL_LOCAL LIBEVORAL_DLL_LOCAL
#endif
* Tracks contain zero or more events. Libsmf doesn't care about actual MIDI data, as long
* as it is valid from the MIDI specification point of view - it may be realtime message,
* SysEx, whatever.
- *
+ *
* The only field in smf_t, smf_track_t, smf_event_t and smf_tempo_t structures your
* code may modify is event->midi_buffer and event->midi_buffer_length. Do not modify
* other fields, _ever_. You may read them, though. Do not declare static instances
* of these types, i.e. never do something like this: "smf_t smf;". Always use
* "smf_t *smf = smf_new();". The same applies to smf_track_t and smf_event_t.
- *
+ *
* Say you want to load a Standard MIDI File (.mid) file and play it back somehow.
* This is (roughly) how you do this:
- *
+ *
* \code
* smf_t *smf;
* smf_event_t *event;
* Whoops, something went wrong.
* return;
* }
- *
+ *
* while ((event = smf_get_next_event(smf)) != NULL) {
* if (smf_event_is_metadata(event))
* continue;
- *
+ *
* wait until event->time_seconds.
* feed_to_midi_output(event->midi_buffer, event->midi_buffer_length);
* }
* smf_delete(smf);
*
* \endcode
- *
+ *
* Saving works like this:
- *
+ *
* \code
*
* smf_t *smf;
* Whoops.
* return;
* }
- *
+ *
* for (int i = 1; i <= number of tracks; i++) {
* track = smf_track_new();
* if (track == NULL) {
* Whoops.
* return;
* }
- *
+ *
* smf_add_track(smf, track);
- *
+ *
* for (int j = 1; j <= number of events you want to put into this track; j++) {
* event = smf_event_new_from_pointer(your MIDI message, message length);
* if (event == NULL) {
* Whoops.
* return;
* }
- *
+ *
* smf_track_add_event_seconds(track, event, seconds since start of the song);
* }
* }
- *
+ *
* ret = smf_save(smf, file_name);
* if (ret) {
* Whoops, saving failed for some reason.
char *smf_event_decode(const smf_event_t *event) WARN_UNUSED_RESULT;
char *smf_event_extract_text(const smf_event_t *event) WARN_UNUSED_RESULT;
-/* Routines for dealing with Variable Length Quantities (VLQ's).
+/* Routines for dealing with Variable Length Quantities (VLQ's).
Slightly odd names reflect original static names within libsmf
*/
int smf_format_vlq (unsigned char *buf, int length, unsigned long value);
/**
* Takes "len" characters starting in "buf", making sure it does not access past the length of the buffer,
* and makes ordinary, zero-terminated string from it. May return NULL if there was any problem.
- */
+ */
static char *
make_string(const unsigned char *buf, const size_t buffer_length, uint32_t len)
{
/** SMF chunk header, used only by smf_load.c and smf_save.c. */
struct chunk_header_struct {
char id[4];
- uint32_t length;
+ uint32_t length;
} ATTRIBUTE_PACKED;
/** SMF chunk, used only by smf_load.c and smf_save.c. */
g_critical("Cannot allocate MIDI buffer structure: %s", strerror(errno));
smf_event_delete(event);
- return (NULL);
+ return (NULL);
}
event->midi_buffer[0] = 0xFF;
}
/**
- * \internal
+ * \internal
*
* Remove all smf_tempo_t structures from SMF.
*/
GList* acts;
for (node = list; node; node = g_list_next (node)) {
-
+
GtkActionGroup* group = (GtkActionGroup*) node->data;
-
+
for (acts = gtk_action_group_list_actions (group); acts; acts = g_list_next (acts)) {
GtkAction* action = (GtkAction*) acts->data;
action_states_to_restore.push_back (ActionState (action, gtk_action_get_sensitive (action)));
uint32_t k = possibly_translate_legal_accelerator_to_real_key (key.get_key());
key = AccelKey (k, Gdk::ModifierType (key.get_mod()));
return ui_manager->get_accel_group()->get_label (key.get_key(), Gdk::ModifierType (key.get_mod()));
- }
+ }
return unbound_string;
}
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts.
*
* Copyright (C) 2007 Pioneer Research Center USA, Inc.
BindingProxy::BindingProxy (boost::shared_ptr<Controllable> c)
: prompter (0),
controllable (c)
-{
+{
}
BindingProxy::BindingProxy ()
: prompter (0)
-{
+{
}
BindingProxy::~BindingProxy ()
bool
BindingProxy::button_press_handler (GdkEventButton *ev)
{
- if ( controllable && is_bind_action(ev) ) {
+ if ( controllable && is_bind_action(ev) ) {
if (Controllable::StartLearning (controllable.get())) {
string prompt = _("operate controller now");
if (prompter == 0) {
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
MouseButton::MouseButton (uint32_t state, uint32_t keycode)
{
uint32_t ignore = Bindings::ignored_state();
-
+
if (gdk_keyval_is_upper (keycode) && gdk_keyval_is_lower (keycode)) {
/* key is not subject to case, so ignore SHIFT
*/
string::size_type lastmod = str.find_last_of ('-');
uint32_t button_number;
-
+
if (lastmod == string::npos) {
button_number = PBD::atoi (str);
} else {
MouseButton::name () const
{
int s = state();
-
+
string str;
if (s & Keyboard::PrimaryModifier) {
str += "Primary";
- }
+ }
if (s & Keyboard::SecondaryModifier) {
if (!str.empty()) {
str += '-';
str += '-';
}
str += "Tertiary";
- }
+ }
if (s & Keyboard::Level4Modifier) {
if (!str.empty()) {
str += '-';
}
str += "Level4";
}
-
+
if (!str.empty()) {
str += '-';
}
KeyboardKey::KeyboardKey (uint32_t state, uint32_t keycode)
{
uint32_t ignore = Bindings::ignored_state();
-
+
if (gdk_keyval_is_upper (keycode) && gdk_keyval_is_lower (keycode)) {
/* key is not subject to case, so ignore SHIFT
*/
KeyboardKey::name () const
{
int s = state();
-
+
string str;
if (s & Keyboard::PrimaryModifier) {
str += "Primary";
- }
+ }
if (s & Keyboard::SecondaryModifier) {
if (!str.empty()) {
str += '-';
str += '-';
}
str += "Tertiary";
- }
+ }
if (s & Keyboard::Level4Modifier) {
if (!str.empty()) {
str += '-';
}
str += "Level4";
}
-
+
if (!str.empty()) {
str += '-';
}
}
MouseButtonBindingMap::iterator b = bbm->find (bb);
-
+
if (b == bbm->end()) {
/* no entry for this key in the state map */
return false;
bbm = &button_release_bindings;
break;
}
-
+
MouseButtonBindingMap::iterator b = bbm->find (bb);
if (b != bbm->end()) {
XMLTree tree;
XMLNode* root = new XMLNode (X_("Bindings"));
tree.set_root (root);
-
+
save (*root);
if (!tree.write (path)) {
if (!tree.read (path)) {
return false;
}
-
+
press_bindings.clear ();
release_bindings.clear ();
Bindings::load (const XMLNode& node)
{
if (node.name() == X_("Press") || node.name() == X_("Release")) {
-
+
Operation op;
-
+
if (node.name() == X_("Press")) {
op = Press;
} else {
op = Release;
}
-
+
const XMLNodeList& children (node.children());
-
+
for (XMLNodeList::const_iterator p = children.begin(); p != children.end(); ++p) {
-
+
XMLProperty* ap;
XMLProperty* kp;
XMLProperty* bp;
-
+
ap = (*p)->property ("action");
kp = (*p)->property ("key");
bp = (*p)->property ("button");
-
+
if (!ap || (!kp && !bp)) {
continue;
}
if (action_map) {
act = action_map->find_action (ap->value());
- }
+ }
if (!act) {
string::size_type slash = ap->value().find ('/');
act = ActionManager::get_action (group.c_str(), action.c_str());
}
}
-
+
if (!act) {
continue;
}
-
+
if (kp) {
KeyboardKey k;
if (!KeyboardKey::make_key (kp->value(), k)) {
}
}
}
-}
+}
RefPtr<Action>
ActionMap::find_action (const string& name)
return RefPtr<Action>();
}
-RefPtr<Action>
+RefPtr<Action>
ActionMap::register_action (const char* path,
const char* name, const char* label, sigc::slot<void> sl)
{
return act;
}
-RefPtr<Action>
+RefPtr<Action>
ActionMap::register_radio_action (const char* path, Gtk::RadioAction::Group& rgroup,
- const char* name, const char* label,
+ const char* name, const char* label,
sigc::slot<void,GtkAction*> sl,
int value)
{
return act;
}
-RefPtr<Action>
+RefPtr<Action>
ActionMap::register_toggle_action (const char* path,
const char* name, const char* label, sigc::slot<void> sl)
{
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
face = fd.get_family();
-}
+}
CairoCell::CairoCell (int32_t id)
: _id (id)
for (int digit = 0; digit < 10; digit++) {
for (n = 0; n < lim; ++n) {
- buf[n] = '0' + digit;
+ buf[n] = '0' + digit;
}
context->get_text_extents (&buf[0], ext);
/*
Copyright (C) 2011 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
{
}
-Glib::PropertyProxy<Gdk::Color>
+Glib::PropertyProxy<Gdk::Color>
CellRendererColorSelector::property_color()
{
return _property_color.get_proxy();
-}
+}
-void
+void
CellRendererColorSelector::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& /*widget*/, const Gdk::Rectangle& /*background_area*/, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState /*flags*/)
{
Gdk::Color c = _property_color.get_value();
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
using namespace Gtkmm2ext;
-CellRendererPixbufMulti::CellRendererPixbufMulti() :
+CellRendererPixbufMulti::CellRendererPixbufMulti() :
Glib::ObjectBase( typeid(CellRendererPixbufMulti) ),
Gtk::CellRenderer(),
property_state_(*this, "active", 0)
property_sensitive() = false;
}
-Glib::PropertyProxy<uint32_t>
+Glib::PropertyProxy<uint32_t>
CellRendererPixbufMulti::property_state()
{
return property_state_.get_proxy();
-}
+}
-// Overridden methods of the parent CellRenderer
-Glib::PropertyProxy_Base
+// Overridden methods of the parent CellRenderer
+Glib::PropertyProxy_Base
CellRendererPixbufMulti::_property_renderable()
{
return property_state();
-}
+}
-bool
+bool
CellRendererPixbufMulti::activate_vfunc(GdkEvent*, Gtk::Widget&, const Glib::ustring& path, const Gdk::Rectangle&, const Gdk::Rectangle&, Gtk::CellRendererState)
{
signal_changed_(path);
return true;
}
-void
+void
CellRendererPixbufMulti::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& /*widget*/, const Gdk::Rectangle& /*background_area*/, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& /*expose_area*/, Gtk::CellRendererState /*flags*/)
{
int offset_width = 0;
window->draw_pixbuf (RefPtr<GC>(), pb, 0, 0, offset_width, offset_height, -1, -1, Gdk::RGB_DITHER_NORMAL, 0, 0);
}
-void
+void
CellRendererPixbufMulti::get_size_vfunc (Gtk::Widget& /*widget*/, const Gdk::Rectangle* /*cell_area*/, int* /*x_offset*/, int* /*y_offset*/, int* /*width*/, int* /*height*/) const
{
}
_pixbufs[which] = pixbuf;
}
-CellRendererPixbufMulti::SignalChanged&
+CellRendererPixbufMulti::SignalChanged&
CellRendererPixbufMulti::signal_changed()
{
return signal_changed_;
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
using namespace Gtkmm2ext;
-CellRendererPixbufToggle::CellRendererPixbufToggle() :
+CellRendererPixbufToggle::CellRendererPixbufToggle() :
Glib::ObjectBase( typeid(CellRendererPixbufToggle) ),
Gtk::CellRenderer(),
property_pixbuf_(*this, "pixbuf"),
property_sensitive() = false;
}
-Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >
+Glib::PropertyProxy< Glib::RefPtr<Gdk::Pixbuf> >
CellRendererPixbufToggle::property_pixbuf()
{
return property_pixbuf_.get_proxy();
-}
+}
-Glib::PropertyProxy<bool>
+Glib::PropertyProxy<bool>
CellRendererPixbufToggle::property_active()
{
return property_active_.get_proxy();
-}
+}
-// Overridden methods of the parent CellRenderer
-Glib::PropertyProxy_Base
+// Overridden methods of the parent CellRenderer
+Glib::PropertyProxy_Base
CellRendererPixbufToggle::_property_renderable()
{
return property_pixbuf();
-}
+}
-bool
+bool
CellRendererPixbufToggle::activate_vfunc(GdkEvent*, Gtk::Widget&, const Glib::ustring& path, const Gdk::Rectangle&, const Gdk::Rectangle&, Gtk::CellRendererState)
{
signal_toggled_(path);
-void
+void
CellRendererPixbufToggle::render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& /*widget*/, const Gdk::Rectangle& /*background_area*/, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& /*expose_area*/, Gtk::CellRendererState /*flags*/)
{
int offset_width = 0;
}
}
-void
+void
CellRendererPixbufToggle::get_size_vfunc (Gtk::Widget& /*widget*/, const Gdk::Rectangle* /*cell_area*/, int* /*x_offset*/, int* /*y_offset*/, int* /*width*/, int* /*height*/) const
{
//cerr << "cell_renderer_pixbuf_toggle get_size" << endl;
inactive_pixbuf = pixbuf;
}
-CellRendererPixbufToggle::SignalToggled&
+CellRendererPixbufToggle::SignalToggled&
CellRendererPixbufToggle::signal_toggled()
{
return signal_toggled_;
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void
ClickBox::style_changed (const Glib::RefPtr<Gtk::Style>&)
{
- layout->context_changed ();
+ layout->context_changed ();
layout->get_pixel_size (twidth, theight);
}
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
enable_model_drag_dest (draggable);
}
-bool
+bool
DnDTreeViewBase::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time)
{
suggested_action = Gdk::DragAction (0);
// Storing vector A->B
double a_to_b_x = xb - xa;
double a_to_b_y = yb - ya;
-
+
// Storing vector A->P
double a_to_p_x = xp - xa;
double a_to_p_y = yp - ya;
-
+
// Basically finding the squared magnitude
// of a_to_b
double atb2 = a_to_b_x * a_to_b_x + a_to_b_y * a_to_b_y;
-
+
// The dot product of a_to_p and a_to_b
double atp_dot_atb = a_to_p_x * a_to_b_x + a_to_p_y * a_to_b_y;
-
+
// The normalized "distance" from a to
// your closest point
double t = atp_dot_atb / atb2;
-
+
// Add the distance to A, moving
// towards B
double x = xa + a_to_b_x * t;
const Glib::RefPtr<Gdk::Pixbuf>& underlay_pixbuf,
const Glib::RefPtr<Gdk::Pixbuf>& handle_pixbuf,
const Glib::RefPtr<Gdk::Pixbuf>& active_handle_pixbuf,
- int min_pos_x,
+ int min_pos_x,
int min_pos_y,
int max_pos_x,
int max_pos_y,
}
gdk_cairo_set_source_pixbuf (cr,
- ((get_state () == Gtk::STATE_ACTIVE) && (_active_face_pixbuf != 0)) ?
- _active_face_pixbuf->gobj() :
+ ((get_state () == Gtk::STATE_ACTIVE) && (_active_face_pixbuf != 0)) ?
+ _active_face_pixbuf->gobj() :
_face_pixbuf->gobj(),
0,
0);
Fader::on_button_press_event (GdkEventButton* ev)
{
focus_handler();
-
+
if (_read_only) {
return false;
}
-
+
if (ev->type != GDK_BUTTON_PRESS) {
return false;
}
if ((ev->x < (_grab_start_handle_x - hw/2)) || (ev->x > (_grab_start_handle_x + hw/2)) || (ev->y < (_grab_start_handle_y - hh/2)) || (ev->y > (_grab_start_handle_y + hh/2))) {
return false;
}
-
+
double ev_pos_x;
double ev_pos_y;
get_closest_point_on_line(_min_pos_x, _min_pos_y,
- _max_pos_x, _max_pos_y,
+ _max_pos_x, _max_pos_y,
ev->x, ev->y,
ev_pos_x, ev_pos_y );
add_modal_grab ();
}
get_closest_point_on_line(_min_pos_x, _min_pos_y,
- _max_pos_x, _max_pos_y,
+ _max_pos_x, _max_pos_y,
_grab_start_handle_x + (ev->x - _grab_start_mouse_x), _grab_start_handle_y + (ev->y - _grab_start_mouse_y),
ev_pos_x, ev_pos_y );
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
next_release_selects = false;
}
-bool
+bool
FocusEntry::on_button_press_event (GdkEventButton* ev)
{
if (!has_focus()) {
return Entry::on_button_press_event (ev);
}
-bool
+bool
FocusEntry::on_button_release_event (GdkEventButton* ev)
{
if (next_release_selects) {
select_region (0, -1);
next_release_selects = false;
return ret;
- }
+ }
return Entry::on_button_release_event (ev);
}
/*
- Copyright (C) 2001 Paul Davis
+ Copyright (C) 2001 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
if (n == current_active) {
button->set_active (true);
- }
+ }
button->signal_clicked().connect (sigc::bind (mem_fun (*this, &GroupedButtons::one_clicked), n));
buttons.push_back (button);
: AbstractUI<UIRequest> (namestr)
, _receiver (*this)
, errors (0)
-
+
{
theMain = new Main (argc, argv);
/* Yes, pointers to Glib::RefPtr. If these are not kept around,
* a segfault somewhere deep in the wonderfully robust glib will result.
* This does not occur if wiget.get_style is used instead of rc.get_style below,
- * except that doesn't actually work...
+ * except that doesn't actually work...
*/
static Glib::RefPtr<Style>* fatal_style = 0;
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts.
*
* Copyright (C) 2007 Pioneer Research Center USA, Inc.
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts (for X11)
*
* Copyright (C) 2007 Pioneer Research Center USA, Inc.
#include <gtkmm2ext/gtkapplication.h>
-int
+int
gtk_application_init (void)
{
return 0;
{
}
-void
+void
gtk_application_set_menu_bar (GtkMenuShell* menushell)
{
}
-void
+void
gtk_application_add_app_menu_item (GtkApplicationMenuGroup* group, GtkMenuItem* item)
{
}
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts (for X11)
*
* Copyright (C) 2007 Pioneer Research Center USA, Inc.
#include <gtkmm2ext/gtkapplication.h>
-int
+int
gtk_application_init (void)
{
return 0;
{
}
-void
+void
gtk_application_set_menu_bar (GtkMenuShell* menushell)
{
(void) menushell;
}
-void
+void
gtk_application_add_app_menu_item (GtkApplicationMenuGroup* group, GtkMenuItem* item)
{
(void) group;
LIBGTKMM2EXT_API extern void uncheck_toggleaction (std::string);
LIBGTKMM2EXT_API extern void set_toggleaction_state (std::string, bool);
-
+
LIBGTKMM2EXT_API extern void save_action_states ();
LIBGTKMM2EXT_API extern void enable_active_actions ();
LIBGTKMM2EXT_API extern void disable_active_actions ();
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts.
*
* Copyright (C) 2009 Paul Davis
namespace Gtkmm2ext {
-class LIBGTKMM2EXT_API Application
+class LIBGTKMM2EXT_API Application
{
public:
static Application* instance();
/*
- Copyright (C) 2000 Paul Barton-Davis
+ Copyright (C) 2000 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace Gtkmm2ext {
-class LIBGTKMM2EXT_API AutoSpin
+class LIBGTKMM2EXT_API AutoSpin
{
public:
/*
- Copyright (C) 2004 Paul Davis
+ Copyright (C) 2004 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
KeyboardKey () {
_val = GDK_VoidSymbol;
}
-
+
KeyboardKey (uint32_t state, uint32_t keycode);
-
+
uint32_t state() const { return _val >> 32; }
uint32_t key() const { return _val & 0xffff; }
-
+
bool operator<(const KeyboardKey& other) const {
return _val < other._val;
}
Glib::RefPtr<Gtk::Action> register_action (const char* path,
const char* name, const char* label, sigc::slot<void> sl);
Glib::RefPtr<Gtk::Action> register_radio_action (const char* path, Gtk::RadioAction::Group&,
- const char* name, const char* label,
+ const char* name, const char* label,
sigc::slot<void,GtkAction*> sl,
int value);
Glib::RefPtr<Gtk::Action> register_toggle_action (const char*path,
private:
typedef std::map<std::string, Glib::RefPtr<Gtk::Action> > _ActionMap;
_ActionMap actions;
-};
+};
class LIBGTKMM2EXT_API Bindings {
public:
- enum Operation {
+ enum Operation {
Press,
Release
};
-
+
Bindings();
~Bindings ();
void load (const XMLNode& node);
bool save (const std::string& path);
void save (XMLNode& root);
-
+
void set_action_map (ActionMap&);
static void set_ignored_state (int mask) {
#include "gtkmm2ext/visibility.h"
-class LIBGTKMM2EXT_API CairoPacker
+class LIBGTKMM2EXT_API CairoPacker
{
public:
CairoPacker () {}
/* set_focus_handler() will cause all button-press events on any
CairoWidget to invoke this slot/functor/function/method/callback.
-
+
We do this because in general, CairoWidgets do not grab
keyboard focus, but a button press on them should
clear focus from any active text entry.
However, derived types can override the behaviour by defining their
own on_button_press_event() handler which returns true under all
- conditions (which will block this handler from being called). If
+ conditions (which will block this handler from being called). If
they wish to invoke any existing focus handler from their own
button press handler, they can just use: focus_handler();
*/
CairoCell* find_cell (uint32_t x, uint32_t y);
void queue_draw_cell (CairoCell* target);
void position_cells_and_get_bbox (GdkRectangle&);
- void set_cell_sizes ();
+ void set_cell_sizes ();
};
#endif /* __libgtmm2ext_cairocell_h__ */
/*
- Copyright (C) 2011 Paul Davis
+ Copyright (C) 2011 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#ifndef __gtkmm2ext_cell_renderer_color_selector_h__
+#ifndef __gtkmm2ext_cell_renderer_color_selector_h__
#define __gtkmm2ext_cell_renderer_color_selector_h__
#include <gtkmm/drawingarea.h>
class LIBGTKMM2EXT_API CellRendererColorSelector : public Gtk::CellRenderer
{
public:
- CellRendererColorSelector();
+ CellRendererColorSelector();
virtual ~CellRendererColorSelector();
virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags);
/*
- Copyright (C) 2000-2009 Paul Davis
+ Copyright (C) 2000-2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#ifndef __gtkmm2ext_cell_renderer_pixbuf_multi_h__
+#ifndef __gtkmm2ext_cell_renderer_pixbuf_multi_h__
#define __gtkmm2ext_cell_renderer_pixbuf_multi_h__
#include <map>
{
public:
- CellRendererPixbufMulti();
+ CellRendererPixbufMulti();
virtual ~CellRendererPixbufMulti(){};
virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags);
SignalChanged& signal_changed();
protected:
-
+
private:
- Glib::Property<uint32_t> property_state_;
+ Glib::Property<uint32_t> property_state_;
std::map<uint32_t,Glib::RefPtr<Gdk::Pixbuf> > _pixbufs;
/*
- Copyright (C) 2000-2009 Paul Davis
+ Copyright (C) 2000-2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#ifndef __gtkmm2ext_cell_renderer_pixbuf_toggle_h__
+#ifndef __gtkmm2ext_cell_renderer_pixbuf_toggle_h__
#define __gtkmm2ext_cell_renderer_pixbuf_toggle_h__
#include <gtkmm/drawingarea.h>
{
public:
- CellRendererPixbufToggle();
+ CellRendererPixbufToggle();
virtual ~CellRendererPixbufToggle(){};
virtual void render_vfunc (const Glib::RefPtr<Gdk::Drawable>& window, Gtk::Widget& widget, const Gdk::Rectangle& background_area, const Gdk::Rectangle& cell_area, const Gdk::Rectangle& expose_area, Gtk::CellRendererState flags);
SignalToggled& signal_toggled();
protected:
-
+
private:
- Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_;
- Glib::Property<bool> property_active_;
+ Glib::Property< Glib::RefPtr<Gdk::Pixbuf> > property_pixbuf_;
+ Glib::Property<bool> property_active_;
Glib::RefPtr<Gdk::Pixbuf> active_pixbuf;
Glib::RefPtr<Gdk::Pixbuf> inactive_pixbuf;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace Gtkmm2ext {
-class LIBGTKMM2EXT_API CursorInfo
+class LIBGTKMM2EXT_API CursorInfo
{
public:
static CursorInfo* lookup_cursor_info (const std::string& image_name);
private:
CursorInfo (const std::string& image_name, int hotspot_x, int hotspot_y);
-
+
typedef std::map<std::string,CursorInfo*> Infos;
static Infos infos;
};
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
DataType data[0];
};
-class LIBGTKMM2EXT_API DnDTreeViewBase : public Gtk::TreeView
+class LIBGTKMM2EXT_API DnDTreeViewBase : public Gtk::TreeView
{
private:
public:
class /*LIBGTKMM2EXT_API*/ DnDTreeView : public DnDTreeViewBase
{
public:
- DnDTreeView() {}
+ DnDTreeView() {}
~DnDTreeView() {}
sigc::signal<void,const std::list<DataType>&,Gtk::TreeView*,int,int,Glib::RefPtr<Gdk::DragContext>&> signal_drop;
};
} // namespace
-
+
#endif /* __gtkmm2ext_dndtreeview_h__ */
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
return _selection;
}
- /** Set the `active' child; this is simply a child which is set to have the
+ /** Set the `active' child; this is simply a child which is set to have the
* visual state "active" for whatever purposes the client may have.
* @param c Child, or 0 for none.
*/
/*
- Copyright (C) 2002 Paul Davis
+ Copyright (C) 2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "gtkmm2ext/visibility.h"
-namespace Gtkmm2ext
+namespace Gtkmm2ext
{
class LIBGTKMM2EXT_API EmScale
static std::map<std::string,EmScale> _emscales;
};
-} // namespace
+} // namespace
#endif /* __libgtkmm2ext_emscale_h__ */
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
class LIBGTKMM2EXT_API Fader : public CairoWidget
{
public:
- Fader (Gtk::Adjustment& adjustment,
+ Fader (Gtk::Adjustment& adjustment,
const Glib::RefPtr<Gdk::Pixbuf>& face_pixbuf,
const Glib::RefPtr<Gdk::Pixbuf>& active_face_pixbuf,
const Glib::RefPtr<Gdk::Pixbuf>& underlay_pixbuf,
const Glib::RefPtr<Gdk::Pixbuf>& handle_pixbuf,
const Glib::RefPtr<Gdk::Pixbuf>& active_handle_pixbuf,
- int min_pos_x,
+ int min_pos_x,
int min_pos_y,
int max_pos_x,
int max_pos_y,
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2001 Paul Davis
+ Copyright (C) 2001 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
extern BaseUI::RequestType AddTimeout;
struct LIBGTKMM2EXT_API UIRequest : public BaseUI::BaseRequestObject {
-
+
/* this once used anonymous unions to merge elements
that are never part of the same request. that makes
the creation of a legal copy constructor difficult
because of the semantics of the slot member.
*/
-
+
Touchable *display;
const char *msg;
Gtk::StateType new_state;
UIRequest () {
type = NullMessage;
}
-
- ~UIRequest () {
+
+ ~UIRequest () {
if (type == ErrorMessage && msg) {
/* msg was strdup()'ed */
free (const_cast<char *>(msg));
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts.
*
* Copyright (C) 2007 Pioneer Research Center USA, Inc.
-/* GTK+ Integration with platform-specific application-wide features
+/* GTK+ Integration with platform-specific application-wide features
* such as the OS X menubar and application delegate concepts.
*
* Copyright (C) 2007 Pioneer Research Center USA, Inc.
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
struct trackable;
}
-#define ENSURE_GUI_THREAD(obj,method, ...) if (!Gtkmm2ext::UI::instance()->caller_is_self()) { abort (); }
+#define ENSURE_GUI_THREAD(obj,method, ...) if (!Gtkmm2ext::UI::instance()->caller_is_self()) { abort (); }
#define gui_context() Gtkmm2ext::UI::instance() /* a UICallback-derived object that specifies the event loop for GUI signal handling */
#define ui_bind(f, ...) boost::protect (boost::bind (f, __VA_ARGS__))
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
Endless
};
- MotionFeedback (Glib::RefPtr<Gdk::Pixbuf>,
+ MotionFeedback (Glib::RefPtr<Gdk::Pixbuf>,
Type type,
boost::shared_ptr<PBD::Controllable>,
double default_value,
virtual void set_controllable (boost::shared_ptr<PBD::Controllable> c);
static void set_lamp_color (const std::string&);
-
+
static Glib::RefPtr<Gdk::Pixbuf> render_pixbuf (int size);
void set_print_func(void (*pf)(char buf[32], const boost::shared_ptr<PBD::Controllable>&, void *),
void set_tip (std::string);
void set_font (Pango::FontDescription font);
void set_center_alignment (bool align_to_center);
-
+
virtual bool dragging () const;
private:
Gtk::Window* _window;
/** Our label */
Gtk::Label* _label;
-
+
/** allow to drag
*/
bool _draggable;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#ifndef __gtkmm2ext_pixscroller_h__
+#ifndef __gtkmm2ext_pixscroller_h__
#define __gtkmm2ext_pixscroller_h__
#include <gtkmm/drawingarea.h>
class LIBGTKMM2EXT_API PixScroller : public Gtk::DrawingArea
{
public:
- PixScroller(Gtk::Adjustment& adjustment,
+ PixScroller(Gtk::Adjustment& adjustment,
Glib::RefPtr<Gdk::Pixbuf> slider,
Glib::RefPtr<Gdk::Pixbuf> rail);
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/* Helpers.c generated by valac, the Vala compiler */
-/*
+/*
Copyright 2009 by Hans Baier
- License: LGPLv2+
+ License: LGPLv2+
*/
#ifndef __prolooks_helpers_h__
LIBGTKMM2EXT_API GdkPixbuf* prolooks_cairo_image_surface_to_pixbuf (cairo_surface_t* surface);
#ifdef __cplusplus
-} // extern "C"
+} // extern "C"
#endif
#endif /* __prolooks_helpers_h__ */
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2008 Paul Davis
+ Copyright (C) 2008 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#ifndef __gtkmm2ext_scroomer_h__
+#ifndef __gtkmm2ext_scroomer_h__
#define __gtkmm2ext_scroomer_h__
#include <gtkmm/drawingarea.h>
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
friend class Gtkmm2ext::TreeView_Selector;
public:
- Selector (SelectorRefillFunction, void *arg,
+ Selector (SelectorRefillFunction, void *arg,
std::vector<std::string> titles);
virtual ~Selector ();
/*
- Copyright (C) 1998-2006 Paul Davis
+ Copyright (C) 1998-2006 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
namespace Gtkmm2ext {
-class LIBGTKMM2EXT_API StateButton
+class LIBGTKMM2EXT_API StateButton
{
public:
StateButton();
explicit StatefulButton(const std::string &label);
virtual ~StatefulButton() {}
void set_widget_name (const std::string& name);
-
+
protected:
void on_realize ();
void on_style_changed (const Glib::RefPtr<Gtk::Style>& style);
void on_state_changed (Gtk::StateType old_state);
-
+
Gtk::Widget* get_child_widget ();
std::string get_widget_name() const { return get_name(); }
};
/*
Copyright (C) 2003 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
LIBGTKMM2EXT_API int pixel_width (const std::string& str, Pango::FontDescription& font);
LIBGTKMM2EXT_API void pixel_size (const std::string& str, Pango::FontDescription& font, int& width, int& height);
- LIBGTKMM2EXT_API void get_ink_pixel_size (Glib::RefPtr<Pango::Layout>,
+ LIBGTKMM2EXT_API void get_ink_pixel_size (Glib::RefPtr<Pango::Layout>,
int& width, int& height);
- LIBGTKMM2EXT_API void get_pixel_size (Glib::RefPtr<Pango::Layout>,
+ LIBGTKMM2EXT_API void get_pixel_size (Glib::RefPtr<Pango::Layout>,
int& width, int& height);
LIBGTKMM2EXT_API void set_size_request_to_display_given_text (Gtk::Widget &w,
gint vpadding);
- LIBGTKMM2EXT_API Glib::RefPtr<Gdk::Pixbuf> pixbuf_from_string (const std::string& name,
- const Pango::FontDescription& font,
- int clip_width,
- int clip_height,
+ LIBGTKMM2EXT_API Glib::RefPtr<Gdk::Pixbuf> pixbuf_from_string (const std::string& name,
+ const Pango::FontDescription& font,
+ int clip_width,
+ int clip_height,
Gdk::Color fg);
- LIBGTKMM2EXT_API void set_popdown_strings (Gtk::ComboBoxText&,
+ LIBGTKMM2EXT_API void set_popdown_strings (Gtk::ComboBoxText&,
const std::vector<std::string>&);
LIBGTKMM2EXT_API void get_popdown_strings (Gtk::ComboBoxText&,
#define LIBGTKMM2EXT_API LIBGTKMM2EXT_DLL_EXPORT
#else
#define LIBGTKMM2EXT_API LIBGTKMM2EXT_DLL_IMPORT
- #endif
+ #endif
#define LIBGTKMM2EXT_LOCAL LIBGTKMM2EXT_DLL_LOCAL
#endif
public:
VisibilityTracker (Gtk::Window&);
virtual ~VisibilityTracker() {}
-
+
void cycle_visibility ();
bool fully_visible() const;
}
-#endif /* __libgtkmm2ext_visibility_tracker__ */
+#endif /* __libgtkmm2ext_visibility_tracker__ */
namespace Gtkmm2ext {
/* widget states: unlike GTK, visual states like "Selected" or "Prelight"
- are orthogonal to active states.
+ are orthogonal to active states.
*/
enum LIBGTKMM2EXT_API ActiveState {
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
public:
/**
- * \param title The first string/element of the window title
- * which will may be the application name or the document
+ * \param title The first string/element of the window title
+ * which will may be the application name or the document
* name in a document based application.
*/
WindowTitle(const std::string& title);
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
if (::g_rename (user_keybindings_path.c_str(), new_path.c_str())) {
error << string_compose (_("Cannot rename your own keybinding file (%1)"), strerror (errno)) << endmsg;
return -1;
- }
+ }
}
{
double default_val,
double step_increment,
double page_increment,
- const char *widget_name,
- bool with_numeric_display,
- int subw,
- int subh)
+ const char *widget_name,
+ bool with_numeric_display,
+ int subw,
+ int subh)
: _controllable (c)
, value (0)
, default_value (default_val)
}
bool
-MotionFeedback::pixwin_button_press_event (GdkEventButton *ev)
-{
+MotionFeedback::pixwin_button_press_event (GdkEventButton *ev)
+{
if (binding_proxy.button_press_handler (ev)) {
return true;
}
}
bool
-MotionFeedback::pixwin_button_release_event (GdkEventButton *ev)
-{
+MotionFeedback::pixwin_button_release_event (GdkEventButton *ev)
+{
if (!_controllable) {
return false;
}
break;
}
- return VBox::on_button_release_event (ev);
+ return VBox::on_button_release_event (ev);
}
bool
-MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev)
-{
+MotionFeedback::pixwin_motion_notify_event (GdkEventMotion *ev)
+{
if (!_controllable) {
return false;
}
gfloat y_delta;
if (!pixwin.has_grab()) {
- return VBox::on_motion_notify_event (ev);
+ return VBox::on_motion_notify_event (ev);
}
multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100 : 1) *
y_delta = grabbed_y - ev->y_root;
grabbed_y = ev->y_root;
-
+
x_delta = ev->x_root - grabbed_x;
-
+
if (y_delta == 0) return TRUE;
-
+
y_delta *= 1 + (x_delta/100);
y_delta *= multiplier;
y_delta /= 10;
-
+
_controllable->set_value (adjust ((grab_is_fine ? step_inc : page_inc) * y_delta));
-
+
} else if (ev->state & Gdk::BUTTON2_MASK) {
/* rotary control */
double x = ev->x - subwidth/2;
double y = - ev->y + subwidth/2;
double angle = std::atan2 (y, x) / M_PI;
-
+
if (angle < -0.5) {
angle += 2.0;
}
-
+
angle = -(2.0/3.0) * (angle - 1.25);
angle *= multiplier;
}
bool
-MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing*)
+MotionFeedback::pixwin_enter_notify_event (GdkEventCrossing*)
{
pixwin.grab_focus();
return false;
}
bool
-MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing*)
+MotionFeedback::pixwin_leave_notify_event (GdkEventCrossing*)
{
pixwin.unset_flags (HAS_FOCUS);
return false;
}
bool
-MotionFeedback::pixwin_key_press_event (GdkEventKey *ev)
+MotionFeedback::pixwin_key_press_event (GdkEventKey *ev)
{
if (!_controllable) {
return false;
double multiplier;
multiplier = ((ev->state & Keyboard::TertiaryModifier) ? 100.0 : 1.0) *
- ((ev->state & Keyboard::SecondaryModifier) ? 10.0 : 1.0) *
+ ((ev->state & Keyboard::SecondaryModifier) ? 10.0 : 1.0) *
((ev->state & Keyboard::PrimaryModifier) ? 2.0 : 1.0);
switch (ev->keyval) {
phase = std::min (phase, (int32_t) 63);
GtkWidget* widget = GTK_WIDGET(pixwin.gobj());
- gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0],
- pixbuf->gobj(),
- phase * subwidth, type * subheight,
+ gdk_draw_pixbuf (GDK_DRAWABLE(window), widget->style->fg_gc[0],
+ pixbuf->gobj(),
+ phase * subwidth, type * subheight,
/* center image in allocated area */
- (get_width() - subwidth)/2,
+ (get_width() - subwidth)/2,
0,
subwidth, subheight, GDK_RGB_DITHER_NORMAL, 0, 0);
}
boost::shared_ptr<PBD::Controllable>
-MotionFeedback::controllable () const
+MotionFeedback::controllable () const
{
return _controllable;
}
-
+
void
MotionFeedback::default_printer (char buf[32], const boost::shared_ptr<PBD::Controllable>& c, void *)
{
g_free (path);
return pixbuf;
-}
+}
void
MotionFeedback::core_draw (cairo_t* cr, int phase, double size, double progress_width, double xorigin, double yorigin,
double progress_radius_outer;
g_return_if_fail (cr != NULL);
-
+
progress_radius = 40.0;
progress_radius_inner = progress_radius - (progress_width / 2.0);
progress_radius_outer = progress_radius + (progress_width / 2.0);
_text = "";
set_text (txt, _centered_text, false);
}
- /* patterns are cached and re-created as needed
+ /* patterns are cached and re-created as needed
* during 'expose' in the GUI thread */
_pattern = 0;
queue_draw ();
/*
Copyright (C) 2005 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
using namespace Gtk;
using namespace Gtkmm2ext;
-PixScroller::PixScroller (Adjustment& a,
+PixScroller::PixScroller (Adjustment& a,
Glib::RefPtr<Gdk::Pixbuf> s,
Glib::RefPtr<Gdk::Pixbuf> r)
: adj (a),
rail_surface = Cairo::ImageSurface::create (format, rail->get_width(), rail->get_height());
rail_context = Cairo::Context::create (rail_surface);
Gdk::Cairo::set_source_pixbuf (rail_context, rail, 0.0, 0.0);
- rail_context->paint();
+ rail_context->paint();
if (slider->get_has_alpha()) {
format = Cairo::FORMAT_ARGB32;
slider_surface = Cairo::ImageSurface::create (format, slider->get_width(), slider->get_height());
slider_context = Cairo::Context::create (slider_surface);
Gdk::Cairo::set_source_pixbuf (slider_context, slider, 0.0, 0.0);
- slider_context->paint();
+ slider_context->paint();
}
void
GdkRectangle intersect;
Glib::RefPtr<Gdk::Window> win (get_window());
Cairo::RefPtr<Cairo::Context> context = get_window()->create_cairo_context();
-
+
if (gdk_rectangle_intersect (railrect.gobj(), &ev->area, &intersect)) {
context->save();
break;
default:
break;
- }
-
+ }
+
return false;
}
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
show_all ();
if (popdown_time != 0) {
- timeout = g_timeout_add (popdown_time,
- remove_prompt_timeout,
+ timeout = g_timeout_add (popdown_time,
+ remove_prompt_timeout,
this);
}
}
/* Helpers.c generated by valac, the Vala compiler
* generated from Helpers.vala, do not modify */
-/*
+/*
Copyright 2009 by Hans Baier
- License: LGPLv2+
+ License: LGPLv2+
*/
#ifdef COMPILER_MSVC
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
- /*
+ /*
Alas a generic 'affirmative' button seems a bit useless sometimes.
You will have to add your own.
After adding, use :
void
Prompter::on_entry_changed ()
{
- /*
- This is set up so that entering text in the entry
- field makes the RESPONSE_ACCEPT button active.
- Of course if you haven't added a RESPONSE_ACCEPT
+ /*
+ This is set up so that entering text in the entry
+ field makes the RESPONSE_ACCEPT button active.
+ Of course if you haven't added a RESPONSE_ACCEPT
button, nothing will happen at all.
*/
/*
- Copyright (C) 2008 Paul Davis
+ Copyright (C) 2008 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
using namespace Gtkmm2ext;
using namespace std;
-StateButton::StateButton ()
+StateButton::StateButton ()
: visual_state (0)
, _self_managed (false)
, _is_realized (false)
if (style_changing) {
return;
}
-
+
if (gtk_widget_get_state (widget) == GTK_STATE_PRELIGHT) {
-
+
/* avoid PRELIGHT: make sure that the prelight colors in this new style match
the colors of the new style in whatever state we were in
before we switched to prelight.
rcstyle->fg[GTK_STATE_PRELIGHT] = style->fg[state_before_prelight];
rcstyle->bg[GTK_STATE_PRELIGHT] = style->bg[state_before_prelight];
rcstyle->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags) (GTK_RC_FG|GTK_RC_BG);
-
+
style_changing = true;
g_object_ref (rcstyle);
gtk_widget_modify_style (widget, rcstyle);
if (state == GTK_STATE_PRELIGHT) {
state_before_prelight = old_state;
-
-
- /* avoid PRELIGHT when currently ACTIVE:
- if we just went into PRELIGHT, make sure that the colors
- match those of whatever state we were in before.
+
+
+ /* avoid PRELIGHT when currently ACTIVE:
+ if we just went into PRELIGHT, make sure that the colors
+ match those of whatever state we were in before.
*/
-
+
GtkRcStyle* rcstyle = gtk_widget_get_modifier_style (widget);
GtkStyle* style = gtk_widget_get_style (widget);
-
+
rcstyle->fg[GTK_STATE_PRELIGHT] = style->fg[old_state];
rcstyle->bg[GTK_STATE_PRELIGHT] = style->bg[old_state];
rcstyle->color_flags[GTK_STATE_PRELIGHT] = (GtkRcFlags) (GTK_RC_FG|GTK_RC_BG);
-
+
g_object_ref (rcstyle);
gtk_widget_modify_style (widget, rcstyle);
{
avoid_prelight_on_style_changed (style, GTK_WIDGET(gobj()));
Button::on_style_changed (style);
-}
+}
void
StatefulToggleButton::on_state_changed (Gtk::StateType old_state)
{
avoid_prelight_on_state_changed (old_state, GTK_WIDGET(gobj()));
Button::on_state_changed (old_state);
-}
+}
Widget*
StatefulToggleButton::get_child_widget ()
void
StatefulToggleButton::set_widget_name (const std::string& name)
{
- set_name (name);
+ set_name (name);
Widget* w = get_child();
if (w) {
- w->set_name (name);
- }
+ w->set_name (name);
+ }
}
/*--------------------------------------------- */
{
avoid_prelight_on_style_changed (style, GTK_WIDGET(gobj()));
Button::on_style_changed (style);
-}
+}
void
StatefulButton::on_state_changed (Gtk::StateType old_state)
{
avoid_prelight_on_state_changed (old_state, GTK_WIDGET(gobj()));
Button::on_state_changed (old_state);
-}
+}
Widget*
StatefulButton::get_child_widget ()
void
StatefulButton::set_widget_name (const std::string& name)
{
- set_name (name);
+ set_name (name);
Widget* w = get_child();
if (w) {
- w->set_name (name);
- }
+ w->set_name (name);
+ }
}
default:
break;
}
-
+
if (realkey != -1) {
SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
false, realkey);
}
/* gdk/quartz maps Command to Meta */
-
+
if (key->accel_mods & GDK_META_MASK) {
use_command = 1;
}
- }
+ }
if (!use_command)
modifiers |= kMenuNoCommandModifier;
static int _in_carbon_menu_event_handler = 0;
-int
+int
gdk_quartz_in_carbon_menu_event_handler ()
{
return _in_carbon_menu_event_handler;
/*
Copyright (C) 2003 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
, _visible (true)
, _torn (false)
, _can_be_torn_off (true)
-
+
{
own_window_width = 0;
own_window_height = 0;
tearoff_event_box.signal_button_release_event().connect (mem_fun (*this, &TearOff::tearoff_click));
tearoff_event_box.set_tooltip_text (_("Click to tear this into its own window"));
-
+
close_event_box.add (close_arrow);
close_event_box.set_events (BUTTON_PRESS_MASK|BUTTON_RELEASE_MASK);
close_event_box.signal_button_release_event().connect (mem_fun (*this, &TearOff::close_click));
if (!_can_be_torn_off) {
return;
}
-
+
if (torn_off()) {
return;
}
_torn = true;
Detach ();
-}
+}
gint
TearOff::close_click (GdkEventButton* /*ev*/)
snprintf (buf, sizeof (buf), "%d", own_window_ypos);
node.add_property ("ypos", buf);
}
-}
+}
void
TearOff::set_state (const XMLNode& node)
own_window.move (own_window_xpos, own_window_ypos);
}
/* otherwise do it once the window is realized, see below */
-}
+}
void
TearOff::own_window_realized ()
Glib::RefPtr<const Gdk::Window> win;
win = own_window.get_window ();
-
+
if (win) {
win->get_size (own_window_width, own_window_height);
win->get_position (own_window_xpos, own_window_ypos);
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
prev = model->get_path (iter);
} else {
-
+
prev.prev();
}
iter = model->get_iter (prev);
}
-
+
if (iter) {
treeview_select_one (selection, model, view, iter, prev, col);
} else {
/* we could not forward, so wrap around to the first row */
- /* grr: no nice way to get an iter for the
+ /* grr: no nice way to get an iter for the
last row, because there is no operator--
for TreeIter
*/
iter = model->get_iter (next);
}
-
+
if (iter) {
treeview_select_one (selection, model, view, iter, next, col);
} else {
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
void
-Gtkmm2ext::set_size_request_to_display_given_text (Gtk::Widget &w,
+Gtkmm2ext::set_size_request_to_display_given_text (Gtk::Widget &w,
const std::vector<std::string>& strings,
gint hpadding, gint vpadding)
{
src_pixel[3]); // R [0] <= [ 2 ]
dst_pixel[1] = demultiply_alpha (src_pixel[1],
src_pixel[3]); // G [1] <= [ 1 ]
- dst_pixel[2] = demultiply_alpha (src_pixel[0],
+ dst_pixel[2] = demultiply_alpha (src_pixel[0],
src_pixel[3]); // B [2] <= [ 0 ]
dst_pixel[3] = src_pixel[3]; // alpha
-
+
#elif G_BYTE_ORDER == G_BIG_ENDIAN
/* Cairo [ B G R A ] is actually [ A R G B ] in memory SOURCE
0 1 2 3
dst_pixel[2] = demultiply_alpha (src_pixel[3],
src_pixel[0]); // B [2] <= [ 3 ]
dst_pixel[3] = src_pixel[0]; // alpha
-
+
#else
#error ardour does not currently support PDP-endianess
#endif
-
+
dst_pixel += 4;
src_pixel += 4;
}
Gtkmm2ext::physical_screen_width (Glib::RefPtr<Gdk::Window> win)
{
GdkScreen* scr = gdk_screen_get_default();
-
+
if (win) {
GdkRectangle r;
gint monitor = gdk_screen_get_monitor_at_window (scr, win->gobj());
line = layout->get_line (0);
/* XXX: might need special care to get the ellipsis character, not sure
- how that works
+ how that works
*/
string s = string (layout->get_text ().substr(line->get_start_index(), line->get_length()));
if (!gdk_event_get_root_coords (ev, &evx, &evy)) {
return false;
}
-
+
gint wx;
gint wy;
gint width, height, depth;
widget_window->get_geometry (x, y, width, height, depth);
widget_window->get_root_origin (wx, wy);
-
- if ((evx >= wx && evx < wx + width) &&
+
+ if ((evx >= wx && evx < wx + width) &&
(evy >= wy && evy < wy + height)) {
return true;
- }
+ }
return false;
}
// MEMO: Normaly MATURE OS clips so called invalidated rects itself making APP free of
// heavy operations which OS does with graphic HW
- // NOTE FROM PAUL: GTK does clip already. The invalidated rect isn't the only area
+ // NOTE FROM PAUL: GTK does clip already. The invalidated rect isn't the only area
// we want to clip to however, which is why this object/class is called FastMeter.
// I have left stuff commented out as I found it when I merged from Ardour in August 2014,
// but this commenting and the previous MEMO comment represent a misunderstanding
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
using namespace MIDI;
-Channel::Channel (MIDI::byte channelnum, Port &p)
+Channel::Channel (MIDI::byte channelnum, Port &p)
: _port (p)
{
_channel_number = channelnum;
memset (_polypress, 0, sizeof (_polypress));
memset (_controller_msb, 0, sizeof (_controller_msb));
memset (_controller_lsb, 0, sizeof (_controller_lsb));
-
+
/* zero all controllers XXX not necessarily the right thing */
memset (_controller_val, 0, sizeof (_controller_val));
}
void
-Channel::process_note_off (Parser & /*parser*/, EventTwoBytes *tb)
+Channel::process_note_off (Parser & /*parser*/, EventTwoBytes *tb)
{
_last_note_off = tb->note_number;
_last_off_velocity = tb->velocity;
}
void
-Channel::process_note_on (Parser & /*parser*/, EventTwoBytes *tb)
+Channel::process_note_on (Parser & /*parser*/, EventTwoBytes *tb)
{
_last_note_on = tb->note_number;
_last_on_velocity = tb->velocity;
}
void
-Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
+Channel::process_controller (Parser & /*parser*/, EventTwoBytes *tb)
{
unsigned short cv;
if (tb->controller_number < 32) { /* unsigned: no test for >= 0 */
/* if this controller is already known to use 14 bits,
- then treat this value as the MSB, and combine it
+ then treat this value as the MSB, and combine it
with the existing LSB.
otherwise, just treat it as a 7 bit value, and set
_controller_val[tb->controller_number] = (controller_value_t)cv;
- } else if ((tb->controller_number >= 32 &&
+ } else if ((tb->controller_number >= 32 &&
tb->controller_number <= 63)) {
-
+
int cn = tb->controller_number - 32;
cv = (unsigned short) _controller_val[cn];
- /* LSB for CC 0-31 arrived.
+ /* LSB for CC 0-31 arrived.
If this is the first time (i.e. its currently
flagged as a 7 bit controller), mark the
controller as 14 bit, adjust the existing value
- to be the MSB, and OR-in the new LSB value.
+ to be the MSB, and OR-in the new LSB value.
otherwise, OR-in the new low 7bits with the old
high 7.
*/
-
+
if (_controller_14bit[cn] == false) {
_controller_14bit[cn] = true;
cv = (cv << 7) | (tb->value & 0x7f);
/* controller can only take 7 bit values */
- _controller_val[tb->controller_number] =
+ _controller_val[tb->controller_number] =
(controller_value_t) tb->value;
}
}
void
-Channel::process_program_change (Parser & /*parser*/, MIDI::byte val)
+Channel::process_program_change (Parser & /*parser*/, MIDI::byte val)
{
_program_number = val;
}
void
-Channel::process_chanpress (Parser & /*parser*/, MIDI::byte val)
+Channel::process_chanpress (Parser & /*parser*/, MIDI::byte val)
{
_chanpress = val;
}
void
-Channel::process_polypress (Parser & /*parser*/, EventTwoBytes *tb)
+Channel::process_polypress (Parser & /*parser*/, EventTwoBytes *tb)
{
_polypress[tb->note_number] = tb->value;
}
void
-Channel::process_pitchbend (Parser & /*parser*/, pitchbend_t val)
+Channel::process_pitchbend (Parser & /*parser*/, pitchbend_t val)
{
_pitch_bend = val;
}
void
-Channel::process_reset (Parser & /*parser*/)
+Channel::process_reset (Parser & /*parser*/)
{
reset (0, 1);
}
Copyright (C) 2012 Paul Davis
Using code from Rui Nuno Capela's qmidinet as inspiration.
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
int
IPMIDIPort::selectable () const
-{
- return sockin;
+{
+ return sockin;
}
XMLNode&
}
}
-static bool
+static bool
get_address (int sock, struct in_addr *inaddr, const string& ifname )
{
// Get interface address from supplied name.
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
byte pressure () { return _chanpress; }
byte poly_pressure (byte n) { return _polypress[n]; }
- byte last_note_on () {
+ byte last_note_on () {
return _last_note_on;
}
- byte last_on_velocity () {
+ byte last_on_velocity () {
return _last_on_velocity;
}
- byte last_note_off () {
+ byte last_note_off () {
return _last_note_off;
}
- byte last_off_velocity () {
+ byte last_off_velocity () {
return _last_off_velocity;
}
- pitchbend_t pitchbend () {
+ pitchbend_t pitchbend () {
return _pitch_bend;
}
- controller_value_t controller_value (byte n) {
+ controller_value_t controller_value (byte n) {
return _controller_val[n%128];
}
/*
- Copyright (C) 2007 Paul Davis
+ Copyright (C) 2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/** If this is not defined, all methods of MidiEvent are RT safe
* but MidiEvent will never deep copy and (depending on the scenario)
- * may not be usable in STL containers, signals, etc.
+ * may not be usable in STL containers, signals, etc.
*/
#define EVORAL_EVENT_ALLOC 1
/*
- Copyright (C) 1998-2010 Paul Barton-Davis
+ Copyright (C) 1998-2010 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
IPMIDIPort (int base_port = lowest_ipmidi_port_default, const std::string& ifname = std::string());
IPMIDIPort (const XMLNode&);
~IPMIDIPort ();
-
+
XMLNode& get_state () const;
void set_state (const XMLNode&);
-
+
int write (const byte *msg, size_t msglen, timestamp_t timestamp);
int read (byte *buf, size_t bufsize);
void parse (framecnt_t timestamp);
int sockin;
int sockout;
struct sockaddr_in addrout;
- Glib::Threads::Mutex write_lock;
+ Glib::Threads::Mutex write_lock;
bool open_sockets (int base_port, const std::string& ifname);
void close_sockets ();
#define LIBMIDIPP_API LIBMIDIPP_DLL_EXPORT
#else
#define LIBMIDIPP_API LIBMIDIPP_DLL_IMPORT
- #endif
+ #endif
#define LIBMIDIPP_LOCAL LIBMIDIPP_DLL_LOCAL
#endif
class PatchBank;
-class LIBMIDIPP_API Patch
+class LIBMIDIPP_API Patch
{
public:
typedef std::list<boost::shared_ptr<Patch> > PatchNameList;
-class LIBMIDIPP_API PatchBank
+class LIBMIDIPP_API PatchBank
{
public:
PatchBank (uint16_t n = 0, std::string a_name = std::string()) : _name(a_name), _number (n) {};
const PatchBanks& patch_banks() const { return _patch_banks; }
- bool available_for_channel(uint8_t channel) const {
- return _available_for_channels.find(channel) != _available_for_channels.end();
+ bool available_for_channel(uint8_t channel) const {
+ return _available_for_channels.find(channel) != _available_for_channels.end();
}
boost::shared_ptr<Patch> find_patch(const PatchPrimaryKey& key) {
if (i != _patch_list.begin()) {
--i;
return _patch_map[*i];
- }
+ }
}
}
std::string _name;
};
-class LIBMIDIPP_API NoteNameList
+class LIBMIDIPP_API NoteNameList
{
public:
typedef std::vector< boost::shared_ptr<Note> > Notes;
boost::shared_ptr<ValueNameList> _value_name_list; ///< Local, ValueNameList
};
-class LIBMIDIPP_API ControlNameList
+class LIBMIDIPP_API ControlNameList
{
public:
typedef std::map<uint16_t, boost::shared_ptr<Control> > Controls;
/// Note: channel here is 0-based while in the MIDNAM-file it's 1-based
const std::string& channel_name_set_name_by_channel(uint8_t channel) {
assert(channel <= 15);
- return _channel_name_set_assignments[channel];
+ return _channel_name_set_assignments[channel];
}
private:
/// array index = channel number
- /// string contents = name of channel name set
+ /// string contents = name of channel name set
std::string _name;
std::string _channel_name_set_assignments[16];
};
/*
- Copyright (C) 2000 Paul Barton-Davis
+ Copyright (C) 2000 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
class MachineControlCommand;
/** Class to handle incoming and outgoing MIDI machine control messages */
-class LIBMIDIPP_API MachineControl
+class LIBMIDIPP_API MachineControl
{
public:
typedef PBD::Signal1<void,MachineControl&> MMCSignal;
};
MachineControl ();
-
+
void set_ports (MIDI::Port* input, MIDI::Port* output);
Port* input_port() { return _input_port; }
status.
*/
- PBD::Signal3<void,MachineControl &,size_t,bool>
+ PBD::Signal3<void,MachineControl &,size_t,bool>
TrackRecordStatusChange;
/* The second argument specifies the desired track record enabled
status.
*/
- PBD::Signal3<void,MachineControl &,size_t,bool>
+ PBD::Signal3<void,MachineControl &,size_t,bool>
TrackMuteChange;
/* The second argument points to a byte array containing
/*
Copyright (C) 1998 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
*/
framecnt_t get_timestamp() const { return _timestamp; }
- void set_timestamp (const framecnt_t timestamp) { _timestamp = timestamp; }
+ void set_timestamp (const framecnt_t timestamp) { _timestamp = timestamp; }
/* signals that anyone can connect to */
size_t message_counter[256];
- enum ParseState {
+ enum ParseState {
NEEDSTATUS,
NEEDONEBYTE,
NEEDTWOBYTES,
/*
- Copyright (C) 1998-2010 Paul Barton-Davis
+ Copyright (C) 1998-2010 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/** block until the output FIFO used by non-process threads
* is empty, checking every @a check_interval_usecs usecs
* for current status. Not to be called by a thread that
- * executes any part of a JACK process callback (will
+ * executes any part of a JACK process callback (will
* simply return immediately in that situation).
*/
virtual void drain (int /* check_interval_usecs */) {}
*/
int midimsg (byte *msg, size_t len, timestamp_t timestamp) {
return !(write (msg, len, timestamp) == (int) len);
- }
+ }
virtual void parse (framecnt_t timestamp) = 0;
/* select(2)/poll(2)-based I/O */
/** Get the file descriptor for port.
- * @return File descriptor, or -1 if not selectable.
+ * @return File descriptor, or -1 if not selectable.
*/
virtual int selectable () const = 0;
- Channel *channel (channel_t chn) {
+ Channel *channel (channel_t chn) {
return _channel[chn&0x7F];
}
struct LIBMIDIPP_API PortSet {
PortSet (std::string str) : owner (str) { }
-
+
std::string owner;
std::list<XMLNode> ports;
};
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 1998 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
0
};
-MIDI::byte
+MIDI::byte
MIDI::decode_controller_name (const char *name)
{
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Port *port;
PortRequest midi_device;
-int
+int
setup_midi ()
{
if ((port = MIDI::Manager::instance()->add_port (midi_device)) == 0) {
info << "MIDI port is not valid" << endmsg;
return -1;
- }
+ }
return 0;
}
-main (int argc, char *argv[])
+main (int argc, char *argv[])
{
byte buf[1];
error << "cannot read byte"
<< endmsg;
break;
- }
+ }
}
}
}
}
-boost::shared_ptr<CustomDeviceMode>
+boost::shared_ptr<CustomDeviceMode>
MasterDeviceNames::custom_device_mode_by_name(const std::string& mode_name)
{
return _custom_device_modes[mode_name];
}
-boost::shared_ptr<ChannelNameSet>
+boost::shared_ptr<ChannelNameSet>
MasterDeviceNames::channel_name_set_by_channel(const std::string& mode, uint8_t channel)
{
boost::shared_ptr<CustomDeviceMode> cdm = custom_device_mode_by_name(mode);
return cns;
}
-boost::shared_ptr<Patch>
-MasterDeviceNames::find_patch(const std::string& mode, uint8_t channel, const PatchPrimaryKey& key)
+boost::shared_ptr<Patch>
+MasterDeviceNames::find_patch(const std::string& mode, uint8_t channel, const PatchPrimaryKey& key)
{
boost::shared_ptr<ChannelNameSet> cns = channel_name_set_by_channel(mode, channel);
if (!cns) return boost::shared_ptr<Patch>();
/*
- Copyright (C) 2000 Paul Barton-Davis
+ Copyright (C) 2000 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
#if 0
- cerr << "+++ MMC type "
+ cerr << "+++ MMC type "
<< hex
<< ((int) *mmc_msg)
<< dec
break;
}
- /* increase skiplen to cover the command byte and
+ /* increase skiplen to cover the command byte and
count byte (if it existed).
*/
bit 4: aux track b
the format of the message (its an MMC Masked Write) is:
-
+
0x41 Command Code
<count> byte count of following data
<name> byte value of the field being written
- <byte #> byte number of target byte in the
+ <byte #> byte number of target byte in the
bitmap being written to
<mask> ones in the mask indicate which bits will be changed
<data> new data for the byte being written
-
+
by the time this code is executing, msg[0] is the
byte number of the target byte. if its zero, we
are writing to a special byte in the standard
special. hence the bits for tracks 1 + 2 are bits
5 and 6 of the first byte of the track
bitmap. so:
-
- change track 1: msg[0] = 0; << first byte of track bitmap
+
+ change track 1: msg[0] = 0; << first byte of track bitmap
msg[1] = 0100000; << binary: bit 5 set
change track 2: msg[0] = 0; << first byte of track bitmap
TrackMuteChange (*this, base_track+n, val);
break;
}
- }
+ }
}
}
integral = ((sh & 0x7) << left_shift) | (sm >> (7 - left_shift));
fractional = ((sm << left_shift) << 7) | sl;
- shuttle_speed = integral +
+ shuttle_speed = integral +
((float)fractional / (1 << (14 - left_shift)));
Shuttle (*this, shuttle_speed, forward);
}
-MIDI::byte *
+MIDI::byte *
MachineControlCommand::fill_buffer (MachineControl* mmc, MIDI::byte* b) const
{
*b++ = 0xf0; // SysEx
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
MachineControl::CommandSignature cs;
MachineControl::ResponseSignature rs;
-int
+int
setup_midi ()
{
if ((port = MIDI::Manager::instance()->add_port (midi_device)) == 0) {
info << "MIDI port is not valid" << endmsg;
return -1;
- }
+ }
mmc = new MachineControl (*port, 0.0, cs, rs);
error << "cannot read byte"
<< endmsg;
break;
- }
+ }
}
}
{
int which_quarter_frame = (msg[1] & 0xf0) >> 4;
- /* Is it an expected frame?
- Remember, the first can be frame 7 or frame 0,
+ /* Is it an expected frame?
+ Remember, the first can be frame 7 or frame 0,
depending on the direction of the MTC generator ...
*/
#ifdef DEBUG_MTC
- cerr << "MTC: (state = " << _mtc_running << ") "
+ cerr << "MTC: (state = " << _mtc_running << ") "
<< which_quarter_frame << " vs. " << expected_mtc_quarter_frame_code
<< " consecutive ? " << consecutive_qtr_frame_cnt
<< endl;
cerr << "Send MTC status as " << _mtc_running << endl;
#endif
mtc_status (_mtc_running);
- }
+ }
switch (_mtc_running) {
case MTC_Forward:
consecutive_qtr_frame_cnt = 0;
#ifdef DEBUG_MTC
- cerr << "MTC: (state = " << _mtc_running << ") "
+ cerr << "MTC: (state = " << _mtc_running << ") "
<< which_quarter_frame << " vs. " << expected_mtc_quarter_frame_code << endl;
#endif
_qtr_mtc_time[3] |= msg[1] & 0xf;
break;
- case 7:
+ case 7:
/* last quarter frame msg has the MS bit of
the hour in bit 0, and the SMPTE FPS type
- in bits 5 and 6
+ in bits 5 and 6
*/
_qtr_mtc_time[3] |= ((msg[1] & 0x1) << 4);
abort(); /*NOTREACHED*/
break;
- }
+ }
#ifdef DEBUG_MTC
cerr << "Emit MTC Qtr\n";
/*
Copyright (C) 1998 Paul Barton-Davis
- This file was inspired by the MIDI parser for KeyKit by
- Tim Thompson.
-
+ This file was inspired by the MIDI parser for KeyKit by
+ Tim Thompson.
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
case MIDI::any:
return "any midi message";
-
+
case off:
return "note off";
-
+
case on:
return "note on";
-
+
case polypress:
return "aftertouch";
-
+
case MIDI::controller:
return "controller";
-
+
case program:
return "program change";
-
+
case chanpress:
return "channel pressure";
-
+
case MIDI::pitchbend:
return "pitch bend";
-
+
case MIDI::sysex:
return "system exclusive";
-
+
case MIDI::song:
return "song position";
-
+
case MIDI::tune:
return "tune";
-
+
case MIDI::eox:
return "end of sysex";
-
+
case MIDI::timing:
return "timing";
-
+
case MIDI::start:
return "start";
-
+
case MIDI::stop:
return "continue";
-
+
case MIDI::contineu:
return "stop";
-
+
case active:
return "active sense";
-
+
default:
return "unknow MIDI event type";
}
}
-Parser::Parser ()
+Parser::Parser ()
{
trace_stream = 0;
trace_prefix = "";
<< (int) msg[2]
<< endmsg;
break;
-
+
case polypress:
*o << trace_prefix
<< "Channel "
<< (int) msg[1]
<< endmsg;
break;
-
+
case MIDI::controller:
*o << trace_prefix
<< "Channel "
break;
case program:
- *o << trace_prefix
+ *o << trace_prefix
<< "Channel "
<< (msg[0]&0xF)+1
<< " Program Change ProgNum "
break;
case chanpress:
- *o << trace_prefix
+ *o << trace_prefix
<< "Channel "
<< (msg[0]&0xF)+1
<< " Channel Pressure "
<< (int) msg[1]
<< endmsg;
break;
-
+
case MIDI::pitchbend:
*o << trace_prefix
<< "Channel "
<< ((msg[2]<<7)|msg[1])
<< endmsg;
break;
-
+
case MIDI::sysex:
if (len == 1) {
switch (msg[0]) {
<< "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
<< endmsg;
break;
- }
+ }
} else {
*o << trace_prefix
<< "System Exclusive (" << len << ") = [ " << hex;
}
break;
-
+
case MIDI::song:
*o << trace_prefix << "Song" << endmsg;
break;
-
+
case MIDI::tune:
*o << trace_prefix << "Tune" << endmsg;
break;
-
+
case MIDI::eox:
*o << trace_prefix << "End-of-System Exclusive" << endmsg;
break;
-
+
case MIDI::timing:
*o << trace_prefix << "Timing" << endmsg;
break;
-
+
case MIDI::start:
*o << trace_prefix << "Start" << endmsg;
break;
-
+
case MIDI::stop:
*o << trace_prefix << "Stop" << endmsg;
break;
-
+
case MIDI::contineu:
*o << trace_prefix << "Continue" << endmsg;
break;
-
+
case active:
*o << trace_prefix << "Active Sense" << endmsg;
break;
-
+
default:
*o << trace_prefix << "Unrecognized MIDI message" << endmsg;
break;
// cerr << "parse: " << hex << (int) inbyte << dec << " state = " << state << " msgindex = " << msgindex << " runnable = " << runnable << endl;
- /* Check active sensing early, so it doesn't interrupt sysex.
-
+ /* Check active sensing early, so it doesn't interrupt sysex.
+
NOTE: active sense messages are not considered to fit under
"any" for the purposes of callbacks. If a caller wants
active sense messages handled, which is unlikely, then
/*
Real time messages can occur ANYPLACE,
- but do not interrupt running status.
+ but do not interrupt running status.
*/
bool rtmsg = false;
if (res.get_value_or (1) >= 0 && !_offline) {
realtime_msg (inbyte);
- }
+ }
return;
- }
+ }
statusbit = (inbyte & 0x80);
}
if (!_offline) {
any (*this, msgbuf, msgindex);
- }
+ }
}
}
}
/* We've completed a 1 or 2 byte message. */
edit_result = edit (msgbuf, msgindex);
-
+
if (edit_result.get_value_or (1)) {
/* message not cancelled by an editor */
}
if (runnable) {
- /* In Runnable mode, we reset the message
- index, but keep the callbacks_pending and state the
- same. This provides the "running status
+ /* In Runnable mode, we reset the message
+ index, but keep the callbacks_pending and state the
+ same. This provides the "running status
byte" feature.
*/
msgindex = 1;
break;
case 0xfe:
/* !!! active sense message in realtime_msg: should not reach here
- */
+ */
break;
case 0xff:
reset (*this);
{
last_status_byte = inbyte;
runnable = true; /* Channel messages can use running status */
-
+
/* The high 4 bits, which determine the type of channel message. */
-
+
switch (inbyte&0xF0) {
case 0x80:
msgtype = off;
break;
}
- // all these messages will be sent via any()
+ // all these messages will be sent via any()
// when they are complete.
// any (*this, &inbyte, 1);
}
-void
+void
Parser::signal (MIDI::byte *msg, size_t len)
{
channel_t chan = msg[0]&0xF;
case off:
channel_active_preparse[chan_i] (*this);
note_off (*this, (EventTwoBytes *) &msg[1]);
- channel_note_off[chan_i]
+ channel_note_off[chan_i]
(*this, (EventTwoBytes *) &msg[1]);
channel_active_postparse[chan_i] (*this);
break;
if (msg[2] == 0) {
note_off (*this, (EventTwoBytes *) &msg[1]);
- channel_note_off[chan_i]
+ channel_note_off[chan_i]
(*this, (EventTwoBytes *) &msg[1]);
} else {
note_on (*this, (EventTwoBytes *) &msg[1]);
- channel_note_on[chan_i]
+ channel_note_on[chan_i]
(*this, (EventTwoBytes *) &msg[1]);
}
case MIDI::controller:
channel_active_preparse[chan_i] (*this);
controller (*this, (EventTwoBytes *) &msg[1]);
- channel_controller[chan_i]
+ channel_controller[chan_i]
(*this, (EventTwoBytes *) &msg[1]);
channel_active_postparse[chan_i] (*this);
break;
case polypress:
channel_active_preparse[chan_i] (*this);
poly_pressure (*this, (EventTwoBytes *) &msg[1]);
- channel_poly_pressure[chan_i]
+ channel_poly_pressure[chan_i]
(*this, (EventTwoBytes *) &msg[1]);
channel_active_postparse[chan_i] (*this);
break;
/*
Copyright (C) 1998 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
}
}
-XMLNode&
+XMLNode&
Port::get_state () const
{
XMLNode* root = new XMLNode (state_node_name);
"Mono to Stereo Panner",
"http://ardour.org/plugin/panner_1in2out",
"http://ardour.org/plugin/panner_1in2out#ui",
- 1, 2,
+ 1, 2,
10000,
Panner1in2out::factory
};
_pannable->pan_azimuth_control->set_value (0.5);
}
}
-
+
update ();
left = desired_left;
return make_pair (0, 1);
}
-double
+double
Panner1in2out::position () const
{
return _pannable->pan_azimuth_control->get_value ();
pan_t pan;
Sample* const src = srcbuf.data();
-
+
/* LEFT OUTPUT */
dst = obufs.get_audio(0).data();
/* pan is 1 so we can just copy the input samples straight in */
mix_buffers_no_gain(dst,src,nframes);
-
+
/* XXX it would be nice to mark that we wrote into the buffer */
}
}
/* note that are overwriting buffers, but its OK
because we're finished with their old contents
(position automation data) and are
- replacing it with panning/gain coefficients
+ replacing it with panning/gain coefficients
that we need to actually process the data.
*/
-
+
buffers[0][n] = panL * (scale * panL + 1.0f - scale);
buffers[1][n] = panR * (scale * panR + 1.0f - scale);
}
}
-std::set<Evoral::Parameter>
+std::set<Evoral::Parameter>
Panner1in2out::what_can_be_automated() const
{
set<Evoral::Parameter> s;
}
}
-string
+string
Panner1in2out::value_as_string (boost::shared_ptr<AutomationControl> ac) const
{
/* DO NOT USE LocaleGuard HERE */
switch (ac->parameter().type()) {
case PanAzimuthAutomation:
/* We show the position of the center of the image relative to the left & right.
- This is expressed as a pair of percentage values that ranges from (100,0)
+ This is expressed as a pair of percentage values that ranges from (100,0)
(hard left) through (50,50) (hard center) to (0,100) (hard right).
-
+
This is pretty wierd, but its the way audio engineers expect it. Just remember that
the center of the USA isn't Kansas, its (50LA, 50NY) and it will all make sense.
panner GUIs can do their own version of this if they need
something less compact.
*/
-
+
return string_compose (_("L%1R%2"), (int) rint (100.0 * (1.0 - val)),
(int) rint (100.0 * val));
-
+
default:
return _("unused");
}
set_width(w > 0 ? wrange : -wrange);
}
-
+
update ();
-
+
/* LEFT SIGNAL */
left_interp[0] = left[0] = desired_left[0];
- right_interp[0] = right[0] = desired_right[0];
-
+ right_interp[0] = right[0] = desired_right[0];
+
/* RIGHT SIGNAL */
left_interp[1] = left[1] = desired_left[1];
right_interp[1] = right[1] = desired_right[1];
-
+
_pannable->pan_azimuth_control->Changed.connect_same_thread (*this, boost::bind (&Panner2in2out::update, this));
_pannable->pan_width_control->Changed.connect_same_thread (*this, boost::bind (&Panner2in2out::update, this));
}
{
}
-double
+double
Panner2in2out::position () const
{
return _pannable->pan_azimuth_control->get_value();
}
-double
+double
Panner2in2out::width () const
{
return _pannable->pan_width_control->get_value();
/* it would be very nice to split this out into a virtual function
that can be accessed from BaseStereoPanner and used in do_distribute_automated().
-
+
but the place where its used in do_distribute_automated() is a tight inner loop,
and making "nframes" virtual function calls to compute values is an absurd
overhead.
*/
-
+
/* x == 0 => hard left = 180.0 degrees
x == 1 => hard right = 0.0 degrees
*/
-
+
float pos[2];
double width = this->width ();
const double direction_as_lr_fract = position ();
pos[1] = direction_as_lr_fract + (width/2.0); // right signal lr_fract
pos[0] = direction_as_lr_fract - (width/2.0); // left signal lr_fract
}
-
+
/* compute target gain coefficients for both input signals */
-
+
float const pan_law_attenuation = -3.0f;
float const scale = 2.0f - 4.0f * powf (10.0f,pan_law_attenuation/20.0f);
float panR;
float panL;
-
+
/* left signal */
-
+
panR = pos[0];
panL = 1 - panR;
desired_left[0] = panL * (scale * panL + 1.0f - scale);
desired_right[0] = panR * (scale * panR + 1.0f - scale);
-
+
/* right signal */
-
+
panR = pos[1];
panL = 1 - panR;
desired_left[1] = panL * (scale * panL + 1.0f - scale);
}
/* if the new left position is less than or equal to zero (hard left) and the left panner
- is already there, we're not moving the left signal.
+ is already there, we're not moving the left signal.
*/
-
+
if (l_pos < 0.0) {
return false;
}
/* if the new right position is less than or equal to 1.0 (hard right) and the right panner
- is already there, we're not moving the right signal.
+ is already there, we're not moving the right signal.
*/
-
+
if (r_pos > 1.0) {
return false;
-
+
}
return true;
pan_t pan;
Sample* const src = srcbuf.data();
-
+
/* LEFT OUTPUT */
dst = obufs.get_audio(0).data();
/* pan is 1 so we can just copy the input samples straight in */
mix_buffers_no_gain(dst,src,nframes);
-
+
/* XXX it would be nice to mark that we wrote into the buffer */
}
}
float panR;
- if (which == 0) {
+ if (which == 0) {
// panning left signal
panR = position[n] - (width[n]/2.0f); // center - width/2
} else {
/* note that are overwriting buffers, but its OK
because we're finished with their old contents
(position/width automation data) and are
- replacing it with panning/gain coefficients
+ replacing it with panning/gain coefficients
that we need to actually process the data.
*/
-
+
buffers[0][n] = panL * (scale * panL + 1.0f - scale);
buffers[1][n] = panR * (scale * panR + 1.0f - scale);
}
return root;
}
-std::set<Evoral::Parameter>
+std::set<Evoral::Parameter>
Panner2in2out::what_can_be_automated() const
{
set<Evoral::Parameter> s;
}
}
-string
+string
Panner2in2out::value_as_string (boost::shared_ptr<AutomationControl> ac) const
{
/* DO NOT USE LocaleGuard HERE */
switch (ac->parameter().type()) {
case PanAzimuthAutomation:
/* We show the position of the center of the image relative to the left & right.
- This is expressed as a pair of percentage values that ranges from (100,0)
+ This is expressed as a pair of percentage values that ranges from (100,0)
(hard left) through (50,50) (hard center) to (0,100) (hard right).
-
+
This is pretty wierd, but its the way audio engineers expect it. Just remember that
the center of the USA isn't Kansas, its (50LA, 50NY) and it will all make sense.
-
+
This is designed to be as narrow as possible. Dedicated
panner GUIs can do their own version of this if they need
something less compact.
*/
-
+
return string_compose (_("L%1R%2"), (int) rint (100.0 * (1.0 - val)),
(int) rint (100.0 * val));
case PanWidthAutomation:
return string_compose (_("Width: %1%%"), (int) floor (100.0 * val));
-
+
default:
return _("unused");
}
private:
bool clamp_stereo_pan (double& direction_as_lr_fract, double& width);
-
+
void distribute_one (AudioBuffer& srcbuf, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes, uint32_t which);
void distribute_one_automated (AudioBuffer& srcbuf, BufferSet& obufs,
framepos_t start, framepos_t end, pframes_t nframes,
Pannerbalance::factory
};
-extern "C" ARDOURPANNER_API PanPluginDescriptor* panner_descriptor () { return &_descriptor; }
+extern "C" ARDOURPANNER_API PanPluginDescriptor* panner_descriptor () { return &_descriptor; }
Pannerbalance::Pannerbalance (boost::shared_ptr<Pannable> p)
: Panner (p)
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
VBAPanner::Signal::resize_gains (uint32_t n)
{
gains.assign (n, 0.0);
-}
+}
VBAPanner::VBAPanner (boost::shared_ptr<Pannable> p, boost::shared_ptr<Speakers> s)
: Panner (p)
for (uint32_t i = 0; i < n; ++i) {
Signal* s = new Signal (_pannable->session(), *this, i, _speakers->n_speakers());
_signals.push_back (s);
-
+
}
update ();
double signal_direction = 1.0 - (_pannable->pan_azimuth_control->get_value() + (w/2));
double grd_step_per_signal = w / (_signals.size() - 1);
for (vector<Signal*>::iterator s = _signals.begin(); s != _signals.end(); ++s) {
-
+
Signal* signal = *s;
int over = signal_direction;
SignalPositionChanged(); /* emit */
}
-void
-VBAPanner::compute_gains (double gains[3], int speaker_ids[3], int azi, int ele)
+void
+VBAPanner::compute_gains (double gains[3], int speaker_ids[3], int azi, int ele)
{
/* calculates gain factors using loudspeaker setup and given direction */
double cartdir[3];
const int dimension = _speakers->dimension();
assert(dimension == 2 || dimension == 3);
- spherical_to_cartesian (azi, ele, 1.0, cartdir[0], cartdir[1], cartdir[2]);
+ spherical_to_cartesian (azi, ele, 1.0, cartdir[0], cartdir[1], cartdir[2]);
big_sm_g = -100000.0;
gains[0] = gains[1] = gains[2] = 0;
big_sm_g = small_g;
- gains[0] = gtmp[0];
- gains[1] = gtmp[1];
+ gains[0] = gtmp[0];
+ gains[1] = gtmp[1];
speaker_ids[0] = _speakers->speaker_for_tuple (i, 0);
speaker_ids[1] = _speakers->speaker_for_tuple (i, 1);
}
}
}
-
+
power = sqrt (gains[0]*gains[0] + gains[1]*gains[1] + gains[2]*gains[2]);
if (power > 0) {
- gains[0] /= power;
+ gains[0] /= power;
gains[1] /= power;
gains[2] /= power;
}
assert (sz == obufs.count().n_audio());
int8_t *outputs = (int8_t*)alloca(sz); // on the stack, no malloc
-
+
/* set initial state of each output "record"
*/
if (signal->outputs[o] != -1) {
/* used last time */
outputs[signal->outputs[o]] |= 1;
- }
+ }
if (signal->desired_outputs[o] != -1) {
/* used this time */
outputs[signal->desired_outputs[o]] |= 1<<1;
- }
+ }
}
/* at this point, we can test a speaker's status:
(*outputs[o] & 2) <= in use this time
(*outputs[o] & 3) == 3 <= in use both times
*outputs[o] == 0 <= not in use either time
-
+
*/
for (int o = 0; o < 3; ++o) {
pan = gain_coefficient * signal->desired_gains[o];
if (pan == 0.0 && signal->gains[output] == 0.0) {
-
+
/* nothing deing delivered to this output */
signal->gains[output] = 0.0;
-
+
} else if (fabs (pan - signal->gains[output]) > 0.00001) {
-
- /* signal to this output but the gain coefficient has changed, so
+
+ /* signal to this output but the gain coefficient has changed, so
interpolate between them.
*/
signal->gains[output] = pan;
} else {
-
+
/* signal to this output, same gain as before so just copy with gain
*/
-
+
mix_buffers_with_gain (obufs.get_audio (output).data(),src,nframes,pan);
signal->gains[output] = pan;
}
*/
}
-void
+void
VBAPanner::distribute_one_automated (AudioBuffer& /*src*/, BufferSet& /*obufs*/,
- framepos_t /*start*/, framepos_t /*end*/,
+ framepos_t /*start*/, framepos_t /*end*/,
pframes_t /*nframes*/, pan_t** /*buffers*/, uint32_t /*which*/)
{
/* XXX to be implemented */
return ChanCount (DataType::AUDIO, _speakers->n_speakers());
}
-std::set<Evoral::Parameter>
+std::set<Evoral::Parameter>
VBAPanner::what_can_be_automated() const
{
set<Evoral::Parameter> s;
}
return s;
}
-
+
string
VBAPanner::describe_parameter (Evoral::Parameter p)
{
}
}
-string
+string
VBAPanner::value_as_string (boost::shared_ptr<AutomationControl> ac) const
{
/* DO NOT USE LocaleGuard HERE */
switch (ac->parameter().type()) {
case PanAzimuthAutomation: /* direction */
return string_compose (_("%1\u00B0"), (int (rint (val * 360.0))+180)%360);
-
+
case PanWidthAutomation: /* diffusion */
return string_compose (_("%1%%"), (int) floor (100.0 * fabs(val)));
case PanElevationAutomation: /* elevation */
return string_compose (_("%1\u00B0"), (int) floor (90.0 * fabs(val)));
-
+
default:
return _("unused");
}
}
boost::shared_ptr<Speakers>
-VBAPanner::get_speakers () const
+VBAPanner::get_speakers () const
{
return _speakers->parent();
}
class Speakers;
class Pannable;
-class VBAPanner : public Panner
-{
+class VBAPanner : public Panner
+{
public:
VBAPanner (boost::shared_ptr<Pannable>, boost::shared_ptr<Speakers>);
~VBAPanner ();
std::vector<Signal*> _signals;
boost::shared_ptr<VBAPSpeakers> _speakers;
-
+
void compute_gains (double g[3], int ls[3], int azi, int ele);
void update ();
void clear_signals ();
void distribute_one (AudioBuffer& src, BufferSet& obufs, gain_t gain_coeff, pframes_t nframes, uint32_t which);
void distribute_one_automated (AudioBuffer& src, BufferSet& obufs,
- framepos_t start, framepos_t end, pframes_t nframes,
+ framepos_t start, framepos_t end, pframes_t nframes,
pan_t** buffers, uint32_t which);
};
private:
static const double MIN_VOL_P_SIDE_LGTH;
- int _dimension;
+ int _dimension;
boost::shared_ptr<Speakers> _parent;
std::vector<Speaker> _speakers;
PBD::ScopedConnection speaker_connection;
struct threeDmatrix : public dvector {
threeDmatrix() : dvector (9, 0.0) {}
};
-
+
struct tmatrix : public dvector {
tmatrix() : dvector (3, 0.0) {}
};
void choose_speaker_pairs ();
void sort_2D_lss (int* sorted_lss);
int calc_2D_inv_tmatrix (double azi1,double azi2, double* inv_mat);
-
+
};
} /* namespace */
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
From an idea by Carl Hetherington.
This program is free software; you can redistribute it and/or modify
std::ostream& operator<< (std::ostream& str, const Backtrace& bt) { return bt.print (str); }
-Backtrace::Backtrace()
-{
+Backtrace::Backtrace()
+{
#ifdef HAVE_EXECINFO
size = ::backtrace (trace, 200);
#endif
return str;
}
-struct BTPair {
+struct BTPair {
Backtrace* ref;
Backtrace* rel;
return str;
}
-struct SPDebug {
+struct SPDebug {
Backtrace* constructor;
Backtrace* destructor;
-
+
SPDebug (Backtrace* c) : constructor (c), destructor (0) {}
~SPDebug () {
delete constructor;
using namespace std;
static PointerMap* _sptrs;
-PointerMap& sptrs() {
+PointerMap& sptrs() {
if (_sptrs == 0) {
_sptrs = new PointerMap;
}
}
static IPointerMap* _interesting_pointers;
-IPointerMap& interesting_pointers() {
+IPointerMap& interesting_pointers() {
if (_interesting_pointers == 0) {
_interesting_pointers = new IPointerMap;
}
if (is_interesting_object (old_obj)) {
if (debug_out) {
- cerr << "\tlost old sp @ " << sp << " for " << old_obj << " UC = " << old_use_count << " now for " << obj << " UC = " << new_use_count
+ cerr << "\tlost old sp @ " << sp << " for " << old_obj << " UC = " << old_use_count << " now for " << obj << " UC = " << new_use_count
<< " (total sp's = " << sptrs().size() << ')' << endl;
}
PointerMap::iterator x = sptrs().find (sp);
sptrs().insert (newpair);
if (debug_out) {
- cerr << "assignment created sp for " << obj << " @ " << sp << " used to point to " << old_obj << " UC = " << old_use_count
- << " UC = " << new_use_count
+ cerr << "assignment created sp for " << obj << " @ " << sp << " used to point to " << old_obj << " UC = " << old_use_count
+ << " UC = " << new_use_count
<< " (total sp's = " << sptrs().size() << ')' << endl;
cerr << *newpair.second << endl;
}
- }
+ }
}
void
if (is_interesting_object (old_obj)) {
if (debug_out) {
- cerr << "\tlost old sp @ " << sp << " for " << old_obj << " UC = " << old_use_count << " now for " << obj << " UC = " << new_use_count
+ cerr << "\tlost old sp @ " << sp << " for " << old_obj << " UC = " << old_use_count << " now for " << obj << " UC = " << new_use_count
<< " (total sp's = " << sptrs().size() << ')' << endl;
}
PointerMap::iterator x = sptrs().find (sp);
sptrs().insert (newpair);
if (debug_out) {
- cerr << "reset created sp for " << obj << " @ " << sp << " used to point to " << old_obj << " UC = " << old_use_count
- << " UC = " << new_use_count
+ cerr << "reset created sp for " << obj << " @ " << sp << " used to point to " << old_obj << " UC = " << old_use_count
+ << " UC = " << new_use_count
<< " (total sp's = " << sptrs().size() << ')' << endl;
cerr << *newpair.second << endl;
}
- }
+ }
}
void
{
}
-void sp_counter_release_hook (void* /*pn*/, long /*use_count*/)
+void sp_counter_release_hook (void* /*pn*/, long /*use_count*/)
{
}
/* convert from cylindrical coordinates in degrees to cartesian */
static const double atorad = 2.0 * M_PI / 360.0 ;
-
+
if (len == 0.0) {
len = 1.0;
}
z = len * sin (ele * atorad);
}
-void
+void
PBD::cartesian_to_spherical (double x, double y, double z, double& azimuth, double& elevation, double& length)
{
/* converts cartesian coordinates to cylindrical in degrees*/
} else {
elevation = 180.0 * (phi / M_PI);
}
-
+
length = rho;
}
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
if (sscanf (prop->value().c_str(), "%f", &val) == 1) {
set_value (val);
- }
+ }
}
return 0;
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
{
if (n < _target.size()) {
return _target[n];
- }
+ }
return 0;
}
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <cmath>
#include <algorithm>
-#include <string>
+#include <string>
#include <stdint.h>
#include <stdlib.h>
return v;
}
-static int32_t
-int_from_hex (char hic, char loc)
+static int32_t
+int_from_hex (char hic, char loc)
{
int hi; /* hi byte */
int lo; /* low byte */
return duration_str;
}
-static bool
+static bool
chars_equal_ignore_case(char x, char y)
{
/* app should have called setlocale() if its wants this comparison to be
return toupper (x) == toupper (y);
}
-bool
+bool
strings_equal_ignore_case (const string& a, const string& b)
{
if (a.length() == b.length()) {
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "crossthread.win.cc"
#endif
-gboolean
+gboolean
cross_thread_channel_call_receive_slot (GIOChannel*, GIOCondition condition, void *data)
{
CrossThreadChannel* ctc = static_cast<CrossThreadChannel*>(data);
if (fds[0] >= 0) {
close (fds[0]);
fds[0] = -1;
- }
+ }
if (fds[1] >= 0) {
close (fds[1]);
fds[1] = -1;
- }
+ }
}
void
return false;
}
-int
+int
CrossThreadChannel::receive (char& msg, bool wait)
{
if (wait) {
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
CrossThreadChannel::CrossThreadChannel (bool non_blocking)
- : receive_channel (0)
+ : receive_channel (0)
, receive_source (0)
, receive_slot ()
, send_socket()
send_address.sin_family = AF_INET;
send_address.sin_addr.s_addr = inet_addr("127.0.0.1");
send_address.sin_port = htons(0);
- int status = bind(send_socket, (SOCKADDR*)&send_address,
+ int status = bind(send_socket, (SOCKADDR*)&send_address,
sizeof(send_address));
if (status != 0) {
recv_address.sin_family = AF_INET;
recv_address.sin_addr.s_addr = inet_addr("127.0.0.1");
recv_address.sin_port = htons(0);
- status = bind(receive_socket, (SOCKADDR*)&recv_address,
+ status = bind(receive_socket, (SOCKADDR*)&recv_address,
sizeof(recv_address));
-
+
if (status != 0) {
std::cerr << "CrossThreadChannel::CrossThreadChannel() Receive socket binding failed with error: " << WSAGetLastError() << std::endl;
return;
// get assigned port number for Receive Socket
int recv_addr_len = sizeof(recv_address);
status = getsockname(receive_socket, (SOCKADDR*)&recv_address, &recv_addr_len);
-
+
if (status != 0) {
std::cerr << "CrossThreadChannel::CrossThreadChannel() Setting receive socket address to local failed with error: " << WSAGetLastError() << std::endl;
return;
return false;
}
-int
+int
CrossThreadChannel::receive (char& msg, bool wait)
{
gsize read = 0;
PBD::list_debug_options ()
{
cout << _("The following debug options are available. Separate multiple options with commas.\nNames are case-insensitive and can be abbreviated.") << endl << endl;
- cout << '\t' << X_("all") << endl;
+ cout << '\t' << X_("all") << endl;
vector<string> options;
using namespace std;
void
-setup_libpbd_enums ()
+setup_libpbd_enums ()
{
EnumWriter& enum_writer (EnumWriter::instance());
vector<int> i;
-/*
+/*
Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it and/or modify
EnumWriter* EnumWriter::_instance = 0;
map<string,string> EnumWriter::hack_table;
-static int
-nocase_cmp(const string & s1, const string& s2)
+static int
+nocase_cmp(const string & s1, const string& s2)
{
string::const_iterator it1 = s1.begin();
string::const_iterator it2 = s2.begin();
- while ((it1 != s1.end()) && (it2 != s2.end())) {
+ while ((it1 != s1.end()) && (it2 != s2.end())) {
if(::toupper(*it1) != ::toupper(*it2)) {//letters differ?
// return -1 to indicate 'smaller than', 1 otherwise
- return (::toupper(*it1) < ::toupper(*it2)) ? -1 : 1;
+ return (::toupper(*it1) < ::toupper(*it2)) ? -1 : 1;
}
++it1;
}
EnumWriter&
-EnumWriter::instance()
+EnumWriter::instance()
{
if (_instance == 0) {
_instance = new EnumWriter;
- }
+ }
return *_instance;
}
if (value & (*i)) {
if (!result.empty()) {
result += ',';
- }
+ }
result += (*s);
}
}
vector<int>::iterator i;
string enum_name = _("unknown enumeration");
-
+
for (Registry::const_iterator x = registry.begin(); x != registry.end(); ++x) {
if (&er == &(*x).second) {
enum_name = (*x).first;
}
}
-
+
for (i = er.values.begin(); i != er.values.end(); ++i) {
if (*i == val) {
return val;
}
}
-
+
warning << string_compose (_("Illegal value loaded for %1 (%2) - %3 used instead"),
- enum_name, val, er.names.front())
+ enum_name, val, er.names.front())
<< endmsg;
return er.values.front();
}
/*
- Copyright (C) 2010 Paul Davis
+ Copyright (C) 2010 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
e.clear ();
if (!_envname.empty()) {
-
+
/* fetch environment from named environment variable, rather than "environ"
*/
if (!estr) {
return;
}
-
- /* parse line by line, and save into "e"
+
+ /* parse line by line, and save into "e"
*/
vector<string> lines;
string estring = *i;
string::size_type equal = estring.find_first_of ('=');
-
+
if (equal == string::npos) {
/* say what? an environ value without = ? */
continue;
}
-
+
string before = estring.substr (0, equal);
string after = estring.substr (equal+1);
-
+
e.insert (pair<string,string>(before,after));
}
-
+
} else {
/* fetch environment from "environ"
*/
for (size_t i = 0; environ[i]; ++i) {
-
+
string estring = environ[i];
string::size_type equal = estring.find_first_of ('=');
-
+
if (equal == string::npos) {
/* say what? an environ value without = ? */
continue;
}
-
+
string before = estring.substr (0, equal);
string after = estring.substr (equal+1);
-
+
e.insert (pair<string,string>(before,after));
}
}
-}
+}
void
EnvironmentalProtectionAgency::restore () const
{
for (map<string,string>::const_iterator i = e.begin(); i != e.end(); ++i) {
g_setenv (i->first.c_str(), i->second.c_str(), 1);
}
-}
+}
void
EnvironmentalProtectionAgency::clear () const
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
static void do_not_delete_the_loop_pointer (void*) { }
-Glib::Threads::Private<EventLoop> EventLoop::thread_event_loop (do_not_delete_the_loop_pointer);
+Glib::Threads::Private<EventLoop> EventLoop::thread_event_loop (do_not_delete_the_loop_pointer);
-EventLoop*
+EventLoop*
EventLoop::get_event_loop_for_thread() {
return thread_event_loop.get ();
}
-void
-EventLoop::set_event_loop_for_thread (EventLoop* loop)
+void
+EventLoop::set_event_loop_for_thread (EventLoop* loop)
{
thread_event_loop.set (loop);
}
-void*
+void*
EventLoop::invalidate_request (void* data)
{
InvalidationRecord* ir = (InvalidationRecord*) data;
/* Some of the requests queued with an EventLoop may involve functors
* that make method calls to objects whose lifetime is shorter
* than the EventLoop's. We do not want to make those calls if the
- * object involve has been destroyed. To prevent this, we
+ * object involve has been destroyed. To prevent this, we
* provide a way to invalidate those requests when the object is
* destroyed.
*
*
* The object is currently being destroyed and so we want to
* mark all requests involving this object that are queued with
- * any EventLoop as invalid.
+ * any EventLoop as invalid.
*
* As of April 2012, we are usign sigc::trackable as the base object
* used to queue calls to ::invalidate_request() to be made upon
(*i)->invalidation = 0;
}
delete ir;
- }
+ }
return 0;
}
/*
- Copyright (C) 2013 Tim Mayberry
+ Copyright (C) 2013 Tim Mayberry
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
{
if (Glib::file_test (path, Glib::FILE_TEST_IS_REGULAR)) {
return g_unlink (path.c_str());
- }
+ }
PBD::ScopedFileDescriptor fd = g_open (path.c_str(), O_CREAT|O_TRUNC|O_RDWR, 0666);
return !((int) fd >= 0);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
"%ebx",
#endif
"%ecx", "%edx");
-
+
regs[0] = eax;
regs[1] = ebx;
regs[2] = ecx;
// N.B. The following would probably work for a pre-VC10 build,
// although it might suffer from optimization issues. We'd need
// to place this function into its own (unoptimized) source file.
- __asm {
+ __asm {
mov ecx, [xcr]
__asm _emit 0x0f __asm _emit 0x01 __asm _emit 0xd0 /*xgetbv*/
}
if (mxcsr_mask & (1<<6)) {
_flags = Flags (_flags | HasDenormalsAreZero);
- }
+ }
#if !defined HAVE_POSIX_MEMALIGN && defined PLATFORM_WINDOWS
_aligned_free (*fxbuf);
}
cpu_brand.assign(cpu_string, cpu_string_ptr - cpu_string);
info << string_compose (_("CPU brand: %1"), cpu_brand) << endmsg;
- }
+ }
}
#endif /* !ARCH_X86 */
}
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* context.
*/
-void
+void
MD5::Update(uint8_t const *input, size_t inputLen)
{
unsigned int i, index, partLen;
// the message digest and zeroizing the context.
// Writes to digestRaw
-void
+void
MD5::Final()
{
uint8_t bits[8];
writeToString();
}
-/// Buffer must be 32+1 (nul) = 33 chars long at least
-void
+/// Buffer must be 32+1 (nul) = 33 chars long at least
+void
MD5::writeToString()
{
int pos;
/// Load a file from disk and digest it
// Digests a file and returns the result.
-char*
+char*
MD5::digestFile (char *filename)
{
Init();
}
/// Digests a byte-array already in memory
-char*
+char*
MD5::digestMemory (uint8_t const * memchunk, size_t len)
{
Init ();
Update (memchunk, len);
Final ();
-
+
return digestChars;
}
// Digests a string and prints the result.
-char*
+char*
MD5::digestString (char const * string)
{
Init ();
return digestChars;
}
-void
+void
MD5::Transform (uint32_t state[4], uint8_t const * block)
{
uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
/* Encodes input (uint32_t) into output (unsigned char). Assumes len is
* a multiple of 4.
*/
-void
+void
MD5::Encode (uint8_t *output, uint32_t const * input, size_t len)
{
size_t i, j;
* a multiple of 4.
*/
-void
+void
MD5::Decode (uint32_t *output, uint8_t const * input, size_t len)
{
size_t i, j;
/*
- Copyright (C) 2002 Paul Davis
+ Copyright (C) 2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
n = 0;
matchlen = 0;
- /* note: strcmp's semantics are not
+ /* note: strcmp's semantics are not
strict enough to use for this.
*/
const char *cpath = path.c_str();
char best[PATH_MAX+1];
- /* From the manpage, under "BUGS" : "The memory allocated by getmntinfo() cannot be free(3)'d by the
+ /* From the manpage, under "BUGS" : "The memory allocated by getmntinfo() cannot be free(3)'d by the
application."
-
+
Thus: we do NOT try to free memory allocated by getmntinfo()
*/
unsigned int n = 0;
matchlen = 0;
- /* note: strcmp's semantics are not
+ /* note: strcmp's semantics are not
strict enough to use for this.
*/
__END_DECLS
#endif
-
+
#endif /* !_GETOPT_H_ */
b = c;
c = a % b;
}
-
+
return b;
}
place = EMSG;
if (IN_ORDER) {
/*
- * GNU extension:
+ * GNU extension:
* return non-option as argument to option 1
*/
optarg = nargv[optind++];
}
if (optchar == 'W' && oli[1] == ';') { /* -W long-option */
/* XXX: what if no long options provided (called by getopt)? */
- if (*place)
+ if (*place)
return -2;
if (++optind >= nargc) { /* no arg */
has_equal++;
} else
current_argv_len = strlen(current_argv);
-
+
for (i = 0; long_options[i].name; i++) {
/* find matching long option */
if (strncmp(current_argv, long_options[i].name,
if (long_options[match].flag) {
*long_options[match].flag = long_options[match].val;
retval = 0;
- } else
+ } else
retval = long_options[match].val;
if (idx)
*idx = match;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
}
bool
-PBD::open_uri (const std::string& uri)
+PBD::open_uri (const std::string& uri)
{
return open_uri (uri.c_str());
}
* On Failure: 0 (NULL)
*/
-static char*
+static char*
realpath (const char *original_path, char resolved_path[_MAX_PATH+1])
{
char *rpath = 0;
return path;
}
- while (true) {
+ while (true) {
if (regexec (&compiled_pattern, path.c_str(), nmatches, matches, 0)) {
break;
}
/* go back and do it again with whatever remains after the
- * substitution
+ * substitution
*/
}
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
using namespace std;
-template<typename RequestBuffer> void
+template<typename RequestBuffer> void
cleanup_request_buffer (void* ptr)
{
RequestBuffer* rb = (RequestBuffer*) ptr;
* allocated dies. That could be before or after the end of the UI
* event loop for which this request buffer provides communication.
*
- * We are not modifying the UI's thread/buffer map, just marking it
+ * We are not modifying the UI's thread/buffer map, just marking it
* dead. If the UI is currently processing the buffers and misses
* this "dead" signal, it will find it the next time it receives
* a request. If the UI has finished processing requests, then
* we will leak this buffer object.
*/
-
+
rb->dead = true;
}
{
void (AbstractUI<RequestObject>::*pmf)(string,pthread_t,string,uint32_t) = &AbstractUI<RequestObject>::register_thread;
- /* better to make this connect a handler that runs in the UI event loop but the syntax seems hard, and
+ /* better to make this connect a handler that runs in the UI event loop but the syntax seems hard, and
register_thread() is thread safe anyway.
*/
/* add the new request queue (ringbuffer) to our map
so that we can iterate over it when the time is right.
This step is not RT-safe, but is assumed to be called
- only at thread initialization time, not repeatedly,
+ only at thread initialization time, not repeatedly,
and so this is of little consequence.
*/
Glib::Threads::Mutex::Lock lm (request_buffer_map_lock);
request_buffers[thread_id] = b;
}
- /* set this thread's per_thread_request_buffer to this new
+ /* set this thread's per_thread_request_buffer to this new
queue/ringbuffer. remember that only this thread will
get this queue when it calls per_thread_request_buffer.get()
for (i = request_buffers.begin(); i != request_buffers.end(); ++i) {
while (true) {
-
+
/* we must process requests 1 by 1 because
the request may run a recursive main
event loop that will itself call
is even remotely consistent with
the condition before we called it.
*/
-
+
i->second->get_read_vector (&vec);
-
+
if (vec.len[0] == 0) {
break;
} else {
delete vec.buf[0];
i->second->increment_read_ptr (1);
}
- }
+ }
}
}
/* We need to use this lock, because its the one
returned by slot_invalidation_mutex() and protects
- against request invalidation.
+ against request invalidation.
*/
request_buffer_map_lock.lock ();
/* at this point, an object involved in a functor could be
* deleted before we actually execute the functor. so there is
* a race condition that makes the invalidation architecture
- * somewhat pointless.
+ * somewhat pointless.
*
* really, we should only allow functors containing shared_ptr
* references to objects to enter into the request queue.
request_buffer_map_lock.unlock ();
/* unlock the request lock while we execute the request, so
- * that we don't needlessly block other threads (note: not RT
+ * that we don't needlessly block other threads (note: not RT
* threads since they have their own queue) from making requests.
*/
req->the_slot = f;
/* the invalidation record is an object which will carry out
- * invalidation of any requests associated with it when it is
+ * invalidation of any requests associated with it when it is
* destroyed. it can be null. if its not null, associate this
* request with the invalidation record. this allows us to
* "cancel" requests submitted to the UI because they involved
/*
- Copyright (C) 1998-2009 Paul Davis
+ Copyright (C) 1998-2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* We have a special case in libpbd of a template class that gets instantiated
* as the base class of several classes in other libraries. It is not possible
- * to use LIBFOO_API to mark this visible, because the FOO in each case is
+ * to use LIBFOO_API to mark this visible, because the FOO in each case is
* different. So we define this generic visible/export/hidden/import pair
* of macros to try to deal with this special case. These should NEVER be
* used anywhere except AbstractUI<T> (or similar cases if they arise.
#define ABSTRACT_UI_API LIBPBD_DLL_EXPORT
#else
#define ABSTRACT_UI_API LIBPBD_DLL_IMPORT
-#endif
+#endif
class Touchable;
struct RequestBuffer : public PBD::RingBufferNPT<RequestObject> {
bool dead;
AbstractUI<RequestObject>& ui;
- RequestBuffer (uint32_t size, AbstractUI<RequestObject>& uir)
+ RequestBuffer (uint32_t size, AbstractUI<RequestObject>& uir)
: PBD::RingBufferNPT<RequestObject> (size)
- , dead (false)
+ , dead (false)
, ui (uir) {}
};
typedef typename RequestBuffer::rw_vector RequestBufferVector;
/*
- Copyright (C) 2000-2009 Paul Davis
+ Copyright (C) 2000-2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* events/requests and dispatch/process them as they arrive.
*
* This implementation starts up a thread that runs a Glib main loop
- * to wait on events/requests etc.
+ * to wait on events/requests etc.
*/
static RequestType CallSlot;
static RequestType Quit;
- /** start up a thread to run the main loop
+ /** start up a thread to run the main loop
*/
void run ();
void quit ();
protected:
- bool _ok;
+ bool _ok;
Glib::RefPtr<Glib::MainLoop> _main_loop;
Glib::RefPtr<Glib::MainContext> m_context;
Glib::Threads::Cond _running;
/* this signals _running from within the event loop,
- from an idle callback
+ from an idle callback
*/
bool signal_running ();
virtual void handle_ui_requests () = 0;
private:
- std::string _name;
+ std::string _name;
BaseUI* base_ui_instance;
CrossThreadChannel request_channel;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace PBD {
LIBPBD_API Glib::ustring basename_nosuffix (Glib::ustring);
-}
+}
#endif /* __libpbd_basename_h__ */
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
From an idea by Carl Hetherington.
This program is free software; you can redistribute it and/or modify
LIBPBD_API void spherical_to_cartesian (double azi, double ele, double len, double& x, double& y, double& z);
LIBPBD_API void cartesian_to_spherical (double x, double y, double z, double& azi, double& ele, double& len);
-
+
struct AngularVector;
struct LIBPBD_API CartesianVector {
-/*
+/*
Copyright (C) 2006 Paul Davis
Author: Hans Fugal
case '8':
case '9':
return true;
-
+
default:
return false;
}
os << obj;
std::string rep = os.str();
-
+
if (!rep.empty()) { // manipulators don't produce output
for (specification_map::const_iterator i = specs.lower_bound(arg_no),
end = specs.upper_bound(arg_no); i != end; ++i) {
output_list::iterator pos = i->second;
++pos;
-
+
output.insert(pos, rep);
}
-
+
os.str(std::string());
//os.clear();
++arg_no;
}
-
+
return *this;
}
}
++arg_no;
-
+
return *this;
}
: arg_no(1)
{
std::string::size_type b = 0, i = 0;
-
+
// fill in output with the strings between the %1 %2 %3 etc. and
// fill in specs with the positions
while (i < fmt.length()) {
else
++i;
}
-
+
if (i - b > 0) // add the rest of the string
output.push_back(fmt.substr(b, i - b));
}
{
// assemble string
std::string str;
-
+
for (output_list::const_iterator i = output.begin(), end = output.end();
i != end; ++i)
str += *i;
-
+
return str;
}
}
// a series of functions which accept a format string on the form "text %1
// more %2 less %3" and a number of templated parameters and spits out the
// composited string
- template <typename T1>
+ template <typename T1>
inline std::string string_compose(const std::string &fmt, const T1 &o1)
{
StringPrivate::Composition c(fmt);
return c.str();
}
- template <typename T1, typename T2>
+ template <typename T1, typename T2>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2)
{
return c.str();
}
- template <typename T1, typename T2, typename T3>
+ template <typename T1, typename T2, typename T3>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3)
{
return c.str();
}
- template <typename T1, typename T2, typename T3, typename T4>
+ template <typename T1, typename T2, typename T3, typename T4>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4)
return c.str();
}
- template <typename T1, typename T2, typename T3, typename T4, typename T5>
+ template <typename T1, typename T2, typename T3, typename T4, typename T5>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5)
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6>
+ typename T6>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6)
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7>
+ typename T6, typename T7>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7, typename T8>
+ typename T6, typename T7, typename T8>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7, typename T8, typename T9>
+ typename T6, typename T7, typename T8, typename T9>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
- typename T6, typename T7, typename T8, typename T9, typename T10>
+ typename T6, typename T7, typename T8, typename T9, typename T10>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
.arg(o10);
return c.str();
}
-
+
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
- typename T11>
+ typename T11>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
- typename T11, typename T12>
+ typename T11, typename T12>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
- typename T11, typename T12, typename T13>
+ typename T11, typename T12, typename T13>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
- typename T11, typename T12, typename T13, typename T14>
+ typename T11, typename T12, typename T13, typename T14>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7, typename T8, typename T9, typename T10,
typename T11, typename T12, typename T13, typename T14,
- typename T15>
+ typename T15>
inline std::string string_compose(const std::string &fmt,
const T1 &o1, const T2 &o2, const T3 &o3,
const T4 &o4, const T5 &o5, const T6 &o6,
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
a Controllable
*/
-class LIBPBD_API IgnorableControllable : public Controllable
+class LIBPBD_API IgnorableControllable : public Controllable
{
- public:
+ public:
IgnorableControllable () : PBD::Controllable ("ignoreMe") {}
~IgnorableControllable () {}
-
+
void set_value (double /*v*/) {}
double get_value () const { return 0.0; }
};
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
PluginParameter
};
- ControllableDescriptor ()
+ ControllableDescriptor ()
: _top_level_type (RemoteControlID)
, _subtype (Gain)
, _rid (0)
/*
- Copyright (C) 2002 Paul Davis
+ Copyright (C) 2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
LIBPBD_API std::vector<std::string> internationalize (const char *, const char **);
LIBPBD_API bool strings_equal_ignore_case (const std::string& a, const std::string& b);
-template <class T> std::string /*LIBPBD_API*/
+template <class T> std::string /*LIBPBD_API*/
to_string (T t, std::ios_base & (*f)(std::ios_base&))
{
std::ostringstream oss;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/** A simple abstraction of a mechanism of signalling one thread from another.
* The signaller calls ::wakeup() to tell the signalled thread to check for
- * work to be done.
+ * work to be done.
*
* This implementation provides both ::selectable() for use in direct
* poll/select-based event loops, and a Glib::IOSource via ::ios() for use
- * in Glib main loop based situations.
+ * in Glib main loop based situations.
*/
-class LIBPBD_API CrossThreadChannel {
+class LIBPBD_API CrossThreadChannel {
public:
/** if @a non_blocking is true, the channel will not cause blocking
* when used in an event loop based on poll/select or the glib main
int receive (char& msg, bool wait = false);
/** empty the channel of all requests.
- * Typically this is done as soon as input
+ * Typically this is done as soon as input
* is noticed on the channel, because the
* handler will look at a separately managed work
* queue. The actual number of queued "wakeups"
namespace DEBUG {
/* this namespace is so that we can write DEBUG::bit_name */
-
+
LIBPBD_API extern DebugBits Stateful;
LIBPBD_API extern DebugBits Properties;
LIBPBD_API extern DebugBits FileManager;
namespace PBD
{
- template<typename T> /*LIBPBD_API*/
+ template<typename T> /*LIBPBD_API*/
std::string demangled_name (T const & obj)
{
#ifdef __GNUC__
See http://msdn.microsoft.com/en-us/library/ms681400%28VS.85%29.aspx
See also: http://msdn.microsoft.com/en-us/library/ms680344%28VS.85%29.aspx
*/
-
+
return typeid(obj).name();
}
} // namespace
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-/*
+/*
Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it and/or modify
bool bitwise;
EnumRegistration() {}
- EnumRegistration (std::vector<int>& v, std::vector<std::string>& s, bool b)
+ EnumRegistration (std::vector<int>& v, std::vector<std::string>& s, bool b)
: values (v), names (s), bitwise (b) {}
};
/*
- Copyright (C) 2010 Paul Davis
+ Copyright (C) 2010 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
public:
EnvironmentalProtectionAgency (bool arm = true, const std::string& envname = std::string());
~EnvironmentalProtectionAgency ();
-
+
void arm ();
void save ();
void restore () const;
-
+
static EnvironmentalProtectionAgency* get_global_epa () { return _global_epa; }
static void set_global_epa (EnvironmentalProtectionAgency* epa) { _global_epa = epa; }
-
+
private:
void clear () const;
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* when something like this is needed (it inherits from EventLoop).
*/
-class LIBPBD_API EventLoop
+class LIBPBD_API EventLoop
{
public:
EventLoop() {}
};
struct BaseRequestObject;
-
+
struct InvalidationRecord {
std::list<BaseRequestObject*> requests;
PBD::EventLoop* event_loop;
bool valid;
InvalidationRecord* invalidation;
boost::function<void()> the_slot;
-
+
BaseRequestObject() : valid (true), invalidation (0) {}
};
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2013 Tim Mayberry
+ Copyright (C) 2013 Tim Mayberry
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace PBD {
LIBPBD_API int ffs(int x);
-}
+}
#endif /* __libpbd_ffs_h__ */
/*
- Copyright (C) 2007 Tim Mayberry
+ Copyright (C) 2007 Tim Mayberry
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
bool negative() const { return (i >> 31) != 0; }
int32_t raw_mantissa() const { return i & ((1 << 23) - 1); }
int32_t raw_exponent() const { return (i >> 23) & 0xFF; }
-
+
int32_t i;
float f;
};
-
+
/* Note: ULPS = Units in the Last Place */
static inline bool floateq (float a, float b, int max_ulps_diff)
{
Float_t ua (a);
Float_t ub (b);
-
+
if (a == b) {
return true;
}
if (ulps_diff <= max_ulps_diff) {
return true;
}
-
+
return false;
}
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-/*
+/*
Copyright (C) 2007 Paul Davis
This program is free software; you can redistribute it and/or modify
#include "pbd/command.h"
#include "pbd/failed_constructor.h"
-/** This command class is initialized
+/** This command class is initialized
*/
namespace PBD {
typedef typename FunctorMap::iterator FunctorMapIterator;
public:
- FunctorCommand(std::string functor, obj_type& object, arg_type b, arg_type a)
+ FunctorCommand(std::string functor, obj_type& object, arg_type b, arg_type a)
: functor_name(functor)
, object(object)
, before(b)
- , after(a)
+ , after(a)
{
method = find_functor(functor);
(object.*method) (after);
}
- void undo() {
+ void undo() {
(object.*method) (before);
}
static FunctorMap functor_map;
};
-// static initialization of functor_map...
+// static initialization of functor_map...
template <class obj_type, class arg_type>
typename FunctorCommand<obj_type, arg_type>::FunctorMap
FunctorCommand<obj_type, arg_type>::functor_map;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void reset ();
bool operator== (const ID& other) const {
- return _id == other._id;
+ return _id == other._id;
}
bool operator!= (const ID& other) const {
bool operator== (const std::string&) const;
- ID& operator= (std::string);
- ID& operator= (const ID&);
+ ID& operator= (std::string);
+ ID& operator= (const ID&);
bool operator< (const ID& other) const {
return _id < other._id;
#define LIBPBD_API LIBPBD_DLL_IMPORT
#define LIBPBD_TEMPLATE_API LIBPBD_TEMPLATE_DLL_IMPORT
#define LIBPBD_TEMPLATE_MEMBER_API LIBPBD_TEMPLATE_MEMBER_DLL_IMPORT
- #endif
+ #endif
#define LIBPBD_LOCAL LIBPBD_DLL_LOCAL
#endif
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 2005 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
void Transform (uint32_t state[4], uint8_t const * block);
void Encode (uint8_t *output, uint32_t const *input, size_t len);
void Decode (uint32_t *output, uint8_t const * input, size_t len);
- void Update (uint8_t const *input, size_t inputLen);
+ void Update (uint8_t const *input, size_t inputLen);
void Final ();
};
-/*
+/*
Copyright (C) 2006 Paul Davis
Author: Hans Fugal
PBD::ScopedConnection _object_death_connection;
};
-/** This command class is initialized with before and after mementos
+/** This command class is initialized with before and after mementos
* (from Stateful::get_state()), so undo becomes restoring the before
* memento, and redo is restoring the after memento.
*/
class LIBPBD_TEMPLATE_API MementoCommand : public Command
{
public:
- MementoCommand (obj_T& a_object, XMLNode* a_before, XMLNode* a_after)
+ MementoCommand (obj_T& a_object, XMLNode* a_before, XMLNode* a_after)
: _binder (new SimpleMementoCommandBinder<obj_T> (a_object)), before (a_before), after (a_after)
{
/* The binder's object died, so we must die */
_binder->DropReferences.connect_same_thread (_binder_death_connection, boost::bind (&MementoCommand::binder_dying, this));
}
- MementoCommand (MementoCommandBinder<obj_T>* b, XMLNode* a_before, XMLNode* a_after)
+ MementoCommand (MementoCommandBinder<obj_T>* b, XMLNode* a_before, XMLNode* a_after)
: _binder (b), before (a_before), after (a_after)
{
/* The binder's object died, so we must die */
void operator() () {
if (after) {
- _binder->get()->set_state(*after, Stateful::current_state_version);
+ _binder->get()->set_state(*after, Stateful::current_state_version);
}
}
- void undo() {
+ void undo() {
if (before) {
- _binder->get()->set_state(*before, Stateful::current_state_version);
+ _binder->get()->set_state(*before, Stateful::current_state_version);
}
}
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/** A pool of data items that can be allocated, read from and written to
* without system memory allocation or locking.
*/
-class LIBPBD_API Pool
+class LIBPBD_API Pool
{
public:
Pool (std::string name, unsigned long item_size, unsigned long nitems);
/** Management of a per-thread pool of data that is allocated by one thread and
* freed by one other thread. Not safe for use when there is more than 1
- * reader and 1 writer.
+ * reader and 1 writer.
*
- * This is basically a wrapper around a thread-local storage instance of a
+ * This is basically a wrapper around a thread-local storage instance of a
* ringbuffer, made safe for use in the case where multiple threads allocate
* from the ringbuffer and a single thread "frees" the allocations.
- *
+ *
* Rather than using locks, each thread has its own ringbuffer (and associated
* data), and so it calls alloc(), passes a pointer to the result of the alloc
- * to another thread, which later calls push() to "free" it.
+ * to another thread, which later calls push() to "free" it.
*/
class LIBPBD_API CrossThreadPool : public Pool
{
}
_current = v;
- }
+ }
}
virtual std::string to_string (T const& v) const = 0;
PropertyTemplate (PropertyTemplate<T> const &);
};
-template<class T> /*LIBPBD_API*/
+template<class T> /*LIBPBD_API*/
std::ostream & operator<<(std::ostream& os, PropertyTemplate<T> const& s)
{
return os << s.val ();
namespace PBD {
template<typename T>
-PropertyChange::PropertyChange(PropertyDescriptor<T> p)
-{
- insert (p.property_id);
+PropertyChange::PropertyChange(PropertyDescriptor<T> p)
+{
+ insert (p.property_id);
}
-template<typename T> PropertyChange
-PropertyChange::operator=(PropertyDescriptor<T> p)
+template<typename T> PropertyChange
+PropertyChange::operator=(PropertyDescriptor<T> p)
{
clear ();
insert (p.property_id);
return *this;
}
-template<typename T> bool
-PropertyChange::contains (PropertyDescriptor<T> p) const
-{
- return find (p.property_id) != end ();
+template<typename T> bool
+PropertyChange::contains (PropertyDescriptor<T> p) const
+{
+ return find (p.property_id) != end ();
}
-template<typename T> void
-PropertyChange::add (PropertyDescriptor<T> p)
-{
- insert (p.property_id);
+template<typename T> void
+PropertyChange::add (PropertyDescriptor<T> p)
+{
+ insert (p.property_id);
}
}
public:
PropertyList ();
PropertyList (PropertyList const &);
-
+
virtual ~PropertyList();
void get_changes_as_xml (XMLNode *);
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "pbd/libpbd_visibility.h"
template<class T>
-class /*LIBPBD_API*/ RingBuffer
+class /*LIBPBD_API*/ RingBuffer
{
public:
RingBuffer (guint sz) {
void decrement_read_idx (guint cnt) {
g_atomic_int_set (&read_idx, (g_atomic_int_get(&read_idx) - cnt) & size_mask);
- }
+ }
void increment_read_idx (guint cnt) {
g_atomic_int_set (&read_idx, (g_atomic_int_get(&read_idx) + cnt) & size_mask);
- }
+ }
void increment_write_idx (guint cnt) {
g_atomic_int_set (&write_idx, (g_atomic_int_get(&write_idx) + cnt) & size_mask);
- }
+ }
guint write_space () const {
guint w, r;
guint size_mask;
};
-template<class T> /*LIBPBD_API*/ guint
+template<class T> /*LIBPBD_API*/ guint
RingBuffer<T>::read (T *dest, guint cnt)
{
guint free_cnt;
}
to_read = cnt > free_cnt ? free_cnt : cnt;
-
+
cnt2 = priv_read_idx + to_read;
if (cnt2 > size) {
n1 = to_read;
n2 = 0;
}
-
+
memcpy (dest, &buf[priv_read_idx], n1 * sizeof (T));
priv_read_idx = (priv_read_idx + n1) & size_mask;
}
to_write = cnt > free_cnt ? free_cnt : cnt;
-
+
cnt2 = priv_write_idx + to_write;
if (cnt2 > size) {
if (cnt2 > size) {
/* Two part vector: the rest of the buffer after the
- current write ptr, plus some from the start of
+ current write ptr, plus some from the start of
the buffer.
*/
if (cnt2 > size) {
/* Two part vector: the rest of the buffer after the
- current write ptr, plus some from the start of
+ current write ptr, plus some from the start of
the buffer.
*/
void decrement_read_ptr (size_t cnt) {
g_atomic_int_set (&read_ptr, (g_atomic_int_get(&read_ptr) - cnt) % size);
- }
+ }
void increment_read_ptr (size_t cnt) {
g_atomic_int_set (&read_ptr, (g_atomic_int_get(&read_ptr) + cnt) % size);
- }
+ }
void increment_write_ptr (size_t cnt) {
g_atomic_int_set (&write_ptr, (g_atomic_int_get(&write_ptr) + cnt) % size);
- }
+ }
size_t write_space () {
size_t w, r;
}
to_read = cnt > free_cnt ? free_cnt : cnt;
-
+
cnt2 = priv_read_ptr + to_read;
if (cnt2 > size) {
n1 = to_read;
n2 = 0;
}
-
+
memcpy (dest, &buf[priv_read_ptr], n1 * sizeof (T));
priv_read_ptr = (priv_read_ptr + n1) % size;
}
to_write = cnt > free_cnt ? free_cnt : cnt;
-
+
cnt2 = priv_write_ptr + to_write;
if (cnt2 > size) {
if (cnt2 > size) {
/* Two part vector: the rest of the buffer after the
- current write ptr, plus some from the start of
+ current write ptr, plus some from the start of
the buffer.
*/
if (cnt2 > size) {
/* Two part vector: the rest of the buffer after the
- current write ptr, plus some from the start of
+ current write ptr, plus some from the start of
the buffer.
*/
/*
- Copyright (C) 2007 Tim Mayberry
+ Copyright (C) 2007 Tim Mayberry
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
* @class Searchpath
*
* The Searchpath class is a helper class for getting a
- * vector of paths contained in a search path string where a
- * "search path string" contains absolute directory paths
+ * vector of paths contained in a search path string where a
+ * "search path string" contains absolute directory paths
* separated by a colon(:) or a semi-colon(;) on windows.
*
* The Searchpath class does not test whether the paths exist
/**
* Initialize Searchpath from a string where the string contains
- * one or more absolute paths to directories which are delimited
- * by a path separation character. The path delimeter is a
+ * one or more absolute paths to directories which are delimited
+ * by a path separation character. The path delimeter is a
* colon(:) on unix and a semi-colon(;) on windows.
*
* Each path contained in the search path may or may not resolve to
* an existing directory in the filesystem.
- *
+ *
* @param search_path A path string.
*/
LIBPBD_TEMPLATE_MEMBER_API Searchpath (const std::string& search_path);
/**
* Add a sub-directory to each path in the search path.
- * @param subdir The directory name, it should not contain
+ * @param subdir The directory name, it should not contain
* any path separating tokens.
*/
LIBPBD_TEMPLATE_MEMBER_API Searchpath& add_subdirectory_to_paths (const std::string& subdir);
XMLNode* child = new XMLNode (PBD::capitalize (property_name()));
history_node->add_child_nocopy (*child);
-
+
/* record the change described in our change member */
if (!_changes.added.empty()) {
void get_value (XMLNode & node) const {
for (typename Container::const_iterator i = _val.begin(); i != _val.end(); ++i) {
node.add_child_nocopy ((*i)->get_state ());
- }
+ }
}
bool changed () const {
}
/** Given a record of changes to this property, pass it to a callback that will
- * update the property in some appropriate way.
+ * update the property in some appropriate way.
*
* This exists because simply using std::sequence methods to add/remove items
* from the property is far too simplistic - the semantics of add/remove may
it. the Destructible is likely to be the Command being built
with this diff().
*/
-
+
for (typename ChangeContainer::const_iterator i = a->changes().added.begin(); i != a->changes().added.end(); ++i) {
(*i)->DropReferences.connect_same_thread (*cmd, boost::bind (&Destructible::drop_references, cmd));
}
_val.clear ();
}
- typename Container::size_type size() const {
+ typename Container::size_type size() const {
return _val.size();
}
- bool empty() const {
+ bool empty() const {
return _val.empty();
}
return _val = other;
}
- typename Container::reference front() {
+ typename Container::reference front() {
return _val.front ();
}
- typename Container::const_reference front() const {
+ typename Container::const_reference front() const {
return _val.front ();
}
- typename Container::reference back() {
+ typename Container::reference back() {
return _val.back ();
}
- typename Container::const_reference back() const {
+ typename Container::const_reference back() const {
return _val.back ();
}
- void sort() {
+ void sort() {
_val.sort ();
}
template<class BinaryPredicate> void sort(BinaryPredicate comp) {
_val.sort (comp);
}
-
+
const ChangeRecord& changes () const { return _changes; }
protected:
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2009-2012 Paul Davis
-
+ Copyright (C) 2009-2012 Paul Davis
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
scoped connections needs to be protected in 2 cases:
(1) (unlikely) we make a connection involving a callback on the
- same object from 2 threads. (wouldn't that just be appalling
+ same object from 2 threads. (wouldn't that just be appalling
programming style?)
-
+
(2) where we are dropping connections in one thread and adding
one from another.
*/
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
LIBPBD_API std::string demangle (const std::string&);
template<typename T>
-class /*LIBPBD_API*/ thing_with_backtrace
+class /*LIBPBD_API*/ thing_with_backtrace
{
public:
thing_with_backtrace () {
#ifdef HAVE_EXECINFO
allocation_backtrace = new void*[50];
allocation_backtrace_size = backtrace (allocation_backtrace, 50);
-#else
+#else
allocation_backtrace_size = 0;
#endif
Glib::Threads::Mutex::Lock lm (all_mutex);
#ifdef HAVE_EXECINFO
allocation_backtrace = new void*[50];
allocation_backtrace_size = backtrace (allocation_backtrace, 50);
-#else
+#else
allocation_backtrace_size = 0;
#endif
Glib::Threads::Mutex::Lock lm (all_mutex);
all.push_back (this);
}
- ~thing_with_backtrace() {
+ ~thing_with_backtrace() {
if (allocation_backtrace_size) {
delete [] allocation_backtrace;
}
for (x = all.begin(); x != all.end(); ++x) {
char **strings;
size_t i;
-
+
strings = backtrace_symbols ((*x)->allocation_backtrace, (*x)->allocation_backtrace_size);
-
+
if (strings) {
stream << "--- ALLOCATED SHARED_PTR @ " << (*x) << std::endl;
for (i = 0; i < (*x)->allocation_backtrace_size && i < 50U; i++) {
/*
- Copyright (C) 2000-2010 Paul Davis
+ Copyright (C) 2000-2010 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
virtual void resume_property_changes ();
bool property_changes_suspended() const { return g_atomic_int_get (const_cast<gint*>(&_stateful_frozen)) > 0; }
-
+
protected:
void add_instant_xml (XMLNode&, const std::string& directory_path);
PropertyChange set_values (XMLNode const &);
/* derived classes can implement this to do cross-checking
- of property values after either a PropertyList or XML
+ of property values after either a PropertyList or XML
driven property change.
*/
virtual void post_set (const PropertyChange&) { };
/*
- Copyright (C) 2010 Paul Davis
+ Copyright (C) 2010 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void operator() ();
void undo ();
-
+
XMLNode& get_state ();
bool empty () const;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace PBD {
-class LIBPBD_API StatefulDestructible : public Stateful, public Destructible
+class LIBPBD_API StatefulDestructible : public Stateful, public Destructible
{
};
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#endif // _CPP_VECTOR || _GLIBCXX_VECTOR || __SGI_STL_VECTOR || _LIBCPP_VECTOR
#if defined(_CPP_MAP) || defined(_GLIBCXX_MAP) || defined(__SGI_STL_MAP)
-template<class K, class T> /*LIBPBD_API*/ void map_delete (std::map<K, T *> *m)
+template<class K, class T> /*LIBPBD_API*/ void map_delete (std::map<K, T *> *m)
{
typename std::map<K, T *>::iterator i;
#endif // _CPP_MAP || _GLIBCXX_MAP || __SGI_STL_MAP
#if defined(_CPP_LIST) || defined(_GLIBCXX_LIST) || defined(__SGI_STL_LIST)
-template<class T> /*LIBPBD_API*/ void list_delete (std::list<T *> *l)
+template<class T> /*LIBPBD_API*/ void list_delete (std::list<T *> *l)
{
typename std::list<T *>::iterator i;
#endif // _CPP_LIST || _GLIBCXX_LIST || __SGI_STL_LIST
#if defined(_CPP_SLIST) || defined(_GLIBCXX_SLIST) || defined(__SGI_STL_SLIST)
-template<class T> /*LIBPBD_API*/ void slist_delete (std::slist<T *> *l)
+template<class T> /*LIBPBD_API*/ void slist_delete (std::slist<T *> *l)
{
typename std::slist<T *>::iterator i;
#endif // _CPP_SLIST || _GLIBCXX_SLIST || __SGI_STL_SLIST
#if defined(_CPP_SET) || defined(_GLIBCXX_SET) || defined(__SGI_STL_SET)
-template<class T> void /*LIBPBD_API*/ set_delete (std::set<T *> *sset)
+template<class T> void /*LIBPBD_API*/ set_delete (std::set<T *> *sset)
{
typename std::set<T *>::iterator i;
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
#ifndef LESS_CONST_STRING_R
struct LIBPBD_API less<const std::string &> {
bool operator() (const std::string &s1, const std::string &s2) {
- return s1 < s2;
+ return s1 < s2;
}
};
#define LESS_CONST_STRING_R
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "pbd/libpbd_visibility.h"
#include "receiver.h"
-class LIBPBD_API TextReceiver : public Receiver
+class LIBPBD_API TextReceiver : public Receiver
{
public:
TextReceiver (const std::string &n);
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
template<typename StringType, typename Iter>
/*LIBPBD_API*/ unsigned int
-tokenize(const StringType& str,
+tokenize(const StringType& str,
const StringType& delims,
Iter it,
bool strip_whitespace=false)
/*
- Copyright (C) 1999 Paul Barton-Davis
+ Copyright (C) 1999 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
class /*LIBPBD_API*/ DynamicTouchable : public Touchable
{
public:
- DynamicTouchable (T& t, void (T::*m)(void))
+ DynamicTouchable (T& t, void (T::*m)(void))
: object (t), method (m) { set_delete_after_touch (true); }
void touch () {
class /*LIBPBD_API*/ DynamicTouchable1 : public Touchable
{
public:
- DynamicTouchable1 (T1& t, void (T1::*m)(T2), T2 a)
+ DynamicTouchable1 (T1& t, void (T1::*m)(T2), T2 a)
: object (t), method (m), arg (a) { set_delete_after_touch (true); }
void touch () {
class /*LIBPBD_API*/ DynamicTouchable2 : public Touchable
{
public:
- DynamicTouchable2 (T1& t, void (T1::*m)(T2, T3), T2 a1, T3 a2)
+ DynamicTouchable2 (T1& t, void (T1::*m)(T2, T3), T2 a1, T3 a2)
: object (t), method (m), arg1 (a1), arg2 (a2) { set_delete_after_touch (true); }
void touch () {
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Transmitter (Channel);
- sigc::signal<void,Channel, const char *> &sender() {
+ sigc::signal<void,Channel, const char *> &sender() {
return *send;
}
};
/* for EGCS 2.91.66, if this function is not compiled within the same
- compilation unit as the one where a ThrownError is thrown, then
+ compilation unit as the one where a ThrownError is thrown, then
nothing will catch the error. This is a pretty small function, so
inlining it here seems like a reasonable workaround.
*/
-/*
+/*
Copyright (C) 2002 Brett Viren & Paul Davis
This program is free software; you can redistribute it and/or modify
If depth==0 it returns just the top
node. If depth<0, it returns everything.
If depth>0, it returns state for that
- many elements of the history, or
+ many elements of the history, or
the full history, whichever is smaller.
*/
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
class LIBPBD_API UUID : public boost::uuids::uuid {
public:
- UUID ()
+ UUID ()
: boost::uuids::uuid (boost::uuids::random_generator()()) {}
UUID (std::string const & str)
: boost::uuids::uuid (boost::uuids::string_generator()(str)) {}
-
+
explicit UUID (boost::uuids::uuid const& u)
: boost::uuids::uuid(u)
{}
operator boost::uuids::uuid() {
return static_cast<boost::uuids::uuid&>(*this);
}
-
+
operator boost::uuids::uuid() const {
return static_cast<boost::uuids::uuid const&>(*this);
}
UUID& operator= (std::string const & str);
std::string to_s () const;
-
+
operator bool() const { return !is_nil(); }
};
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 1998-99 Paul Barton-Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/* since some overloaded ::operator new() might use this,
its important that we use a "lower level" allocator to
- get more space.
+ get more space.
*/
block = malloc (nitems * item_size);
/*---------------------------------------------*/
-MultiAllocSingleReleasePool::MultiAllocSingleReleasePool (string n, unsigned long isize, unsigned long nitems)
+MultiAllocSingleReleasePool::MultiAllocSingleReleasePool (string n, unsigned long isize, unsigned long nitems)
: Pool (n, isize, nitems)
{
}
{
}
-SingleAllocMultiReleasePool::SingleAllocMultiReleasePool (string n, unsigned long isize, unsigned long nitems)
+SingleAllocMultiReleasePool::SingleAllocMultiReleasePool (string n, unsigned long isize, unsigned long nitems)
: Pool (n, isize, nitems)
{
}
/*-------------------------------------------------------*/
-static void
+static void
free_per_thread_pool (void* ptr)
{
/* Rather than deleting the CrossThreadPool now, we add it to our trash buffer.
cp->parent()->add_to_trash (cp);
}
}
-
+
PerThreadPool::PerThreadPool ()
: _key (free_per_thread_pool)
, _trash (0)
DEBUG_TRACE (DEBUG::Pool, string_compose ("%1 %2 has %3 pending free entries waiting, status size %4 free %5 used %6\n", pthread_name(), name(), pending.read_space(),
total(), available(), used()));
-
+
while (pending.read (&ptr, 1) == 1) {
DEBUG_TRACE (DEBUG::Pool, string_compose ("%1 %2 pushes back a pending free list entry before allocating\n", pthread_name(), name()));
free_list.write (&ptr, 1);
}
void*
-CrossThreadPool::alloc ()
+CrossThreadPool::alloc ()
{
/* process anything waiting to be deleted (i.e. moved back to the free list) */
flush_pending ();
}
void
-CrossThreadPool::push (void* t)
+CrossThreadPool::push (void* t)
{
pending.write (&t, 1);
}
using namespace PBD;
-PropertyList::PropertyList()
- : _property_owner (true)
+PropertyList::PropertyList()
+ : _property_owner (true)
{
}
{
for (const_iterator i = begin(); i != end(); ++i) {
DEBUG_TRACE (DEBUG::Properties, string_compose ("Add changes to %1 for %2\n",
- history_node->name(),
+ history_node->name(),
i->second->property_name()));
i->second->get_changes_as_xml (history_node);
}
/*
- Copyright (C) 2002 Paul Davis
+ Copyright (C) 2002 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void* (*thread_work)(void*);
void* arg;
std::string name;
-
+
ThreadStartWithName (void* (*f)(void*), void* a, const std::string& s)
: thread_work (f), arg (a), name (s) {}
};
return ret;
}
-int
+int
pthread_create_and_store (string name, pthread_t *thread, void * (*start_routine)(void *), void * arg)
{
pthread_attr_t default_attr;
if (str) {
return str;
- }
+ }
return "unknown";
}
void
-pthread_kill_all (int signum)
+pthread_kill_all (int signum)
{
pthread_mutex_lock (&thread_map_lock);
for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
}
void
-pthread_cancel_all ()
+pthread_cancel_all ()
{
pthread_mutex_lock (&thread_map_lock);
}
void
-pthread_cancel_one (pthread_t thread)
+pthread_cancel_one (pthread_t thread)
{
pthread_mutex_lock (&thread_map_lock);
for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2007 Tim Mayberry
+ Copyright (C) 2007 Tim Mayberry
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Searchpath::add_subdirectory_to_paths (const string& subdir)
{
for (vector<std::string>::iterator i = begin(); i != end(); ++i) {
- // should these new paths just be added to the end of
+ // should these new paths just be added to the end of
// the search path rather than replace?
*i = Glib::build_filename (*i, subdir);
}
* whole idea, and we put it here for convenience.
*/
-void
+void
export_search_path (const string& base_dir, const char* varname, const char* dir)
{
string path;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <execinfo.h>
#include <cxxabi.h>
-static std::string
+static std::string
symbol_demangle (const std::string& l)
{
int status;
return l;
}
-std::string
+std::string
PBD::demangle (std::string const & l)
{
std::string::size_type const b = l.find_first_of ("(");
size_t size;
char **strings;
size_t i;
-
+
size = backtrace (array, 200);
if (size) {
strings = backtrace_symbols (array, size);
-
+
if (strings) {
for (i = 0; i < size && (levels == 0 || i < size_t(levels)); i++) {
}
#endif
-std::string
+std::string
PBD::demangle (std::string const & l) /* JE - !!!! 'PBD' namespace might possibly get removed (except it's still used in 'libs/canvas/item.cc') */
{
return std::string();
#else
-std::string
+std::string
PBD::demangle (std::string const & l) /* JE - !!!! 'PBD' namespace might possibly get removed (except it's still used in 'libs/canvas/item.cc') */
{
return std::string();
/*
- Copyright (C) 2000-2001 Paul Davis
+ Copyright (C) 2000-2001 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
{
delete _properties;
- // Do not delete _extra_xml. The use of add_child_nocopy()
+ // Do not delete _extra_xml. The use of add_child_nocopy()
// means it needs to live on indefinately.
delete _instant_xml;
if (!node && add_if_missing) {
node = new XMLNode (str);
add_extra_xml (*node);
- }
+ }
return node;
}
void
Stateful::save_extra_xml (const XMLNode& node)
{
- /* Looks for the child node called "Extra" and makes _extra_xml
+ /* Looks for the child node called "Extra" and makes _extra_xml
point to a copy of it. Will delete any existing node pointed
to by _extra_xml if a new Extra node is found, but not
otherwise.
/* Important: the destructor for an XMLTree deletes
all of its nodes, starting at _root. We therefore
- cannot simply hand it our persistent _instant_xml
+ cannot simply hand it our persistent _instant_xml
node as its _root, because we will lose it whenever
the Tree goes out of scope.
- So instead, copy the _instant_xml node (which does
+ So instead, copy the _instant_xml node (which does
a deep copy), and hand that to the tree.
*/
}
bool
-Stateful::changed() const
+Stateful::changed() const
{
for (OwnedPropertyList::const_iterator i = _properties->begin(); i != _properties->end(); ++i) {
if (i->second->changed()) {
i->second->clear_owned_changes ();
}
}
-
+
bool
-Stateful::set_id (const XMLNode& node)
+Stateful::set_id (const XMLNode& node)
{
const XMLProperty* prop;
if ((prop = node.property ("id")) != 0) {
_id = prop->value ();
return true;
- }
+ }
return false;
}
/*
- Copyright (C) 2010 Paul Davis
+ Copyright (C) 2010 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
XMLNode* changes = new XMLNode (X_("Changes"));
_changes->get_changes_as_xml (changes);
-
+
node->add_child_nocopy (*changes);
return *node;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
int
replace_all (std::string& str,
std::string const& target,
- std::string const& replacement)
+ std::string const& replacement)
{
std::string::size_type start = str.find (target, 0);
int cnt = 0;
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
switch (c) {
case ' ' :
case '"' : arg += c; break; // "\\", "\" at end-of-string => "\"
- case '\0':
+ case '\0':
case '\\': arg += '\\'; break;
default : arg += '\\'; arg += c; break;
}
assert((*i)->property("name"));
// cout << "Found bank number " << counter++ << " with name: " << (*i)->property("name")->value() << endl;
for(XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
-// cout << "\t found program " << (*j)->property("id")->value() <<
+// cout << "\t found program " << (*j)->property("id")->value() <<
// " with name: " << (*j)->property("name")->value() << endl;
}
}
assert(result->size() == 5);
for(XMLSharedNodeList::const_iterator i = result->begin(); i != result->end(); ++i) {
-// cout << "\t found program " << (*i)->property("id")->value() <<
+// cout << "\t found program " << (*i)->property("id")->value() <<
// " with name: " << (*i)->property("name")->value() << endl;
}
assert(result->size() == 16);
for(XMLSharedNodeList::const_iterator i = result->begin(); i != result->end(); ++i) {
-// cout << "\t found source '" << (*i)->property("name")->value() <<
+// cout << "\t found source '" << (*i)->property("name")->value() <<
// "' with id: " << (*i)->property("id")->value() << endl;
}
for(XMLSharedNodeList::const_iterator i = result->begin(); i != result->end(); ++i) {
assert((*i)->property("id"));
assert((*i)->property("name"));
-// cout << "\t found element '" << (*i)->name() <<
-// "' with id: " << (*i)->property("id")->value() <<
+// cout << "\t found element '" << (*i)->name() <<
+// "' with id: " << (*i)->property("id")->value() <<
// "' and name: " << (*i)->property("name")->value() << endl;
}
// cout << "\t found Patchbank " << (*i)->property("Name")->value() << endl;
boost::shared_ptr<XMLSharedNodeList> patches = doc3.find ("//Patch[@Name]", i->get());
for(XMLSharedNodeList::const_iterator p = patches->begin(); p != patches->end(); ++p) {
-// cout << "\t\t found patch number " << (*p)->property("Number")->value()
+// cout << "\t\t found patch number " << (*p)->property("Number")->value()
// << " with name: " << (*p)->property("Name")->value() << endl;
}
}
for(XMLSharedNodeList::const_iterator i = result->begin(); i != result->end(); ++i) {
boost::shared_ptr<XMLNode> node = (*i);
-// cout << "\t found attribute node: " << node->name()
+// cout << "\t found attribute node: " << node->name()
// << " value: " << node->attribute_value() << endl;
}
assert(result->size() == 15);
for(XMLSharedNodeList::const_iterator i = result->begin(); i != result->end(); ++i) {
boost::shared_ptr<XMLNode> node = (*i);
-// cout << "\t found available Channel: " << node->name()
+// cout << "\t found available Channel: " << node->name()
// << " value: " << node->attribute_value() << endl;
}
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
- Copyright (C) 1998-99 Paul Barton-Davis
+ Copyright (C) 1998-99 Paul Barton-Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/* NOTE: this is just a default action for a Transmitter or a
derived class. Any class can override this to produce some
- other action when deliver() is called.
+ other action when deliver() is called.
*/
*this << '\0';
* provides some time for the user to see the message.
*/
#endif
- }
+ }
}
bool
extern "C" {
void pbd_c_error (const char *str)
-
+
{
PBD::error << str << endmsg;
}
-/*
+/*
Copyright (C) 2001 Brett Viren & Paul Davis
This program is free software; you can redistribute it and/or modify
clear ();
}
-void
+void
command_death (UndoTransaction* ut, Command* c)
{
if (ut->clearing()) {
}
}
-UndoTransaction&
+UndoTransaction&
UndoTransaction::operator= (const UndoTransaction& rhs)
{
if (this == &rhs) return *this;
class UndoRedoSignaller {
public:
- UndoRedoSignaller (UndoHistory& uh)
- : _history (uh) {
- _history.BeginUndoRedo();
+ UndoRedoSignaller (UndoHistory& uh)
+ : _history (uh) {
+ _history.BeginUndoRedo();
}
- ~UndoRedoSignaller() {
- _history.EndUndoRedo();
+ ~UndoRedoSignaller() {
+ _history.EndUndoRedo();
}
private:
Changed (); /* EMIT SIGNAL */
}
-XMLNode&
+XMLNode&
UndoHistory::get_state (int32_t depth)
{
XMLNode *node = new XMLNode ("UndoHistory");
/*
- Copyright (C) 2000-2007 Paul Davis
+ Copyright (C) 2000-2007 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void
strip_whitespace_edges (string& str)
-{
- string::size_type i;
- string::size_type len;
+{
+ string::size_type i;
+ string::size_type len;
string::size_type s = 0;
-
+
len = str.length();
if (len == 1) {
}
/* strip front */
-
+
for (i = 0; i < len; ++i) {
if (!isspace (str[i])) {
break;
}
/* strip back */
-
+
if (len > 1) {
-
+
s = i;
i = len - 1;
if (s == i) {
return;
}
-
+
do {
if (!isspace (str[i]) || i == 0) {
break;
--i;
- } while (true);
-
+ } while (true);
+
str = str.substr (s, (i - s) + 1);
} else {
_proplist.clear ();
}
-XMLNode&
+XMLNode&
XMLNode::operator= (const XMLNode& from)
{
if (&from != this) {
if (idx & 0x20) {
lo ^= 0xaaaaaaab;
- xk ^= 0x10000000;
+ xk ^= 0x10000000;
}
uint32_t hi = swapbytes32 (lo) ^ xk;
return ((uint64_t)hi << 32) | (lo ^ xor_lo);
//printf("name=`%s` start=%04x length=%04x offset=%04x findex=%d\n", name,start,length,sampleoffset,findex);
std::string filename = string(name) + extension;
- wav_t f = {
+ wav_t f = {
filename,
findex,
(int64_t)(start*ratefactor),
j+=somethingbytes;
*/
std::string filename = string(name) + extension;
- wav_t f = {
+ wav_t f = {
filename,
0,
(int64_t)(start*ratefactor),
j+=somethingbytes;
*/
std::string filename = string(name) + extension;
- wav_t f = {
+ wav_t f = {
filename,
0,
(int64_t)(start*ratefactor),
#define LIBPTFORMAT_API LIBPTFORMAT_DLL_EXPORT
#else
#define LIBPTFORMAT_API LIBPTFORMAT_DLL_IMPORT
- #endif
+ #endif
#define LIBPTFORMAT_LOCAL LIBPTFORMAT_DLL_LOCAL
#endif
return *this;
}
virtual ~Window() { delete[] m_cache; }
-
+
void cut(T *src) const { cut(src, src); }
void cut(const T *src, T *dst) const {
for (size_t i = 0; i < m_size; ++i) dst[i] = src[i] * m_cache[i];
WindowType m_type;
size_t m_size;
T *m_cache;
-
+
void encache();
};
mult[i] = mult[i] * 0.5;
}
break;
-
+
case BartlettWindow:
for (i = 0; i < n/2; ++i) {
mult[i] = mult[i] * (i / T(n/2));
mult[i + n/2] = mult[i + n/2] * (1.0 - (i / T(n/2)));
}
break;
-
+
case HammingWindow:
for (i = 0; i < n; ++i) {
mult[i] = mult[i] * (0.54 - 0.46 * cos(2 * M_PI * i / n));
}
break;
-
+
case HanningWindow:
for (i = 0; i < n; ++i) {
mult[i] = mult[i] * (0.50 - 0.50 * cos(2 * M_PI * i / n));
}
break;
-
+
case BlackmanWindow:
for (i = 0; i < n; ++i) {
mult[i] = mult[i] * (0.42 - 0.50 * cos(2 * M_PI * i / n)
+ 0.08 * cos(4 * M_PI * i / n));
}
break;
-
+
case GaussianWindow:
for (i = 0; i < n; ++i) {
mult[i] = mult[i] * exp((-1.0 / (n*n)) * ((T(2*i) - n) *
(T(2*i) - n)));
}
break;
-
+
case ParzenWindow:
for (i = 0; i < n; ++i) {
mult[i] = mult[i] * (1.0 - fabs((T(2*i) - n) / T(n + 1)));
#if !defined(_WIN32_WINNT) || (_WIN32_WINNT-0 < 0x0500)
typedef enum {
- NameUnknown = 0,
- NameFullyQualifiedDN = 1,
- NameSamCompatible = 2,
- NameDisplay = 3,
- NameUniqueId = 6,
- NameCanonical = 7,
- NameUserPrincipal = 8,
- NameCanonicalEx = 9,
- NameServicePrincipal = 10,
+ NameUnknown = 0,
+ NameFullyQualifiedDN = 1,
+ NameSamCompatible = 2,
+ NameDisplay = 3,
+ NameUniqueId = 6,
+ NameCanonical = 7,
+ NameUserPrincipal = 8,
+ NameCanonicalEx = 9,
+ NameServicePrincipal = 10,
NameDnsDomain = 12
} EXTENDED_NAME_FORMAT, *PEXTENDED_NAME_FORMAT;
#endif
MathUtilities::NormaliseType normalise;
};
-class Chromagram
+class Chromagram
{
public:
private:
/* Filter bank parameters */
- double lowestFrequency;
- int linearFilters;
+ double lowestFrequency;
+ int linearFilters;
double linearSpacing;
int logFilters;
double logSpacing;
-
+
/* FFT length */
int fftSize;
-
+
int totalFilters;
double logPower;
-
+
/* Misc. */
int samplingRate;
int nceps;
-
+
/* MFCC vector */
double *ceps;
-
+
double **mfccDCTMatrix;
double **mfccFilterWeights;
-
+
/* The analysis window */
Window<double> *window;
-
+
/* For the FFT */
double *realOut;
double *imagOut;
double whiteningFloor; // if < 0, a sensible default will be used
};
-class DetectionFunction
+class DetectionFunction
{
public:
double* getSpectrumMagnitude();
PhaseVocoder* m_phaseVoc; // Phase Vocoder
};
-#endif
+#endif
QFitThresh QuadThresh;
};
-class PeakPicking
+class PeakPicking
{
public:
PeakPicking( PPickParams Config );
class FFTReal;
-class PhaseVocoder
+class PhaseVocoder
{
public:
PhaseVocoder( unsigned int size );
#ifndef DECIMATOR_H
#define DECIMATOR_H
-class Decimator
+class Decimator
{
public:
void process( const double* src, double* dst );
double* decBuffer;
};
-#endif //
+#endif //
// defaults are sensible for 11025Hz with 0.2 second hopsize
{
public:
- ClusterMeltSegmenterParams() :
+ ClusterMeltSegmenterParams() :
featureType(FEATURE_TYPE_CONSTQ),
hopSize(0.2),
windowSize(0.6),
fmin(62),
- fmax(16000),
+ fmax(16000),
nbins(8),
ncomponents(20),
nHMMStates(40),
Window<double> *window;
FFTReal *fft;
- ConstantQ* constq;
+ ConstantQ* constq;
MFCC* mfcc;
model_t* model; // the HMM
int* q; // the decoded HMM state sequence
vector<vector<double> > histograms;
-
+
feature_types featureType;
double hopSize; // in seconds
double windowSize; // in seconds
-
+
// constant-Q parameters
int fmin;
int fmax;
int nbins;
int ncoeff;
-
+
// PCA parameters
int ncomponents;
-
+
// HMM parameters
int nHMMStates;
-
+
// clustering parameters
int nclusters;
int histogramLength;
virtual void segment() = 0; // call once all the features have been extracted
virtual void segment(int m) = 0; // specify desired number of segment-types
virtual void clear() { features.clear(); }
- const Segmentation& getSegmentation() const { return segmentation; }
+ const Segmentation& getSegmentation() const { return segmentation; }
protected:
vector<vector<double> > features;
Segmentation segmentation;
for (j = 0; j < k; j++)
mexPrintf("%d ", nc[i][j]);
mexPrintf("\n");
- }
+ }
*/
features[i][ncoeff] = env;
if (env > maxenv)
maxenv = env;
- }
+ }
/* normalise the envelopes */
for (i = 0; i < nframes; i++)
features[i][ncoeff] /= maxenv;
int i, j, t;
double norm;
- for (i = 0; i < nx*m; i++)
+ for (i = 0; i < nx*m; i++)
h[i] = 0;
for (i = hlen/2; i < nx-hlen/2; i++)
}
/* segment using HMM and then histogram clustering */
-void cluster_segment(int* q, double** features, int frames_read, int feature_length, int nHMM_states,
+void cluster_segment(int* q, double** features, int frames_read, int feature_length, int nHMM_states,
int histogram_length, int nclusters, int neighbour_limit)
{
int i, j;
maxval = 0;
for (j = 0; j < feature_length; j++)
{
- if (features[i][j] > maxval)
+ if (features[i][j] > maxval)
{
maxval = features[i][j];
maxbin = j;
hmm_print(model);
*/
/* decode the hidden state sequence */
- viterbi_decode(features, frames_read, model, q);
+ viterbi_decode(features, frames_read, model, q);
hmm_close(model);
/*****************************/
}
/*****************************/
-
+
/*
fprintf(stderr, "HMM state sequence:\n");
for (i = 0; i < frames_read; i++)
/* now q holds a sequence of cluster assignments */
- free(h);
+ free(h);
free(bsched);
}
/* segment constant-Q or chroma features */
-void constq_segment(int* q, double** features, int frames_read, int bins, int ncoeff, int feature_type,
+void constq_segment(int* q, double** features, int frames_read, int bins, int ncoeff, int feature_type,
int nHMM_states, int histogram_length, int nclusters, int neighbour_limit)
{
int feature_length;
void create_histograms(int* x, int nx, int m, int hlen, double* h);
-void cluster_segment(int* q, double** features, int frames_read, int feature_length, int nHMM_states,
+void cluster_segment(int* q, double** features, int frames_read, int feature_length, int nHMM_states,
int histogram_length, int nclusters, int neighbour_limit);
-void constq_segment(int* q, double** features, int frames_read, int bins, int ncoeff, int feature_type,
+void constq_segment(int* q, double** features, int frames_read, int bins, int ncoeff, int feature_type,
int nHMM_states, int histogram_length, int nclusters, int neighbour_limit);
#ifdef __cplusplus
segment_t* segments;
} segmentation_t;
-typedef enum
-{
- FEATURE_TYPE_UNKNOWN = 0,
- FEATURE_TYPE_CONSTQ = 1,
+typedef enum
+{
+ FEATURE_TYPE_UNKNOWN = 0,
+ FEATURE_TYPE_CONSTQ = 1,
FEATURE_TYPE_CHROMA = 2,
FEATURE_TYPE_MFCC = 3
} feature_types;
#include "FiltFilt.h"
struct DFProcConfig{
- unsigned int length;
- unsigned int LPOrd;
- double *LPACoeffs;
- double *LPBCoeffs;
+ unsigned int length;
+ unsigned int LPOrd;
+ double *LPACoeffs;
+ double *LPBCoeffs;
unsigned int winPre;
- unsigned int winPost;
+ unsigned int winPost;
double AlphaNormParam;
bool isMedianPositive;
};
-class DFProcess
+class DFProcess
{
public:
DFProcess( DFProcConfig Config );
double* BCoeffs;
};
-class FiltFilt
+class FiltFilt
{
public:
FiltFilt( FiltFiltConfig Config );
double* BCoeffs;
};
-class Filter
+class Filter
{
public:
Filter( FilterConfig Config );
#include <stdio.h>
-class Framer
+class Framer
{
public:
void setSource( double* src, unsigned int length );
* This class takes an input audio signal and a sequence of beat
* locations (calculated e.g. by TempoTrackV2) and estimates which of
* the beat locations are downbeats (first beat of the bar).
- *
+ *
* The input audio signal is expected to have been downsampled to a
* very low sampling rate (e.g. 2700Hz). A utility function for
* downsampling and buffering incoming block-by-block audio is
/**
* Estimate which beats are down-beats.
- *
+ *
* audio contains the input audio stream after downsampling, and
* audioLength contains the number of samples in this downsampled
* stream.
* and the region following it.
*/
void getBeatSD(vector<double> &beatsd) const;
-
+
/**
* For your downsampling convenience: call this function
* repeatedly with input audio blocks containing dfIncrement
* samples at the original sample rate, to decimate them to the
* downsampled rate and buffer them within the DownBeat class.
- *
+ *
* Call getBufferedAudio() to retrieve the results after all
* blocks have been processed.
*/
void pushAudioBlock(const float *audio);
-
+
/**
* Retrieve the accumulated audio produced by pushAudioBlock calls.
*/
// 44100, but surely the fixed window sizes and comb filtering will
// make it prefer double or half time when run at e.g. 96000?
-class TempoTrackV2
+class TempoTrackV2
{
public:
/**
{
for (size_t i = 0; i < 12; ++i) (*this)[i] = 0.0;
}
-
+
};
#ifndef FFT_H
#define FFT_H
-class FFT
+class FFT
{
public:
FFT(unsigned int nsamples);
void process(bool inverse,
const double *realIn, const double *imagIn,
double *realOut, double *imagOut);
-
+
private:
unsigned int m_n;
void *m_private;
private:
unsigned int m_n;
void *m_private_real;
-};
+};
#endif
free(model->mu);
for (i = 0; i < model->L; i++)
free(model->cov[i]);
- free(model->cov);
+ free(model->cov);
free(model);
}
for (t = 0; t < T; t++)
for (j = 0; j < N; j++)
cov[d][e] += gamma[t][j] * (x[t][d] - mu[j][d]) * (x[t][e] - mu[j][e]);
-
+
cov[d][e] /= sum_sum_gamma;
-
+
if (ISNAN(cov[d][e]))
{
printf("cov[%d][%d] was nan\n", d, e);
double* a = (double*) malloc(L*L*sizeof(double));
int i, j;
for(j=0; j < L; j++)
- for (i=0; i < L; i++)
+ for (i=0; i < L; i++)
a[j*L+i] = cov[i][j];
int M = (int) L;
dgetri_(&M, a, &M, ipiv, work, &lwork, &ret);
for(j=0; j < L; j++)
- for (i=0; i < L; i++)
+ for (i=0; i < L; i++)
icov[i][j] = a[j*L+i];
#ifndef HAVE_ATLAS
*
*/
-#ifndef PI
+#ifndef PI
#define PI 3.14159265358979323846264338327950288
-#endif
+#endif
typedef struct _model_t {
int N; /* number of states */
} model_t;
void hmm_train(double** x, int T, model_t* model); /* with scaling */
-void forward_backwards(double*** xi, double** gamma, double* loglik, double* loglik1, double* loglik2, int iter,
+void forward_backwards(double*** xi, double** gamma, double* loglik, double* loglik1, double* loglik2, int iter,
int N, int T, double* p0, double** a, double** b);
void baum_welch(double* p0, double** a, double** mu, double** cov, int N, int T, int L, double** x, double*** xi, double** gamma);
void viterbi_decode(double** x, int T, model_t* model, int* q); /* using logs */
/* Allow the use in C++ code. */
#ifdef __cplusplus
-extern "C"
+extern "C"
{
#endif
* ===========================================================================
*/
-/*
+/*
* Routines with standard 4 prefixes (s, d, c, z)
*/
-void cblas_sswap(const int N, float *X, const int incX,
+void cblas_sswap(const int N, float *X, const int incX,
float *Y, const int incY);
-void cblas_scopy(const int N, const float *X, const int incX,
+void cblas_scopy(const int N, const float *X, const int incX,
float *Y, const int incY);
void cblas_saxpy(const int N, const float alpha, const float *X,
const int incX, float *Y, const int incY);
-void cblas_dswap(const int N, double *X, const int incX,
+void cblas_dswap(const int N, double *X, const int incX,
double *Y, const int incY);
-void cblas_dcopy(const int N, const double *X, const int incX,
+void cblas_dcopy(const int N, const double *X, const int incX,
double *Y, const int incY);
void cblas_daxpy(const int N, const double alpha, const double *X,
const int incX, double *Y, const int incY);
-void cblas_cswap(const int N, void *X, const int incX,
+void cblas_cswap(const int N, void *X, const int incX,
void *Y, const int incY);
-void cblas_ccopy(const int N, const void *X, const int incX,
+void cblas_ccopy(const int N, const void *X, const int incX,
void *Y, const int incY);
void cblas_caxpy(const int N, const void *alpha, const void *X,
const int incX, void *Y, const int incY);
-void cblas_zswap(const int N, void *X, const int incX,
+void cblas_zswap(const int N, void *X, const int incX,
void *Y, const int incY);
-void cblas_zcopy(const int N, const void *X, const int incX,
+void cblas_zcopy(const int N, const void *X, const int incX,
void *Y, const int incY);
void cblas_zaxpy(const int N, const void *alpha, const void *X,
const int incX, void *Y, const int incY);
-/*
+/*
* Routines with S and D prefix only
*/
void cblas_srotg(float *a, float *b, float *c, float *s);
double *Y, const int incY, const double *P);
-/*
+/*
* Routines with S D C Z CS and ZD prefixes
*/
void cblas_sscal(const int N, const float alpha, float *X, const int incX);
* ===========================================================================
*/
-/*
+/*
* Routines with standard 4 prefixes (S, D, C, Z)
*/
void cblas_sgemv(const enum CBLAS_ORDER order,
const int incX, const float beta, float *Y, const int incY);
void cblas_strmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const float *A, const int lda,
+ const int N, const float *A, const int lda,
float *X, const int incX);
void cblas_stbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const int K, const float *A, const int lda,
+ const int N, const int K, const float *A, const int lda,
float *X, const int incX);
void cblas_stpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
const int incX, const double beta, double *Y, const int incY);
void cblas_dtrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const double *A, const int lda,
+ const int N, const double *A, const int lda,
double *X, const int incX);
void cblas_dtbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const int K, const double *A, const int lda,
+ const int N, const int K, const double *A, const int lda,
double *X, const int incX);
void cblas_dtpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
const int incX, const void *beta, void *Y, const int incY);
void cblas_ctrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const void *A, const int lda,
+ const int N, const void *A, const int lda,
void *X, const int incX);
void cblas_ctbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const int K, const void *A, const int lda,
+ const int N, const int K, const void *A, const int lda,
void *X, const int incX);
void cblas_ctpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
const int incX, const void *beta, void *Y, const int incY);
void cblas_ztrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const void *A, const int lda,
+ const int N, const void *A, const int lda,
void *X, const int incX);
void cblas_ztbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
- const int N, const int K, const void *A, const int lda,
+ const int N, const int K, const void *A, const int lda,
void *X, const int incX);
void cblas_ztpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
const int N, const void *Ap, void *X, const int incX);
-/*
+/*
* Routines with S and D prefixes only
*/
void cblas_ssymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
const int incX, const double *Y, const int incY, double *A);
-/*
+/*
* Routines with C and Z prefixes only
*/
void cblas_chemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
* ===========================================================================
*/
-/*
+/*
* Routines with standard 4 prefixes (S, D, C, Z)
*/
void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA,
void *B, const int ldb);
-/*
+/*
* Routines with prefixes C and Z only
*/
void cblas_chemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side,
#ifdef __cplusplus
}
-#endif
+#endif
#endif
Documentation of the LAPACK interfaces, including reference implementations, can be found on the web
starting from the LAPACK FAQ page at this URL (verified live as of April 2002):
http://netlib.org/lapack/faq.html
-
+
A hardcopy maanual is:
- LAPACK Users' Guide, Third Edition.
+ LAPACK Users' Guide, Third Edition.
@BOOK{laug,
AUTHOR = {Anderson, E. and Bai, Z. and Bischof, C. and
Blackford, S. and Demmel, J. and Dongarra, J. and
*/
#ifndef __CLAPACK_H
#define __CLAPACK_H
-
+
#ifdef __cplusplus
extern "C" {
#endif
typedef struct { __CLPK_doublereal r, i; } __CLPK_doublecomplex;
/* Subroutine */ int cbdsqr_(char *uplo, __CLPK_integer *n, __CLPK_integer *ncvt, __CLPK_integer *
- nru, __CLPK_integer *ncc, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *vt, __CLPK_integer *ldvt,
- __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_real *rwork,
+ nru, __CLPK_integer *ncc, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *vt, __CLPK_integer *ldvt,
+ __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int cgbbrd_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *ncc,
- __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *pt, __CLPK_integer *ldpt,
+ __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *d__,
+ __CLPK_real *e, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *pt, __CLPK_integer *ldpt,
__CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbcon_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond,
+ __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real
+ __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real
*colcnd, __CLPK_real *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
ku, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *afb, __CLPK_integer *
ldafb, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *
ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int cgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *
ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *kl,
__CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *afb,
- __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed, __CLPK_real *r__, __CLPK_real *c__,
- __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real
+ __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed, __CLPK_real *r__, __CLPK_real *c__,
+ __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real
*ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbtf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbtrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int cgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
- ku, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_complex
+ ku, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_complex
*b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int cgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_real *scale, __CLPK_integer *m, __CLPK_complex *v, __CLPK_integer *ldv,
+
+/* Subroutine */ int cgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_real *scale, __CLPK_integer *m, __CLPK_complex *v, __CLPK_integer *ldv,
__CLPK_integer *info);
-
-/* Subroutine */ int cgebal_(char *job, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int cgebal_(char *job, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *scale, __CLPK_integer *info);
-
+
/* Subroutine */ int cgebd2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
- __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tauq, __CLPK_complex *taup, __CLPK_complex *work,
+ __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tauq, __CLPK_complex *taup, __CLPK_complex *work,
__CLPK_integer *info);
-
+
/* Subroutine */ int cgebrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
- __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tauq, __CLPK_complex *taup, __CLPK_complex *work,
+ __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tauq, __CLPK_complex *taup, __CLPK_complex *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgecon_(char *norm, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgeequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
- __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *colcnd, __CLPK_real *amax,
+ __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *colcnd, __CLPK_real *amax,
__CLPK_integer *info);
-
-/* Subroutine */ int cgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
- __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_complex *w, __CLPK_complex *vs,
+
+/* Subroutine */ int cgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
+ __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_complex *w, __CLPK_complex *vs,
__CLPK_integer *ldvs, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_logical *
bwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgeesx_(char *jobvs, char *sort, __CLPK_L_fp select, char *
sense, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_complex *
w, __CLPK_complex *vs, __CLPK_integer *ldvs, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_complex *
work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int cgeev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_complex *w, __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr,
+
+/* Subroutine */ int cgeev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_complex *w, __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr,
__CLPK_integer *ldvr, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int cgeevx_(char *balanc, char *jobvl, char *jobvr, char *
- sense, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *w, __CLPK_complex *vl,
+ sense, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *w, __CLPK_complex *vl,
__CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_integer *ilo, __CLPK_integer *ihi,
- __CLPK_real *scale, __CLPK_real *abnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_complex *work,
+ __CLPK_real *scale, __CLPK_real *abnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_complex *work,
__CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *alpha, __CLPK_complex *
- beta, __CLPK_complex *vsl, __CLPK_integer *ldvsl, __CLPK_complex *vsr, __CLPK_integer *ldvsr,
+ beta, __CLPK_complex *vsl, __CLPK_integer *ldvsl, __CLPK_complex *vsr, __CLPK_integer *ldvsr,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int cgegv_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_complex *a,
+
+/* Subroutine */ int cgegv_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *alpha, __CLPK_complex *beta,
__CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_complex *
work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *
- a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer
+ a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer
*info);
-
+
/* Subroutine */ int cgelq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cgelqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgels_(char *trans, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *jpvt, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *jpvt, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int cgeql2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cgeqlf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgeqp3_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *jpvt, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *
rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgeqpf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *jpvt, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int cgeqr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cgeqrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_complex *
- b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
+ b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgerq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cgerqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgesc2_(__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *
rhs, __CLPK_integer *ipiv, __CLPK_integer *jpiv, __CLPK_real *scale);
-
+
/* Subroutine */ int cgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cgesvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_integer *
- ipiv, char *equed, __CLPK_real *r__, __CLPK_real *c__, __CLPK_complex *b, __CLPK_integer *ldb,
- __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
+ ipiv, char *equed, __CLPK_real *r__, __CLPK_real *c__, __CLPK_complex *b, __CLPK_integer *ldb,
+ __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgetc2_(__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *
ipiv, __CLPK_integer *jpiv, __CLPK_integer *info);
-
+
/* Subroutine */ int cgetf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int cgetrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int cgetri_(__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *
ipiv, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int cggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real *rscale, __CLPK_integer *m, __CLPK_complex *v,
+
+/* Subroutine */ int cggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real *rscale, __CLPK_integer *m, __CLPK_complex *v,
__CLPK_integer *ldv, __CLPK_integer *info);
-
-/* Subroutine */ int cggbal_(char *job, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
- __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *lscale,
+
+/* Subroutine */ int cggbal_(char *job, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
+ __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *lscale,
__CLPK_real *rscale, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int cgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+
+/* Subroutine */ int cgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
selctg, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *
- ldb, __CLPK_integer *sdim, __CLPK_complex *alpha, __CLPK_complex *beta, __CLPK_complex *vsl,
+ ldb, __CLPK_integer *sdim, __CLPK_complex *alpha, __CLPK_complex *beta, __CLPK_complex *vsl,
__CLPK_integer *ldvsl, __CLPK_complex *vsr, __CLPK_integer *ldvsr, __CLPK_complex *work, __CLPK_integer *
lwork, __CLPK_real *rwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int cggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+
+/* Subroutine */ int cggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
selctg, char *sense, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b,
__CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_complex *alpha, __CLPK_complex *beta, __CLPK_complex *
- vsl, __CLPK_integer *ldvsl, __CLPK_complex *vsr, __CLPK_integer *ldvsr, __CLPK_real *rconde, __CLPK_real
- *rcondv, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork,
+ vsl, __CLPK_integer *ldvsl, __CLPK_complex *vsr, __CLPK_integer *ldvsr, __CLPK_real *rconde, __CLPK_real
+ *rcondv, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int cggev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_complex *a,
+
+/* Subroutine */ int cggev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *alpha, __CLPK_complex *beta,
__CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_complex *
work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cggevx_(char *balanc, char *jobvl, char *jobvr, char *
sense, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
__CLPK_complex *alpha, __CLPK_complex *beta, __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *
vr, __CLPK_integer *ldvr, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real *
- rscale, __CLPK_real *abnrm, __CLPK_real *bbnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_complex
- *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_logical *bwork,
+ rscale, __CLPK_real *abnrm, __CLPK_real *bbnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_complex
+ *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_logical *bwork,
__CLPK_integer *info);
-
-/* Subroutine */ int cggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *d__, __CLPK_complex *x,
+
+/* Subroutine */ int cggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *d__, __CLPK_complex *x,
__CLPK_complex *y, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgghrd_(char *compq, char *compz, __CLPK_integer *n, __CLPK_integer *
ilo, __CLPK_integer *ihi, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
__CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *info);
-
-/* Subroutine */ int cgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__, __CLPK_complex *d__,
+
+/* Subroutine */ int cgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__, __CLPK_complex *d__,
__CLPK_complex *x, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_complex *taua, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *taub,
+
+/* Subroutine */ int cggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_complex *taua, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *taub,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_complex *taua, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *taub,
+
+/* Subroutine */ int cggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_complex *taua, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *taub,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+
+/* Subroutine */ int cggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_integer *p, __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *a, __CLPK_integer *
- lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_complex *u,
- __CLPK_integer *ldu, __CLPK_complex *v, __CLPK_integer *ldv, __CLPK_complex *q, __CLPK_integer *ldq,
+ lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_complex *u,
+ __CLPK_integer *ldu, __CLPK_complex *v, __CLPK_integer *ldv, __CLPK_complex *q, __CLPK_integer *ldq,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int cggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *p, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer
- *ldb, __CLPK_real *tola, __CLPK_real *tolb, __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *u,
- __CLPK_integer *ldu, __CLPK_complex *v, __CLPK_integer *ldv, __CLPK_complex *q, __CLPK_integer *ldq,
+
+/* Subroutine */ int cggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *p, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer
+ *ldb, __CLPK_real *tola, __CLPK_real *tolb, __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *u,
+ __CLPK_integer *ldu, __CLPK_complex *v, __CLPK_integer *ldv, __CLPK_complex *q, __CLPK_integer *ldq,
__CLPK_integer *iwork, __CLPK_real *rwork, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *
info);
-
+
/* Subroutine */ int cgtcon_(char *norm, __CLPK_integer *n, __CLPK_complex *dl, __CLPK_complex *
d__, __CLPK_complex *du, __CLPK_complex *du2, __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *
rcond, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cgtrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
dl, __CLPK_complex *d__, __CLPK_complex *du, __CLPK_complex *dlf, __CLPK_complex *df, __CLPK_complex *
duf, __CLPK_complex *du2, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *
- x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
+ x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int cgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *dl, __CLPK_complex *
d__, __CLPK_complex *du, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cgtsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *dl, __CLPK_complex *d__, __CLPK_complex *du, __CLPK_complex *dlf, __CLPK_complex *
df, __CLPK_complex *duf, __CLPK_complex *du2, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *
- ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
+ ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cgttrf_(__CLPK_integer *n, __CLPK_complex *dl, __CLPK_complex *d__, __CLPK_complex *
du, __CLPK_complex *du2, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int cgttrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
dl, __CLPK_complex *d__, __CLPK_complex *du, __CLPK_complex *du2, __CLPK_integer *ipiv, __CLPK_complex *
b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int cgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_complex *dl, __CLPK_complex *d__, __CLPK_complex *du, __CLPK_complex *du2, __CLPK_integer *ipiv,
+
+/* Subroutine */ int cgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_complex *dl, __CLPK_complex *d__, __CLPK_complex *du, __CLPK_complex *du2, __CLPK_integer *ipiv,
__CLPK_complex *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int chbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int chbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int chbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int chbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *
iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int chbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *q, __CLPK_integer *ldq,
+
+/* Subroutine */ int chbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *q, __CLPK_integer *ldq,
__CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *
- m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork,
+ m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int chbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
- __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb, __CLPK_integer *ldbb,
+
+/* Subroutine */ int chbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+ __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb, __CLPK_integer *ldbb,
__CLPK_complex *x, __CLPK_integer *ldx, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int chbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
- __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb, __CLPK_integer *ldbb,
- __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork,
+
+/* Subroutine */ int chbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+ __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb, __CLPK_integer *ldbb,
+ __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int chbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_integer *ka, __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb,
+
+/* Subroutine */ int chbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_integer *ka, __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb,
__CLPK_integer *ldbb, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *
- il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__,
+ il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__,
__CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_integer *
ifail, __CLPK_integer *info);
-
-/* Subroutine */ int chbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int chbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *q, __CLPK_integer *
ldq, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int checon_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_integer *
info);
-
-/* Subroutine */ int cheev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_real *w, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
+
+/* Subroutine */ int cheev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_real *w, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int cheevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_real *w, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
+
+/* Subroutine */ int cheevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_real *w, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
__CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int cheevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int cheevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *
- iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
+ iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_integer *isuppz, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *
lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int cheevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int cheevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *
- iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
+ iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_integer *
ifail, __CLPK_integer *info);
-
+
/* Subroutine */ int chegs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int chegst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int chegv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *w,
+ n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *w,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chegvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *w,
+ n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *w,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *
iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chegvx_(__CLPK_integer *itype, char *jobz, char *range, char *
- uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
+ uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
__CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *
m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork,
__CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
+
/* Subroutine */ int cherfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_complex *
- b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
+ b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chesv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chesvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_integer *
ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond,
- __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
+ __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int chetf2_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int chetrd_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
- __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork,
+ __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int chetrf_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chetri_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int chetrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int chgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b,
+
+/* Subroutine */ int chgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b,
__CLPK_integer *ldb, __CLPK_complex *alpha, __CLPK_complex *beta, __CLPK_complex *q, __CLPK_integer *ldq,
__CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *
rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chpcon_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int chpev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
- __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork,
+
+/* Subroutine */ int chpev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
+ __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int chpevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
- __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork,
- __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+
+/* Subroutine */ int chpevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
+ __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork,
+ __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
-
-/* Subroutine */ int chpevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int chpevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_complex *ap, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *
abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *
work, __CLPK_real *rwork, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
+
/* Subroutine */ int chpgst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_complex *
ap, __CLPK_complex *bp, __CLPK_integer *info);
-
+
/* Subroutine */ int chpgv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_complex *ap, __CLPK_complex *bp, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
+ n, __CLPK_complex *ap, __CLPK_complex *bp, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chpgvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_complex *ap, __CLPK_complex *bp, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
+ n, __CLPK_complex *ap, __CLPK_complex *bp, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *
iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int chpgvx_(__CLPK_integer *itype, char *jobz, char *range, char *
- uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_complex *bp, __CLPK_real *vl, __CLPK_real *vu,
+ uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_complex *bp, __CLPK_real *vl, __CLPK_real *vu,
__CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *
- z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork,
+ z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork,
__CLPK_integer *ifail, __CLPK_integer *info);
-
+
/* Subroutine */ int chprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_complex *afp, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x,
- __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
+ __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int chpsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int chpsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *ap, __CLPK_complex *afp, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *
- ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
+ ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int chptrd_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *d__,
+
+/* Subroutine */ int chptrd_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *d__,
__CLPK_real *e, __CLPK_complex *tau, __CLPK_integer *info);
-
+
/* Subroutine */ int chptrf_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int chptri_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
ipiv, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int chptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int chsein_(char *side, char *eigsrc, char *initv, __CLPK_logical *
select, __CLPK_integer *n, __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w, __CLPK_complex *
vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *
- m, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *ifaill, __CLPK_integer *ifailr,
+ m, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *ifaill, __CLPK_integer *ifailr,
__CLPK_integer *info);
-
+
/* Subroutine */ int chseqr_(char *job, char *compz, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w, __CLPK_complex *z__,
+ __CLPK_integer *ihi, __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w, __CLPK_complex *z__,
__CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int clabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tauq, __CLPK_complex *taup,
+
+/* Subroutine */ int clabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *tauq, __CLPK_complex *taup,
__CLPK_complex *x, __CLPK_integer *ldx, __CLPK_complex *y, __CLPK_integer *ldy);
-
+
/* Subroutine */ int clacgv_(__CLPK_integer *n, __CLPK_complex *x, __CLPK_integer *incx);
-
-/* Subroutine */ int clacon_(__CLPK_integer *n, __CLPK_complex *v, __CLPK_complex *x, __CLPK_real *est,
+
+/* Subroutine */ int clacon_(__CLPK_integer *n, __CLPK_complex *v, __CLPK_complex *x, __CLPK_real *est,
__CLPK_integer *kase);
-
-/* Subroutine */ int clacp2_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int clacp2_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int clacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a,
+
+/* Subroutine */ int clacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb);
-
+
/* Subroutine */ int clacrm_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_real *rwork);
-
+
/* Subroutine */ int clacrt_(__CLPK_integer *n, __CLPK_complex *cx, __CLPK_integer *incx, __CLPK_complex *
cy, __CLPK_integer *incy, __CLPK_complex *c__, __CLPK_complex *s);
-
-/* Subroutine */ int claed0_(__CLPK_integer *qsiz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int claed0_(__CLPK_integer *qsiz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
__CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *qstore, __CLPK_integer *ldqs, __CLPK_real *rwork,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int claed7_(__CLPK_integer *n, __CLPK_integer *cutpnt, __CLPK_integer *qsiz,
+
+/* Subroutine */ int claed7_(__CLPK_integer *n, __CLPK_integer *cutpnt, __CLPK_integer *qsiz,
__CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_real *d__, __CLPK_complex *
q, __CLPK_integer *ldq, __CLPK_real *rho, __CLPK_integer *indxq, __CLPK_real *qstore, __CLPK_integer *
qptr, __CLPK_integer *prmptr, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *
- givcol, __CLPK_real *givnum, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork,
+ givcol, __CLPK_real *givnum, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int claed8_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *qsiz, __CLPK_complex *
- q, __CLPK_integer *ldq, __CLPK_real *d__, __CLPK_real *rho, __CLPK_integer *cutpnt, __CLPK_real *z__,
- __CLPK_real *dlamda, __CLPK_complex *q2, __CLPK_integer *ldq2, __CLPK_real *w, __CLPK_integer *indxp,
- __CLPK_integer *indx, __CLPK_integer *indxq, __CLPK_integer *perm, __CLPK_integer *givptr,
+ q, __CLPK_integer *ldq, __CLPK_real *d__, __CLPK_real *rho, __CLPK_integer *cutpnt, __CLPK_real *z__,
+ __CLPK_real *dlamda, __CLPK_complex *q2, __CLPK_integer *ldq2, __CLPK_real *w, __CLPK_integer *indxp,
+ __CLPK_integer *indx, __CLPK_integer *indxq, __CLPK_integer *perm, __CLPK_integer *givptr,
__CLPK_integer *givcol, __CLPK_real *givnum, __CLPK_integer *info);
-
-/* Subroutine */ int claein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
- __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w, __CLPK_complex *v, __CLPK_complex *b,
+
+/* Subroutine */ int claein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
+ __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w, __CLPK_complex *v, __CLPK_complex *b,
__CLPK_integer *ldb, __CLPK_real *rwork, __CLPK_real *eps3, __CLPK_real *smlnum, __CLPK_integer *info);
-
+
/* Subroutine */ int claesy_(__CLPK_complex *a, __CLPK_complex *b, __CLPK_complex *c__, __CLPK_complex *
rt1, __CLPK_complex *rt2, __CLPK_complex *evscal, __CLPK_complex *cs1, __CLPK_complex *sn1);
-
-/* Subroutine */ int claev2_(__CLPK_complex *a, __CLPK_complex *b, __CLPK_complex *c__, __CLPK_real *rt1,
+
+/* Subroutine */ int claev2_(__CLPK_complex *a, __CLPK_complex *b, __CLPK_complex *c__, __CLPK_real *rt1,
__CLPK_real *rt2, __CLPK_real *cs1, __CLPK_complex *sn1);
-
-/* Subroutine */ int clags2_(__CLPK_logical *upper, __CLPK_real *a1, __CLPK_complex *a2, __CLPK_real *a3,
- __CLPK_real *b1, __CLPK_complex *b2, __CLPK_real *b3, __CLPK_real *csu, __CLPK_complex *snu, __CLPK_real *csv,
+
+/* Subroutine */ int clags2_(__CLPK_logical *upper, __CLPK_real *a1, __CLPK_complex *a2, __CLPK_real *a3,
+ __CLPK_real *b1, __CLPK_complex *b2, __CLPK_real *b3, __CLPK_real *csu, __CLPK_complex *snu, __CLPK_real *csv,
__CLPK_complex *snv, __CLPK_real *csq, __CLPK_complex *snq);
-
+
/* Subroutine */ int clagtm_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *
alpha, __CLPK_complex *dl, __CLPK_complex *d__, __CLPK_complex *du, __CLPK_complex *x, __CLPK_integer *
ldx, __CLPK_real *beta, __CLPK_complex *b, __CLPK_integer *ldb);
-
+
/* Subroutine */ int clahef_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_integer *kb,
- __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *w, __CLPK_integer *ldw,
+ __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *w, __CLPK_integer *ldw,
__CLPK_integer *info);
-
-/* Subroutine */ int clahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w,
+
+/* Subroutine */ int clahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *h__, __CLPK_integer *ldh, __CLPK_complex *w,
__CLPK_integer *iloz, __CLPK_integer *ihiz, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *
info);
-
-/* Subroutine */ int clahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *y,
+
+/* Subroutine */ int clahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *y,
__CLPK_integer *ldy);
-
+
/* Subroutine */ int claic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_complex *x, __CLPK_real *sest,
__CLPK_complex *w, __CLPK_complex *gamma, __CLPK_real *sestpr, __CLPK_complex *s, __CLPK_complex *c__);
-
-/* Subroutine */ int clals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *bx,
- __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
+
+/* Subroutine */ int clals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *bx,
+ __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
__CLPK_integer *ldgcol, __CLPK_real *givnum, __CLPK_integer *ldgnum, __CLPK_real *poles, __CLPK_real *
difl, __CLPK_real *difr, __CLPK_real *z__, __CLPK_integer *k, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *
rwork, __CLPK_integer *info);
-
-/* Subroutine */ int clalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *bx, __CLPK_integer *ldbx,
- __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *k, __CLPK_real *difl, __CLPK_real *difr,
+
+/* Subroutine */ int clalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *bx, __CLPK_integer *ldbx,
+ __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *k, __CLPK_real *difl, __CLPK_real *difr,
__CLPK_real *z__, __CLPK_real *poles, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *
- ldgcol, __CLPK_integer *perm, __CLPK_real *givnum, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *rwork,
+ ldgcol, __CLPK_integer *perm, __CLPK_real *givnum, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *rwork,
__CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int clapll_(__CLPK_integer *n, __CLPK_complex *x, __CLPK_integer *incx, __CLPK_complex *
y, __CLPK_integer *incy, __CLPK_real *ssmin);
-
-/* Subroutine */ int clapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex
+
+/* Subroutine */ int clapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex
*x, __CLPK_integer *ldx, __CLPK_integer *k);
-
+
/* Subroutine */ int claqgb_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real
+ __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real
*colcnd, __CLPK_real *amax, char *equed);
-
+
/* Subroutine */ int claqge_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *colcnd, __CLPK_real *amax, char *
equed);
-
+
/* Subroutine */ int claqhb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
__CLPK_integer *ldab, __CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, char *equed);
-
+
/* Subroutine */ int claqhe_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, char *equed);
-
-/* Subroutine */ int claqhp_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *s,
+
+/* Subroutine */ int claqhp_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *s,
__CLPK_real *scond, __CLPK_real *amax, char *equed);
-
-/* Subroutine */ int claqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_complex
- *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_complex *tau, __CLPK_real *vn1, __CLPK_real *vn2,
+
+/* Subroutine */ int claqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_complex
+ *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_complex *tau, __CLPK_real *vn1, __CLPK_real *vn2,
__CLPK_complex *work);
-
-/* Subroutine */ int claqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
+
+/* Subroutine */ int claqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
*nb, __CLPK_integer *kb, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_complex *
tau, __CLPK_real *vn1, __CLPK_real *vn2, __CLPK_complex *auxv, __CLPK_complex *f, __CLPK_integer *ldf);
-
+
/* Subroutine */ int claqsb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
__CLPK_integer *ldab, __CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, char *equed);
-
-/* Subroutine */ int claqsp_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *s,
+
+/* Subroutine */ int claqsp_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *s,
__CLPK_real *scond, __CLPK_real *amax, char *equed);
-
+
/* Subroutine */ int claqsy_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, char *equed);
-
+
/* Subroutine */ int clar1v_(__CLPK_integer *n, __CLPK_integer *b1, __CLPK_integer *bn, __CLPK_real *
- sigma, __CLPK_real *d__, __CLPK_real *l, __CLPK_real *ld, __CLPK_real *lld, __CLPK_real *gersch, __CLPK_complex
+ sigma, __CLPK_real *d__, __CLPK_real *l, __CLPK_real *ld, __CLPK_real *lld, __CLPK_real *gersch, __CLPK_complex
*z__, __CLPK_real *ztz, __CLPK_real *mingma, __CLPK_integer *r__, __CLPK_integer *isuppz, __CLPK_real *
work);
-
+
/* Subroutine */ int clar2v_(__CLPK_integer *n, __CLPK_complex *x, __CLPK_complex *y, __CLPK_complex *z__,
__CLPK_integer *incx, __CLPK_real *c__, __CLPK_complex *s, __CLPK_integer *incc);
-
-/* Subroutine */ int clarcm_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int clarcm_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_real *rwork);
-
-/* Subroutine */ int clarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *v,
+
+/* Subroutine */ int clarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *v,
__CLPK_integer *incv, __CLPK_complex *tau, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *
work);
-
+
/* Subroutine */ int clarfb_(char *side, char *trans, char *direct, char *
- storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *v, __CLPK_integer *ldv,
- __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work,
+ storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *v, __CLPK_integer *ldv,
+ __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work,
__CLPK_integer *ldwork);
-
+
/* Subroutine */ int clarfg_(__CLPK_integer *n, __CLPK_complex *alpha, __CLPK_complex *x, __CLPK_integer *
incx, __CLPK_complex *tau);
-
+
/* Subroutine */ int clarft_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
k, __CLPK_complex *v, __CLPK_integer *ldv, __CLPK_complex *tau, __CLPK_complex *t, __CLPK_integer *ldt);
-
-/* Subroutine */ int clarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *v,
+
+/* Subroutine */ int clarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *v,
__CLPK_complex *tau, __CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work);
-
+
/* Subroutine */ int clargv_(__CLPK_integer *n, __CLPK_complex *x, __CLPK_integer *incx, __CLPK_complex *
y, __CLPK_integer *incy, __CLPK_real *c__, __CLPK_integer *incc);
-
-/* Subroutine */ int clarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n,
+
+/* Subroutine */ int clarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n,
__CLPK_complex *x);
-
-/* Subroutine */ int clarrv_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *l, __CLPK_integer *isplit,
- __CLPK_integer *m, __CLPK_real *w, __CLPK_integer *iblock, __CLPK_real *gersch, __CLPK_real *tol,
+
+/* Subroutine */ int clarrv_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *l, __CLPK_integer *isplit,
+ __CLPK_integer *m, __CLPK_real *w, __CLPK_integer *iblock, __CLPK_real *gersch, __CLPK_real *tol,
__CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_real *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int clartg_(__CLPK_complex *f, __CLPK_complex *g, __CLPK_real *cs, __CLPK_complex *sn,
+
+/* Subroutine */ int clartg_(__CLPK_complex *f, __CLPK_complex *g, __CLPK_real *cs, __CLPK_complex *sn,
__CLPK_complex *r__);
-
+
/* Subroutine */ int clartv_(__CLPK_integer *n, __CLPK_complex *x, __CLPK_integer *incx, __CLPK_complex *
y, __CLPK_integer *incy, __CLPK_real *c__, __CLPK_complex *s, __CLPK_integer *incc);
-
-/* Subroutine */ int clarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
- __CLPK_complex *v, __CLPK_integer *incv, __CLPK_complex *tau, __CLPK_complex *c__, __CLPK_integer *ldc,
+
+/* Subroutine */ int clarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
+ __CLPK_complex *v, __CLPK_integer *incv, __CLPK_complex *tau, __CLPK_complex *c__, __CLPK_integer *ldc,
__CLPK_complex *work);
-
+
/* Subroutine */ int clarzb_(char *side, char *trans, char *direct, char *
- storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *v,
- __CLPK_integer *ldv, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *c__, __CLPK_integer *ldc,
+ storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *v,
+ __CLPK_integer *ldv, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *c__, __CLPK_integer *ldc,
__CLPK_complex *work, __CLPK_integer *ldwork);
-
+
/* Subroutine */ int clarzt_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
k, __CLPK_complex *v, __CLPK_integer *ldv, __CLPK_complex *tau, __CLPK_complex *t, __CLPK_integer *ldt);
-
+
/* Subroutine */ int clascl_(char *type__, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_real *
- cfrom, __CLPK_real *cto, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
+ cfrom, __CLPK_real *cto, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
+
/* Subroutine */ int claset_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *
alpha, __CLPK_complex *beta, __CLPK_complex *a, __CLPK_integer *lda);
-
+
/* Subroutine */ int clasr_(char *side, char *pivot, char *direct, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_real *c__, __CLPK_real *s, __CLPK_complex *a, __CLPK_integer *lda);
-
+
/* Subroutine */ int classq_(__CLPK_integer *n, __CLPK_complex *x, __CLPK_integer *incx, __CLPK_real *
scale, __CLPK_real *sumsq);
-
+
/* Subroutine */ int claswp_(__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *
k1, __CLPK_integer *k2, __CLPK_integer *ipiv, __CLPK_integer *incx);
-
+
/* Subroutine */ int clasyf_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_integer *kb,
- __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *w, __CLPK_integer *ldw,
+ __CLPK_complex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *w, __CLPK_integer *ldw,
__CLPK_integer *info);
-
+
/* Subroutine */ int clatbs_(char *uplo, char *trans, char *diag, char *
normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *
x, __CLPK_real *scale, __CLPK_real *cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int clatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_complex *z__, __CLPK_integer
- *ldz, __CLPK_complex *rhs, __CLPK_real *rdsum, __CLPK_real *rdscal, __CLPK_integer *ipiv, __CLPK_integer
+
+/* Subroutine */ int clatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_complex *z__, __CLPK_integer
+ *ldz, __CLPK_complex *rhs, __CLPK_real *rdsum, __CLPK_real *rdscal, __CLPK_integer *ipiv, __CLPK_integer
*jpiv);
-
+
/* Subroutine */ int clatps_(char *uplo, char *trans, char *diag, char *
normin, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_complex *x, __CLPK_real *scale, __CLPK_real *cnorm,
__CLPK_integer *info);
-
-/* Subroutine */ int clatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_complex *a,
+
+/* Subroutine */ int clatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_real *e, __CLPK_complex *tau, __CLPK_complex *w, __CLPK_integer *ldw);
-
+
/* Subroutine */ int clatrs_(char *uplo, char *trans, char *diag, char *
normin, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *x, __CLPK_real *scale,
__CLPK_real *cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int clatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l, __CLPK_complex *a,
+
+/* Subroutine */ int clatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work);
-
-/* Subroutine */ int clatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *v,
- __CLPK_integer *incv, __CLPK_complex *tau, __CLPK_complex *c1, __CLPK_complex *c2, __CLPK_integer *ldc,
+
+/* Subroutine */ int clatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *v,
+ __CLPK_integer *incv, __CLPK_complex *tau, __CLPK_complex *c1, __CLPK_complex *c2, __CLPK_integer *ldc,
__CLPK_complex *work);
-
+
/* Subroutine */ int clauu2_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
+
/* Subroutine */ int clauum_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
+
/* Subroutine */ int cpbcon_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
- __CLPK_integer *ldab, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork,
+ __CLPK_integer *ldab, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int cpbequ_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
__CLPK_integer *ldab, __CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int cpbrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
- nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *afb, __CLPK_integer *ldafb,
+ nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *afb, __CLPK_integer *ldafb,
__CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *
berr, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cpbstf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
__CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int cpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int cpbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int cpbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *afb, __CLPK_integer *
- ldafb, char *equed, __CLPK_real *s, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x,
- __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work,
+ ldafb, char *equed, __CLPK_real *s, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x,
+ __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work,
__CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cpbtf2_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
__CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int cpbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_complex *ab,
__CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int cpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
+
/* Subroutine */ int cpocon_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int cpoequ_(__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *s,
+
+/* Subroutine */ int cpoequ_(__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *s,
__CLPK_real *scond, __CLPK_real *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int cporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_complex *b, __CLPK_integer *ldb,
- __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work,
+ __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work,
__CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cposvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, char *
- equed, __CLPK_real *s, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx,
- __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
+ equed, __CLPK_real *s, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx,
+ __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int cpotf2_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
+
/* Subroutine */ int cpotrf_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
+
/* Subroutine */ int cpotri_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
+
/* Subroutine */ int cpotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cppcon_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *anorm,
__CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int cppequ_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *s,
+
+/* Subroutine */ int cppequ_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_real *s,
__CLPK_real *scond, __CLPK_real *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int cpprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
- ap, __CLPK_complex *afp, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx,
+ ap, __CLPK_complex *afp, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx,
__CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cppsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_complex *ap, __CLPK_complex *afp, char *equed, __CLPK_real *s, __CLPK_complex *b,
- __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real
+ nrhs, __CLPK_complex *ap, __CLPK_complex *afp, char *equed, __CLPK_real *s, __CLPK_complex *b,
+ __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real
*berr, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cpptrf_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
info);
-
+
/* Subroutine */ int cpptri_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
info);
-
+
/* Subroutine */ int cpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int cptcon_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_complex *e, __CLPK_real *anorm,
+
+/* Subroutine */ int cptcon_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_complex *e, __CLPK_real *anorm,
__CLPK_real *rcond, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cptrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__,
- __CLPK_complex *e, __CLPK_real *df, __CLPK_complex *ef, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex
- *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
+ __CLPK_complex *e, __CLPK_real *df, __CLPK_complex *ef, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex
+ *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int cptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_complex *e,
+
+/* Subroutine */ int cptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_complex *e,
__CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cptsvx_(char *fact, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__,
- __CLPK_complex *e, __CLPK_real *df, __CLPK_complex *ef, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex
- *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work,
+ __CLPK_complex *e, __CLPK_real *df, __CLPK_complex *ef, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex
+ *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work,
__CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cpttrf_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_complex *e, __CLPK_integer *info);
-
+
/* Subroutine */ int cpttrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__,
__CLPK_complex *e, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cptts2_(__CLPK_integer *iuplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *
d__, __CLPK_complex *e, __CLPK_complex *b, __CLPK_integer *ldb);
-
+
/* Subroutine */ int crot_(__CLPK_integer *n, __CLPK_complex *cx, __CLPK_integer *incx, __CLPK_complex *
cy, __CLPK_integer *incy, __CLPK_real *c__, __CLPK_complex *s);
-
+
/* Subroutine */ int cspcon_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int cspmv_(char *uplo, __CLPK_integer *n, __CLPK_complex *alpha, __CLPK_complex *
ap, __CLPK_complex *x, __CLPK_integer *incx, __CLPK_complex *beta, __CLPK_complex *y, __CLPK_integer *
incy);
-
+
/* Subroutine */ int cspr_(char *uplo, __CLPK_integer *n, __CLPK_complex *alpha, __CLPK_complex *x,
__CLPK_integer *incx, __CLPK_complex *ap);
-
+
/* Subroutine */ int csprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_complex *afp, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x,
- __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
+ __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int cspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int cspsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *ap, __CLPK_complex *afp, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *
- ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
+ ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int csptrf_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int csptri_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_integer *
ipiv, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int csptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
ap, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int csrot_(__CLPK_integer *n, __CLPK_complex *cx, __CLPK_integer *incx, __CLPK_complex *
cy, __CLPK_integer *incy, __CLPK_real *c__, __CLPK_real *s);
-
+
/* Subroutine */ int csrscl_(__CLPK_integer *n, __CLPK_real *sa, __CLPK_complex *sx, __CLPK_integer *incx);
-
-/* Subroutine */ int cstedc_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int cstedc_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
__CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *
rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cstein_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_integer *m, __CLPK_real
- *w, __CLPK_integer *iblock, __CLPK_integer *isplit, __CLPK_complex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int cstein_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_integer *m, __CLPK_real
+ *w, __CLPK_integer *iblock, __CLPK_integer *isplit, __CLPK_complex *z__, __CLPK_integer *ldz,
__CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int csteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int csteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
__CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int csycon_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_integer *
info);
-
+
/* Subroutine */ int csymv_(char *uplo, __CLPK_integer *n, __CLPK_complex *alpha, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *x, __CLPK_integer *incx, __CLPK_complex *beta, __CLPK_complex *y,
__CLPK_integer *incy);
-
+
/* Subroutine */ int csyr_(char *uplo, __CLPK_integer *n, __CLPK_complex *alpha, __CLPK_complex *x,
__CLPK_integer *incx, __CLPK_complex *a, __CLPK_integer *lda);
-
+
/* Subroutine */ int csyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_complex *
- b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
+ b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int csysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int csysvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *af, __CLPK_integer *ldaf, __CLPK_integer *
ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *rcond,
- __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
+ __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int csytf2_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int csytrf_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int csytri_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int csytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int ctbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *rcond, __CLPK_complex *work,
+
+/* Subroutine */ int ctbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *rcond, __CLPK_complex *work,
__CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *b,
- __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
+
+/* Subroutine */ int ctbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *b,
+ __CLPK_integer *ldb, __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr,
__CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *b,
+
+/* Subroutine */ int ctbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int ctgevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
- __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm,
+
+/* Subroutine */ int ctgevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
+ __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm,
__CLPK_integer *m, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *q,
+
+/* Subroutine */ int ctgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *q,
__CLPK_integer *ldq, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *j1, __CLPK_integer *info);
-
-/* Subroutine */ int ctgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *q,
+
+/* Subroutine */ int ctgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *q,
__CLPK_integer *ldq, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *ifst, __CLPK_integer *
ilst, __CLPK_integer *info);
-
-/* Subroutine */ int ctgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
- __CLPK_logical *select, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b,
+
+/* Subroutine */ int ctgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
+ __CLPK_logical *select, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b,
__CLPK_integer *ldb, __CLPK_complex *alpha, __CLPK_complex *beta, __CLPK_complex *q, __CLPK_integer *ldq,
__CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *m, __CLPK_real *pl, __CLPK_real *pr, __CLPK_real *
- dif, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+ dif, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ctgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+
+/* Subroutine */ int ctgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
__CLPK_integer *p, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *a, __CLPK_integer *
- lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *tola, __CLPK_real *tolb, __CLPK_real *alpha,
- __CLPK_real *beta, __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *v, __CLPK_integer *ldv,
+ lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *tola, __CLPK_real *tolb, __CLPK_real *alpha,
+ __CLPK_real *beta, __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *v, __CLPK_integer *ldv,
__CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *work, __CLPK_integer *ncycle, __CLPK_integer *
info);
-
-/* Subroutine */ int ctgsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
- __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_real *s, __CLPK_real
- *dif, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer
+
+/* Subroutine */ int ctgsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
+ __CLPK_complex *vl, __CLPK_integer *ldvl, __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_real *s, __CLPK_real
+ *dif, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer
*iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int ctgsy2_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
- n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__,
- __CLPK_integer *ldc, __CLPK_complex *d__, __CLPK_integer *ldd, __CLPK_complex *e, __CLPK_integer *lde,
- __CLPK_complex *f, __CLPK_integer *ldf, __CLPK_real *scale, __CLPK_real *rdsum, __CLPK_real *rdscal,
+ n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__,
+ __CLPK_integer *ldc, __CLPK_complex *d__, __CLPK_integer *ldd, __CLPK_complex *e, __CLPK_integer *lde,
+ __CLPK_complex *f, __CLPK_integer *ldf, __CLPK_real *scale, __CLPK_real *rdsum, __CLPK_real *rdscal,
__CLPK_integer *info);
-
+
/* Subroutine */ int ctgsyl_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
- n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__,
- __CLPK_integer *ldc, __CLPK_complex *d__, __CLPK_integer *ldd, __CLPK_complex *e, __CLPK_integer *lde,
- __CLPK_complex *f, __CLPK_integer *ldf, __CLPK_real *scale, __CLPK_real *dif, __CLPK_complex *work,
+ n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *c__,
+ __CLPK_integer *ldc, __CLPK_complex *d__, __CLPK_integer *ldd, __CLPK_complex *e, __CLPK_integer *lde,
+ __CLPK_complex *f, __CLPK_integer *ldf, __CLPK_real *scale, __CLPK_real *dif, __CLPK_complex *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int ctpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_complex *ap, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_complex *ap, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x,
- __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
+
+/* Subroutine */ int ctprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_complex *ap, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_complex *x,
+ __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ctptri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_complex *ap,
+
+/* Subroutine */ int ctptri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_complex *ap,
__CLPK_integer *info);
-
-/* Subroutine */ int ctptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int ctptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_complex *ap, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int ctrcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork,
+
+/* Subroutine */ int ctrcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *rcond, __CLPK_complex *work, __CLPK_real *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ctrevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *vl, __CLPK_integer *ldvl,
- __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_complex *work,
+
+/* Subroutine */ int ctrevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *vl, __CLPK_integer *ldvl,
+ __CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_complex *work,
__CLPK_real *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int ctrexc_(char *compq, __CLPK_integer *n, __CLPK_complex *t, __CLPK_integer *
ldt, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_integer *ifst, __CLPK_integer *ilst, __CLPK_integer *
info);
-
-/* Subroutine */ int ctrrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
- __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real
+
+/* Subroutine */ int ctrrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
+ __CLPK_complex *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_complex *work, __CLPK_real
*rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctrsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
- *n, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *w,
- __CLPK_integer *m, __CLPK_real *s, __CLPK_real *sep, __CLPK_complex *work, __CLPK_integer *lwork,
+
+/* Subroutine */ int ctrsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
+ *n, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *w,
+ __CLPK_integer *m, __CLPK_real *s, __CLPK_real *sep, __CLPK_complex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ctrsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *vl, __CLPK_integer *ldvl,
+
+/* Subroutine */ int ctrsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_complex *t, __CLPK_integer *ldt, __CLPK_complex *vl, __CLPK_integer *ldvl,
__CLPK_complex *vr, __CLPK_integer *ldvr, __CLPK_real *s, __CLPK_real *sep, __CLPK_integer *mm, __CLPK_integer *
m, __CLPK_complex *work, __CLPK_integer *ldwork, __CLPK_real *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ctrsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
- *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int ctrsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
+ *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
__CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_real *scale, __CLPK_integer *info);
-
-/* Subroutine */ int ctrti2_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_complex *a,
+
+/* Subroutine */ int ctrti2_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int ctrtri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_complex *a,
+
+/* Subroutine */ int ctrtri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int ctrtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int ctrtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int ctzrqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_integer *info);
-
+
/* Subroutine */ int ctzrzf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cung2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cung2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cung2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cung2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cungbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int cungbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int cunghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *
- a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer
+ a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer
*info);
-
-/* Subroutine */ int cungl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cungl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cunglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cunglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cungql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cungql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cungqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cungqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cungr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cungr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cungrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
+
+/* Subroutine */ int cungrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int cungtr_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_complex *tau, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cunm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cunm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cunmbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
+
+/* Subroutine */ int cunmbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
__CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cunmhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
+
+/* Subroutine */ int cunmhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
__CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cunml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cunmlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunmlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cunmql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunmql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cunmqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunmqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cunmr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunmr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cunmr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
+
+/* Subroutine */ int cunmr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
__CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cunmrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunmrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int cunmrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
+
+/* Subroutine */ int cunmrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau,
__CLPK_complex *c__, __CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int cunmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
+
+/* Subroutine */ int cunmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_complex *tau, __CLPK_complex *c__,
__CLPK_integer *ldc, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int cupgtr_(char *uplo, __CLPK_integer *n, __CLPK_complex *ap, __CLPK_complex *
tau, __CLPK_complex *q, __CLPK_integer *ldq, __CLPK_complex *work, __CLPK_integer *info);
-
-/* Subroutine */ int cupmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_complex *ap, __CLPK_complex *tau, __CLPK_complex *c__, __CLPK_integer *ldc,
+
+/* Subroutine */ int cupmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_complex *ap, __CLPK_complex *tau, __CLPK_complex *c__, __CLPK_integer *ldc,
__CLPK_complex *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dbdsdc_(char *uplo, char *compq, __CLPK_integer *n, __CLPK_doublereal *
- d__, __CLPK_doublereal *e, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt,
+ d__, __CLPK_doublereal *e, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt,
__CLPK_integer *ldvt, __CLPK_doublereal *q, __CLPK_integer *iq, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dbdsqr_(char *uplo, __CLPK_integer *n, __CLPK_integer *ncvt, __CLPK_integer *
- nru, __CLPK_integer *ncc, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *vt,
+ nru, __CLPK_integer *ncc, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *vt,
__CLPK_integer *ldvt, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *c__, __CLPK_integer *
ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int ddisna_(char *job, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
d__, __CLPK_doublereal *sep, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbbrd_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *ncc,
__CLPK_integer *kl, __CLPK_integer *ku, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *
- d__, __CLPK_doublereal *e, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *pt,
- __CLPK_integer *ldpt, __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work,
+ d__, __CLPK_doublereal *e, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *pt,
+ __CLPK_integer *ldpt, __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work,
__CLPK_integer *info);
-
+
/* Subroutine */ int dgbcon_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *anorm,
+ __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *anorm,
__CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
+ __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
__CLPK_doublereal *rowcnd, __CLPK_doublereal *colcnd, __CLPK_doublereal *amax, __CLPK_integer *
info);
-
+
/* Subroutine */ int dgbrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
- ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *afb,
- __CLPK_integer *ldafb, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *afb,
+ __CLPK_integer *ldafb, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
- nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
+ nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *kl,
- __CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab,
- __CLPK_doublereal *afb, __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed,
- __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
+ __CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab,
+ __CLPK_doublereal *afb, __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed,
+ __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbtf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbtrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int dgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
- ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
+ ku, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+
+/* Subroutine */ int dgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
__CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_integer *m, __CLPK_doublereal *v, __CLPK_integer *
ldv, __CLPK_integer *info);
-
+
/* Subroutine */ int dgebal_(char *job, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_integer *info);
-
+
/* Subroutine */ int dgebd2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tauq, __CLPK_doublereal *
taup, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dgebrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tauq, __CLPK_doublereal *
taup, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgecon_(char *norm, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
- lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd, __CLPK_doublereal
+ lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd, __CLPK_doublereal
*colcnd, __CLPK_doublereal *amax, __CLPK_integer *info);
-
-/* Subroutine */ int dgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_doublereal *wr,
- __CLPK_doublereal *wi, __CLPK_doublereal *vs, __CLPK_integer *ldvs, __CLPK_doublereal *work,
+
+/* Subroutine */ int dgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_doublereal *wr,
+ __CLPK_doublereal *wi, __CLPK_doublereal *vs, __CLPK_integer *ldvs, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeesx_(char *jobvs, char *sort, __CLPK_L_fp select, char *
- sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *sdim,
- __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_doublereal *vs, __CLPK_integer *ldvs,
+ sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *sdim,
+ __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_doublereal *vs, __CLPK_integer *ldvs,
__CLPK_doublereal *rconde, __CLPK_doublereal *rcondv, __CLPK_doublereal *work, __CLPK_integer *
lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_doublereal *vl,
- __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *work,
+ a, __CLPK_integer *lda, __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_doublereal *vl,
+ __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeevx_(char *balanc, char *jobvl, char *jobvr, char *
- sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *wr,
- __CLPK_doublereal *wi, __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr,
- __CLPK_integer *ldvr, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *scale,
- __CLPK_doublereal *abnrm, __CLPK_doublereal *rconde, __CLPK_doublereal *rcondv, __CLPK_doublereal
+ sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *wr,
+ __CLPK_doublereal *wi, __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr,
+ __CLPK_integer *ldvr, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *scale,
+ __CLPK_doublereal *abnrm, __CLPK_doublereal *rconde, __CLPK_doublereal *rcondv, __CLPK_doublereal
*work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n,
+
+/* Subroutine */ int dgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *
- alphar, __CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vsl,
- __CLPK_integer *ldvsl, __CLPK_doublereal *vsr, __CLPK_integer *ldvsr, __CLPK_doublereal *work,
+ alphar, __CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vsl,
+ __CLPK_integer *ldvsl, __CLPK_doublereal *vsr, __CLPK_integer *ldvsr, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgegv_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *alphar,
- __CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vl, __CLPK_integer *ldvl,
- __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *alphar,
+ __CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vl, __CLPK_integer *ldvl,
+ __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
+
+/* Subroutine */ int dgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
+
+/* Subroutine */ int dgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgelq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dgelqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgels_(char *trans, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *
s, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgelss_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dgelss_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *
s, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
jpvt, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublereal *work, __CLPK_integer *
info);
-
-/* Subroutine */ int dgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
jpvt, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublereal *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeql2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeqlf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeqp3_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *jpvt, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dgeqpf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *jpvt, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeqr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dgeqrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf, __CLPK_integer *
- ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx,
- __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork,
+ ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx,
+ __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dgerq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dgerqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgesc2_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
+
+/* Subroutine */ int dgesc2_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
__CLPK_doublereal *rhs, __CLPK_integer *ipiv, __CLPK_integer *jpiv, __CLPK_doublereal *scale);
-
+
/* Subroutine */ int dgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *u, __CLPK_integer *ldu,
- __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *u, __CLPK_integer *ldu,
+ __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *a, __CLPK_integer
+
+/* Subroutine */ int dgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *a, __CLPK_integer
*lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *u, __CLPK_integer *
- ldu, __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ ldu, __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dgesvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
- __CLPK_integer *ipiv, char *equed, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
+ nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
+ __CLPK_integer *ipiv, char *equed, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgetc2_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer
+
+/* Subroutine */ int dgetc2_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer
*ipiv, __CLPK_integer *jpiv, __CLPK_integer *info);
-
+
/* Subroutine */ int dgetf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int dgetrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int dgetri_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer
+
+/* Subroutine */ int dgetri_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer
*ipiv, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale, __CLPK_integer *m,
+
+/* Subroutine */ int dggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale, __CLPK_integer *m,
__CLPK_doublereal *v, __CLPK_integer *ldv, __CLPK_integer *info);
-
+
/* Subroutine */ int dggbal_(char *job, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
- lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi,
+ lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi,
__CLPK_doublereal *lscale, __CLPK_doublereal *rscale, __CLPK_doublereal *work, __CLPK_integer *
info);
-
-/* Subroutine */ int dgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
- delctg, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
- __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublereal *alphar, __CLPK_doublereal *alphai,
- __CLPK_doublereal *beta, __CLPK_doublereal *vsl, __CLPK_integer *ldvsl, __CLPK_doublereal *vsr,
- __CLPK_integer *ldvsr, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_logical *bwork,
+
+/* Subroutine */ int dgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+ delctg, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
+ __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublereal *alphar, __CLPK_doublereal *alphai,
+ __CLPK_doublereal *beta, __CLPK_doublereal *vsl, __CLPK_integer *ldvsl, __CLPK_doublereal *vsr,
+ __CLPK_integer *ldvsr, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_logical *bwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
- delctg, char *sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
- __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublereal *alphar,
+
+/* Subroutine */ int dggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+ delctg, char *sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
+ __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublereal *alphar,
__CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vsl, __CLPK_integer *ldvsl,
__CLPK_doublereal *vsr, __CLPK_integer *ldvsr, __CLPK_doublereal *rconde, __CLPK_doublereal *
rcondv, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *
liwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dggev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *alphar,
- __CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vl, __CLPK_integer *ldvl,
- __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *alphar,
+ __CLPK_doublereal *alphai, __CLPK_doublereal *beta, __CLPK_doublereal *vl, __CLPK_integer *ldvl,
+ __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dggevx_(char *balanc, char *jobvl, char *jobvr, char *
- sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
+ sense, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
__CLPK_integer *ldb, __CLPK_doublereal *alphar, __CLPK_doublereal *alphai, __CLPK_doublereal *
- beta, __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale,
+ beta, __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale,
__CLPK_doublereal *abnrm, __CLPK_doublereal *bbnrm, __CLPK_doublereal *rconde, __CLPK_doublereal *
rcondv, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_logical *
bwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *d__,
- __CLPK_doublereal *x, __CLPK_doublereal *y, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *d__,
+ __CLPK_doublereal *x, __CLPK_doublereal *y, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dgghrd_(char *compq, char *compz, __CLPK_integer *n, __CLPK_integer *
- ilo, __CLPK_integer *ihi, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
+ ilo, __CLPK_integer *ihi, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
__CLPK_integer *ldb, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *
ldz, __CLPK_integer *info);
-
+
/* Subroutine */ int dgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *c__,
- __CLPK_doublereal *d__, __CLPK_doublereal *x, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *c__,
+ __CLPK_doublereal *d__, __CLPK_doublereal *x, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *taua, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ a, __CLPK_integer *lda, __CLPK_doublereal *taua, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_doublereal *taub, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *taua, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ a, __CLPK_integer *lda, __CLPK_doublereal *taua, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_doublereal *taub, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_integer *p, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a,
- __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *alpha,
- __CLPK_doublereal *beta, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *v, __CLPK_integer
- *ldv, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int dggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_integer *p, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a,
+ __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *alpha,
+ __CLPK_doublereal *beta, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *v, __CLPK_integer
+ *ldv, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *p, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
- __CLPK_integer *ldb, __CLPK_doublereal *tola, __CLPK_doublereal *tolb, __CLPK_integer *k, __CLPK_integer
- *l, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *v, __CLPK_integer *ldv,
- __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *iwork, __CLPK_doublereal *tau,
+
+/* Subroutine */ int dggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *p, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
+ __CLPK_integer *ldb, __CLPK_doublereal *tola, __CLPK_doublereal *tolb, __CLPK_integer *k, __CLPK_integer
+ *l, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *v, __CLPK_integer *ldv,
+ __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *iwork, __CLPK_doublereal *tau,
__CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dgtcon_(char *norm, __CLPK_integer *n, __CLPK_doublereal *dl,
- __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *du2, __CLPK_integer *ipiv,
+
+/* Subroutine */ int dgtcon_(char *norm, __CLPK_integer *n, __CLPK_doublereal *dl,
+ __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *du2, __CLPK_integer *ipiv,
__CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgtrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *dlf,
- __CLPK_doublereal *df, __CLPK_doublereal *duf, __CLPK_doublereal *du2, __CLPK_integer *ipiv,
+
+/* Subroutine */ int dgtrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *dlf,
+ __CLPK_doublereal *df, __CLPK_doublereal *duf, __CLPK_doublereal *du2, __CLPK_integer *ipiv,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *
info);
-
-/* Subroutine */ int dgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *dl,
- __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer
+
+/* Subroutine */ int dgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *dl,
+ __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer
*info);
-
+
/* Subroutine */ int dgtsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *
- dlf, __CLPK_doublereal *df, __CLPK_doublereal *duf, __CLPK_doublereal *du2, __CLPK_integer *ipiv,
+ dlf, __CLPK_doublereal *df, __CLPK_doublereal *duf, __CLPK_doublereal *du2, __CLPK_integer *ipiv,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dgttrf_(__CLPK_integer *n, __CLPK_doublereal *dl, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dgttrf_(__CLPK_integer *n, __CLPK_doublereal *dl, __CLPK_doublereal *d__,
__CLPK_doublereal *du, __CLPK_doublereal *du2, __CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int dgttrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *du2,
+
+/* Subroutine */ int dgttrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *du2,
__CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *du2,
+
+/* Subroutine */ int dgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du, __CLPK_doublereal *du2,
__CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int dhgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
+
+/* Subroutine */ int dhgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *
b, __CLPK_integer *ldb, __CLPK_doublereal *alphar, __CLPK_doublereal *alphai, __CLPK_doublereal *
- beta, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz,
+ beta, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz,
__CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dhsein_(char *side, char *eigsrc, char *initv, __CLPK_logical *
- select, __CLPK_integer *n, __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal *wr,
- __CLPK_doublereal *wi, __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr,
+ select, __CLPK_integer *n, __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal *wr,
+ __CLPK_doublereal *wi, __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr,
__CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublereal *work, __CLPK_integer *
ifaill, __CLPK_integer *ifailr, __CLPK_integer *info);
-
+
/* Subroutine */ int dhseqr_(char *job, char *compz, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal *wr,
- __CLPK_doublereal *wi, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ __CLPK_integer *ihi, __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal *wr,
+ __CLPK_doublereal *wi, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dlabad_(__CLPK_doublereal *small, __CLPK_doublereal *large);
-
+
/* Subroutine */ int dlabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tauq,
- __CLPK_doublereal *taup, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *y, __CLPK_integer
+ a, __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tauq,
+ __CLPK_doublereal *taup, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *y, __CLPK_integer
*ldy);
-
-/* Subroutine */ int dlacon_(__CLPK_integer *n, __CLPK_doublereal *v, __CLPK_doublereal *x,
+
+/* Subroutine */ int dlacon_(__CLPK_integer *n, __CLPK_doublereal *v, __CLPK_doublereal *x,
__CLPK_integer *isgn, __CLPK_doublereal *est, __CLPK_integer *kase);
-
+
/* Subroutine */ int dlacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int dladiv_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
+
+/* Subroutine */ int dladiv_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
__CLPK_doublereal *d__, __CLPK_doublereal *p, __CLPK_doublereal *q);
-
-/* Subroutine */ int dlae2_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
+
+/* Subroutine */ int dlae2_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
__CLPK_doublereal *rt1, __CLPK_doublereal *rt2);
-
-/* Subroutine */ int dlaebz_(__CLPK_integer *ijob, __CLPK_integer *nitmax, __CLPK_integer *n,
- __CLPK_integer *mmax, __CLPK_integer *minp, __CLPK_integer *nbmin, __CLPK_doublereal *abstol,
+
+/* Subroutine */ int dlaebz_(__CLPK_integer *ijob, __CLPK_integer *nitmax, __CLPK_integer *n,
+ __CLPK_integer *mmax, __CLPK_integer *minp, __CLPK_integer *nbmin, __CLPK_doublereal *abstol,
__CLPK_doublereal *reltol, __CLPK_doublereal *pivmin, __CLPK_doublereal *d__, __CLPK_doublereal *
- e, __CLPK_doublereal *e2, __CLPK_integer *nval, __CLPK_doublereal *ab, __CLPK_doublereal *c__,
- __CLPK_integer *mout, __CLPK_integer *nab, __CLPK_doublereal *work, __CLPK_integer *iwork,
+ e, __CLPK_doublereal *e2, __CLPK_integer *nval, __CLPK_doublereal *ab, __CLPK_doublereal *c__,
+ __CLPK_integer *mout, __CLPK_integer *nab, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dlaed0_(__CLPK_integer *icompq, __CLPK_integer *qsiz, __CLPK_integer *n,
- __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *q, __CLPK_integer *ldq,
- __CLPK_doublereal *qstore, __CLPK_integer *ldqs, __CLPK_doublereal *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int dlaed0_(__CLPK_integer *icompq, __CLPK_integer *qsiz, __CLPK_integer *n,
+ __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *q, __CLPK_integer *ldq,
+ __CLPK_doublereal *qstore, __CLPK_integer *ldqs, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dlaed1_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *q,
- __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_doublereal *rho, __CLPK_integer *cutpnt,
+
+/* Subroutine */ int dlaed1_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *q,
+ __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_doublereal *rho, __CLPK_integer *cutpnt,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dlaed2_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *n1, __CLPK_doublereal *
- d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_doublereal *rho,
- __CLPK_doublereal *z__, __CLPK_doublereal *dlamda, __CLPK_doublereal *w, __CLPK_doublereal *q2,
- __CLPK_integer *indx, __CLPK_integer *indxc, __CLPK_integer *indxp, __CLPK_integer *coltyp,
+ d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_doublereal *rho,
+ __CLPK_doublereal *z__, __CLPK_doublereal *dlamda, __CLPK_doublereal *w, __CLPK_doublereal *q2,
+ __CLPK_integer *indx, __CLPK_integer *indxc, __CLPK_integer *indxp, __CLPK_integer *coltyp,
__CLPK_integer *info);
-
+
/* Subroutine */ int dlaed3_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *n1, __CLPK_doublereal *
d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *rho, __CLPK_doublereal *dlamda,
- __CLPK_doublereal *q2, __CLPK_integer *indx, __CLPK_integer *ctot, __CLPK_doublereal *w,
+ __CLPK_doublereal *q2, __CLPK_integer *indx, __CLPK_integer *ctot, __CLPK_doublereal *w,
__CLPK_doublereal *s, __CLPK_integer *info);
-
-/* Subroutine */ int dlaed4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dlaed4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_doublereal *d__,
__CLPK_doublereal *z__, __CLPK_doublereal *delta, __CLPK_doublereal *rho, __CLPK_doublereal *dlam,
__CLPK_integer *info);
-
-/* Subroutine */ int dlaed5_(__CLPK_integer *i__, __CLPK_doublereal *d__, __CLPK_doublereal *z__,
+
+/* Subroutine */ int dlaed5_(__CLPK_integer *i__, __CLPK_doublereal *d__, __CLPK_doublereal *z__,
__CLPK_doublereal *delta, __CLPK_doublereal *rho, __CLPK_doublereal *dlam);
-
+
/* Subroutine */ int dlaed6_(__CLPK_integer *kniter, __CLPK_logical *orgati, __CLPK_doublereal *
rho, __CLPK_doublereal *d__, __CLPK_doublereal *z__, __CLPK_doublereal *finit, __CLPK_doublereal *
tau, __CLPK_integer *info);
-
-/* Subroutine */ int dlaed7_(__CLPK_integer *icompq, __CLPK_integer *n, __CLPK_integer *qsiz,
- __CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_doublereal *d__,
- __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_doublereal *rho, __CLPK_integer
+
+/* Subroutine */ int dlaed7_(__CLPK_integer *icompq, __CLPK_integer *n, __CLPK_integer *qsiz,
+ __CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_doublereal *d__,
+ __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_doublereal *rho, __CLPK_integer
*cutpnt, __CLPK_doublereal *qstore, __CLPK_integer *qptr, __CLPK_integer *prmptr, __CLPK_integer *
- perm, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_doublereal *givnum,
+ perm, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_doublereal *givnum,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dlaed8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_integer *n, __CLPK_integer
- *qsiz, __CLPK_doublereal *d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *indxq,
+
+/* Subroutine */ int dlaed8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_integer *n, __CLPK_integer
+ *qsiz, __CLPK_doublereal *d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *indxq,
__CLPK_doublereal *rho, __CLPK_integer *cutpnt, __CLPK_doublereal *z__, __CLPK_doublereal *dlamda,
- __CLPK_doublereal *q2, __CLPK_integer *ldq2, __CLPK_doublereal *w, __CLPK_integer *perm, __CLPK_integer
- *givptr, __CLPK_integer *givcol, __CLPK_doublereal *givnum, __CLPK_integer *indxp, __CLPK_integer
+ __CLPK_doublereal *q2, __CLPK_integer *ldq2, __CLPK_doublereal *w, __CLPK_integer *perm, __CLPK_integer
+ *givptr, __CLPK_integer *givcol, __CLPK_doublereal *givnum, __CLPK_integer *indxp, __CLPK_integer
*indx, __CLPK_integer *info);
-
-/* Subroutine */ int dlaed9_(__CLPK_integer *k, __CLPK_integer *kstart, __CLPK_integer *kstop,
+
+/* Subroutine */ int dlaed9_(__CLPK_integer *k, __CLPK_integer *kstart, __CLPK_integer *kstop,
__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *
- rho, __CLPK_doublereal *dlamda, __CLPK_doublereal *w, __CLPK_doublereal *s, __CLPK_integer *lds,
+ rho, __CLPK_doublereal *dlamda, __CLPK_doublereal *w, __CLPK_doublereal *s, __CLPK_integer *lds,
__CLPK_integer *info);
-
-/* Subroutine */ int dlaeda_(__CLPK_integer *n, __CLPK_integer *tlvls, __CLPK_integer *curlvl,
- __CLPK_integer *curpbm, __CLPK_integer *prmptr, __CLPK_integer *perm, __CLPK_integer *givptr,
- __CLPK_integer *givcol, __CLPK_doublereal *givnum, __CLPK_doublereal *q, __CLPK_integer *qptr,
+
+/* Subroutine */ int dlaeda_(__CLPK_integer *n, __CLPK_integer *tlvls, __CLPK_integer *curlvl,
+ __CLPK_integer *curpbm, __CLPK_integer *prmptr, __CLPK_integer *perm, __CLPK_integer *givptr,
+ __CLPK_integer *givcol, __CLPK_doublereal *givnum, __CLPK_doublereal *q, __CLPK_integer *qptr,
__CLPK_doublereal *z__, __CLPK_doublereal *ztemp, __CLPK_integer *info);
-
-/* Subroutine */ int dlaein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
- __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal *wr, __CLPK_doublereal *wi,
- __CLPK_doublereal *vr, __CLPK_doublereal *vi, __CLPK_doublereal *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int dlaein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
+ __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal *wr, __CLPK_doublereal *wi,
+ __CLPK_doublereal *vr, __CLPK_doublereal *vi, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_doublereal *work, __CLPK_doublereal *eps3, __CLPK_doublereal *smlnum, __CLPK_doublereal *
bignum, __CLPK_integer *info);
-
-/* Subroutine */ int dlaev2_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
+
+/* Subroutine */ int dlaev2_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
__CLPK_doublereal *rt1, __CLPK_doublereal *rt2, __CLPK_doublereal *cs1, __CLPK_doublereal *sn1);
-
-/* Subroutine */ int dlaexc_(__CLPK_logical *wantq, __CLPK_integer *n, __CLPK_doublereal *t,
- __CLPK_integer *ldt, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *j1, __CLPK_integer *n1,
+
+/* Subroutine */ int dlaexc_(__CLPK_logical *wantq, __CLPK_integer *n, __CLPK_doublereal *t,
+ __CLPK_integer *ldt, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *j1, __CLPK_integer *n1,
__CLPK_integer *n2, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dlag2_(__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
+
+/* Subroutine */ int dlag2_(__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
__CLPK_integer *ldb, __CLPK_doublereal *safmin, __CLPK_doublereal *scale1, __CLPK_doublereal *
scale2, __CLPK_doublereal *wr1, __CLPK_doublereal *wr2, __CLPK_doublereal *wi);
-
-/* Subroutine */ int dlags2_(__CLPK_logical *upper, __CLPK_doublereal *a1, __CLPK_doublereal *a2,
- __CLPK_doublereal *a3, __CLPK_doublereal *b1, __CLPK_doublereal *b2, __CLPK_doublereal *b3,
- __CLPK_doublereal *csu, __CLPK_doublereal *snu, __CLPK_doublereal *csv, __CLPK_doublereal *snv,
+
+/* Subroutine */ int dlags2_(__CLPK_logical *upper, __CLPK_doublereal *a1, __CLPK_doublereal *a2,
+ __CLPK_doublereal *a3, __CLPK_doublereal *b1, __CLPK_doublereal *b2, __CLPK_doublereal *b3,
+ __CLPK_doublereal *csu, __CLPK_doublereal *snu, __CLPK_doublereal *csv, __CLPK_doublereal *snv,
__CLPK_doublereal *csq, __CLPK_doublereal *snq);
-
-/* Subroutine */ int dlagtf_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_doublereal *lambda,
- __CLPK_doublereal *b, __CLPK_doublereal *c__, __CLPK_doublereal *tol, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dlagtf_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_doublereal *lambda,
+ __CLPK_doublereal *b, __CLPK_doublereal *c__, __CLPK_doublereal *tol, __CLPK_doublereal *d__,
__CLPK_integer *in, __CLPK_integer *info);
-
-/* Subroutine */ int dlagtm_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *alpha, __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du,
- __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *beta, __CLPK_doublereal *b, __CLPK_integer
+
+/* Subroutine */ int dlagtm_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *alpha, __CLPK_doublereal *dl, __CLPK_doublereal *d__, __CLPK_doublereal *du,
+ __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *beta, __CLPK_doublereal *b, __CLPK_integer
*ldb);
-
-/* Subroutine */ int dlagts_(__CLPK_integer *job, __CLPK_integer *n, __CLPK_doublereal *a,
- __CLPK_doublereal *b, __CLPK_doublereal *c__, __CLPK_doublereal *d__, __CLPK_integer *in,
+
+/* Subroutine */ int dlagts_(__CLPK_integer *job, __CLPK_integer *n, __CLPK_doublereal *a,
+ __CLPK_doublereal *b, __CLPK_doublereal *c__, __CLPK_doublereal *d__, __CLPK_integer *in,
__CLPK_doublereal *y, __CLPK_doublereal *tol, __CLPK_integer *info);
-
-/* Subroutine */ int dlagv2_(__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
+
+/* Subroutine */ int dlagv2_(__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b,
__CLPK_integer *ldb, __CLPK_doublereal *alphar, __CLPK_doublereal *alphai, __CLPK_doublereal *
beta, __CLPK_doublereal *csl, __CLPK_doublereal *snl, __CLPK_doublereal *csr, __CLPK_doublereal *
snr);
-
-/* Subroutine */ int dlahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal
- *wr, __CLPK_doublereal *wi, __CLPK_integer *iloz, __CLPK_integer *ihiz, __CLPK_doublereal *z__,
+
+/* Subroutine */ int dlahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *h__, __CLPK_integer *ldh, __CLPK_doublereal
+ *wr, __CLPK_doublereal *wi, __CLPK_integer *iloz, __CLPK_integer *ihiz, __CLPK_doublereal *z__,
__CLPK_integer *ldz, __CLPK_integer *info);
-
+
/* Subroutine */ int dlahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *t, __CLPK_integer *ldt,
+ a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *t, __CLPK_integer *ldt,
__CLPK_doublereal *y, __CLPK_integer *ldy);
-
-/* Subroutine */ int dlaic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_doublereal *x,
+
+/* Subroutine */ int dlaic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_doublereal *x,
__CLPK_doublereal *sest, __CLPK_doublereal *w, __CLPK_doublereal *gamma, __CLPK_doublereal *
sestpr, __CLPK_doublereal *s, __CLPK_doublereal *c__);
-
-/* Subroutine */ int dlaln2_(__CLPK_logical *ltrans, __CLPK_integer *na, __CLPK_integer *nw,
- __CLPK_doublereal *smin, __CLPK_doublereal *ca, __CLPK_doublereal *a, __CLPK_integer *lda,
- __CLPK_doublereal *d1, __CLPK_doublereal *d2, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_doublereal *x, __CLPK_integer *ldx,
+
+/* Subroutine */ int dlaln2_(__CLPK_logical *ltrans, __CLPK_integer *na, __CLPK_integer *nw,
+ __CLPK_doublereal *smin, __CLPK_doublereal *ca, __CLPK_doublereal *a, __CLPK_integer *lda,
+ __CLPK_doublereal *d1, __CLPK_doublereal *d2, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_doublereal *x, __CLPK_integer *ldx,
__CLPK_doublereal *scale, __CLPK_doublereal *xnorm, __CLPK_integer *info);
-
-/* Subroutine */ int dlals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal
- *bx, __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
+
+/* Subroutine */ int dlals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal
+ *bx, __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
__CLPK_integer *ldgcol, __CLPK_doublereal *givnum, __CLPK_integer *ldgnum, __CLPK_doublereal *
poles, __CLPK_doublereal *difl, __CLPK_doublereal *difr, __CLPK_doublereal *z__, __CLPK_integer *
k, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dlalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
+
+/* Subroutine */ int dlalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *bx, __CLPK_integer *
- ldbx, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *k,
+ ldbx, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *k,
__CLPK_doublereal *difl, __CLPK_doublereal *difr, __CLPK_doublereal *z__, __CLPK_doublereal *
poles, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_integer *
perm, __CLPK_doublereal *givnum, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublereal *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dlalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
- *nrhs, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublereal *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int dlalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
+ *nrhs, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dlamc1_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd, __CLPK_logical
+
+/* Subroutine */ int dlamc1_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd, __CLPK_logical
*ieee1);
-
-/* Subroutine */ int dlamc2_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd,
- __CLPK_doublereal *eps, __CLPK_integer *emin, __CLPK_doublereal *rmin, __CLPK_integer *emax,
+
+/* Subroutine */ int dlamc2_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd,
+ __CLPK_doublereal *eps, __CLPK_integer *emin, __CLPK_doublereal *rmin, __CLPK_integer *emax,
__CLPK_doublereal *rmax);
-
+
/* Subroutine */ int dlamc4_(__CLPK_integer *emin, __CLPK_doublereal *start, __CLPK_integer *base);
-
-/* Subroutine */ int dlamc5_(__CLPK_integer *beta, __CLPK_integer *p, __CLPK_integer *emin,
+
+/* Subroutine */ int dlamc5_(__CLPK_integer *beta, __CLPK_integer *p, __CLPK_integer *emin,
__CLPK_logical *ieee, __CLPK_integer *emax, __CLPK_doublereal *rmax);
-
-/* Subroutine */ int dlamrg_(__CLPK_integer *n1, __CLPK_integer *n2, __CLPK_doublereal *a, __CLPK_integer
+
+/* Subroutine */ int dlamrg_(__CLPK_integer *n1, __CLPK_integer *n2, __CLPK_doublereal *a, __CLPK_integer
*dtrd1, __CLPK_integer *dtrd2, __CLPK_integer *index);
-
-/* Subroutine */ int dlanv2_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
+
+/* Subroutine */ int dlanv2_(__CLPK_doublereal *a, __CLPK_doublereal *b, __CLPK_doublereal *c__,
__CLPK_doublereal *d__, __CLPK_doublereal *rt1r, __CLPK_doublereal *rt1i, __CLPK_doublereal *rt2r,
__CLPK_doublereal *rt2i, __CLPK_doublereal *cs, __CLPK_doublereal *sn);
-
-/* Subroutine */ int dlapll_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
+
+/* Subroutine */ int dlapll_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
__CLPK_doublereal *y, __CLPK_integer *incy, __CLPK_doublereal *ssmin);
-
-/* Subroutine */ int dlapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dlapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_integer *k);
-
+
/* Subroutine */ int dlaqgb_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
+ __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
__CLPK_doublereal *rowcnd, __CLPK_doublereal *colcnd, __CLPK_doublereal *amax, char *equed);
-
+
/* Subroutine */ int dlaqge_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
- lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd, __CLPK_doublereal
+ lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd, __CLPK_doublereal
*colcnd, __CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int dlaqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublereal *tau,
+
+/* Subroutine */ int dlaqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublereal *tau,
__CLPK_doublereal *vn1, __CLPK_doublereal *vn2, __CLPK_doublereal *work);
-
-/* Subroutine */ int dlaqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
- *nb, __CLPK_integer *kb, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *jpvt,
- __CLPK_doublereal *tau, __CLPK_doublereal *vn1, __CLPK_doublereal *vn2, __CLPK_doublereal *auxv,
+
+/* Subroutine */ int dlaqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
+ *nb, __CLPK_integer *kb, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *jpvt,
+ __CLPK_doublereal *tau, __CLPK_doublereal *vn1, __CLPK_doublereal *vn2, __CLPK_doublereal *auxv,
__CLPK_doublereal *f, __CLPK_integer *ldf);
-
+
/* Subroutine */ int dlaqsb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax,
char *equed);
-
-/* Subroutine */ int dlaqsp_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
+
+/* Subroutine */ int dlaqsp_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, char *equed);
-
+
/* Subroutine */ int dlaqsy_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int dlaqtr_(__CLPK_logical *ltran, __CLPK_logical *lreal, __CLPK_integer *n,
- __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *b, __CLPK_doublereal *w, __CLPK_doublereal
+
+/* Subroutine */ int dlaqtr_(__CLPK_logical *ltran, __CLPK_logical *lreal, __CLPK_integer *n,
+ __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *b, __CLPK_doublereal *w, __CLPK_doublereal
*scale, __CLPK_doublereal *x, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dlar1v_(__CLPK_integer *n, __CLPK_integer *b1, __CLPK_integer *bn, __CLPK_doublereal
+
+/* Subroutine */ int dlar1v_(__CLPK_integer *n, __CLPK_integer *b1, __CLPK_integer *bn, __CLPK_doublereal
*sigma, __CLPK_doublereal *d__, __CLPK_doublereal *l, __CLPK_doublereal *ld, __CLPK_doublereal *
- lld, __CLPK_doublereal *gersch, __CLPK_doublereal *z__, __CLPK_doublereal *ztz, __CLPK_doublereal
+ lld, __CLPK_doublereal *gersch, __CLPK_doublereal *z__, __CLPK_doublereal *ztz, __CLPK_doublereal
*mingma, __CLPK_integer *r__, __CLPK_integer *isuppz, __CLPK_doublereal *work);
-
-/* Subroutine */ int dlar2v_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_doublereal *y,
- __CLPK_doublereal *z__, __CLPK_integer *incx, __CLPK_doublereal *c__, __CLPK_doublereal *s,
+
+/* Subroutine */ int dlar2v_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_doublereal *y,
+ __CLPK_doublereal *z__, __CLPK_integer *incx, __CLPK_doublereal *c__, __CLPK_doublereal *s,
__CLPK_integer *incc);
-
+
/* Subroutine */ int dlarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *v,
- __CLPK_integer *incv, __CLPK_doublereal *tau, __CLPK_doublereal *c__, __CLPK_integer *ldc,
+ __CLPK_integer *incv, __CLPK_doublereal *tau, __CLPK_doublereal *c__, __CLPK_integer *ldc,
__CLPK_doublereal *work);
-
+
/* Subroutine */ int dlarfb_(char *side, char *trans, char *direct, char *
storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *v, __CLPK_integer *
- ldv, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *c__, __CLPK_integer *ldc,
+ ldv, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *c__, __CLPK_integer *ldc,
__CLPK_doublereal *work, __CLPK_integer *ldwork);
-
-/* Subroutine */ int dlarfg_(__CLPK_integer *n, __CLPK_doublereal *alpha, __CLPK_doublereal *x,
+
+/* Subroutine */ int dlarfg_(__CLPK_integer *n, __CLPK_doublereal *alpha, __CLPK_doublereal *x,
__CLPK_integer *incx, __CLPK_doublereal *tau);
-
+
/* Subroutine */ int dlarft_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
- k, __CLPK_doublereal *v, __CLPK_integer *ldv, __CLPK_doublereal *tau, __CLPK_doublereal *t,
+ k, __CLPK_doublereal *v, __CLPK_integer *ldv, __CLPK_doublereal *tau, __CLPK_doublereal *t,
__CLPK_integer *ldt);
-
+
/* Subroutine */ int dlarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
v, __CLPK_doublereal *tau, __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work);
-
-/* Subroutine */ int dlargv_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
+
+/* Subroutine */ int dlargv_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
__CLPK_doublereal *y, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_integer *incc);
-
-/* Subroutine */ int dlarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n,
+
+/* Subroutine */ int dlarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n,
__CLPK_doublereal *x);
-
-/* Subroutine */ int dlarrb_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
- __CLPK_doublereal *ld, __CLPK_doublereal *lld, __CLPK_integer *ifirst, __CLPK_integer *ilast,
+
+/* Subroutine */ int dlarrb_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
+ __CLPK_doublereal *ld, __CLPK_doublereal *lld, __CLPK_integer *ifirst, __CLPK_integer *ilast,
__CLPK_doublereal *sigma, __CLPK_doublereal *reltol, __CLPK_doublereal *w, __CLPK_doublereal *
wgap, __CLPK_doublereal *werr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *
info);
-
-/* Subroutine */ int dlarre_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
- __CLPK_doublereal *tol, __CLPK_integer *nsplit, __CLPK_integer *isplit, __CLPK_integer *m,
+
+/* Subroutine */ int dlarre_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+ __CLPK_doublereal *tol, __CLPK_integer *nsplit, __CLPK_integer *isplit, __CLPK_integer *m,
__CLPK_doublereal *w, __CLPK_doublereal *woff, __CLPK_doublereal *gersch, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dlarrf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
- __CLPK_doublereal *ld, __CLPK_doublereal *lld, __CLPK_integer *ifirst, __CLPK_integer *ilast,
+
+/* Subroutine */ int dlarrf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
+ __CLPK_doublereal *ld, __CLPK_doublereal *lld, __CLPK_integer *ifirst, __CLPK_integer *ilast,
__CLPK_doublereal *w, __CLPK_doublereal *dplus, __CLPK_doublereal *lplus, __CLPK_doublereal *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dlarrv_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
- __CLPK_integer *isplit, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock,
- __CLPK_doublereal *gersch, __CLPK_doublereal *tol, __CLPK_doublereal *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int dlarrv_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
+ __CLPK_integer *isplit, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock,
+ __CLPK_doublereal *gersch, __CLPK_doublereal *tol, __CLPK_doublereal *z__, __CLPK_integer *ldz,
__CLPK_integer *isuppz, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dlartg_(__CLPK_doublereal *f, __CLPK_doublereal *g, __CLPK_doublereal *cs,
+
+/* Subroutine */ int dlartg_(__CLPK_doublereal *f, __CLPK_doublereal *g, __CLPK_doublereal *cs,
__CLPK_doublereal *sn, __CLPK_doublereal *r__);
-
-/* Subroutine */ int dlartv_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
- __CLPK_doublereal *y, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_integer
+
+/* Subroutine */ int dlartv_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
+ __CLPK_doublereal *y, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_integer
*incc);
-
+
/* Subroutine */ int dlaruv_(__CLPK_integer *iseed, __CLPK_integer *n, __CLPK_doublereal *x);
-
-/* Subroutine */ int dlarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
- __CLPK_doublereal *v, __CLPK_integer *incv, __CLPK_doublereal *tau, __CLPK_doublereal *c__,
+
+/* Subroutine */ int dlarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
+ __CLPK_doublereal *v, __CLPK_integer *incv, __CLPK_doublereal *tau, __CLPK_doublereal *c__,
__CLPK_integer *ldc, __CLPK_doublereal *work);
-
+
/* Subroutine */ int dlarzb_(char *side, char *trans, char *direct, char *
storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *v,
__CLPK_integer *ldv, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *c__, __CLPK_integer *
ldc, __CLPK_doublereal *work, __CLPK_integer *ldwork);
-
+
/* Subroutine */ int dlarzt_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
- k, __CLPK_doublereal *v, __CLPK_integer *ldv, __CLPK_doublereal *tau, __CLPK_doublereal *t,
+ k, __CLPK_doublereal *v, __CLPK_integer *ldv, __CLPK_doublereal *tau, __CLPK_doublereal *t,
__CLPK_integer *ldt);
-
-/* Subroutine */ int dlas2_(__CLPK_doublereal *f, __CLPK_doublereal *g, __CLPK_doublereal *h__,
+
+/* Subroutine */ int dlas2_(__CLPK_doublereal *f, __CLPK_doublereal *g, __CLPK_doublereal *h__,
__CLPK_doublereal *ssmin, __CLPK_doublereal *ssmax);
-
-/* Subroutine */ int dlascl_(char *type__, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublereal *cfrom, __CLPK_doublereal *cto, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dlascl_(char *type__, __CLPK_integer *kl, __CLPK_integer *ku,
+ __CLPK_doublereal *cfrom, __CLPK_doublereal *cto, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd0_(__CLPK_integer *n, __CLPK_integer *sqre, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dlasd0_(__CLPK_integer *n, __CLPK_integer *sqre, __CLPK_doublereal *d__,
__CLPK_doublereal *e, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *
ldvt, __CLPK_integer *smlsiz, __CLPK_integer *iwork, __CLPK_doublereal *work, __CLPK_integer *
info);
-
-/* Subroutine */ int dlasd1_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre,
- __CLPK_doublereal *d__, __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_doublereal *u,
+
+/* Subroutine */ int dlasd1_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre,
+ __CLPK_doublereal *d__, __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_doublereal *u,
__CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_integer *idxq, __CLPK_integer *
iwork, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd2_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
+
+/* Subroutine */ int dlasd2_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
*k, __CLPK_doublereal *d__, __CLPK_doublereal *z__, __CLPK_doublereal *alpha, __CLPK_doublereal *
- beta, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *ldvt,
- __CLPK_doublereal *dsigma, __CLPK_doublereal *u2, __CLPK_integer *ldu2, __CLPK_doublereal *vt2,
+ beta, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *ldvt,
+ __CLPK_doublereal *dsigma, __CLPK_doublereal *u2, __CLPK_integer *ldu2, __CLPK_doublereal *vt2,
__CLPK_integer *ldvt2, __CLPK_integer *idxp, __CLPK_integer *idx, __CLPK_integer *idxc, __CLPK_integer *
idxq, __CLPK_integer *coltyp, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd3_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
- *k, __CLPK_doublereal *d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *dsigma,
- __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *u2, __CLPK_integer *ldu2,
- __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *vt2, __CLPK_integer *ldvt2,
+
+/* Subroutine */ int dlasd3_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
+ *k, __CLPK_doublereal *d__, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *dsigma,
+ __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *u2, __CLPK_integer *ldu2,
+ __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *vt2, __CLPK_integer *ldvt2,
__CLPK_integer *idxc, __CLPK_integer *ctot, __CLPK_doublereal *z__, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dlasd4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_doublereal *d__,
__CLPK_doublereal *z__, __CLPK_doublereal *delta, __CLPK_doublereal *rho, __CLPK_doublereal *
sigma, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd5_(__CLPK_integer *i__, __CLPK_doublereal *d__, __CLPK_doublereal *z__,
+
+/* Subroutine */ int dlasd5_(__CLPK_integer *i__, __CLPK_doublereal *d__, __CLPK_doublereal *z__,
__CLPK_doublereal *delta, __CLPK_doublereal *rho, __CLPK_doublereal *dsigma, __CLPK_doublereal *
work);
-
-/* Subroutine */ int dlasd6_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_doublereal *d__, __CLPK_doublereal *vf, __CLPK_doublereal *vl,
- __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_integer *idxq, __CLPK_integer *perm,
+
+/* Subroutine */ int dlasd6_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_doublereal *d__, __CLPK_doublereal *vf, __CLPK_doublereal *vl,
+ __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_integer *idxq, __CLPK_integer *perm,
__CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_doublereal *givnum,
__CLPK_integer *ldgnum, __CLPK_doublereal *poles, __CLPK_doublereal *difl, __CLPK_doublereal *
- difr, __CLPK_doublereal *z__, __CLPK_integer *k, __CLPK_doublereal *c__, __CLPK_doublereal *s,
+ difr, __CLPK_doublereal *z__, __CLPK_integer *k, __CLPK_doublereal *c__, __CLPK_doublereal *s,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd7_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_integer *k, __CLPK_doublereal *d__, __CLPK_doublereal *z__,
- __CLPK_doublereal *zw, __CLPK_doublereal *vf, __CLPK_doublereal *vfw, __CLPK_doublereal *vl,
+
+/* Subroutine */ int dlasd7_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_integer *k, __CLPK_doublereal *d__, __CLPK_doublereal *z__,
+ __CLPK_doublereal *zw, __CLPK_doublereal *vf, __CLPK_doublereal *vfw, __CLPK_doublereal *vl,
__CLPK_doublereal *vlw, __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_doublereal *
- dsigma, __CLPK_integer *idx, __CLPK_integer *idxp, __CLPK_integer *idxq, __CLPK_integer *perm,
+ dsigma, __CLPK_integer *idx, __CLPK_integer *idxp, __CLPK_integer *idxq, __CLPK_integer *perm,
__CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_doublereal *givnum,
__CLPK_integer *ldgnum, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_doublereal *d__,
- __CLPK_doublereal *z__, __CLPK_doublereal *vf, __CLPK_doublereal *vl, __CLPK_doublereal *difl,
+
+/* Subroutine */ int dlasd8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_doublereal *d__,
+ __CLPK_doublereal *z__, __CLPK_doublereal *vf, __CLPK_doublereal *vl, __CLPK_doublereal *difl,
__CLPK_doublereal *difr, __CLPK_integer *lddifr, __CLPK_doublereal *dsigma, __CLPK_doublereal *
work, __CLPK_integer *info);
-
-/* Subroutine */ int dlasd9_(__CLPK_integer *icompq, __CLPK_integer *ldu, __CLPK_integer *k,
- __CLPK_doublereal *d__, __CLPK_doublereal *z__, __CLPK_doublereal *vf, __CLPK_doublereal *vl,
+
+/* Subroutine */ int dlasd9_(__CLPK_integer *icompq, __CLPK_integer *ldu, __CLPK_integer *k,
+ __CLPK_doublereal *d__, __CLPK_doublereal *z__, __CLPK_doublereal *vf, __CLPK_doublereal *vl,
__CLPK_doublereal *difl, __CLPK_doublereal *difr, __CLPK_doublereal *dsigma, __CLPK_doublereal *
work, __CLPK_integer *info);
-
-/* Subroutine */ int dlasda_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
- __CLPK_integer *sqre, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *u, __CLPK_integer
- *ldu, __CLPK_doublereal *vt, __CLPK_integer *k, __CLPK_doublereal *difl, __CLPK_doublereal *difr,
- __CLPK_doublereal *z__, __CLPK_doublereal *poles, __CLPK_integer *givptr, __CLPK_integer *givcol,
- __CLPK_integer *ldgcol, __CLPK_integer *perm, __CLPK_doublereal *givnum, __CLPK_doublereal *c__,
+
+/* Subroutine */ int dlasda_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
+ __CLPK_integer *sqre, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *u, __CLPK_integer
+ *ldu, __CLPK_doublereal *vt, __CLPK_integer *k, __CLPK_doublereal *difl, __CLPK_doublereal *difr,
+ __CLPK_doublereal *z__, __CLPK_doublereal *poles, __CLPK_integer *givptr, __CLPK_integer *givcol,
+ __CLPK_integer *ldgcol, __CLPK_integer *perm, __CLPK_doublereal *givnum, __CLPK_doublereal *c__,
__CLPK_doublereal *s, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dlasdq_(char *uplo, __CLPK_integer *sqre, __CLPK_integer *n, __CLPK_integer *
- ncvt, __CLPK_integer *nru, __CLPK_integer *ncc, __CLPK_doublereal *d__, __CLPK_doublereal *e,
- __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *u, __CLPK_integer *ldu,
+ ncvt, __CLPK_integer *nru, __CLPK_integer *ncc, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+ __CLPK_doublereal *vt, __CLPK_integer *ldvt, __CLPK_doublereal *u, __CLPK_integer *ldu,
__CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dlasdt_(__CLPK_integer *n, __CLPK_integer *lvl, __CLPK_integer *nd, __CLPK_integer *
inode, __CLPK_integer *ndiml, __CLPK_integer *ndimr, __CLPK_integer *msub);
-
+
/* Subroutine */ int dlaset_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
alpha, __CLPK_doublereal *beta, __CLPK_doublereal *a, __CLPK_integer *lda);
-
-/* Subroutine */ int dlasq1_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int dlasq1_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dlasq2_(__CLPK_integer *n, __CLPK_doublereal *z__, __CLPK_integer *info);
-
-/* Subroutine */ int dlasq3_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
+
+/* Subroutine */ int dlasq3_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
__CLPK_integer *pp, __CLPK_doublereal *dmin__, __CLPK_doublereal *sigma, __CLPK_doublereal *desig,
- __CLPK_doublereal *qmax, __CLPK_integer *nfail, __CLPK_integer *iter, __CLPK_integer *ndiv,
+ __CLPK_doublereal *qmax, __CLPK_integer *nfail, __CLPK_integer *iter, __CLPK_integer *ndiv,
__CLPK_logical *ieee);
-
-/* Subroutine */ int dlasq4_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
- __CLPK_integer *pp, __CLPK_integer *n0in, __CLPK_doublereal *dmin__, __CLPK_doublereal *dmin1,
- __CLPK_doublereal *dmin2, __CLPK_doublereal *dn, __CLPK_doublereal *dn1, __CLPK_doublereal *dn2,
+
+/* Subroutine */ int dlasq4_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
+ __CLPK_integer *pp, __CLPK_integer *n0in, __CLPK_doublereal *dmin__, __CLPK_doublereal *dmin1,
+ __CLPK_doublereal *dmin2, __CLPK_doublereal *dn, __CLPK_doublereal *dn1, __CLPK_doublereal *dn2,
__CLPK_doublereal *tau, __CLPK_integer *ttype);
-
-/* Subroutine */ int dlasq5_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
- __CLPK_integer *pp, __CLPK_doublereal *tau, __CLPK_doublereal *dmin__, __CLPK_doublereal *dmin1,
+
+/* Subroutine */ int dlasq5_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
+ __CLPK_integer *pp, __CLPK_doublereal *tau, __CLPK_doublereal *dmin__, __CLPK_doublereal *dmin1,
__CLPK_doublereal *dmin2, __CLPK_doublereal *dn, __CLPK_doublereal *dnm1, __CLPK_doublereal *dnm2,
__CLPK_logical *ieee);
-
-/* Subroutine */ int dlasq6_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
+
+/* Subroutine */ int dlasq6_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_doublereal *z__,
__CLPK_integer *pp, __CLPK_doublereal *dmin__, __CLPK_doublereal *dmin1, __CLPK_doublereal *dmin2,
__CLPK_doublereal *dn, __CLPK_doublereal *dnm1, __CLPK_doublereal *dnm2);
-
+
/* Subroutine */ int dlasr_(char *side, char *pivot, char *direct, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublereal *a, __CLPK_integer *
lda);
-
+
/* Subroutine */ int dlasrt_(char *id, __CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_integer *
info);
-
-/* Subroutine */ int dlassq_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
+
+/* Subroutine */ int dlassq_(__CLPK_integer *n, __CLPK_doublereal *x, __CLPK_integer *incx,
__CLPK_doublereal *scale, __CLPK_doublereal *sumsq);
-
-/* Subroutine */ int dlasv2_(__CLPK_doublereal *f, __CLPK_doublereal *g, __CLPK_doublereal *h__,
+
+/* Subroutine */ int dlasv2_(__CLPK_doublereal *f, __CLPK_doublereal *g, __CLPK_doublereal *h__,
__CLPK_doublereal *ssmin, __CLPK_doublereal *ssmax, __CLPK_doublereal *snr, __CLPK_doublereal *
csr, __CLPK_doublereal *snl, __CLPK_doublereal *csl);
-
-/* Subroutine */ int dlaswp_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer
+
+/* Subroutine */ int dlaswp_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer
*k1, __CLPK_integer *k2, __CLPK_integer *ipiv, __CLPK_integer *incx);
-
-/* Subroutine */ int dlasy2_(__CLPK_logical *ltranl, __CLPK_logical *ltranr, __CLPK_integer *isgn,
+
+/* Subroutine */ int dlasy2_(__CLPK_logical *ltranl, __CLPK_logical *ltranr, __CLPK_integer *isgn,
__CLPK_integer *n1, __CLPK_integer *n2, __CLPK_doublereal *tl, __CLPK_integer *ldtl, __CLPK_doublereal *
- tr, __CLPK_integer *ldtr, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *scale,
+ tr, __CLPK_integer *ldtr, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *scale,
__CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *xnorm, __CLPK_integer *info);
-
+
/* Subroutine */ int dlasyf_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_integer *kb,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *w, __CLPK_integer *
ldw, __CLPK_integer *info);
-
+
/* Subroutine */ int dlatbs_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *ab, __CLPK_integer *ldab,
+ normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *ab, __CLPK_integer *ldab,
__CLPK_doublereal *x, __CLPK_doublereal *scale, __CLPK_doublereal *cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int dlatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_doublereal *z__,
- __CLPK_integer *ldz, __CLPK_doublereal *rhs, __CLPK_doublereal *rdsum, __CLPK_doublereal *rdscal,
+
+/* Subroutine */ int dlatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_doublereal *z__,
+ __CLPK_integer *ldz, __CLPK_doublereal *rhs, __CLPK_doublereal *rdsum, __CLPK_doublereal *rdscal,
__CLPK_integer *ipiv, __CLPK_integer *jpiv);
-
+
/* Subroutine */ int dlatps_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_doublereal *x, __CLPK_doublereal *scale,
+ normin, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_doublereal *x, __CLPK_doublereal *scale,
__CLPK_doublereal *cnorm, __CLPK_integer *info);
-
+
/* Subroutine */ int dlatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *e, __CLPK_doublereal *tau, __CLPK_doublereal *w,
+ a, __CLPK_integer *lda, __CLPK_doublereal *e, __CLPK_doublereal *tau, __CLPK_doublereal *w,
__CLPK_integer *ldw);
-
+
/* Subroutine */ int dlatrs_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *x,
+ normin, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *x,
__CLPK_doublereal *scale, __CLPK_doublereal *cnorm, __CLPK_integer *info);
-
+
/* Subroutine */ int dlatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work);
-
+
/* Subroutine */ int dlatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
- v, __CLPK_integer *incv, __CLPK_doublereal *tau, __CLPK_doublereal *c1, __CLPK_doublereal *c2,
+ v, __CLPK_integer *incv, __CLPK_doublereal *tau, __CLPK_doublereal *c1, __CLPK_doublereal *c2,
__CLPK_integer *ldc, __CLPK_doublereal *work);
-
+
/* Subroutine */ int dlauu2_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *info);
-
+
/* Subroutine */ int dlauum_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *info);
-
-/* Subroutine */ int dopgtr_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
- __CLPK_doublereal *tau, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *work,
+
+/* Subroutine */ int dopgtr_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
+ __CLPK_doublereal *tau, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dopmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_doublereal *tau, __CLPK_doublereal *c__, __CLPK_integer
+
+/* Subroutine */ int dopmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_doublereal *tau, __CLPK_doublereal *c__, __CLPK_integer
*ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dorg2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dorg2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dorgbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
+
+/* Subroutine */ int dorgbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dorghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
+
+/* Subroutine */ int dorghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dorgl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dorglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dorgql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dorgqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dorgr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dorgrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dorgtr_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dorm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dorm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dorm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dorm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dormbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau,
- __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork,
+
+/* Subroutine */ int dormbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau,
+ __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dormhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dormhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *
- tau, __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ tau, __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dorml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dorml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dormlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dormlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dormql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dormql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dormqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dormqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dormr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dormr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dormr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau,
+
+/* Subroutine */ int dormr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau,
__CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dormrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int dormrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dormrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau,
- __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork,
+
+/* Subroutine */ int dormrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau,
+ __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dormtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+
+/* Subroutine */ int dormtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *tau, __CLPK_doublereal *
c__, __CLPK_integer *ldc, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dpbcon_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
ab, __CLPK_integer *ldab, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dpbequ_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax,
__CLPK_integer *info);
-
+
/* Subroutine */ int dpbrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
- nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *afb, __CLPK_integer *ldafb,
+ nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *afb, __CLPK_integer *ldafb,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int dpbstf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
ab, __CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int dpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
- nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int dpbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *afb,
+
+/* Subroutine */ int dpbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *afb,
__CLPK_integer *ldafb, char *equed, __CLPK_doublereal *s, __CLPK_doublereal *b, __CLPK_integer *
ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dpbtf2_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
ab, __CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int dpbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublereal *
ab, __CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int dpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
- nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int dpocon_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dpoequ_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
+
+/* Subroutine */ int dpoequ_(__CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, __CLPK_integer *info);
-
-/* Subroutine */ int dporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
+
+/* Subroutine */ int dporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *
info);
-
-/* Subroutine */ int dposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
+
+/* Subroutine */ int dposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
*a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int dposvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
+ nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
char *equed, __CLPK_doublereal *s, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *
x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *
berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dpotf2_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *info);
-
+
/* Subroutine */ int dpotrf_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *info);
-
+
/* Subroutine */ int dpotri_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *info);
-
-/* Subroutine */ int dpotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dpotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int dppcon_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
+
+/* Subroutine */ int dppcon_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
__CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dppequ_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
+
+/* Subroutine */ int dppequ_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, __CLPK_integer *info);
-
-/* Subroutine */ int dpprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *ap, __CLPK_doublereal *afp, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+
+/* Subroutine */ int dpprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *ap, __CLPK_doublereal *afp, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
+
+/* Subroutine */ int dppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
*ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int dppsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *afp, char *equed, __CLPK_doublereal *s,
+ nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *afp, char *equed, __CLPK_doublereal *s,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dpptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_integer *
info);
-
+
/* Subroutine */ int dpptri_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_integer *
info);
-
-/* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dptcon_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int dptcon_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dpteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+
+/* Subroutine */ int dpteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dptrfs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublereal *df, __CLPK_doublereal *ef, __CLPK_doublereal *b, __CLPK_integer
+
+/* Subroutine */ int dptrfs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublereal *df, __CLPK_doublereal *ef, __CLPK_doublereal *b, __CLPK_integer
*ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
__CLPK_doublereal *e, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dptsvx_(char *fact, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *df, __CLPK_doublereal *ef,
+
+/* Subroutine */ int dptsvx_(char *fact, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *df, __CLPK_doublereal *ef,
__CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *
rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *
info);
-
-/* Subroutine */ int dpttrf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int dpttrf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_integer *info);
-
-/* Subroutine */ int dpttrs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dpttrs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
__CLPK_doublereal *e, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dptts2_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
+
+/* Subroutine */ int dptts2_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
__CLPK_doublereal *e, __CLPK_doublereal *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int drscl_(__CLPK_integer *n, __CLPK_doublereal *sa, __CLPK_doublereal *sx,
+
+/* Subroutine */ int drscl_(__CLPK_integer *n, __CLPK_doublereal *sa, __CLPK_doublereal *sx,
__CLPK_integer *incx);
-
-/* Subroutine */ int dsbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+
+/* Subroutine */ int dsbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublereal *z__,
__CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dsbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublereal *z__,
- __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+
+/* Subroutine */ int dsbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+ __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dsbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dsbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_integer *kd, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *q, __CLPK_integer *
- ldq, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu,
- __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublereal *z__,
- __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *ifail,
+ ldq, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu,
+ __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+ __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *ifail,
__CLPK_integer *info);
-
-/* Subroutine */ int dsbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+
+/* Subroutine */ int dsbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
__CLPK_integer *kb, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *bb, __CLPK_integer *
ldbb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dsbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+
+/* Subroutine */ int dsbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
__CLPK_integer *kb, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *bb, __CLPK_integer *
- ldbb, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ ldbb, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dsbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+
+/* Subroutine */ int dsbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
__CLPK_integer *kb, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *bb, __CLPK_integer *
- ldbb, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ ldbb, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dsbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dsbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_integer *ka, __CLPK_integer *kb, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *
- bb, __CLPK_integer *ldbb, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *vl,
- __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer
- *m, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ bb, __CLPK_integer *ldbb, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *vl,
+ __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer
+ *m, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int dsbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int dsbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dspcon_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_integer *
- ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer
+ ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer
*iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dspev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublereal *
- ap, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ ap, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-
+
/* Subroutine */ int dspevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublereal *
- ap, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ ap, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dspevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dspevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_doublereal *ap, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *
- iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublereal *z__,
- __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *ifail,
+ iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+ __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *ifail,
__CLPK_integer *info);
-
-/* Subroutine */ int dspgst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dspgst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
__CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_integer *info);
-
+
/* Subroutine */ int dspgv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+ n, __CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_doublereal *w, __CLPK_doublereal *z__,
__CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dspgvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_doublereal *w, __CLPK_doublereal *z__,
- __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+ n, __CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+ __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dspgvx_(__CLPK_integer *itype, char *jobz, char *range, char *
- uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_doublereal *vl,
- __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer
- *m, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+ uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_doublereal *bp, __CLPK_doublereal *vl,
+ __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer
+ *m, __CLPK_doublereal *w, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int dsprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *ap, __CLPK_doublereal *afp, __CLPK_integer *ipiv, __CLPK_doublereal *b,
- __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
+
+/* Subroutine */ int dsprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *ap, __CLPK_doublereal *afp, __CLPK_integer *ipiv, __CLPK_doublereal *b,
+ __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
+
+/* Subroutine */ int dspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
*ap, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int dspsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *afp, __CLPK_integer *ipiv, __CLPK_doublereal *b,
- __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond,
- __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork,
+ nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *afp, __CLPK_integer *ipiv, __CLPK_doublereal *b,
+ __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond,
+ __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dsptrd_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
+
+/* Subroutine */ int dsptrd_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
__CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tau, __CLPK_integer *info);
-
+
/* Subroutine */ int dsptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_integer *
ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int dsptri_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap, __CLPK_integer *
ipiv, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dsptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dsptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *ap, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int dstebz_(char *range, char *order, __CLPK_integer *n, __CLPK_doublereal
- *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol,
- __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_integer *m, __CLPK_integer *nsplit,
- __CLPK_doublereal *w, __CLPK_integer *iblock, __CLPK_integer *isplit, __CLPK_doublereal *work,
+
+/* Subroutine */ int dstebz_(char *range, char *order, __CLPK_integer *n, __CLPK_doublereal
+ *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol,
+ __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_integer *m, __CLPK_integer *nsplit,
+ __CLPK_doublereal *w, __CLPK_integer *iblock, __CLPK_integer *isplit, __CLPK_doublereal *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dstedc_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+
+/* Subroutine */ int dstedc_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dstegr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_doublereal *
- d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
- __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
- __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
+ d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
+ __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+ __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dstein_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
- __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock, __CLPK_integer *isplit,
- __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int dstein_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+ __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock, __CLPK_integer *isplit,
+ __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int dsteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+
+/* Subroutine */ int dsteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dsterf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int dsterf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_integer *info);
-
-/* Subroutine */ int dstev_(char *jobz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+
+/* Subroutine */ int dstev_(char *jobz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int dstevd_(char *jobz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+
+/* Subroutine */ int dstevd_(char *jobz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dstevr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_doublereal *
- d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
- __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
- __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
+ d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
+ __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+ __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dstevx_(char *jobz, char *range, __CLPK_integer *n, __CLPK_doublereal *
- d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
- __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
- __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork,
+ d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
+ __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+ __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *ifail, __CLPK_integer *info);
-
+
/* Subroutine */ int dsycon_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsyev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublereal *a,
- __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int dsyevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublereal *
- a, __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ a, __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dsyevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dsyevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *
- il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
- __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
+ il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+ __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dsyevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dsyevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *
- il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
- __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork,
+ il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+ __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork,
__CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int dsygs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dsygs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int dsygst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int dsygst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
+
/* Subroutine */ int dsygv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsygvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+ n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsygvx_(__CLPK_integer *itype, char *jobz, char *range, char *
- uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer
- *ldb, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu,
- __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublereal *z__,
- __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+ uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer
+ *ldb, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu,
+ __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublereal *z__,
+ __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int dsyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dsyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf, __CLPK_integer *
- ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx,
- __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork,
+ ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx,
+ __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dsysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
- *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int dsysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal
+ *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb,
__CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsysvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
+ nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *af, __CLPK_integer *ldaf,
__CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *
- ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsytd2_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tau, __CLPK_integer *info);
-
+
/* Subroutine */ int dsytf2_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int dsytrd_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *tau, __CLPK_doublereal *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsytrf_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dsytri_(char *uplo, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_integer *ipiv, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dsytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int dsytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *b, __CLPK_integer *
ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dtbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *rcond,
+
+/* Subroutine */ int dtbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *rcond,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal
- *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
+
+/* Subroutine */ int dtbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal
+ *b, __CLPK_integer *ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal
+
+/* Subroutine */ int dtbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal
*b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int dtgevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_integer
+
+/* Subroutine */ int dtgevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_integer
*mm, __CLPK_integer *m, __CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dtgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
+
+/* Subroutine */ int dtgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *
q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *j1, __CLPK_integer *
n1, __CLPK_integer *n2, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
+
+/* Subroutine */ int dtgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
__CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *
- q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *ifst,
+ q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz, __CLPK_integer *ifst,
__CLPK_integer *ilst, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
+
+/* Subroutine */ int dtgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
__CLPK_logical *select, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *
b, __CLPK_integer *ldb, __CLPK_doublereal *alphar, __CLPK_doublereal *alphai, __CLPK_doublereal *
- beta, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz,
- __CLPK_integer *m, __CLPK_doublereal *pl, __CLPK_doublereal *pr, __CLPK_doublereal *dif,
- __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+ beta, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_doublereal *z__, __CLPK_integer *ldz,
+ __CLPK_integer *m, __CLPK_doublereal *pl, __CLPK_doublereal *pr, __CLPK_doublereal *dif,
+ __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dtgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *p, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a,
- __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *tola,
- __CLPK_doublereal *tolb, __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_doublereal *u,
+
+/* Subroutine */ int dtgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *p, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublereal *a,
+ __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublereal *tola,
+ __CLPK_doublereal *tolb, __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_doublereal *u,
__CLPK_integer *ldu, __CLPK_doublereal *v, __CLPK_integer *ldv, __CLPK_doublereal *q, __CLPK_integer *
ldq, __CLPK_doublereal *work, __CLPK_integer *ncycle, __CLPK_integer *info);
-
-/* Subroutine */ int dtgsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr,
+
+/* Subroutine */ int dtgsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *vl, __CLPK_integer *ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr,
__CLPK_doublereal *s, __CLPK_doublereal *dif, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublereal *
work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dtgsy2_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
- n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *d__, __CLPK_integer *ldd,
+ n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *d__, __CLPK_integer *ldd,
__CLPK_doublereal *e, __CLPK_integer *lde, __CLPK_doublereal *f, __CLPK_integer *ldf, __CLPK_doublereal *
- scale, __CLPK_doublereal *rdsum, __CLPK_doublereal *rdscal, __CLPK_integer *iwork, __CLPK_integer
+ scale, __CLPK_doublereal *rdsum, __CLPK_doublereal *rdscal, __CLPK_integer *iwork, __CLPK_integer
*pq, __CLPK_integer *info);
-
+
/* Subroutine */ int dtgsyl_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
- n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *d__, __CLPK_integer *ldd,
+ n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *d__, __CLPK_integer *ldd,
__CLPK_doublereal *e, __CLPK_integer *lde, __CLPK_doublereal *f, __CLPK_integer *ldf, __CLPK_doublereal *
scale, __CLPK_doublereal *dif, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_doublereal *ap, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int dtpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_doublereal *ap, __CLPK_doublereal *rcond, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int dtprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb,
- __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+
+/* Subroutine */ int dtprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int dtptri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_doublereal *
ap, __CLPK_integer *info);
-
-/* Subroutine */ int dtptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int dtptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_doublereal *ap, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int dtrcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *rcond, __CLPK_doublereal *work,
+
+/* Subroutine */ int dtrcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *rcond, __CLPK_doublereal *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtrevc_(char *side, char *howmny, __CLPK_logical *select,
+
+/* Subroutine */ int dtrevc_(char *side, char *howmny, __CLPK_logical *select,
__CLPK_integer *n, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *vl, __CLPK_integer *
- ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m,
+ ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m,
__CLPK_doublereal *work, __CLPK_integer *info);
-
+
/* Subroutine */ int dtrexc_(char *compq, __CLPK_integer *n, __CLPK_doublereal *t, __CLPK_integer *
- ldt, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *ifst, __CLPK_integer *ilst,
+ ldt, __CLPK_doublereal *q, __CLPK_integer *ldq, __CLPK_integer *ifst, __CLPK_integer *ilst,
__CLPK_doublereal *work, __CLPK_integer *info);
-
-/* Subroutine */ int dtrrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int dtrrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *
- ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ ldb, __CLPK_doublereal *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtrsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
- *n, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *q, __CLPK_integer *ldq,
- __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_integer *m, __CLPK_doublereal *s, __CLPK_doublereal
+
+/* Subroutine */ int dtrsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
+ *n, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *q, __CLPK_integer *ldq,
+ __CLPK_doublereal *wr, __CLPK_doublereal *wi, __CLPK_integer *m, __CLPK_doublereal *s, __CLPK_doublereal
*sep, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *
liwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtrsna_(char *job, char *howmny, __CLPK_logical *select,
+
+/* Subroutine */ int dtrsna_(char *job, char *howmny, __CLPK_logical *select,
__CLPK_integer *n, __CLPK_doublereal *t, __CLPK_integer *ldt, __CLPK_doublereal *vl, __CLPK_integer *
- ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *s, __CLPK_doublereal *sep,
+ ldvl, __CLPK_doublereal *vr, __CLPK_integer *ldvr, __CLPK_doublereal *s, __CLPK_doublereal *sep,
__CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublereal *work, __CLPK_integer *ldwork, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int dtrsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
+
+/* Subroutine */ int dtrsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
*m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *
ldb, __CLPK_doublereal *c__, __CLPK_integer *ldc, __CLPK_doublereal *scale, __CLPK_integer *info);
-
+
/* Subroutine */ int dtrti2_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_integer *info);
-
+
/* Subroutine */ int dtrtri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int dtrtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int dtrtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_doublereal *a, __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *
ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int dtzrqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_integer *info);
-
+
/* Subroutine */ int dtzrzf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublereal *tau, __CLPK_doublereal *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
__CLPK_integer icmax1_(__CLPK_integer *n, __CLPK_complex *cx, __CLPK_integer *incx);
-
+
__CLPK_integer ieeeck_(__CLPK_integer *ispec, __CLPK_real *zero, __CLPK_real *one);
-
-__CLPK_integer ilaenv_(__CLPK_integer *ispec, char *name__, char *opts, __CLPK_integer *n1,
- __CLPK_integer *n2, __CLPK_integer *n3, __CLPK_integer *n4, __CLPK_ftnlen name_len, __CLPK_ftnlen
+
+__CLPK_integer ilaenv_(__CLPK_integer *ispec, char *name__, char *opts, __CLPK_integer *n1,
+ __CLPK_integer *n2, __CLPK_integer *n3, __CLPK_integer *n4, __CLPK_ftnlen name_len, __CLPK_ftnlen
opts_len);
-
+
__CLPK_integer izmax1_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx);
-
-/* Subroutine */ int sbdsdc_(char *uplo, char *compq, __CLPK_integer *n, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *q,
+
+/* Subroutine */ int sbdsdc_(char *uplo, char *compq, __CLPK_integer *n, __CLPK_real *d__,
+ __CLPK_real *e, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *q,
__CLPK_integer *iq, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sbdsqr_(char *uplo, __CLPK_integer *n, __CLPK_integer *ncvt, __CLPK_integer *
nru, __CLPK_integer *ncc, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *
u, __CLPK_integer *ldu, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sdisna_(char *job, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *d__,
+
+/* Subroutine */ int sdisna_(char *job, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *d__,
__CLPK_real *sep, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbbrd_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *ncc,
__CLPK_integer *kl, __CLPK_integer *ku, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *d__, __CLPK_real *
- e, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *pt, __CLPK_integer *ldpt, __CLPK_real *c__, __CLPK_integer
+ e, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *pt, __CLPK_integer *ldpt, __CLPK_real *c__, __CLPK_integer
*ldc, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbcon_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond,
+ __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond,
__CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *
colcnd, __CLPK_real *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
ku, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb, __CLPK_integer *ldafb,
__CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *
ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
- nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb,
+ nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int sgbsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *kl,
- __CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb,
- __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed, __CLPK_real *r__, __CLPK_real *c__,
+ __CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb,
+ __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed, __CLPK_real *r__, __CLPK_real *c__,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr,
__CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbtf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbtrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int sgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
- ku, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *b,
+ ku, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_real *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_real *scale, __CLPK_integer *m, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_integer
+
+/* Subroutine */ int sgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_real *scale, __CLPK_integer *m, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_integer
*info);
-
-/* Subroutine */ int sgebal_(char *job, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgebal_(char *job, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *scale, __CLPK_integer *info);
-
-/* Subroutine */ int sgebd2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgebd2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *d__, __CLPK_real *e, __CLPK_real *tauq, __CLPK_real *taup, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgebrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgebrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *d__, __CLPK_real *e, __CLPK_real *tauq, __CLPK_real *taup, __CLPK_real *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgecon_(char *norm, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgecon_(char *norm, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgeequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
- __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *colcnd, __CLPK_real *amax, __CLPK_integer
+
+/* Subroutine */ int sgeequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+ __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *colcnd, __CLPK_real *amax, __CLPK_integer
*info);
-
-/* Subroutine */ int sgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *vs,
+
+/* Subroutine */ int sgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *vs,
__CLPK_integer *ldvs, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_logical *bwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int sgeesx_(char *jobvs, char *sort, __CLPK_L_fp select, char *
- sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_real *wr,
+ sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_real *wr,
__CLPK_real *wi, __CLPK_real *vs, __CLPK_integer *ldvs, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_logical *bwork,
__CLPK_integer *info);
-
-/* Subroutine */ int sgeev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
+
+/* Subroutine */ int sgeev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
__CLPK_integer *ldvr, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgeevx_(char *balanc, char *jobvl, char *jobvr, char *
sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *
vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_integer *ilo, __CLPK_integer *
ihi, __CLPK_real *scale, __CLPK_real *abnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real
+
+/* Subroutine */ int sgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real
*beta, __CLPK_real *vsl, __CLPK_integer *ldvsl, __CLPK_real *vsr, __CLPK_integer *ldvsr, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgegv_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real
- *beta, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_real *work,
+
+/* Subroutine */ int sgegv_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real
+ *beta, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a,
+
+/* Subroutine */ int sgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a,
+
+/* Subroutine */ int sgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgelq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgelq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgelqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgelqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgels_(char *trans, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *work,
+ nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int sgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *s, __CLPK_real *rcond, __CLPK_integer *
rank, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgelss_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int sgelss_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *s, __CLPK_real *rcond, __CLPK_integer *
rank, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *jpvt, __CLPK_real *rcond,
+
+/* Subroutine */ int sgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *jpvt, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *jpvt, __CLPK_real *rcond,
+
+/* Subroutine */ int sgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *jpvt, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgeql2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgeql2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgeqlf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgeqlf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgeqp3_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgeqp3_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *jpvt, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgeqpf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgeqpf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *jpvt, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgeqr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgeqr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgeqrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgeqrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_real *b,
+
+/* Subroutine */ int sgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_real *b,
__CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgerq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgerq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgerqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgerqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgesc2_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *rhs,
+
+/* Subroutine */ int sgesc2_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *rhs,
__CLPK_integer *ipiv, __CLPK_integer *jpiv, __CLPK_real *scale);
-
-/* Subroutine */ int sgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int sgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *s, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *ldvt,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *s, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt,
+
+/* Subroutine */ int sgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *s, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt,
__CLPK_integer *ldvt, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgesvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv,
- char *equed, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x,
- __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work,
+ nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv,
+ char *equed, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x,
+ __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgetc2_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *ipiv,
__CLPK_integer *jpiv, __CLPK_integer *info);
-
-/* Subroutine */ int sgetf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgetf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int sgetrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sgetrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int sgetri_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *ipiv,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int sgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real *rscale, __CLPK_integer *m, __CLPK_real *v,
+
+/* Subroutine */ int sggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real *rscale, __CLPK_integer *m, __CLPK_real *v,
__CLPK_integer *ldv, __CLPK_integer *info);
-
-/* Subroutine */ int sggbal_(char *job, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
- __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real
+
+/* Subroutine */ int sggbal_(char *job, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+ __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real
*rscale, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
- selctg, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
- __CLPK_integer *sdim, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *vsl,
+
+/* Subroutine */ int sgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+ selctg, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
+ __CLPK_integer *sdim, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *vsl,
__CLPK_integer *ldvsl, __CLPK_real *vsr, __CLPK_integer *ldvsr, __CLPK_real *work, __CLPK_integer *lwork,
__CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
- selctg, char *sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b,
- __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta,
- __CLPK_real *vsl, __CLPK_integer *ldvsl, __CLPK_real *vsr, __CLPK_integer *ldvsr, __CLPK_real *rconde,
+
+/* Subroutine */ int sggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+ selctg, char *sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b,
+ __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta,
+ __CLPK_real *vsl, __CLPK_integer *ldvsl, __CLPK_real *vsr, __CLPK_integer *ldvsr, __CLPK_real *rconde,
__CLPK_real *rcondv, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *
liwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real
- *beta, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_real *work,
+
+/* Subroutine */ int sggev_(char *jobvl, char *jobvr, __CLPK_integer *n, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real
+ *beta, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sggevx_(char *balanc, char *jobvl, char *jobvr, char *
- sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real
- *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
+ sense, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real
+ *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
__CLPK_integer *ldvr, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *lscale, __CLPK_real *rscale,
- __CLPK_real *abnrm, __CLPK_real *bbnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_real *work,
+ __CLPK_real *abnrm, __CLPK_real *bbnrm, __CLPK_real *rconde, __CLPK_real *rcondv, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *d__, __CLPK_real *x, __CLPK_real *y,
+
+/* Subroutine */ int sggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *d__, __CLPK_real *x, __CLPK_real *y,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgghrd_(char *compq, char *compz, __CLPK_integer *n, __CLPK_integer *
- ilo, __CLPK_integer *ihi, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real
+ ilo, __CLPK_integer *ihi, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real
*q, __CLPK_integer *ldq, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *info);
-
-/* Subroutine */ int sgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *c__, __CLPK_real *d__, __CLPK_real *x,
+
+/* Subroutine */ int sgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *c__, __CLPK_real *d__, __CLPK_real *x,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_real *a,
+
+/* Subroutine */ int sggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *taua, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *taub, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int sggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *taua, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *taub, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+
+/* Subroutine */ int sggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_integer *p, __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_real *u, __CLPK_integer *
- ldu, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *work,
+ ldu, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *p, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int sggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *p, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
__CLPK_real *tola, __CLPK_real *tolb, __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *u, __CLPK_integer *ldu,
__CLPK_real *v, __CLPK_integer *ldv, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *iwork, __CLPK_real *
tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sgtcon_(char *norm, __CLPK_integer *n, __CLPK_real *dl, __CLPK_real *d__,
+
+/* Subroutine */ int sgtcon_(char *norm, __CLPK_integer *n, __CLPK_real *dl, __CLPK_real *d__,
__CLPK_real *du, __CLPK_real *du2, __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sgtrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *dl,
- __CLPK_real *d__, __CLPK_real *du, __CLPK_real *dlf, __CLPK_real *df, __CLPK_real *duf, __CLPK_real *du2,
+ __CLPK_real *d__, __CLPK_real *du, __CLPK_real *dlf, __CLPK_real *df, __CLPK_real *duf, __CLPK_real *du2,
__CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *
ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *dl, __CLPK_real *d__,
+
+/* Subroutine */ int sgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *dl, __CLPK_real *d__,
__CLPK_real *du, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int sgtsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_real *dl, __CLPK_real *d__, __CLPK_real *du, __CLPK_real *dlf, __CLPK_real *df, __CLPK_real *duf,
+ nrhs, __CLPK_real *dl, __CLPK_real *d__, __CLPK_real *du, __CLPK_real *dlf, __CLPK_real *df, __CLPK_real *duf,
__CLPK_real *du2, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *
- ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
+ ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int sgttrf_(__CLPK_integer *n, __CLPK_real *dl, __CLPK_real *d__, __CLPK_real *du, __CLPK_real *
du2, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int sgttrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *dl,
__CLPK_real *d__, __CLPK_real *du, __CLPK_real *du2, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int sgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real
+
+/* Subroutine */ int sgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real
*dl, __CLPK_real *d__, __CLPK_real *du, __CLPK_real *du2, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *
ldb);
-
-/* Subroutine */ int shgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
+
+/* Subroutine */ int shgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *
- ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *q, __CLPK_integer *ldq,
+ ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *q, __CLPK_integer *ldq,
__CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int shsein_(char *side, char *eigsrc, char *initv, __CLPK_logical *
- select, __CLPK_integer *n, __CLPK_real *h__, __CLPK_integer *ldh, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real
- *vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m,
+ select, __CLPK_integer *n, __CLPK_real *h__, __CLPK_integer *ldh, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real
+ *vl, __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m,
__CLPK_real *work, __CLPK_integer *ifaill, __CLPK_integer *ifailr, __CLPK_integer *info);
-
+
/* Subroutine */ int shseqr_(char *job, char *compz, __CLPK_integer *n, __CLPK_integer *ilo,
__CLPK_integer *ihi, __CLPK_real *h__, __CLPK_integer *ldh, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *z__,
__CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int slabad_(__CLPK_real *small, __CLPK_real *large);
-
-/* Subroutine */ int slabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *tauq, __CLPK_real *taup, __CLPK_real *x,
+
+/* Subroutine */ int slabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *tauq, __CLPK_real *taup, __CLPK_real *x,
__CLPK_integer *ldx, __CLPK_real *y, __CLPK_integer *ldy);
-
-/* Subroutine */ int slacon_(__CLPK_integer *n, __CLPK_real *v, __CLPK_real *x, __CLPK_integer *isgn,
+
+/* Subroutine */ int slacon_(__CLPK_integer *n, __CLPK_real *v, __CLPK_real *x, __CLPK_integer *isgn,
__CLPK_real *est, __CLPK_integer *kase);
-
-/* Subroutine */ int slacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int slacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int sladiv_(__CLPK_real *a, __CLPK_real *b, __CLPK_real *c__, __CLPK_real *d__, __CLPK_real *p,
+
+/* Subroutine */ int sladiv_(__CLPK_real *a, __CLPK_real *b, __CLPK_real *c__, __CLPK_real *d__, __CLPK_real *p,
__CLPK_real *q);
-
+
/* Subroutine */ int slae2_(__CLPK_real *a, __CLPK_real *b, __CLPK_real *c__, __CLPK_real *rt1, __CLPK_real *rt2);
-
-/* Subroutine */ int slaebz_(__CLPK_integer *ijob, __CLPK_integer *nitmax, __CLPK_integer *n,
+
+/* Subroutine */ int slaebz_(__CLPK_integer *ijob, __CLPK_integer *nitmax, __CLPK_integer *n,
__CLPK_integer *mmax, __CLPK_integer *minp, __CLPK_integer *nbmin, __CLPK_real *abstol, __CLPK_real *
- reltol, __CLPK_real *pivmin, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *e2, __CLPK_integer *nval,
- __CLPK_real *ab, __CLPK_real *c__, __CLPK_integer *mout, __CLPK_integer *nab, __CLPK_real *work, __CLPK_integer
+ reltol, __CLPK_real *pivmin, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *e2, __CLPK_integer *nval,
+ __CLPK_real *ab, __CLPK_real *c__, __CLPK_integer *mout, __CLPK_integer *nab, __CLPK_real *work, __CLPK_integer
*iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slaed0_(__CLPK_integer *icompq, __CLPK_integer *qsiz, __CLPK_integer *n, __CLPK_real
- *d__, __CLPK_real *e, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *qstore, __CLPK_integer *ldqs,
+
+/* Subroutine */ int slaed0_(__CLPK_integer *icompq, __CLPK_integer *qsiz, __CLPK_integer *n, __CLPK_real
+ *d__, __CLPK_real *e, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *qstore, __CLPK_integer *ldqs,
__CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slaed1_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *q, __CLPK_integer *ldq,
+
+/* Subroutine */ int slaed1_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *q, __CLPK_integer *ldq,
__CLPK_integer *indxq, __CLPK_real *rho, __CLPK_integer *cutpnt, __CLPK_real *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slaed2_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *n1, __CLPK_real *d__,
+
+/* Subroutine */ int slaed2_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *n1, __CLPK_real *d__,
__CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_real *rho, __CLPK_real *z__, __CLPK_real *
dlamda, __CLPK_real *w, __CLPK_real *q2, __CLPK_integer *indx, __CLPK_integer *indxc, __CLPK_integer *
indxp, __CLPK_integer *coltyp, __CLPK_integer *info);
-
-/* Subroutine */ int slaed3_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *n1, __CLPK_real *d__,
+
+/* Subroutine */ int slaed3_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *n1, __CLPK_real *d__,
__CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *rho, __CLPK_real *dlamda, __CLPK_real *q2, __CLPK_integer *
indx, __CLPK_integer *ctot, __CLPK_real *w, __CLPK_real *s, __CLPK_integer *info);
-
-/* Subroutine */ int slaed4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__,
+
+/* Subroutine */ int slaed4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__,
__CLPK_real *delta, __CLPK_real *rho, __CLPK_real *dlam, __CLPK_integer *info);
-
-/* Subroutine */ int slaed5_(__CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *delta,
+
+/* Subroutine */ int slaed5_(__CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *delta,
__CLPK_real *rho, __CLPK_real *dlam);
-
-/* Subroutine */ int slaed6_(__CLPK_integer *kniter, __CLPK_logical *orgati, __CLPK_real *rho,
+
+/* Subroutine */ int slaed6_(__CLPK_integer *kniter, __CLPK_logical *orgati, __CLPK_real *rho,
__CLPK_real *d__, __CLPK_real *z__, __CLPK_real *finit, __CLPK_real *tau, __CLPK_integer *info);
-
-/* Subroutine */ int slaed7_(__CLPK_integer *icompq, __CLPK_integer *n, __CLPK_integer *qsiz,
- __CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_real *d__, __CLPK_real *q,
+
+/* Subroutine */ int slaed7_(__CLPK_integer *icompq, __CLPK_integer *n, __CLPK_integer *qsiz,
+ __CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_real *d__, __CLPK_real *q,
__CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_real *rho, __CLPK_integer *cutpnt, __CLPK_real *
qstore, __CLPK_integer *qptr, __CLPK_integer *prmptr, __CLPK_integer *perm, __CLPK_integer *
- givptr, __CLPK_integer *givcol, __CLPK_real *givnum, __CLPK_real *work, __CLPK_integer *iwork,
+ givptr, __CLPK_integer *givcol, __CLPK_real *givnum, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int slaed8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_integer *n, __CLPK_integer
- *qsiz, __CLPK_real *d__, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_real *rho,
- __CLPK_integer *cutpnt, __CLPK_real *z__, __CLPK_real *dlamda, __CLPK_real *q2, __CLPK_integer *ldq2,
+
+/* Subroutine */ int slaed8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_integer *n, __CLPK_integer
+ *qsiz, __CLPK_real *d__, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *indxq, __CLPK_real *rho,
+ __CLPK_integer *cutpnt, __CLPK_real *z__, __CLPK_real *dlamda, __CLPK_real *q2, __CLPK_integer *ldq2,
__CLPK_real *w, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_real *
givnum, __CLPK_integer *indxp, __CLPK_integer *indx, __CLPK_integer *info);
-
-/* Subroutine */ int slaed9_(__CLPK_integer *k, __CLPK_integer *kstart, __CLPK_integer *kstop,
+
+/* Subroutine */ int slaed9_(__CLPK_integer *k, __CLPK_integer *kstart, __CLPK_integer *kstop,
__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *rho, __CLPK_real *dlamda,
__CLPK_real *w, __CLPK_real *s, __CLPK_integer *lds, __CLPK_integer *info);
-
-/* Subroutine */ int slaeda_(__CLPK_integer *n, __CLPK_integer *tlvls, __CLPK_integer *curlvl,
- __CLPK_integer *curpbm, __CLPK_integer *prmptr, __CLPK_integer *perm, __CLPK_integer *givptr,
- __CLPK_integer *givcol, __CLPK_real *givnum, __CLPK_real *q, __CLPK_integer *qptr, __CLPK_real *z__,
+
+/* Subroutine */ int slaeda_(__CLPK_integer *n, __CLPK_integer *tlvls, __CLPK_integer *curlvl,
+ __CLPK_integer *curpbm, __CLPK_integer *prmptr, __CLPK_integer *perm, __CLPK_integer *givptr,
+ __CLPK_integer *givcol, __CLPK_real *givnum, __CLPK_real *q, __CLPK_integer *qptr, __CLPK_real *z__,
__CLPK_real *ztemp, __CLPK_integer *info);
-
-/* Subroutine */ int slaein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
- __CLPK_real *h__, __CLPK_integer *ldh, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *vr, __CLPK_real *vi, __CLPK_real
- *b, __CLPK_integer *ldb, __CLPK_real *work, __CLPK_real *eps3, __CLPK_real *smlnum, __CLPK_real *bignum,
+
+/* Subroutine */ int slaein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
+ __CLPK_real *h__, __CLPK_integer *ldh, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *vr, __CLPK_real *vi, __CLPK_real
+ *b, __CLPK_integer *ldb, __CLPK_real *work, __CLPK_real *eps3, __CLPK_real *smlnum, __CLPK_real *bignum,
__CLPK_integer *info);
-
+
/* Subroutine */ int slaev2_(__CLPK_real *a, __CLPK_real *b, __CLPK_real *c__, __CLPK_real *rt1, __CLPK_real *
rt2, __CLPK_real *cs1, __CLPK_real *sn1);
-
+
/* Subroutine */ int slaexc_(__CLPK_logical *wantq, __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *
- ldt, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *j1, __CLPK_integer *n1, __CLPK_integer *n2,
+ ldt, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *j1, __CLPK_integer *n1, __CLPK_integer *n2,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int slag2_(__CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int slag2_(__CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
__CLPK_real *safmin, __CLPK_real *scale1, __CLPK_real *scale2, __CLPK_real *wr1, __CLPK_real *wr2, __CLPK_real *
wi);
-
-/* Subroutine */ int slags2_(__CLPK_logical *upper, __CLPK_real *a1, __CLPK_real *a2, __CLPK_real *a3,
+
+/* Subroutine */ int slags2_(__CLPK_logical *upper, __CLPK_real *a1, __CLPK_real *a2, __CLPK_real *a3,
__CLPK_real *b1, __CLPK_real *b2, __CLPK_real *b3, __CLPK_real *csu, __CLPK_real *snu, __CLPK_real *csv, __CLPK_real *
snv, __CLPK_real *csq, __CLPK_real *snq);
-
-/* Subroutine */ int slagtf_(__CLPK_integer *n, __CLPK_real *a, __CLPK_real *lambda, __CLPK_real *b, __CLPK_real
+
+/* Subroutine */ int slagtf_(__CLPK_integer *n, __CLPK_real *a, __CLPK_real *lambda, __CLPK_real *b, __CLPK_real
*c__, __CLPK_real *tol, __CLPK_real *d__, __CLPK_integer *in, __CLPK_integer *info);
-
+
/* Subroutine */ int slagtm_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *
alpha, __CLPK_real *dl, __CLPK_real *d__, __CLPK_real *du, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *
beta, __CLPK_real *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int slagts_(__CLPK_integer *job, __CLPK_integer *n, __CLPK_real *a, __CLPK_real *b, __CLPK_real
+
+/* Subroutine */ int slagts_(__CLPK_integer *job, __CLPK_integer *n, __CLPK_real *a, __CLPK_real *b, __CLPK_real
*c__, __CLPK_real *d__, __CLPK_integer *in, __CLPK_real *y, __CLPK_real *tol, __CLPK_integer *info);
-
-/* Subroutine */ int slagv2_(__CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int slagv2_(__CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb,
__CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *csl, __CLPK_real *snl, __CLPK_real *
csr, __CLPK_real *snr);
-
-/* Subroutine */ int slahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
+
+/* Subroutine */ int slahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *h__, __CLPK_integer *ldh, __CLPK_real *wr, __CLPK_real *
wi, __CLPK_integer *iloz, __CLPK_integer *ihiz, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *
info);
-
-/* Subroutine */ int slahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb, __CLPK_real *a,
+
+/* Subroutine */ int slahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *y, __CLPK_integer *ldy);
-
-/* Subroutine */ int slaic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_real *x, __CLPK_real *sest,
+
+/* Subroutine */ int slaic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_real *x, __CLPK_real *sest,
__CLPK_real *w, __CLPK_real *gamma, __CLPK_real *sestpr, __CLPK_real *s, __CLPK_real *c__);
-
+
/* Subroutine */ int slaln2_(__CLPK_logical *ltrans, __CLPK_integer *na, __CLPK_integer *nw, __CLPK_real *
- smin, __CLPK_real *ca, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *d1, __CLPK_real *d2, __CLPK_real *b,
- __CLPK_integer *ldb, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *scale,
+ smin, __CLPK_real *ca, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *d1, __CLPK_real *d2, __CLPK_real *b,
+ __CLPK_integer *ldb, __CLPK_real *wr, __CLPK_real *wi, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *scale,
__CLPK_real *xnorm, __CLPK_integer *info);
-
-/* Subroutine */ int slals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *bx,
- __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
+
+/* Subroutine */ int slals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *bx,
+ __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
__CLPK_integer *ldgcol, __CLPK_real *givnum, __CLPK_integer *ldgnum, __CLPK_real *poles, __CLPK_real *
difl, __CLPK_real *difr, __CLPK_real *z__, __CLPK_integer *k, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *
work, __CLPK_integer *info);
-
-/* Subroutine */ int slalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
+
+/* Subroutine */ int slalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *bx, __CLPK_integer *ldbx, __CLPK_real *
u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *k, __CLPK_real *difl, __CLPK_real *difr, __CLPK_real *
- z__, __CLPK_real *poles, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol,
+ z__, __CLPK_real *poles, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol,
__CLPK_integer *perm, __CLPK_real *givnum, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *work, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
- *nrhs, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *rcond,
+
+/* Subroutine */ int slalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
+ *nrhs, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slamc1_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd, __CLPK_logical
+
+/* Subroutine */ int slamc1_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd, __CLPK_logical
*ieee1);
-
+
/* Subroutine */ int slamc2_(__CLPK_integer *beta, __CLPK_integer *t, __CLPK_logical *rnd, __CLPK_real *
eps, __CLPK_integer *emin, __CLPK_real *rmin, __CLPK_integer *emax, __CLPK_real *rmax);
-
+
/* Subroutine */ int slamc4_(__CLPK_integer *emin, __CLPK_real *start, __CLPK_integer *base);
-
-/* Subroutine */ int slamc5_(__CLPK_integer *beta, __CLPK_integer *p, __CLPK_integer *emin,
+
+/* Subroutine */ int slamc5_(__CLPK_integer *beta, __CLPK_integer *p, __CLPK_integer *emin,
__CLPK_logical *ieee, __CLPK_integer *emax, __CLPK_real *rmax);
-
+
/* Subroutine */ int slamrg_(__CLPK_integer *n1, __CLPK_integer *n2, __CLPK_real *a, __CLPK_integer *
strd1, __CLPK_integer *strd2, __CLPK_integer *index);
-
+
/* Subroutine */ int slanv2_(__CLPK_real *a, __CLPK_real *b, __CLPK_real *c__, __CLPK_real *d__, __CLPK_real *
rt1r, __CLPK_real *rt1i, __CLPK_real *rt2r, __CLPK_real *rt2i, __CLPK_real *cs, __CLPK_real *sn);
-
-/* Subroutine */ int slapll_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *y,
+
+/* Subroutine */ int slapll_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *y,
__CLPK_integer *incy, __CLPK_real *ssmin);
-
+
/* Subroutine */ int slapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *x,
__CLPK_integer *ldx, __CLPK_integer *k);
-
+
/* Subroutine */ int slaqgb_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *
colcnd, __CLPK_real *amax, char *equed);
-
-/* Subroutine */ int slaqge_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int slaqge_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *r__, __CLPK_real *c__, __CLPK_real *rowcnd, __CLPK_real *colcnd, __CLPK_real *amax, char *
equed);
-
+
/* Subroutine */ int slaqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_real *tau, __CLPK_real *vn1, __CLPK_real *vn2, __CLPK_real *
work);
-
-/* Subroutine */ int slaqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
- *nb, __CLPK_integer *kb, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_real *tau,
+
+/* Subroutine */ int slaqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
+ *nb, __CLPK_integer *kb, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_real *tau,
__CLPK_real *vn1, __CLPK_real *vn2, __CLPK_real *auxv, __CLPK_real *f, __CLPK_integer *ldf);
-
-/* Subroutine */ int slaqsb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
+
+/* Subroutine */ int slaqsb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, char *equed);
-
+
/* Subroutine */ int slaqsp_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *s, __CLPK_real *
scond, __CLPK_real *amax, char *equed);
-
-/* Subroutine */ int slaqsy_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int slaqsy_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, char *equed);
-
-/* Subroutine */ int slaqtr_(__CLPK_logical *ltran, __CLPK_logical *lreal, __CLPK_integer *n, __CLPK_real
- *t, __CLPK_integer *ldt, __CLPK_real *b, __CLPK_real *w, __CLPK_real *scale, __CLPK_real *x, __CLPK_real *work,
+
+/* Subroutine */ int slaqtr_(__CLPK_logical *ltran, __CLPK_logical *lreal, __CLPK_integer *n, __CLPK_real
+ *t, __CLPK_integer *ldt, __CLPK_real *b, __CLPK_real *w, __CLPK_real *scale, __CLPK_real *x, __CLPK_real *work,
__CLPK_integer *info);
-
+
/* Subroutine */ int slar1v_(__CLPK_integer *n, __CLPK_integer *b1, __CLPK_integer *bn, __CLPK_real *
sigma, __CLPK_real *d__, __CLPK_real *l, __CLPK_real *ld, __CLPK_real *lld, __CLPK_real *gersch, __CLPK_real *
z__, __CLPK_real *ztz, __CLPK_real *mingma, __CLPK_integer *r__, __CLPK_integer *isuppz, __CLPK_real *
work);
-
-/* Subroutine */ int slar2v_(__CLPK_integer *n, __CLPK_real *x, __CLPK_real *y, __CLPK_real *z__, __CLPK_integer
+
+/* Subroutine */ int slar2v_(__CLPK_integer *n, __CLPK_real *x, __CLPK_real *y, __CLPK_real *z__, __CLPK_integer
*incx, __CLPK_real *c__, __CLPK_real *s, __CLPK_integer *incc);
-
-/* Subroutine */ int slarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *v,
+
+/* Subroutine */ int slarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *v,
__CLPK_integer *incv, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *work);
-
+
/* Subroutine */ int slarfb_(char *side, char *trans, char *direct, char *
- storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *v, __CLPK_integer *ldv,
+ storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *v, __CLPK_integer *ldv,
__CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *work, __CLPK_integer *
ldwork);
-
-/* Subroutine */ int slarfg_(__CLPK_integer *n, __CLPK_real *alpha, __CLPK_real *x, __CLPK_integer *incx,
+
+/* Subroutine */ int slarfg_(__CLPK_integer *n, __CLPK_real *alpha, __CLPK_real *x, __CLPK_integer *incx,
__CLPK_real *tau);
-
+
/* Subroutine */ int slarft_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
k, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_real *tau, __CLPK_real *t, __CLPK_integer *ldt);
-
-/* Subroutine */ int slarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *v,
+
+/* Subroutine */ int slarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *v,
__CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *work);
-
-/* Subroutine */ int slargv_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *y,
+
+/* Subroutine */ int slargv_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *y,
__CLPK_integer *incy, __CLPK_real *c__, __CLPK_integer *incc);
-
-/* Subroutine */ int slarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n, __CLPK_real
+
+/* Subroutine */ int slarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n, __CLPK_real
*x);
-
+
/* Subroutine */ int slarrb_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *l, __CLPK_real *ld, __CLPK_real *
- lld, __CLPK_integer *ifirst, __CLPK_integer *ilast, __CLPK_real *sigma, __CLPK_real *reltol, __CLPK_real
+ lld, __CLPK_integer *ifirst, __CLPK_integer *ilast, __CLPK_real *sigma, __CLPK_real *reltol, __CLPK_real
*w, __CLPK_real *wgap, __CLPK_real *werr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slarre_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *tol,
- __CLPK_integer *nsplit, __CLPK_integer *isplit, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *woff,
+
+/* Subroutine */ int slarre_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *tol,
+ __CLPK_integer *nsplit, __CLPK_integer *isplit, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *woff,
__CLPK_real *gersch, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int slarrf_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *l, __CLPK_real *ld, __CLPK_real *
lld, __CLPK_integer *ifirst, __CLPK_integer *ilast, __CLPK_real *w, __CLPK_real *dplus, __CLPK_real *
lplus, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slarrv_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *l, __CLPK_integer *isplit,
+
+/* Subroutine */ int slarrv_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *l, __CLPK_integer *isplit,
__CLPK_integer *m, __CLPK_real *w, __CLPK_integer *iblock, __CLPK_real *gersch, __CLPK_real *tol, __CLPK_real *
- z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_real *work, __CLPK_integer *iwork,
+ z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int slartg_(__CLPK_real *f, __CLPK_real *g, __CLPK_real *cs, __CLPK_real *sn, __CLPK_real *r__);
-
-/* Subroutine */ int slartv_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *y,
+
+/* Subroutine */ int slartv_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *y,
__CLPK_integer *incy, __CLPK_real *c__, __CLPK_real *s, __CLPK_integer *incc);
-
+
/* Subroutine */ int slaruv_(__CLPK_integer *iseed, __CLPK_integer *n, __CLPK_real *x);
-
-/* Subroutine */ int slarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
+
+/* Subroutine */ int slarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
__CLPK_real *v, __CLPK_integer *incv, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *
work);
-
+
/* Subroutine */ int slarzb_(char *side, char *trans, char *direct, char *
- storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *v,
+ storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *v,
__CLPK_integer *ldv, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *
work, __CLPK_integer *ldwork);
-
+
/* Subroutine */ int slarzt_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
k, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_real *tau, __CLPK_real *t, __CLPK_integer *ldt);
-
+
/* Subroutine */ int slas2_(__CLPK_real *f, __CLPK_real *g, __CLPK_real *h__, __CLPK_real *ssmin, __CLPK_real *
ssmax);
-
+
/* Subroutine */ int slascl_(char *type__, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_real *
- cfrom, __CLPK_real *cto, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+ cfrom, __CLPK_real *cto, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
-/* Subroutine */ int slasd0_(__CLPK_integer *n, __CLPK_integer *sqre, __CLPK_real *d__, __CLPK_real *e,
- __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_integer *smlsiz,
+
+/* Subroutine */ int slasd0_(__CLPK_integer *n, __CLPK_integer *sqre, __CLPK_real *d__, __CLPK_real *e,
+ __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_integer *smlsiz,
__CLPK_integer *iwork, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int slasd1_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_real *
- d__, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt,
+ d__, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt,
__CLPK_integer *ldvt, __CLPK_integer *idxq, __CLPK_integer *iwork, __CLPK_real *work, __CLPK_integer *
info);
-
-/* Subroutine */ int slasd2_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
+
+/* Subroutine */ int slasd2_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
*k, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_real *u, __CLPK_integer *
- ldu, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *dsigma, __CLPK_real *u2, __CLPK_integer *ldu2,
+ ldu, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *dsigma, __CLPK_real *u2, __CLPK_integer *ldu2,
__CLPK_real *vt2, __CLPK_integer *ldvt2, __CLPK_integer *idxp, __CLPK_integer *idx, __CLPK_integer *idxc,
__CLPK_integer *idxq, __CLPK_integer *coltyp, __CLPK_integer *info);
-
-/* Subroutine */ int slasd3_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
+
+/* Subroutine */ int slasd3_(__CLPK_integer *nl, __CLPK_integer *nr, __CLPK_integer *sqre, __CLPK_integer
*k, __CLPK_real *d__, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *dsigma, __CLPK_real *u, __CLPK_integer *
- ldu, __CLPK_real *u2, __CLPK_integer *ldu2, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *vt2,
+ ldu, __CLPK_real *u2, __CLPK_integer *ldu2, __CLPK_real *vt, __CLPK_integer *ldvt, __CLPK_real *vt2,
__CLPK_integer *ldvt2, __CLPK_integer *idxc, __CLPK_integer *ctot, __CLPK_real *z__, __CLPK_integer *
info);
-
-/* Subroutine */ int slasd4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__,
+
+/* Subroutine */ int slasd4_(__CLPK_integer *n, __CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__,
__CLPK_real *delta, __CLPK_real *rho, __CLPK_real *sigma, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int slasd5_(__CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *delta,
+
+/* Subroutine */ int slasd5_(__CLPK_integer *i__, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *delta,
__CLPK_real *rho, __CLPK_real *dsigma, __CLPK_real *work);
-
-/* Subroutine */ int slasd6_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+
+/* Subroutine */ int slasd6_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
__CLPK_integer *sqre, __CLPK_real *d__, __CLPK_real *vf, __CLPK_real *vl, __CLPK_real *alpha, __CLPK_real *beta,
- __CLPK_integer *idxq, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
+ __CLPK_integer *idxq, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
__CLPK_integer *ldgcol, __CLPK_real *givnum, __CLPK_integer *ldgnum, __CLPK_real *poles, __CLPK_real *
difl, __CLPK_real *difr, __CLPK_real *z__, __CLPK_integer *k, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int slasd7_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_integer *k, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *zw, __CLPK_real *vf,
+
+/* Subroutine */ int slasd7_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_integer *k, __CLPK_real *d__, __CLPK_real *z__, __CLPK_real *zw, __CLPK_real *vf,
__CLPK_real *vfw, __CLPK_real *vl, __CLPK_real *vlw, __CLPK_real *alpha, __CLPK_real *beta, __CLPK_real *dsigma,
__CLPK_integer *idx, __CLPK_integer *idxp, __CLPK_integer *idxq, __CLPK_integer *perm, __CLPK_integer *
givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_real *givnum, __CLPK_integer *
ldgnum, __CLPK_real *c__, __CLPK_real *s, __CLPK_integer *info);
-
+
/* Subroutine */ int slasd8_(__CLPK_integer *icompq, __CLPK_integer *k, __CLPK_real *d__, __CLPK_real *
- z__, __CLPK_real *vf, __CLPK_real *vl, __CLPK_real *difl, __CLPK_real *difr, __CLPK_integer *lddifr,
+ z__, __CLPK_real *vf, __CLPK_real *vl, __CLPK_real *difl, __CLPK_real *difr, __CLPK_integer *lddifr,
__CLPK_real *dsigma, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int slasd9_(__CLPK_integer *icompq, __CLPK_integer *ldu, __CLPK_integer *k, __CLPK_real *
d__, __CLPK_real *z__, __CLPK_real *vf, __CLPK_real *vl, __CLPK_real *difl, __CLPK_real *difr, __CLPK_real *
dsigma, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int slasda_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
- __CLPK_integer *sqre, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt,
+
+/* Subroutine */ int slasda_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
+ __CLPK_integer *sqre, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *vt,
__CLPK_integer *k, __CLPK_real *difl, __CLPK_real *difr, __CLPK_real *z__, __CLPK_real *poles, __CLPK_integer *
givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_integer *perm, __CLPK_real *givnum,
__CLPK_real *c__, __CLPK_real *s, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int slasdq_(char *uplo, __CLPK_integer *sqre, __CLPK_integer *n, __CLPK_integer *
- ncvt, __CLPK_integer *nru, __CLPK_integer *ncc, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *vt,
+ ncvt, __CLPK_integer *nru, __CLPK_integer *ncc, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *vt,
__CLPK_integer *ldvt, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *
work, __CLPK_integer *info);
-
+
/* Subroutine */ int slasdt_(__CLPK_integer *n, __CLPK_integer *lvl, __CLPK_integer *nd, __CLPK_integer *
inode, __CLPK_integer *ndiml, __CLPK_integer *ndimr, __CLPK_integer *msub);
-
-/* Subroutine */ int slaset_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *alpha,
+
+/* Subroutine */ int slaset_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *alpha,
__CLPK_real *beta, __CLPK_real *a, __CLPK_integer *lda);
-
-/* Subroutine */ int slasq1_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *work,
+
+/* Subroutine */ int slasq1_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *work,
__CLPK_integer *info);
-
+
/* Subroutine */ int slasq2_(__CLPK_integer *n, __CLPK_real *z__, __CLPK_integer *info);
-
+
/* Subroutine */ int slasq3_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_real *z__, __CLPK_integer *pp,
- __CLPK_real *dmin__, __CLPK_real *sigma, __CLPK_real *desig, __CLPK_real *qmax, __CLPK_integer *nfail,
+ __CLPK_real *dmin__, __CLPK_real *sigma, __CLPK_real *desig, __CLPK_real *qmax, __CLPK_integer *nfail,
__CLPK_integer *iter, __CLPK_integer *ndiv, __CLPK_logical *ieee);
-
+
/* Subroutine */ int slasq4_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_real *z__, __CLPK_integer *pp,
- __CLPK_integer *n0in, __CLPK_real *dmin__, __CLPK_real *dmin1, __CLPK_real *dmin2, __CLPK_real *dn,
+ __CLPK_integer *n0in, __CLPK_real *dmin__, __CLPK_real *dmin1, __CLPK_real *dmin2, __CLPK_real *dn,
__CLPK_real *dn1, __CLPK_real *dn2, __CLPK_real *tau, __CLPK_integer *ttype);
-
+
/* Subroutine */ int slasq5_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_real *z__, __CLPK_integer *pp,
__CLPK_real *tau, __CLPK_real *dmin__, __CLPK_real *dmin1, __CLPK_real *dmin2, __CLPK_real *dn, __CLPK_real *
dnm1, __CLPK_real *dnm2, __CLPK_logical *ieee);
-
+
/* Subroutine */ int slasq6_(__CLPK_integer *i0, __CLPK_integer *n0, __CLPK_real *z__, __CLPK_integer *pp,
__CLPK_real *dmin__, __CLPK_real *dmin1, __CLPK_real *dmin2, __CLPK_real *dn, __CLPK_real *dnm1, __CLPK_real *
dnm2);
-
+
/* Subroutine */ int slasr_(char *side, char *pivot, char *direct, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_real *c__, __CLPK_real *s, __CLPK_real *a, __CLPK_integer *lda);
-
+
/* Subroutine */ int slasrt_(char *id, __CLPK_integer *n, __CLPK_real *d__, __CLPK_integer *info);
-
-/* Subroutine */ int slassq_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *scale,
+
+/* Subroutine */ int slassq_(__CLPK_integer *n, __CLPK_real *x, __CLPK_integer *incx, __CLPK_real *scale,
__CLPK_real *sumsq);
-
+
/* Subroutine */ int slasv2_(__CLPK_real *f, __CLPK_real *g, __CLPK_real *h__, __CLPK_real *ssmin, __CLPK_real *
ssmax, __CLPK_real *snr, __CLPK_real *csr, __CLPK_real *snl, __CLPK_real *csl);
-
-/* Subroutine */ int slaswp_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *k1,
+
+/* Subroutine */ int slaswp_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *k1,
__CLPK_integer *k2, __CLPK_integer *ipiv, __CLPK_integer *incx);
-
-/* Subroutine */ int slasy2_(__CLPK_logical *ltranl, __CLPK_logical *ltranr, __CLPK_integer *isgn,
+
+/* Subroutine */ int slasy2_(__CLPK_logical *ltranl, __CLPK_logical *ltranr, __CLPK_integer *isgn,
__CLPK_integer *n1, __CLPK_integer *n2, __CLPK_real *tl, __CLPK_integer *ldtl, __CLPK_real *tr, __CLPK_integer *
- ldtr, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *scale, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real
+ ldtr, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *scale, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real
*xnorm, __CLPK_integer *info);
-
+
/* Subroutine */ int slasyf_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_integer *kb,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_real *w, __CLPK_integer *ldw, __CLPK_integer
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_real *w, __CLPK_integer *ldw, __CLPK_integer
*info);
-
+
/* Subroutine */ int slatbs_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *x,
+ normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *x,
__CLPK_real *scale, __CLPK_real *cnorm, __CLPK_integer *info);
-
+
/* Subroutine */ int slatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_real *z__, __CLPK_integer *
ldz, __CLPK_real *rhs, __CLPK_real *rdsum, __CLPK_real *rdscal, __CLPK_integer *ipiv, __CLPK_integer *
jpiv);
-
+
/* Subroutine */ int slatps_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *x, __CLPK_real *scale, __CLPK_real *cnorm,
+ normin, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *x, __CLPK_real *scale, __CLPK_real *cnorm,
__CLPK_integer *info);
-
-/* Subroutine */ int slatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_real *a,
+
+/* Subroutine */ int slatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *e, __CLPK_real *tau, __CLPK_real *w, __CLPK_integer *ldw);
-
+
/* Subroutine */ int slatrs_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *x, __CLPK_real *scale, __CLPK_real
+ normin, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *x, __CLPK_real *scale, __CLPK_real
*cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int slatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l, __CLPK_real *a,
+
+/* Subroutine */ int slatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work);
-
-/* Subroutine */ int slatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *v,
+
+/* Subroutine */ int slatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *v,
__CLPK_integer *incv, __CLPK_real *tau, __CLPK_real *c1, __CLPK_real *c2, __CLPK_integer *ldc, __CLPK_real *
work);
-
-/* Subroutine */ int slauu2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int slauu2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
-/* Subroutine */ int slauum_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int slauum_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
-/* Subroutine */ int sopgtr_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *tau,
+
+/* Subroutine */ int sopgtr_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *tau,
__CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sopmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *work,
+
+/* Subroutine */ int sopmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc, __CLPK_real *work,
__CLPK_integer *info);
-
-/* Subroutine */ int sorg2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorg2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sorg2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorg2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sorgbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer
+
+/* Subroutine */ int sorgbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer
*info);
-
-/* Subroutine */ int sorghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a,
+
+/* Subroutine */ int sorghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorgl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorgl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sorglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorgql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorgql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorgqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorgqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorgr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorgr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sorgrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
+
+/* Subroutine */ int sorgrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorgtr_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int sorgtr_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sorm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sorm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sorm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sormbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__,
+
+/* Subroutine */ int sormbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__,
__CLPK_integer *ldc, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sormhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sormhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *
c__, __CLPK_integer *ldc, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sorml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sorml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sormlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sormlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sormql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sormql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sormqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sormqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sormr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sormr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sormr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__,
+
+/* Subroutine */ int sormr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__,
__CLPK_integer *ldc, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sormrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int sormrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sormrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__,
+
+/* Subroutine */ int sormrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__,
__CLPK_integer *ldc, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int sormtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+
+/* Subroutine */ int sormtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *tau, __CLPK_real *c__, __CLPK_integer *ldc,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int spbcon_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
- __CLPK_integer *ldab, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int spbcon_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
+ __CLPK_integer *ldab, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int spbequ_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
+
+/* Subroutine */ int spbequ_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_real *s, __CLPK_real *scond, __CLPK_real *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int spbrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
- nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb, __CLPK_integer *ldafb, __CLPK_real *b,
+ nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb, __CLPK_integer *ldafb, __CLPK_real *b,
__CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int spbstf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
+
+/* Subroutine */ int spbstf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int spbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int spbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb, __CLPK_integer *ldafb,
- char *equed, __CLPK_real *s, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx,
- __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int spbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *afb, __CLPK_integer *ldafb,
+ char *equed, __CLPK_real *s, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx,
+ __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int spbtf2_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
+
+/* Subroutine */ int spbtf2_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_integer *info);
-
-/* Subroutine */ int spbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
+
+/* Subroutine */ int spbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int spbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int spocon_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int spocon_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int spoequ_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *s, __CLPK_real
+
+/* Subroutine */ int spoequ_(__CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *s, __CLPK_real
*scond, __CLPK_real *amax, __CLPK_integer *info);
-
-/* Subroutine */ int sporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int sporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x,
- __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
+ __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int sposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int sposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int sposvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, char *equed,
- __CLPK_real *s, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *rcond,
+ nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, char *equed,
+ __CLPK_real *s, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *rcond,
__CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int spotf2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int spotf2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
-/* Subroutine */ int spotrf_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int spotrf_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
-/* Subroutine */ int spotri_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int spotri_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *info);
-
-/* Subroutine */ int spotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int spotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sppcon_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *anorm,
+
+/* Subroutine */ int sppcon_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *anorm,
__CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sppequ_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *s, __CLPK_real *
scond, __CLPK_real *amax, __CLPK_integer *info);
-
-/* Subroutine */ int spprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
- __CLPK_real *afp, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr,
+
+/* Subroutine */ int spprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
+ __CLPK_real *afp, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr,
__CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
+
+/* Subroutine */ int sppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int sppsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_real *ap, __CLPK_real *afp, char *equed, __CLPK_real *s, __CLPK_real *b, __CLPK_integer *
- ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real
+ ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real
*work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int spptrf_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *info);
-
+
/* Subroutine */ int spptri_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *info);
-
-/* Subroutine */ int spptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
+
+/* Subroutine */ int spptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sptcon_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *anorm,
+
+/* Subroutine */ int sptcon_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *anorm,
__CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int spteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int spteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
__CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sptrfs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
- __CLPK_real *df, __CLPK_real *ef, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx,
+
+/* Subroutine */ int sptrfs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
+ __CLPK_real *df, __CLPK_real *ef, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx,
__CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int sptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int sptsvx_(char *fact, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_real *df, __CLPK_real *ef, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer
+ __CLPK_real *e, __CLPK_real *df, __CLPK_real *ef, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer
*ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int spttrf_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_integer *info);
-
-/* Subroutine */ int spttrs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int spttrs_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sptts2_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int sptts2_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *d__, __CLPK_real *e,
__CLPK_real *b, __CLPK_integer *ldb);
-
+
/* Subroutine */ int srscl_(__CLPK_integer *n, __CLPK_real *sa, __CLPK_real *sx, __CLPK_integer *incx);
-
-/* Subroutine */ int ssbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int ssbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work,
__CLPK_integer *info);
-
-/* Subroutine */ int ssbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int ssbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int ssbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_integer *kd, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *vl,
__CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *
w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *
ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+
+/* Subroutine */ int ssbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
__CLPK_integer *kb, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *bb, __CLPK_integer *ldbb, __CLPK_real *
x, __CLPK_integer *ldx, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int ssbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+
+/* Subroutine */ int ssbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
__CLPK_integer *kb, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *bb, __CLPK_integer *ldbb, __CLPK_real *
w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int ssbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+
+/* Subroutine */ int ssbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
__CLPK_integer *kb, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *bb, __CLPK_integer *ldbb, __CLPK_real *
w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *
iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int ssbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
__CLPK_integer *ka, __CLPK_integer *kb, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *bb, __CLPK_integer *
- ldbb, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer
- *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real
+ ldbb, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer
+ *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real
*work, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *q, __CLPK_integer *ldq,
+
+/* Subroutine */ int ssbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *q, __CLPK_integer *ldq,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sspcon_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *ipiv,
+
+/* Subroutine */ int sspcon_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *ipiv,
__CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sspev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *ap,
+
+/* Subroutine */ int sspev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *ap,
__CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sspevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *ap,
- __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer
+
+/* Subroutine */ int sspevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *ap,
+ __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer
*iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int sspevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_real *ap, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
+
+/* Subroutine */ int sspevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_real *ap, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
__CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *
iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
+
/* Subroutine */ int sspgst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_real *ap,
__CLPK_real *bp, __CLPK_integer *info);
-
+
/* Subroutine */ int sspgv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_real *ap, __CLPK_real *bp, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work,
+ n, __CLPK_real *ap, __CLPK_real *bp, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work,
__CLPK_integer *info);
-
+
/* Subroutine */ int sspgvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_real *ap, __CLPK_real *bp, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work,
+ n, __CLPK_real *ap, __CLPK_real *bp, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int sspgvx_(__CLPK_integer *itype, char *jobz, char *range, char *
uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *bp, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il,
__CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *
ldz, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
+
+/* Subroutine */ int ssprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
__CLPK_real *afp, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *
ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *
info);
-
-/* Subroutine */ int sspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
+
+/* Subroutine */ int sspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
__CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int sspsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_real *ap, __CLPK_real *afp, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real
- *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work,
+ nrhs, __CLPK_real *ap, __CLPK_real *afp, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real
+ *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssptrd_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *d__,
+
+/* Subroutine */ int ssptrd_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *d__,
__CLPK_real *e, __CLPK_real *tau, __CLPK_integer *info);
-
-/* Subroutine */ int ssptrf_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *ipiv,
+
+/* Subroutine */ int ssptrf_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *ipiv,
__CLPK_integer *info);
-
-/* Subroutine */ int ssptri_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *ipiv,
+
+/* Subroutine */ int ssptri_(char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_integer *ipiv,
__CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int ssptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
+
+/* Subroutine */ int ssptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *ap,
__CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int sstebz_(char *range, char *order, __CLPK_integer *n, __CLPK_real *vl,
- __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int sstebz_(char *range, char *order, __CLPK_integer *n, __CLPK_real *vl,
+ __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_real *d__, __CLPK_real *e,
__CLPK_integer *m, __CLPK_integer *nsplit, __CLPK_real *w, __CLPK_integer *iblock, __CLPK_integer *
isplit, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int sstedc_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
- __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+
+/* Subroutine */ int sstedc_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+ __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int sstegr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
+
+/* Subroutine */ int sstegr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
+ __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
__CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int sstein_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_integer *m, __CLPK_real
+
+/* Subroutine */ int sstein_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_integer *m, __CLPK_real
*w, __CLPK_integer *iblock, __CLPK_integer *isplit, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *
work, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+
+/* Subroutine */ int ssteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
__CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-
+
/* Subroutine */ int ssterf_(__CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_integer *info);
-
+
/* Subroutine */ int sstev_(char *jobz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real *
z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int sstevd_(char *jobz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real
- *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+
+/* Subroutine */ int sstevd_(char *jobz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e, __CLPK_real
+ *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int sstevr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
+
+/* Subroutine */ int sstevr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
+ __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
__CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int sstevx_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
+
+/* Subroutine */ int sstevx_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
+ __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
__CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *
iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssycon_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
- __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int ssycon_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+ __CLPK_integer *ipiv, __CLPK_real *anorm, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ssyev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int ssyev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *w, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssyevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *w, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
+
+/* Subroutine */ int ssyevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *w, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssyevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu,
+
+/* Subroutine */ int ssyevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu,
__CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *
- isuppz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+ isuppz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ssyevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu,
+
+/* Subroutine */ int ssyevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu,
__CLPK_real *abstol, __CLPK_integer *m, __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *
work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssygs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int ssygs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int ssygst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int ssygst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int ssygv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *w, __CLPK_real *work,
+ n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *w, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int ssygvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *w, __CLPK_real *work,
+ n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *w, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int ssygvx_(__CLPK_integer *itype, char *jobz, char *range, char *
uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *
- vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m,
- __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer
+ vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol, __CLPK_integer *m,
+ __CLPK_real *w, __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer
*iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int ssyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_real *b,
+
+/* Subroutine */ int ssyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv, __CLPK_real *b,
__CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *
work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
- __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *work,
+
+/* Subroutine */ int ssysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+ __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int ssysvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv,
+ nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *af, __CLPK_integer *ldaf, __CLPK_integer *ipiv,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *rcond, __CLPK_real *ferr,
__CLPK_real *berr, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *
info);
-
-/* Subroutine */ int ssytd2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int ssytd2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *d__, __CLPK_real *e, __CLPK_real *tau, __CLPK_integer *info);
-
-/* Subroutine */ int ssytf2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int ssytf2_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int ssytrd_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int ssytrd_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *d__, __CLPK_real *e, __CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int ssytrf_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int ssytrf_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int ssytri_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int ssytri_(char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int ssytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
+
+/* Subroutine */ int ssytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int stbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *rcond, __CLPK_real *work,
+
+/* Subroutine */ int stbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *rcond, __CLPK_real *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int stbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *b, __CLPK_integer
- *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work,
+
+/* Subroutine */ int stbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *b, __CLPK_integer
+ *ldb, __CLPK_real *x, __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work,
__CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int stbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *b, __CLPK_integer
+
+/* Subroutine */ int stbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *b, __CLPK_integer
*ldb, __CLPK_integer *info);
-
-/* Subroutine */ int stgevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *vl,
- __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_real
+
+/* Subroutine */ int stgevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *vl,
+ __CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_real
*work, __CLPK_integer *info);
-
-/* Subroutine */ int stgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n, __CLPK_real
+
+/* Subroutine */ int stgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n, __CLPK_real
*a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *
- z__, __CLPK_integer *ldz, __CLPK_integer *j1, __CLPK_integer *n1, __CLPK_integer *n2, __CLPK_real *work,
+ z__, __CLPK_integer *ldz, __CLPK_integer *j1, __CLPK_integer *n1, __CLPK_integer *n2, __CLPK_real *work,
__CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int stgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n, __CLPK_real
+
+/* Subroutine */ int stgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n, __CLPK_real
*a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *
z__, __CLPK_integer *ldz, __CLPK_integer *ifst, __CLPK_integer *ilst, __CLPK_real *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
-/* Subroutine */ int stgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
+
+/* Subroutine */ int stgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
__CLPK_logical *select, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *
- ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *q, __CLPK_integer *ldq,
- __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *m, __CLPK_real *pl, __CLPK_real *pr, __CLPK_real *dif,
+ ldb, __CLPK_real *alphar, __CLPK_real *alphai, __CLPK_real *beta, __CLPK_real *q, __CLPK_integer *ldq,
+ __CLPK_real *z__, __CLPK_integer *ldz, __CLPK_integer *m, __CLPK_real *pl, __CLPK_real *pr, __CLPK_real *dif,
__CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *
info);
-
-/* Subroutine */ int stgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+
+/* Subroutine */ int stgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
__CLPK_integer *p, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *tola, __CLPK_real *tolb, __CLPK_real *alpha, __CLPK_real *
beta, __CLPK_real *u, __CLPK_integer *ldu, __CLPK_real *v, __CLPK_integer *ldv, __CLPK_real *q, __CLPK_integer *
ldq, __CLPK_real *work, __CLPK_integer *ncycle, __CLPK_integer *info);
-
-/* Subroutine */ int stgsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *vl,
+
+/* Subroutine */ int stgsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *vl,
__CLPK_integer *ldvl, __CLPK_real *vr, __CLPK_integer *ldvr, __CLPK_real *s, __CLPK_real *dif, __CLPK_integer *
mm, __CLPK_integer *m, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int stgsy2_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *c__, __CLPK_integer *
- ldc, __CLPK_real *d__, __CLPK_integer *ldd, __CLPK_real *e, __CLPK_integer *lde, __CLPK_real *f, __CLPK_integer
- *ldf, __CLPK_real *scale, __CLPK_real *rdsum, __CLPK_real *rdscal, __CLPK_integer *iwork, __CLPK_integer
+ ldc, __CLPK_real *d__, __CLPK_integer *ldd, __CLPK_real *e, __CLPK_integer *lde, __CLPK_real *f, __CLPK_integer
+ *ldf, __CLPK_real *scale, __CLPK_real *rdsum, __CLPK_real *rdscal, __CLPK_integer *iwork, __CLPK_integer
*pq, __CLPK_integer *info);
-
+
/* Subroutine */ int stgsyl_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *c__, __CLPK_integer *
- ldc, __CLPK_real *d__, __CLPK_integer *ldd, __CLPK_real *e, __CLPK_integer *lde, __CLPK_real *f, __CLPK_integer
+ ldc, __CLPK_real *d__, __CLPK_integer *ldd, __CLPK_real *e, __CLPK_integer *lde, __CLPK_real *f, __CLPK_integer
*ldf, __CLPK_real *scale, __CLPK_real *dif, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *
iwork, __CLPK_integer *info);
-
-/* Subroutine */ int stpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int stpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_real *ap, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int stprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int stprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_real *ap, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x, __CLPK_integer *ldx,
__CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int stptri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *ap,
+
+/* Subroutine */ int stptri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *ap,
__CLPK_integer *info);
-
-/* Subroutine */ int stptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int stptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_real *ap, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int strcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int strcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *rcond, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int strevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
+
+/* Subroutine */ int strevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
__CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_real *work, __CLPK_integer *info);
-
-/* Subroutine */ int strexc_(char *compq, __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *ldt,
- __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *ifst, __CLPK_integer *ilst, __CLPK_real *work,
+
+/* Subroutine */ int strexc_(char *compq, __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *ldt,
+ __CLPK_real *q, __CLPK_integer *ldq, __CLPK_integer *ifst, __CLPK_integer *ilst, __CLPK_real *work,
__CLPK_integer *info);
-
-/* Subroutine */ int strrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x,
- __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int strrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *x,
+ __CLPK_integer *ldx, __CLPK_real *ferr, __CLPK_real *berr, __CLPK_real *work, __CLPK_integer *iwork,
__CLPK_integer *info);
-
-/* Subroutine */ int strsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
- *n, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *wr, __CLPK_real *wi,
+
+/* Subroutine */ int strsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
+ *n, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *q, __CLPK_integer *ldq, __CLPK_real *wr, __CLPK_real *wi,
__CLPK_integer *m, __CLPK_real *s, __CLPK_real *sep, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *
iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int strsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
+
+/* Subroutine */ int strsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_real *t, __CLPK_integer *ldt, __CLPK_real *vl, __CLPK_integer *ldvl, __CLPK_real *vr,
__CLPK_integer *ldvr, __CLPK_real *s, __CLPK_real *sep, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_real *
work, __CLPK_integer *ldwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int strsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
+
+/* Subroutine */ int strsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
*m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_real *
c__, __CLPK_integer *ldc, __CLPK_real *scale, __CLPK_integer *info);
-
-/* Subroutine */ int strti2_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int strti2_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int strtri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *a,
+
+/* Subroutine */ int strtri_(char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int strtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int strtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
__CLPK_integer *nrhs, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
-/* Subroutine */ int stzrqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int stzrqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_integer *info);
-
-/* Subroutine */ int stzrzf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+
+/* Subroutine */ int stzrzf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *tau, __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int xerbla_(char *srname, __CLPK_integer *info);
-
+
/* Subroutine */ int zbdsqr_(char *uplo, __CLPK_integer *n, __CLPK_integer *ncvt, __CLPK_integer *
- nru, __CLPK_integer *ncc, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *vt,
- __CLPK_integer *ldvt, __CLPK_doublecomplex *u, __CLPK_integer *ldu, __CLPK_doublecomplex *c__,
+ nru, __CLPK_integer *ncc, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *vt,
+ __CLPK_integer *ldvt, __CLPK_doublecomplex *u, __CLPK_integer *ldu, __CLPK_doublecomplex *c__,
__CLPK_integer *ldc, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zdrot_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx,
+
+/* Subroutine */ int zdrot_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx,
__CLPK_doublecomplex *cy, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_doublereal *s);
-
-/* Subroutine */ int zdrscl_(__CLPK_integer *n, __CLPK_doublereal *sa, __CLPK_doublecomplex *sx,
+
+/* Subroutine */ int zdrscl_(__CLPK_integer *n, __CLPK_doublereal *sa, __CLPK_doublecomplex *sx,
__CLPK_integer *incx);
-
+
/* Subroutine */ int zgbbrd_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *ncc,
- __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
- __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *q, __CLPK_integer *ldq,
- __CLPK_doublecomplex *pt, __CLPK_integer *ldpt, __CLPK_doublecomplex *c__, __CLPK_integer *ldc,
+ __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
+ __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *q, __CLPK_integer *ldq,
+ __CLPK_doublecomplex *pt, __CLPK_integer *ldpt, __CLPK_doublecomplex *c__, __CLPK_integer *ldc,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zgbcon_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *anorm,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublereal *anorm,
__CLPK_doublereal *rcond, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int zgbequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
__CLPK_doublereal *rowcnd, __CLPK_doublereal *colcnd, __CLPK_doublereal *amax, __CLPK_integer *
info);
-
+
/* Subroutine */ int zgbrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
ku, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *
- afb, __CLPK_integer *ldafb, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ afb, __CLPK_integer *ldafb, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zgbsv_(__CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_integer *
nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_doublecomplex *
b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int zgbsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *kl,
- __CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
- __CLPK_doublecomplex *afb, __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed,
- __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
+ __CLPK_integer *ku, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
+ __CLPK_doublecomplex *afb, __CLPK_integer *ldafb, __CLPK_integer *ipiv, char *equed,
+ __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int zgbtf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int zgbtrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv, __CLPK_integer *info);
-
+
/* Subroutine */ int zgbtrs_(char *trans, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *
- ku, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
+ ku, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *ipiv,
__CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_integer *m, __CLPK_doublecomplex *v,
+
+/* Subroutine */ int zgebak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_integer *m, __CLPK_doublecomplex *v,
__CLPK_integer *ldv, __CLPK_integer *info);
-
-/* Subroutine */ int zgebal_(char *job, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer
+
+/* Subroutine */ int zgebal_(char *job, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer
*lda, __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_integer *info);
-
-/* Subroutine */ int zgebd2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tauq,
+
+/* Subroutine */ int zgebd2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tauq,
__CLPK_doublecomplex *taup, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zgebrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tauq,
+
+/* Subroutine */ int zgebrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tauq,
__CLPK_doublecomplex *taup, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *
info);
-
-/* Subroutine */ int zgecon_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgecon_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgeequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd,
+
+/* Subroutine */ int zgeequ_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd,
__CLPK_doublereal *colcnd, __CLPK_doublereal *amax, __CLPK_integer *info);
-
-/* Subroutine */ int zgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_doublecomplex *w,
+
+/* Subroutine */ int zgees_(char *jobvs, char *sort, __CLPK_L_fp select, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *sdim, __CLPK_doublecomplex *w,
__CLPK_doublecomplex *vs, __CLPK_integer *ldvs, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_doublereal *rwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zgeesx_(char *jobvs, char *sort, __CLPK_L_fp select, char *
- sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *sdim,
+ sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *sdim,
__CLPK_doublecomplex *w, __CLPK_doublecomplex *vs, __CLPK_integer *ldvs, __CLPK_doublereal *
- rconde, __CLPK_doublereal *rcondv, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
+ rconde, __CLPK_doublereal *rcondv, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_doublereal *rwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgeev_(char *jobvl, char *jobvr, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *w, __CLPK_doublecomplex *vl,
- __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zgeev_(char *jobvl, char *jobvr, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *w, __CLPK_doublecomplex *vl,
+ __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublecomplex *work,
__CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zgeevx_(char *balanc, char *jobvl, char *jobvr, char *
- sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *w,
- __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_doublereal *abnrm,
+ sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *w,
+ __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *scale, __CLPK_doublereal *abnrm,
__CLPK_doublereal *rconde, __CLPK_doublereal *rcondv, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vsl,
+
+/* Subroutine */ int zgegs_(char *jobvsl, char *jobvsr, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vsl,
__CLPK_integer *ldvsl, __CLPK_doublecomplex *vsr, __CLPK_integer *ldvsr, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgegv_(char *jobvl, char *jobvr, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vl, __CLPK_integer
- *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublecomplex *work, __CLPK_integer
+
+/* Subroutine */ int zgegv_(char *jobvl, char *jobvr, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vl, __CLPK_integer
+ *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublecomplex *work, __CLPK_integer
*lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
+
+/* Subroutine */ int zgehd2_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
+
+/* Subroutine */ int zgehrd_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgelq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgelq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zgelqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgelqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int zgels_(char *trans, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_integer *jpvt, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zgelsx_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_integer *jpvt, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_integer *jpvt, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zgelsy_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_integer *jpvt, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
__CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgeql2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgeql2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zgeqlf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgeqlf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zgeqp3_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zgeqp3_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work,
__CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgeqpf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zgeqpf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgeqr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgeqr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zgeqrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgeqrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
- __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
+
+/* Subroutine */ int zgerfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
+ __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
__CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgerq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgerq2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zgerqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgerqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zgesc2_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zgesc2_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_doublecomplex *rhs, __CLPK_integer *ipiv, __CLPK_integer *jpiv, __CLPK_doublereal *scale);
-
-/* Subroutine */ int zgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgesv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *
info);
-
+
/* Subroutine */ int zgesvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *
- ldaf, __CLPK_integer *ipiv, char *equed, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+ ldaf, __CLPK_integer *ipiv, char *equed, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgetc2_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zgetc2_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_integer *jpiv, __CLPK_integer *info);
-
-/* Subroutine */ int zgetf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgetf2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int zgetrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zgetrf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int zgetri_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zgetri_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zgetrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale, __CLPK_integer *m,
+
+/* Subroutine */ int zggbak_(char *job, char *side, __CLPK_integer *n, __CLPK_integer *ilo,
+ __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale, __CLPK_integer *m,
__CLPK_doublecomplex *v, __CLPK_integer *ldv, __CLPK_integer *info);
-
-/* Subroutine */ int zggbal_(char *job, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer
- *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi,
+
+/* Subroutine */ int zggbal_(char *job, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer
+ *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *ilo, __CLPK_integer *ihi,
__CLPK_doublereal *lscale, __CLPK_doublereal *rscale, __CLPK_doublereal *work, __CLPK_integer *
info);
-
-/* Subroutine */ int zgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
- delctg, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zgges_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+ delctg, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *
- beta, __CLPK_doublecomplex *vsl, __CLPK_integer *ldvsl, __CLPK_doublecomplex *vsr, __CLPK_integer
- *ldvsr, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
+ beta, __CLPK_doublecomplex *vsl, __CLPK_integer *ldvsl, __CLPK_doublecomplex *vsr, __CLPK_integer
+ *ldvsr, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
- delctg, char *sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublecomplex *alpha,
- __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vsl, __CLPK_integer *ldvsl,
+
+/* Subroutine */ int zggesx_(char *jobvsl, char *jobvsr, char *sort, __CLPK_L_fp
+ delctg, char *sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *sdim, __CLPK_doublecomplex *alpha,
+ __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vsl, __CLPK_integer *ldvsl,
__CLPK_doublecomplex *vsr, __CLPK_integer *ldvsr, __CLPK_doublereal *rconde, __CLPK_doublereal *
- rcondv, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
+ rcondv, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggev_(char *jobvl, char *jobvr, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vl, __CLPK_integer
- *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublecomplex *work, __CLPK_integer
+
+/* Subroutine */ int zggev_(char *jobvl, char *jobvr, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *vl, __CLPK_integer
+ *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublecomplex *work, __CLPK_integer
*lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zggevx_(char *balanc, char *jobvl, char *jobvr, char *
- sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
- __CLPK_integer *ldb, __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta,
- __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale,
+ sense, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+ __CLPK_integer *ldb, __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta,
+ __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublereal *lscale, __CLPK_doublereal *rscale,
__CLPK_doublereal *abnrm, __CLPK_doublereal *bbnrm, __CLPK_doublereal *rconde, __CLPK_doublereal *
- rcondv, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
+ rcondv, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *iwork, __CLPK_logical *bwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *d__, __CLPK_doublecomplex *x, __CLPK_doublecomplex *y, __CLPK_doublecomplex
+
+/* Subroutine */ int zggglm_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *d__, __CLPK_doublecomplex *x, __CLPK_doublecomplex *y, __CLPK_doublecomplex
*work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zgghrd_(char *compq, char *compz, __CLPK_integer *n, __CLPK_integer *
- ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
- __CLPK_integer *ldb, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__,
+ ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+ __CLPK_integer *ldb, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__,
__CLPK_integer *ldz, __CLPK_integer *info);
-
-/* Subroutine */ int zgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *c__, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *x,
+
+/* Subroutine */ int zgglse_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *p,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *c__, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *x,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p,
+
+/* Subroutine */ int zggqrf_(__CLPK_integer *n, __CLPK_integer *m, __CLPK_integer *p,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *taua, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_doublecomplex *taub, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n,
+
+/* Subroutine */ int zggrqf_(__CLPK_integer *m, __CLPK_integer *p, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *taua, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_doublecomplex *taub, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_integer *p, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublereal *alpha,
- __CLPK_doublereal *beta, __CLPK_doublecomplex *u, __CLPK_integer *ldu, __CLPK_doublecomplex *v,
- __CLPK_integer *ldv, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zggsvd_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_integer *p, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublereal *alpha,
+ __CLPK_doublereal *beta, __CLPK_doublecomplex *u, __CLPK_integer *ldu, __CLPK_doublecomplex *v,
+ __CLPK_integer *ldv, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int zggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *p, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
- *b, __CLPK_integer *ldb, __CLPK_doublereal *tola, __CLPK_doublereal *tolb, __CLPK_integer *k,
- __CLPK_integer *l, __CLPK_doublecomplex *u, __CLPK_integer *ldu, __CLPK_doublecomplex *v, __CLPK_integer
+
+/* Subroutine */ int zggsvp_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *p, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
+ *b, __CLPK_integer *ldb, __CLPK_doublereal *tola, __CLPK_doublereal *tolb, __CLPK_integer *k,
+ __CLPK_integer *l, __CLPK_doublecomplex *u, __CLPK_integer *ldu, __CLPK_doublecomplex *v, __CLPK_integer
*ldv, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_integer *iwork, __CLPK_doublereal *
rwork, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zgtcon_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *dl,
+
+/* Subroutine */ int zgtcon_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *dl,
__CLPK_doublecomplex *d__, __CLPK_doublecomplex *du, __CLPK_doublecomplex *du2, __CLPK_integer *
- ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *work,
+ ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *work,
__CLPK_integer *info);
-
-/* Subroutine */ int zgtrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
- __CLPK_doublecomplex *dlf, __CLPK_doublecomplex *df, __CLPK_doublecomplex *duf,
- __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+
+/* Subroutine */ int zgtrfs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
+ __CLPK_doublecomplex *dlf, __CLPK_doublecomplex *df, __CLPK_doublecomplex *duf,
+ __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublecomplex *dl,
+
+/* Subroutine */ int zgtsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublecomplex *dl,
__CLPK_doublecomplex *d__, __CLPK_doublecomplex *du, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int zgtsvx_(char *fact, char *trans, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
- __CLPK_doublecomplex *dlf, __CLPK_doublecomplex *df, __CLPK_doublecomplex *duf,
- __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
+ nrhs, __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
+ __CLPK_doublecomplex *dlf, __CLPK_doublecomplex *df, __CLPK_doublecomplex *duf,
+ __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int zgttrf_(__CLPK_integer *n, __CLPK_doublecomplex *dl, __CLPK_doublecomplex *
d__, __CLPK_doublecomplex *du, __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_integer *
info);
-
-/* Subroutine */ int zgttrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
- __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zgttrs_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
+ __CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int zgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
+
+/* Subroutine */ int zgtts2_(__CLPK_integer *itrans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__, __CLPK_doublecomplex *du,
__CLPK_doublecomplex *du2, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int zhbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublecomplex *z__,
+
+/* Subroutine */ int zhbev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublecomplex *z__,
__CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublecomplex *z__,
- __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
+
+/* Subroutine */ int zhbevd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *w, __CLPK_doublecomplex *z__,
+ __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *q,
+
+/* Subroutine */ int zhbevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *q,
__CLPK_integer *ldq, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *
iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublecomplex *z__,
__CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *iwork,
__CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int zhbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
- __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *bb,
- __CLPK_integer *ldbb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int zhbgst_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+ __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *bb,
+ __CLPK_integer *ldbb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
- __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *bb,
- __CLPK_integer *ldbb, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int zhbgv_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+ __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *bb,
+ __CLPK_integer *ldbb, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_integer *ka, __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
- __CLPK_doublecomplex *bb, __CLPK_integer *ldbb, __CLPK_doublecomplex *q, __CLPK_integer *ldq,
+
+/* Subroutine */ int zhbgvx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_integer *ka, __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
+ __CLPK_doublecomplex *bb, __CLPK_integer *ldbb, __CLPK_doublecomplex *q, __CLPK_integer *ldq,
__CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *
- abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+ abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *
ifail, __CLPK_integer *info);
-
-/* Subroutine */ int zhbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int zhbtrd_(char *vect, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zhecon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond,
+
+/* Subroutine */ int zhecon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond,
__CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zheev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex
- *a, __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
+
+/* Subroutine */ int zheev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex
+ *a, __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zheevd_(char *jobz, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublecomplex *work,
- __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork,
+
+/* Subroutine */ int zheevd_(char *jobz, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *w, __CLPK_doublecomplex *work,
+ __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int zheevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *vl, __CLPK_doublereal *vu,
+
+/* Subroutine */ int zheevr_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *vl, __CLPK_doublereal *vu,
__CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *
w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *lrwork, __CLPK_integer *
iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int zheevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *vl, __CLPK_doublereal *vu,
+
+/* Subroutine */ int zheevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *vl, __CLPK_doublereal *vu,
__CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *
w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *
info);
-
-/* Subroutine */ int zhegs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zhegs2_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int zhegst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zhegst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int zhegv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_doublereal *w, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *info);
-
+
/* Subroutine */ int zhegvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_doublereal *w, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zhegvx_(__CLPK_integer *itype, char *jobz, char *range, char *
- uplo, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+ uplo, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *
iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublecomplex *z__,
__CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int zherfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
- __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
+
+/* Subroutine */ int zherfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
+ __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
__CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhesv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zhesv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zhesvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *
ldaf, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
- __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhetf2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zhetf2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int zhetrd_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zhetrd_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhetrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
+
+/* Subroutine */ int zhetrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zhetri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zhetri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zhetrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zhetrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zhgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zhgeqz_(char *job, char *compq, char *compz, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *
beta, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__, __CLPK_integer *
ldz, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
-/* Subroutine */ int zhpcon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zhpcon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zhpev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex
+
+/* Subroutine */ int zhpev_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex
*ap, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhpevd_(char *jobz, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *ap, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int zhpevd_(char *jobz, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *ap, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *
lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhpevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
- __CLPK_doublecomplex *ap, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
- __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+
+/* Subroutine */ int zhpevx_(char *jobz, char *range, char *uplo, __CLPK_integer *n,
+ __CLPK_doublecomplex *ap, __CLPK_doublereal *vl, __CLPK_doublereal *vu, __CLPK_integer *il,
+ __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
__CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_doublereal *
rwork, __CLPK_integer *iwork, __CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int zhpgst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
+
+/* Subroutine */ int zhpgst_(__CLPK_integer *itype, char *uplo, __CLPK_integer *n,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *bp, __CLPK_integer *info);
-
+
/* Subroutine */ int zhpgv_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *bp, __CLPK_doublereal *w, __CLPK_doublecomplex
+ n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *bp, __CLPK_doublereal *w, __CLPK_doublecomplex
*z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int zhpgvd_(__CLPK_integer *itype, char *jobz, char *uplo, __CLPK_integer *
- n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *bp, __CLPK_doublereal *w, __CLPK_doublecomplex
+ n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *bp, __CLPK_doublereal *w, __CLPK_doublecomplex
*z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *
rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *
info);
-
+
/* Subroutine */ int zhpgvx_(__CLPK_integer *itype, char *jobz, char *range, char *
uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *bp, __CLPK_doublereal *
- vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol,
- __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+ vl, __CLPK_doublereal *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol,
+ __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *
ifail, __CLPK_integer *info);
-
-/* Subroutine */ int zhprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int zhprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_integer *ipiv, __CLPK_doublecomplex *
- b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
+ b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
-/* Subroutine */ int zhpsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zhpsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int zhpsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_integer *ipiv,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+ nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_integer *ipiv,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zhptrd_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zhptrd_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tau, __CLPK_integer *info);
-
-/* Subroutine */ int zhptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zhptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int zhptri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zhptri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zhptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zhptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int zhsein_(char *side, char *eigsrc, char *initv, __CLPK_logical *
select, __CLPK_integer *n, __CLPK_doublecomplex *h__, __CLPK_integer *ldh, __CLPK_doublecomplex *
w, __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr,
- __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork,
+ __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork,
__CLPK_integer *ifaill, __CLPK_integer *ifailr, __CLPK_integer *info);
-
+
/* Subroutine */ int zhseqr_(char *job, char *compz, __CLPK_integer *n, __CLPK_integer *ilo,
- __CLPK_integer *ihi, __CLPK_doublecomplex *h__, __CLPK_integer *ldh, __CLPK_doublecomplex *w,
+ __CLPK_integer *ihi, __CLPK_doublecomplex *h__, __CLPK_integer *ldh, __CLPK_doublecomplex *w,
__CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zlabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+
+/* Subroutine */ int zlabrd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nb,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e,
__CLPK_doublecomplex *tauq, __CLPK_doublecomplex *taup, __CLPK_doublecomplex *x, __CLPK_integer *
ldx, __CLPK_doublecomplex *y, __CLPK_integer *ldy);
-
+
/* Subroutine */ int zlacgv_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx);
-
-/* Subroutine */ int zlacon_(__CLPK_integer *n, __CLPK_doublecomplex *v, __CLPK_doublecomplex *x,
+
+/* Subroutine */ int zlacon_(__CLPK_integer *n, __CLPK_doublecomplex *v, __CLPK_doublecomplex *x,
__CLPK_doublereal *est, __CLPK_integer *kase);
-
+
/* Subroutine */ int zlacp2_(char *uplo, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *
a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int zlacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int zlacpy_(char *uplo, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int zlacrm_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublecomplex *c__,
+
+/* Subroutine */ int zlacrm_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *b, __CLPK_integer *ldb, __CLPK_doublecomplex *c__,
__CLPK_integer *ldc, __CLPK_doublereal *rwork);
-
-/* Subroutine */ int zlacrt_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx,
+
+/* Subroutine */ int zlacrt_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx,
__CLPK_doublecomplex *cy, __CLPK_integer *incy, __CLPK_doublecomplex *c__, __CLPK_doublecomplex *
s);
-
-/* Subroutine */ int zlaed0_(__CLPK_integer *qsiz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *qstore,
+
+/* Subroutine */ int zlaed0_(__CLPK_integer *qsiz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *qstore,
__CLPK_integer *ldqs, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int zlaed7_(__CLPK_integer *n, __CLPK_integer *cutpnt, __CLPK_integer *qsiz,
- __CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_doublereal *d__,
- __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublereal *rho, __CLPK_integer *indxq,
- __CLPK_doublereal *qstore, __CLPK_integer *qptr, __CLPK_integer *prmptr, __CLPK_integer *perm,
+
+/* Subroutine */ int zlaed7_(__CLPK_integer *n, __CLPK_integer *cutpnt, __CLPK_integer *qsiz,
+ __CLPK_integer *tlvls, __CLPK_integer *curlvl, __CLPK_integer *curpbm, __CLPK_doublereal *d__,
+ __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublereal *rho, __CLPK_integer *indxq,
+ __CLPK_doublereal *qstore, __CLPK_integer *qptr, __CLPK_integer *prmptr, __CLPK_integer *perm,
__CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_doublereal *givnum, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int zlaed8_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *qsiz,
- __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublereal *d__, __CLPK_doublereal *rho,
+
+/* Subroutine */ int zlaed8_(__CLPK_integer *k, __CLPK_integer *n, __CLPK_integer *qsiz,
+ __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublereal *d__, __CLPK_doublereal *rho,
__CLPK_integer *cutpnt, __CLPK_doublereal *z__, __CLPK_doublereal *dlamda, __CLPK_doublecomplex *
- q2, __CLPK_integer *ldq2, __CLPK_doublereal *w, __CLPK_integer *indxp, __CLPK_integer *indx,
- __CLPK_integer *indxq, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
+ q2, __CLPK_integer *ldq2, __CLPK_doublereal *w, __CLPK_integer *indxp, __CLPK_integer *indx,
+ __CLPK_integer *indxq, __CLPK_integer *perm, __CLPK_integer *givptr, __CLPK_integer *givcol,
__CLPK_doublereal *givnum, __CLPK_integer *info);
-
-/* Subroutine */ int zlaein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
- __CLPK_doublecomplex *h__, __CLPK_integer *ldh, __CLPK_doublecomplex *w, __CLPK_doublecomplex *v,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublereal *rwork, __CLPK_doublereal *eps3,
+
+/* Subroutine */ int zlaein_(__CLPK_logical *rightv, __CLPK_logical *noinit, __CLPK_integer *n,
+ __CLPK_doublecomplex *h__, __CLPK_integer *ldh, __CLPK_doublecomplex *w, __CLPK_doublecomplex *v,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublereal *rwork, __CLPK_doublereal *eps3,
__CLPK_doublereal *smlnum, __CLPK_integer *info);
-
-/* Subroutine */ int zlaesy_(__CLPK_doublecomplex *a, __CLPK_doublecomplex *b,
- __CLPK_doublecomplex *c__, __CLPK_doublecomplex *rt1, __CLPK_doublecomplex *rt2,
+
+/* Subroutine */ int zlaesy_(__CLPK_doublecomplex *a, __CLPK_doublecomplex *b,
+ __CLPK_doublecomplex *c__, __CLPK_doublecomplex *rt1, __CLPK_doublecomplex *rt2,
__CLPK_doublecomplex *evscal, __CLPK_doublecomplex *cs1, __CLPK_doublecomplex *sn1);
-
-/* Subroutine */ int zlaev2_(__CLPK_doublecomplex *a, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zlaev2_(__CLPK_doublecomplex *a, __CLPK_doublecomplex *b,
__CLPK_doublecomplex *c__, __CLPK_doublereal *rt1, __CLPK_doublereal *rt2, __CLPK_doublereal *cs1,
__CLPK_doublecomplex *sn1);
-
+
/* Subroutine */ int zlags2_(__CLPK_logical *upper, __CLPK_doublereal *a1, __CLPK_doublecomplex *
a2, __CLPK_doublereal *a3, __CLPK_doublereal *b1, __CLPK_doublecomplex *b2, __CLPK_doublereal *b3,
__CLPK_doublereal *csu, __CLPK_doublecomplex *snu, __CLPK_doublereal *csv, __CLPK_doublecomplex *
snv, __CLPK_doublereal *csq, __CLPK_doublecomplex *snq);
-
-/* Subroutine */ int zlagtm_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *alpha, __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__,
- __CLPK_doublecomplex *du, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *beta,
+
+/* Subroutine */ int zlagtm_(char *trans, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *alpha, __CLPK_doublecomplex *dl, __CLPK_doublecomplex *d__,
+ __CLPK_doublecomplex *du, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *beta,
__CLPK_doublecomplex *b, __CLPK_integer *ldb);
-
+
/* Subroutine */ int zlahef_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_integer *kb,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *w,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *w,
__CLPK_integer *ldw, __CLPK_integer *info);
-
-/* Subroutine */ int zlahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *h__, __CLPK_integer *ldh,
- __CLPK_doublecomplex *w, __CLPK_integer *iloz, __CLPK_integer *ihiz, __CLPK_doublecomplex *z__,
+
+/* Subroutine */ int zlahqr_(__CLPK_logical *wantt, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *h__, __CLPK_integer *ldh,
+ __CLPK_doublecomplex *w, __CLPK_integer *iloz, __CLPK_integer *ihiz, __CLPK_doublecomplex *z__,
__CLPK_integer *ldz, __CLPK_integer *info);
-
-/* Subroutine */ int zlahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *t,
+
+/* Subroutine */ int zlahrd_(__CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *nb,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *t,
__CLPK_integer *ldt, __CLPK_doublecomplex *y, __CLPK_integer *ldy);
-
-/* Subroutine */ int zlaic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_doublecomplex *x,
+
+/* Subroutine */ int zlaic1_(__CLPK_integer *job, __CLPK_integer *j, __CLPK_doublecomplex *x,
__CLPK_doublereal *sest, __CLPK_doublecomplex *w, __CLPK_doublecomplex *gamma, __CLPK_doublereal *
sestpr, __CLPK_doublecomplex *s, __CLPK_doublecomplex *c__);
-
-/* Subroutine */ int zlals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
- __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *bx, __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr,
+
+/* Subroutine */ int zlals0_(__CLPK_integer *icompq, __CLPK_integer *nl, __CLPK_integer *nr,
+ __CLPK_integer *sqre, __CLPK_integer *nrhs, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *bx, __CLPK_integer *ldbx, __CLPK_integer *perm, __CLPK_integer *givptr,
__CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_doublereal *givnum, __CLPK_integer *ldgnum,
__CLPK_doublereal *poles, __CLPK_doublereal *difl, __CLPK_doublereal *difr, __CLPK_doublereal *
- z__, __CLPK_integer *k, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublereal *rwork,
+ z__, __CLPK_integer *k, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublereal *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zlalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *bx,
+
+/* Subroutine */ int zlalsa_(__CLPK_integer *icompq, __CLPK_integer *smlsiz, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *bx,
__CLPK_integer *ldbx, __CLPK_doublereal *u, __CLPK_integer *ldu, __CLPK_doublereal *vt, __CLPK_integer *
k, __CLPK_doublereal *difl, __CLPK_doublereal *difr, __CLPK_doublereal *z__, __CLPK_doublereal *
poles, __CLPK_integer *givptr, __CLPK_integer *givcol, __CLPK_integer *ldgcol, __CLPK_integer *
perm, __CLPK_doublereal *givnum, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublereal *
rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int zlapll_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
+
+/* Subroutine */ int zlapll_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
__CLPK_doublecomplex *y, __CLPK_integer *incy, __CLPK_doublereal *ssmin);
-
-/* Subroutine */ int zlapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int zlapmt_(__CLPK_logical *forwrd, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_integer *k);
-
+
/* Subroutine */ int zlaqgb_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *r__, __CLPK_doublereal *c__,
__CLPK_doublereal *rowcnd, __CLPK_doublereal *colcnd, __CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int zlaqge_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd,
+
+/* Subroutine */ int zlaqge_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *r__, __CLPK_doublereal *c__, __CLPK_doublereal *rowcnd,
__CLPK_doublereal *colcnd, __CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int zlaqhb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond,
+
+/* Subroutine */ int zlaqhb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond,
__CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int zlaqhe_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax,
+
+/* Subroutine */ int zlaqhe_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax,
char *equed);
-
-/* Subroutine */ int zlaqhp_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zlaqhp_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int zlaqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zlaqp2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *jpvt, __CLPK_doublecomplex *tau,
__CLPK_doublereal *vn1, __CLPK_doublereal *vn2, __CLPK_doublecomplex *work);
-
-/* Subroutine */ int zlaqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
- *nb, __CLPK_integer *kb, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *jpvt,
+
+/* Subroutine */ int zlaqps_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *offset, __CLPK_integer
+ *nb, __CLPK_integer *kb, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *jpvt,
__CLPK_doublecomplex *tau, __CLPK_doublereal *vn1, __CLPK_doublereal *vn2, __CLPK_doublecomplex *
auxv, __CLPK_doublecomplex *f, __CLPK_integer *ldf);
-
-/* Subroutine */ int zlaqsb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond,
+
+/* Subroutine */ int zlaqsb_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond,
__CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int zlaqsp_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zlaqsp_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, char *equed);
-
-/* Subroutine */ int zlaqsy_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax,
+
+/* Subroutine */ int zlaqsy_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax,
char *equed);
-
-/* Subroutine */ int zlar1v_(__CLPK_integer *n, __CLPK_integer *b1, __CLPK_integer *bn, __CLPK_doublereal
+
+/* Subroutine */ int zlar1v_(__CLPK_integer *n, __CLPK_integer *b1, __CLPK_integer *bn, __CLPK_doublereal
*sigma, __CLPK_doublereal *d__, __CLPK_doublereal *l, __CLPK_doublereal *ld, __CLPK_doublereal *
- lld, __CLPK_doublereal *gersch, __CLPK_doublecomplex *z__, __CLPK_doublereal *ztz,
+ lld, __CLPK_doublereal *gersch, __CLPK_doublecomplex *z__, __CLPK_doublereal *ztz,
__CLPK_doublereal *mingma, __CLPK_integer *r__, __CLPK_integer *isuppz, __CLPK_doublereal *work);
-
-/* Subroutine */ int zlar2v_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_doublecomplex *y,
- __CLPK_doublecomplex *z__, __CLPK_integer *incx, __CLPK_doublereal *c__, __CLPK_doublecomplex *s,
+
+/* Subroutine */ int zlar2v_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_doublecomplex *y,
+ __CLPK_doublecomplex *z__, __CLPK_integer *incx, __CLPK_doublereal *c__, __CLPK_doublecomplex *s,
__CLPK_integer *incc);
-
+
/* Subroutine */ int zlarcm_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *
lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *c__, __CLPK_integer *ldc,
__CLPK_doublereal *rwork);
-
-/* Subroutine */ int zlarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex
+
+/* Subroutine */ int zlarf_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex
*v, __CLPK_integer *incv, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *c__, __CLPK_integer *
ldc, __CLPK_doublecomplex *work);
-
+
/* Subroutine */ int zlarfb_(char *side, char *trans, char *direct, char *
- storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublecomplex *v, __CLPK_integer
+ storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublecomplex *v, __CLPK_integer
*ldv, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *c__, __CLPK_integer *
ldc, __CLPK_doublecomplex *work, __CLPK_integer *ldwork);
-
+
/* Subroutine */ int zlarfg_(__CLPK_integer *n, __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *
x, __CLPK_integer *incx, __CLPK_doublecomplex *tau);
-
+
/* Subroutine */ int zlarft_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
k, __CLPK_doublecomplex *v, __CLPK_integer *ldv, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
t, __CLPK_integer *ldt);
-
-/* Subroutine */ int zlarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int zlarfx_(char *side, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *v, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *c__, __CLPK_integer *
ldc, __CLPK_doublecomplex *work);
-
-/* Subroutine */ int zlargv_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
+
+/* Subroutine */ int zlargv_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
__CLPK_doublecomplex *y, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_integer *incc);
-
-/* Subroutine */ int zlarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n,
+
+/* Subroutine */ int zlarnv_(__CLPK_integer *idist, __CLPK_integer *iseed, __CLPK_integer *n,
__CLPK_doublecomplex *x);
-
-/* Subroutine */ int zlarrv_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
- __CLPK_integer *isplit, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock,
+
+/* Subroutine */ int zlarrv_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *l,
+ __CLPK_integer *isplit, __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock,
__CLPK_doublereal *gersch, __CLPK_doublereal *tol, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_integer *isuppz, __CLPK_doublereal *work, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zlartg_(__CLPK_doublecomplex *f, __CLPK_doublecomplex *g, __CLPK_doublereal *
cs, __CLPK_doublecomplex *sn, __CLPK_doublecomplex *r__);
-
-/* Subroutine */ int zlartv_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
- __CLPK_doublecomplex *y, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_doublecomplex *s,
+
+/* Subroutine */ int zlartv_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
+ __CLPK_doublecomplex *y, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_doublecomplex *s,
__CLPK_integer *incc);
-
-/* Subroutine */ int zlarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
+
+/* Subroutine */ int zlarz_(char *side, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
__CLPK_doublecomplex *v, __CLPK_integer *incv, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work);
-
+
/* Subroutine */ int zlarzb_(char *side, char *trans, char *direct, char *
- storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex
- *v, __CLPK_integer *ldv, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *c__,
+ storev, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex
+ *v, __CLPK_integer *ldv, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *c__,
__CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *ldwork);
-
+
/* Subroutine */ int zlarzt_(char *direct, char *storev, __CLPK_integer *n, __CLPK_integer *
k, __CLPK_doublecomplex *v, __CLPK_integer *ldv, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
t, __CLPK_integer *ldt);
-
-/* Subroutine */ int zlascl_(char *type__, __CLPK_integer *kl, __CLPK_integer *ku,
- __CLPK_doublereal *cfrom, __CLPK_doublereal *cto, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int zlascl_(char *type__, __CLPK_integer *kl, __CLPK_integer *ku,
+ __CLPK_doublereal *cfrom, __CLPK_doublereal *cto, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int zlaset_(char *uplo, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int zlaset_(char *uplo, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *alpha, __CLPK_doublecomplex *beta, __CLPK_doublecomplex *a, __CLPK_integer *
lda);
-
+
/* Subroutine */ int zlasr_(char *side, char *pivot, char *direct, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublecomplex *a,
+ __CLPK_integer *n, __CLPK_doublereal *c__, __CLPK_doublereal *s, __CLPK_doublecomplex *a,
__CLPK_integer *lda);
-
-/* Subroutine */ int zlassq_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
+
+/* Subroutine */ int zlassq_(__CLPK_integer *n, __CLPK_doublecomplex *x, __CLPK_integer *incx,
__CLPK_doublereal *scale, __CLPK_doublereal *sumsq);
-
-/* Subroutine */ int zlaswp_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zlaswp_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_integer *k1, __CLPK_integer *k2, __CLPK_integer *ipiv, __CLPK_integer *incx);
-
+
/* Subroutine */ int zlasyf_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb, __CLPK_integer *kb,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *w,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *w,
__CLPK_integer *ldw, __CLPK_integer *info);
-
+
/* Subroutine */ int zlatbs_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
+ normin, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
__CLPK_doublecomplex *x, __CLPK_doublereal *scale, __CLPK_doublereal *cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int zlatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_doublecomplex *z__,
+
+/* Subroutine */ int zlatdf_(__CLPK_integer *ijob, __CLPK_integer *n, __CLPK_doublecomplex *z__,
__CLPK_integer *ldz, __CLPK_doublecomplex *rhs, __CLPK_doublereal *rdsum, __CLPK_doublereal *
rdscal, __CLPK_integer *ipiv, __CLPK_integer *jpiv);
-
+
/* Subroutine */ int zlatps_(char *uplo, char *trans, char *diag, char *
normin, __CLPK_integer *n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *x, __CLPK_doublereal *
scale, __CLPK_doublereal *cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int zlatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *e, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zlatrd_(char *uplo, __CLPK_integer *n, __CLPK_integer *nb,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *e, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *w, __CLPK_integer *ldw);
-
+
/* Subroutine */ int zlatrs_(char *uplo, char *trans, char *diag, char *
- normin, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *x,
+ normin, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *x,
__CLPK_doublereal *scale, __CLPK_doublereal *cnorm, __CLPK_integer *info);
-
-/* Subroutine */ int zlatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
+
+/* Subroutine */ int zlatrz_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *l,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work);
-
-/* Subroutine */ int zlatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n,
+
+/* Subroutine */ int zlatzm_(char *side, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *v, __CLPK_integer *incv, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
c1, __CLPK_doublecomplex *c2, __CLPK_integer *ldc, __CLPK_doublecomplex *work);
-
-/* Subroutine */ int zlauu2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zlauu2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int zlauum_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zlauum_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int zpbcon_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int zpbcon_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *anorm, __CLPK_doublereal *
rcond, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zpbequ_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond,
+
+/* Subroutine */ int zpbequ_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *s, __CLPK_doublereal *scond,
__CLPK_doublereal *amax, __CLPK_integer *info);
-
+
/* Subroutine */ int zpbrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *afb, __CLPK_integer *
ldafb, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *
rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zpbstf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int zpbstf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int zpbsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *b, __CLPK_integer *
ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zpbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
- __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *afb,
- __CLPK_integer *ldafb, char *equed, __CLPK_doublereal *s, __CLPK_doublecomplex *b, __CLPK_integer
+
+/* Subroutine */ int zpbsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+ __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *afb,
+ __CLPK_integer *ldafb, char *equed, __CLPK_doublereal *s, __CLPK_doublecomplex *b, __CLPK_integer
*ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *
- ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork,
+ ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zpbtf2_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int zpbtf2_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *info);
-
-/* Subroutine */ int zpbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
+
+/* Subroutine */ int zpbtrf_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_integer *info);
-
+
/* Subroutine */ int zpbtrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *kd, __CLPK_integer *
nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *b, __CLPK_integer *
ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zpocon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zpocon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zpoequ_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zpoequ_(__CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, __CLPK_integer *info);
-
-/* Subroutine */ int zporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+
+/* Subroutine */ int zporfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *
rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zposv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int zposvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *
- ldaf, char *equed, __CLPK_doublereal *s, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
+ ldaf, char *equed, __CLPK_doublereal *s, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
-/* Subroutine */ int zpotf2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zpotf2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int zpotrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zpotrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int zpotri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zpotri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int zpotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zpotrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int zppcon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
- __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *work, __CLPK_doublereal
+
+/* Subroutine */ int zppcon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+ __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *work, __CLPK_doublereal
*rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zppequ_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zppequ_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublereal *s, __CLPK_doublereal *scond, __CLPK_doublereal *amax, __CLPK_integer *info);
-
-/* Subroutine */ int zpprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int zpprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int zppsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
+
/* Subroutine */ int zppsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, char *equed, __CLPK_doublereal *
- s, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+ s, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zpptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zpptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *info);
-
-/* Subroutine */ int zpptri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zpptri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *info);
-
-/* Subroutine */ int zpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int zpptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zptcon_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublecomplex *e,
+
+/* Subroutine */ int zptcon_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublecomplex *e,
__CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
-/* Subroutine */ int zptrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublereal *df, __CLPK_doublecomplex *ef,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+
+/* Subroutine */ int zptrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublereal *df, __CLPK_doublecomplex *ef,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *
rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
+
+/* Subroutine */ int zptsv_(__CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_doublereal *d__,
__CLPK_doublecomplex *e, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int zptsvx_(char *fact, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublereal *df, __CLPK_doublecomplex *ef,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+
+/* Subroutine */ int zptsvx_(char *fact, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublereal *df, __CLPK_doublecomplex *ef,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zpttrf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublecomplex *e,
+
+/* Subroutine */ int zpttrf_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublecomplex *e,
__CLPK_integer *info);
-
-/* Subroutine */ int zpttrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zpttrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int zptts2_(__CLPK_integer *iuplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int zptts2_(__CLPK_integer *iuplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublereal *d__, __CLPK_doublecomplex *e, __CLPK_doublecomplex *b, __CLPK_integer *ldb);
-
-/* Subroutine */ int zrot_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx,
+
+/* Subroutine */ int zrot_(__CLPK_integer *n, __CLPK_doublecomplex *cx, __CLPK_integer *incx,
__CLPK_doublecomplex *cy, __CLPK_integer *incy, __CLPK_doublereal *c__, __CLPK_doublecomplex *s);
-
-/* Subroutine */ int zspcon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zspcon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zspmv_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
+
+/* Subroutine */ int zspmv_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *x, __CLPK_integer *incx, __CLPK_doublecomplex *
beta, __CLPK_doublecomplex *y, __CLPK_integer *incy);
-
-/* Subroutine */ int zspr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
+
+/* Subroutine */ int zspr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
__CLPK_doublecomplex *x, __CLPK_integer *incx, __CLPK_doublecomplex *ap);
-
-/* Subroutine */ int zsprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+
+/* Subroutine */ int zsprfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
__CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_integer *ipiv, __CLPK_doublecomplex *
- b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
+ b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
-/* Subroutine */ int zspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zspsv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
+
/* Subroutine */ int zspsvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
- nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_integer *ipiv,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+ nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *afp, __CLPK_integer *ipiv,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zsptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zsptrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int zsptri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zsptri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zsptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int zsptrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *ap, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int zstedc_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work,
- __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork,
+
+/* Subroutine */ int zstedc_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublecomplex *work,
+ __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork,
__CLPK_integer *liwork, __CLPK_integer *info);
-
-/* Subroutine */ int zstein_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
- __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock, __CLPK_integer *isplit,
- __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork,
+
+/* Subroutine */ int zstein_(__CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e,
+ __CLPK_integer *m, __CLPK_doublereal *w, __CLPK_integer *iblock, __CLPK_integer *isplit,
+ __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublereal *work, __CLPK_integer *iwork,
__CLPK_integer *ifail, __CLPK_integer *info);
-
-/* Subroutine */ int zsteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+
+/* Subroutine */ int zsteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-
-/* Subroutine */ int zsycon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond,
+
+/* Subroutine */ int zsycon_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublereal *anorm, __CLPK_doublereal *rcond,
__CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zsymv_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *x, __CLPK_integer *incx,
+
+/* Subroutine */ int zsymv_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *x, __CLPK_integer *incx,
__CLPK_doublecomplex *beta, __CLPK_doublecomplex *y, __CLPK_integer *incy);
-
-/* Subroutine */ int zsyr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
+
+/* Subroutine */ int zsyr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *alpha,
__CLPK_doublecomplex *x, __CLPK_integer *incx, __CLPK_doublecomplex *a, __CLPK_integer *lda);
-
-/* Subroutine */ int zsyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
- __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
+
+/* Subroutine */ int zsyrfs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *ldaf,
+ __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
__CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zsysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zsysv_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
+
/* Subroutine */ int zsysvx_(char *fact, char *uplo, __CLPK_integer *n, __CLPK_integer *
nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *af, __CLPK_integer *
ldaf, __CLPK_integer *ipiv, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x,
- __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+ __CLPK_integer *ldx, __CLPK_doublereal *rcond, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int zsytf2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zsytf2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_integer *info);
-
-/* Subroutine */ int zsytrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
+
+/* Subroutine */ int zsytrf_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zsytri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zsytri_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zsytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int zsytrs_(char *uplo, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *ipiv, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int ztbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *rcond,
+
+/* Subroutine */ int ztbcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *rcond,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
- __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
+
+/* Subroutine */ int ztbrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
+ __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx,
__CLPK_doublereal *ferr, __CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *
rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
+
+/* Subroutine */ int ztbtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *kd, __CLPK_integer *nrhs, __CLPK_doublecomplex *ab, __CLPK_integer *ldab,
__CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int ztgevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer
+
+/* Subroutine */ int ztgevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer
*ldb, __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *
ldvr, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ztgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int ztgex2_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_integer *j1, __CLPK_integer *info);
-
-/* Subroutine */ int ztgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+
+/* Subroutine */ int ztgexc_(__CLPK_logical *wantq, __CLPK_logical *wantz, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
__CLPK_integer *ifst, __CLPK_integer *ilst, __CLPK_integer *info);
-
-/* Subroutine */ int ztgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
- __CLPK_logical *select, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int ztgsen_(__CLPK_integer *ijob, __CLPK_logical *wantq, __CLPK_logical *wantz,
+ __CLPK_logical *select, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublecomplex *alpha, __CLPK_doublecomplex *
beta, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *z__, __CLPK_integer *
- ldz, __CLPK_integer *m, __CLPK_doublereal *pl, __CLPK_doublereal *pr, __CLPK_doublereal *dif,
- __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+ ldz, __CLPK_integer *m, __CLPK_doublereal *pl, __CLPK_doublereal *pr, __CLPK_doublereal *dif,
+ __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
-
-/* Subroutine */ int ztgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
- __CLPK_integer *p, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublereal *tola,
+
+/* Subroutine */ int ztgsja_(char *jobu, char *jobv, char *jobq, __CLPK_integer *m,
+ __CLPK_integer *p, __CLPK_integer *n, __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb, __CLPK_doublereal *tola,
__CLPK_doublereal *tolb, __CLPK_doublereal *alpha, __CLPK_doublereal *beta, __CLPK_doublecomplex *
- u, __CLPK_integer *ldu, __CLPK_doublecomplex *v, __CLPK_integer *ldv, __CLPK_doublecomplex *q,
+ u, __CLPK_integer *ldu, __CLPK_doublecomplex *v, __CLPK_integer *ldv, __CLPK_doublecomplex *q,
__CLPK_integer *ldq, __CLPK_doublecomplex *work, __CLPK_integer *ncycle, __CLPK_integer *info);
-
-/* Subroutine */ int ztgsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer
+
+/* Subroutine */ int ztgsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer
*ldb, __CLPK_doublecomplex *vl, __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *
- ldvr, __CLPK_doublereal *s, __CLPK_doublereal *dif, __CLPK_integer *mm, __CLPK_integer *m,
+ ldvr, __CLPK_doublereal *s, __CLPK_doublereal *dif, __CLPK_integer *mm, __CLPK_integer *m,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
+
/* Subroutine */ int ztgsy2_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
- n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *d__, __CLPK_integer *ldd,
- __CLPK_doublecomplex *e, __CLPK_integer *lde, __CLPK_doublecomplex *f, __CLPK_integer *ldf,
+ n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *d__, __CLPK_integer *ldd,
+ __CLPK_doublecomplex *e, __CLPK_integer *lde, __CLPK_doublecomplex *f, __CLPK_integer *ldf,
__CLPK_doublereal *scale, __CLPK_doublereal *rdsum, __CLPK_doublereal *rdscal, __CLPK_integer *
info);
-
+
/* Subroutine */ int ztgsyl_(char *trans, __CLPK_integer *ijob, __CLPK_integer *m, __CLPK_integer *
- n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *d__, __CLPK_integer *ldd,
- __CLPK_doublecomplex *e, __CLPK_integer *lde, __CLPK_doublecomplex *f, __CLPK_integer *ldf,
+ n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *d__, __CLPK_integer *ldd,
+ __CLPK_doublecomplex *e, __CLPK_integer *lde, __CLPK_doublecomplex *f, __CLPK_integer *ldf,
__CLPK_doublereal *scale, __CLPK_doublereal *dif, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_integer *iwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
- __CLPK_doublecomplex *ap, __CLPK_doublereal *rcond, __CLPK_doublecomplex *work, __CLPK_doublereal
+
+/* Subroutine */ int ztpcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+ __CLPK_doublecomplex *ap, __CLPK_doublereal *rcond, __CLPK_doublecomplex *work, __CLPK_doublereal
*rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
+
+/* Subroutine */ int ztprfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr, __CLPK_doublereal *berr,
__CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztptri_(char *uplo, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int ztptri_(char *uplo, char *diag, __CLPK_integer *n,
__CLPK_doublecomplex *ap, __CLPK_integer *info);
-
-/* Subroutine */ int ztptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+
+/* Subroutine */ int ztptrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
__CLPK_integer *info);
-
-/* Subroutine */ int ztrcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int ztrcon_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *rcond, __CLPK_doublecomplex *
work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztrevc_(char *side, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *vl,
- __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer
+
+/* Subroutine */ int ztrevc_(char *side, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *vl,
+ __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_integer *mm, __CLPK_integer
*m, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztrexc_(char *compq, __CLPK_integer *n, __CLPK_doublecomplex *t,
+
+/* Subroutine */ int ztrexc_(char *compq, __CLPK_integer *n, __CLPK_doublecomplex *t,
__CLPK_integer *ldt, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_integer *ifst, __CLPK_integer *
ilst, __CLPK_integer *info);
-
-/* Subroutine */ int ztrrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
- __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
+
+/* Subroutine */ int ztrrfs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+ __CLPK_integer *ldb, __CLPK_doublecomplex *x, __CLPK_integer *ldx, __CLPK_doublereal *ferr,
__CLPK_doublereal *berr, __CLPK_doublecomplex *work, __CLPK_doublereal *rwork, __CLPK_integer *
info);
-
-/* Subroutine */ int ztrsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
- *n, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *q, __CLPK_integer *ldq,
- __CLPK_doublecomplex *w, __CLPK_integer *m, __CLPK_doublereal *s, __CLPK_doublereal *sep,
+
+/* Subroutine */ int ztrsen_(char *job, char *compq, __CLPK_logical *select, __CLPK_integer
+ *n, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *q, __CLPK_integer *ldq,
+ __CLPK_doublecomplex *w, __CLPK_integer *m, __CLPK_doublereal *s, __CLPK_doublereal *sep,
__CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztrsna_(char *job, char *howmny, __CLPK_logical *select,
- __CLPK_integer *n, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *vl,
- __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublereal *s,
- __CLPK_doublereal *sep, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublecomplex *work,
+
+/* Subroutine */ int ztrsna_(char *job, char *howmny, __CLPK_logical *select,
+ __CLPK_integer *n, __CLPK_doublecomplex *t, __CLPK_integer *ldt, __CLPK_doublecomplex *vl,
+ __CLPK_integer *ldvl, __CLPK_doublecomplex *vr, __CLPK_integer *ldvr, __CLPK_doublereal *s,
+ __CLPK_doublereal *sep, __CLPK_integer *mm, __CLPK_integer *m, __CLPK_doublecomplex *work,
__CLPK_integer *ldwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-
-/* Subroutine */ int ztrsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
- *m, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
- __CLPK_integer *ldb, __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublereal *scale,
+
+/* Subroutine */ int ztrsyl_(char *trana, char *tranb, __CLPK_integer *isgn, __CLPK_integer
+ *m, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+ __CLPK_integer *ldb, __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublereal *scale,
__CLPK_integer *info);
-
-/* Subroutine */ int ztrti2_(char *uplo, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int ztrti2_(char *uplo, char *diag, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int ztrtri_(char *uplo, char *diag, __CLPK_integer *n,
+
+/* Subroutine */ int ztrtri_(char *uplo, char *diag, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_integer *info);
-
-/* Subroutine */ int ztrtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
- __CLPK_integer *nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
+
+/* Subroutine */ int ztrtrs_(char *uplo, char *trans, char *diag, __CLPK_integer *n,
+ __CLPK_integer *nrhs, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b,
__CLPK_integer *ldb, __CLPK_integer *info);
-
-/* Subroutine */ int ztzrqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int ztzrqf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_integer *info);
-
-/* Subroutine */ int ztzrzf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int ztzrzf_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zung2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zung2l_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zung2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zung2r_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zungbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zungbr_(char *vect, __CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zunghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
+
+/* Subroutine */ int zunghr_(__CLPK_integer *n, __CLPK_integer *ilo, __CLPK_integer *ihi,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zungl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zungl2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zunglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zunglq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zungql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zungql_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zungqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zungqr_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zungr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zungr2_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zungrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
+
+/* Subroutine */ int zungrq_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zungtr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+
+/* Subroutine */ int zungtr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zunm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunm2l_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zunm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunm2r_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zunmbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
+
+/* Subroutine */ int zunmbr_(char *vect, char *side, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
*tau, __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zunmhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+
+/* Subroutine */ int zunmhr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *ilo, __CLPK_integer *ihi, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_doublecomplex *tau, __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *
work, __CLPK_integer *lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zunml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunml2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zunmlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunmlq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zunmql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunmql_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zunmqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunmqr_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zunmr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunmr2_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *info);
-
-/* Subroutine */ int zunmr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
+
+/* Subroutine */ int zunmr3_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
*tau, __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *
info);
-
-/* Subroutine */ int zunmrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunmrq_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zunmrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
+
+/* Subroutine */ int zunmrz_(char *side, char *trans, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_integer *k, __CLPK_integer *l, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex
*tau, __CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *
lwork, __CLPK_integer *info);
-
-/* Subroutine */ int zunmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
- __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
+
+/* Subroutine */ int zunmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+ __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *tau,
__CLPK_doublecomplex *c__, __CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *lwork,
__CLPK_integer *info);
-
-/* Subroutine */ int zupgtr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+
+/* Subroutine */ int zupgtr_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublecomplex *tau, __CLPK_doublecomplex *q, __CLPK_integer *ldq, __CLPK_doublecomplex *
work, __CLPK_integer *info);
-
-/* Subroutine */ int zupmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
+
+/* Subroutine */ int zupmtr_(char *side, char *uplo, char *trans, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_doublecomplex *ap, __CLPK_doublecomplex *tau, __CLPK_doublecomplex *c__,
__CLPK_integer *ldc, __CLPK_doublecomplex *work, __CLPK_integer *info);
*/
/* Subroutine */ int cgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
- a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *s, __CLPK_real *rcond,
+ a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *s, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *
iwork, __CLPK_integer *info);
/* Subroutine */ int cgelss_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs, __CLPK_complex *
- a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *s, __CLPK_real *rcond,
+ a, __CLPK_integer *lda, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *s, __CLPK_real *rcond,
__CLPK_integer *rank, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *
info);
-/* Subroutine */ int cgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a,
- __CLPK_integer *lda, __CLPK_real *s, __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *vt, __CLPK_integer
- *ldvt, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork,
+/* Subroutine */ int cgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a,
+ __CLPK_integer *lda, __CLPK_real *s, __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *vt, __CLPK_integer
+ *ldvt, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork, __CLPK_integer *iwork,
__CLPK_integer *info);
-/* Subroutine */ int cgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
+/* Subroutine */ int cgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *s, __CLPK_complex *u, __CLPK_integer *ldu, __CLPK_complex *
- vt, __CLPK_integer *ldvt, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
+ vt, __CLPK_integer *ldvt, __CLPK_complex *work, __CLPK_integer *lwork, __CLPK_real *rwork,
__CLPK_integer *info);
-/* Subroutine */ int chbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
- __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb, __CLPK_integer *ldbb,
- __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork,
- __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+/* Subroutine */ int chbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+ __CLPK_integer *kb, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_complex *bb, __CLPK_integer *ldbb,
+ __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_complex *work, __CLPK_integer *lwork,
+ __CLPK_real *rwork, __CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
/* Subroutine */ int chetd2_(char *uplo, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
/* Complex */ void cladiv_(__CLPK_complex * ret_val, __CLPK_complex *x, __CLPK_complex *y);
-/* Subroutine */ int clalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
- *nrhs, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *rcond,
- __CLPK_integer *rank, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork,
+/* Subroutine */ int clalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
+ *nrhs, __CLPK_real *d__, __CLPK_real *e, __CLPK_complex *b, __CLPK_integer *ldb, __CLPK_real *rcond,
+ __CLPK_integer *rank, __CLPK_complex *work, __CLPK_real *rwork, __CLPK_integer *iwork,
__CLPK_integer *info);
-__CLPK_doublereal clangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
+__CLPK_doublereal clangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *work);
-__CLPK_doublereal clange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a,
+__CLPK_doublereal clange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_real *work);
-__CLPK_doublereal clangt_(char *norm, __CLPK_integer *n, __CLPK_complex *dl, __CLPK_complex *d__,
+__CLPK_doublereal clangt_(char *norm, __CLPK_integer *n, __CLPK_complex *dl, __CLPK_complex *d__,
__CLPK_complex *du);
-__CLPK_doublereal clanhb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
+__CLPK_doublereal clanhb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *work);
-__CLPK_doublereal clanhe_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
+__CLPK_doublereal clanhe_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_real *work);
-__CLPK_doublereal clanhp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
+__CLPK_doublereal clanhp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
__CLPK_real *work);
-__CLPK_doublereal clanhs_(char *norm, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
+__CLPK_doublereal clanhs_(char *norm, __CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda,
__CLPK_real *work);
__CLPK_doublereal clanht_(char *norm, __CLPK_integer *n, __CLPK_real *d__, __CLPK_complex *e);
-__CLPK_doublereal clansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
+__CLPK_doublereal clansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *work);
-__CLPK_doublereal clansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
+__CLPK_doublereal clansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *ap,
__CLPK_real *work);
-__CLPK_doublereal clansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
+__CLPK_doublereal clansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_complex *a,
__CLPK_integer *lda, __CLPK_real *work);
-__CLPK_doublereal clantb_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+__CLPK_doublereal clantb_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_integer *k, __CLPK_complex *ab, __CLPK_integer *ldab, __CLPK_real *work);
-__CLPK_doublereal clantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+__CLPK_doublereal clantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_complex *ap, __CLPK_real *work);
-__CLPK_doublereal clantr_(char *norm, char *uplo, char *diag, __CLPK_integer *m,
+__CLPK_doublereal clantr_(char *norm, char *uplo, char *diag, __CLPK_integer *m,
__CLPK_integer *n, __CLPK_complex *a, __CLPK_integer *lda, __CLPK_real *work);
-/* Subroutine */ int cpteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
+/* Subroutine */ int cpteqr_(char *compz, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e,
__CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_real *work, __CLPK_integer *info);
-/* Subroutine */ int cstegr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
- __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
- __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz,
- __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
+/* Subroutine */ int cstegr_(char *jobz, char *range, __CLPK_integer *n, __CLPK_real *d__,
+ __CLPK_real *e, __CLPK_real *vl, __CLPK_real *vu, __CLPK_integer *il, __CLPK_integer *iu, __CLPK_real *abstol,
+ __CLPK_integer *m, __CLPK_real *w, __CLPK_complex *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz,
+ __CLPK_real *work, __CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork,
__CLPK_integer *info);
__CLPK_doublereal dlamc3_(__CLPK_doublereal *a, __CLPK_doublereal *b);
__CLPK_doublereal dlamch_(char *cmach);
-__CLPK_doublereal dlangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
+__CLPK_doublereal dlangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal dlange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a,
+__CLPK_doublereal dlange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublereal *a,
__CLPK_integer *lda, __CLPK_doublereal *work);
-__CLPK_doublereal dlangt_(char *norm, __CLPK_integer *n, __CLPK_doublereal *dl, __CLPK_doublereal *d__,
+__CLPK_doublereal dlangt_(char *norm, __CLPK_integer *n, __CLPK_doublereal *dl, __CLPK_doublereal *d__,
__CLPK_doublereal *du);
-__CLPK_doublereal dlanhs_(char *norm, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
+__CLPK_doublereal dlanhs_(char *norm, __CLPK_integer *n, __CLPK_doublereal *a, __CLPK_integer *lda,
__CLPK_doublereal *work);
-__CLPK_doublereal dlansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
+__CLPK_doublereal dlansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal dlansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
+__CLPK_doublereal dlansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublereal *ap,
__CLPK_doublereal *work);
__CLPK_doublereal dlanst_(char *norm, __CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublereal *e);
-__CLPK_doublereal dlansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublereal *a,
+__CLPK_doublereal dlansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublereal *a,
__CLPK_integer *lda, __CLPK_doublereal *work);
__CLPK_doublereal dlantb_(char *norm, char *uplo, char *diag, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublereal *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal dlantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+__CLPK_doublereal dlantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_doublereal *ap, __CLPK_doublereal *work);
__CLPK_doublereal dlantr_(char *norm, char *uplo, char *diag, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublereal slangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_real *work);
-__CLPK_doublereal slange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+__CLPK_doublereal slange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *work);
__CLPK_doublereal slangt_(char *norm, __CLPK_integer *n, __CLPK_real *dl, __CLPK_real *d__, __CLPK_real *du);
__CLPK_doublereal slanhs_(char *norm, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda, __CLPK_real *work);
-__CLPK_doublereal slansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *ab,
+__CLPK_doublereal slansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k, __CLPK_real *ab,
__CLPK_integer *ldab, __CLPK_real *work);
__CLPK_doublereal slansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_real *ap, __CLPK_real *work);
__CLPK_doublereal slanst_(char *norm, __CLPK_integer *n, __CLPK_real *d__, __CLPK_real *e);
-__CLPK_doublereal slansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
+__CLPK_doublereal slansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_real *a, __CLPK_integer *lda,
__CLPK_real *work);
__CLPK_doublereal slantb_(char *norm, char *uplo, char *diag, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_real *ab, __CLPK_integer *ldab, __CLPK_real *work);
-__CLPK_doublereal slantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *ap,
+__CLPK_doublereal slantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n, __CLPK_real *ap,
__CLPK_real *work);
__CLPK_doublereal slantr_(char *norm, char *uplo, char *diag, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublereal slapy3_(__CLPK_real *x, __CLPK_real *y, __CLPK_real *z__);
-/* Subroutine */ int zgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublereal *s, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
+/* Subroutine */ int zgelsd_(__CLPK_integer *m, __CLPK_integer *n, __CLPK_integer *nrhs,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
+ __CLPK_doublereal *s, __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
__CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-/* Subroutine */ int zgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublecomplex *u,
- __CLPK_integer *ldu, __CLPK_doublecomplex *vt, __CLPK_integer *ldvt, __CLPK_doublecomplex *work,
+/* Subroutine */ int zgesdd_(char *jobz, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublecomplex *u,
+ __CLPK_integer *ldu, __CLPK_doublecomplex *vt, __CLPK_integer *ldvt, __CLPK_doublecomplex *work,
__CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-/* Subroutine */ int zgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
- __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublecomplex *u,
- __CLPK_integer *ldu, __CLPK_doublecomplex *vt, __CLPK_integer *ldvt, __CLPK_doublecomplex *work,
+/* Subroutine */ int zgesvd_(char *jobu, char *jobvt, __CLPK_integer *m, __CLPK_integer *n,
+ __CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *s, __CLPK_doublecomplex *u,
+ __CLPK_integer *ldu, __CLPK_doublecomplex *vt, __CLPK_integer *ldvt, __CLPK_doublecomplex *work,
__CLPK_integer *lwork, __CLPK_doublereal *rwork, __CLPK_integer *info);
-/* Subroutine */ int zhbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
- __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *bb,
- __CLPK_integer *ldbb, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
- __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
+/* Subroutine */ int zhbgvd_(char *jobz, char *uplo, __CLPK_integer *n, __CLPK_integer *ka,
+ __CLPK_integer *kb, __CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublecomplex *bb,
+ __CLPK_integer *ldbb, __CLPK_doublereal *w, __CLPK_doublecomplex *z__, __CLPK_integer *ldz,
+ __CLPK_doublecomplex *work, __CLPK_integer *lwork, __CLPK_doublereal *rwork,
__CLPK_integer *lrwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
-/* Subroutine */ int zhetd2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
- __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tau,
+/* Subroutine */ int zhetd2_(char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+ __CLPK_integer *lda, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *tau,
__CLPK_integer *info);
-/* Double Complex */ void zladiv_(__CLPK_doublecomplex * ret_val, __CLPK_doublecomplex *x,
+/* Double Complex */ void zladiv_(__CLPK_doublecomplex * ret_val, __CLPK_doublecomplex *x,
__CLPK_doublecomplex *y);
-/* Subroutine */ int zlalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
+/* Subroutine */ int zlalsd_(char *uplo, __CLPK_integer *smlsiz, __CLPK_integer *n, __CLPK_integer
*nrhs, __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublecomplex *b, __CLPK_integer *ldb,
- __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
+ __CLPK_doublereal *rcond, __CLPK_integer *rank, __CLPK_doublecomplex *work,
__CLPK_doublereal *rwork, __CLPK_integer *iwork, __CLPK_integer *info);
-__CLPK_doublereal zlangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
+__CLPK_doublereal zlangb_(char *norm, __CLPK_integer *n, __CLPK_integer *kl, __CLPK_integer *ku,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal zlange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
+__CLPK_doublereal zlange_(char *norm, __CLPK_integer *m, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublereal *work);
-__CLPK_doublereal zlangt_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *dl,
+__CLPK_doublereal zlangt_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *dl,
__CLPK_doublecomplex *d__, __CLPK_doublecomplex *du);
-__CLPK_doublereal zlanhb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
+__CLPK_doublereal zlanhb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal zlanhe_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+__CLPK_doublereal zlanhe_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublereal *work);
-__CLPK_doublereal zlanhp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+__CLPK_doublereal zlanhp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublereal *work);
-__CLPK_doublereal zlanhs_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
+__CLPK_doublereal zlanhs_(char *norm, __CLPK_integer *n, __CLPK_doublecomplex *a, __CLPK_integer *lda,
__CLPK_doublereal *work);
__CLPK_doublereal zlanht_(char *norm, __CLPK_integer *n, __CLPK_doublereal *d__, __CLPK_doublecomplex *e);
-__CLPK_doublereal zlansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
+__CLPK_doublereal zlansb_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal zlansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
+__CLPK_doublereal zlansp_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *ap,
__CLPK_doublereal *work);
-__CLPK_doublereal zlansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
+__CLPK_doublereal zlansy_(char *norm, char *uplo, __CLPK_integer *n, __CLPK_doublecomplex *a,
__CLPK_integer *lda, __CLPK_doublereal *work);
__CLPK_doublereal zlantb_(char *norm, char *uplo, char *diag, __CLPK_integer *n, __CLPK_integer *k,
__CLPK_doublecomplex *ab, __CLPK_integer *ldab, __CLPK_doublereal *work);
-__CLPK_doublereal zlantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
+__CLPK_doublereal zlantp_(char *norm, char *uplo, char *diag, __CLPK_integer *n,
__CLPK_doublecomplex *ap, __CLPK_doublereal *work);
__CLPK_doublereal zlantr_(char *norm, char *uplo, char *diag, __CLPK_integer *m, __CLPK_integer *n,
__CLPK_doublecomplex *a, __CLPK_integer *lda, __CLPK_doublereal *work);
-/* Subroutine */ int zpteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
- __CLPK_doublereal *e, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
+/* Subroutine */ int zpteqr_(char *compz, __CLPK_integer *n, __CLPK_doublereal *d__,
+ __CLPK_doublereal *e, __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_doublereal *work,
__CLPK_integer *info);
-/* Subroutine */ int zstegr_(char *jobz, char *range, __CLPK_integer *n,
- __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu,
- __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
- __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
+/* Subroutine */ int zstegr_(char *jobz, char *range, __CLPK_integer *n,
+ __CLPK_doublereal *d__, __CLPK_doublereal *e, __CLPK_doublereal *vl, __CLPK_doublereal *vu,
+ __CLPK_integer *il, __CLPK_integer *iu, __CLPK_doublereal *abstol, __CLPK_integer *m, __CLPK_doublereal *w,
+ __CLPK_doublecomplex *z__, __CLPK_integer *ldz, __CLPK_integer *isuppz, __CLPK_doublereal *work,
__CLPK_integer *lwork, __CLPK_integer *iwork, __CLPK_integer *liwork, __CLPK_integer *info);
#ifdef __cplusplus
#define EPS 2.2204e-016
-class Correlation
+class Correlation
{
public:
void doAutoUnBiased( double* src, double* dst, unsigned int length );
};
-#endif //
+#endif //
#include "nan-inf.h"
-class MathUtilities
+class MathUtilities
{
public:
static double round( double x );
const vector<double> &y,
vector<double> &coef);
-
+
private:
TPolyFit &operator = (const TPolyFit &); // disable assignment
TPolyFit(); // and instantiation
TPolyFit(const TPolyFit&); // and copying
-
+
static void Square (const Matrix &x, // Matrix multiplication routine
const vector<double> &y,
Matrix &a, // A = transpose X times X
for( int i = 0; i < ncol; ++i)
coef[i] = w[i][0];
-
-
+
+
return true;
} // end; { procedure GaussJordan }
//----------------------------------------------------------------------------------------------
{
//GaussJordan2; // first half of GaussJordan
// actual start of gaussj
-
+
double big, t;
double pivot;
double determ;
#endif
-
+
Earn/Bitnet: fionn@dgaeso51, fim@dgaipp1s, murtagh@stsci
Span: esomc1::fionn
Internet: murtagh@scivax.stsci.edu
-
- F. Murtagh, Munich, 6 June 1989 */
+
+ F. Murtagh, Munich, 6 June 1989 */
/*********************************************************************/
#include <stdio.h>
/* Allocate storage for dummy and new vectors. */
evals = (double*) malloc(m*sizeof(double)); /* Storage alloc. for vector of eigenvalues */
interm = (double*) malloc(m*sizeof(double)); /* Storage alloc. for 'intermediate' vector */
- //MALLOC_ARRAY(symmat2,m,m,double);
+ //MALLOC_ARRAY(symmat2,m,m,double);
//for (i = 0; i < m; i++) {
// for (j = 0; j < m; j++) {
// symmat2[i][j] = symmat[i][j]; /* Needed below for col. projections */
}
virtual void performTask() = 0;
-
+
private:
virtual void run() {
m_todo.lock();
void wait(int us = 0);
void signal();
-
+
private:
#ifdef _WIN32
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it
and/or modify it under the terms of the GNU Lesser
}
void
-BasicUI::access_action ( std::string action_path )
+BasicUI::access_action ( std::string action_path )
{
int split_at = action_path.find( "/" );
std::string group = action_path.substr( 0, split_at );
}
void
-BasicUI::loop_toggle ()
+BasicUI::loop_toggle ()
{
if (session->get_play_loop()) {
session->request_play_loop (false);
session->goto_end ();
}
-void
+void
BasicUI::add_marker (const std::string& markername)
{
framepos_t where = session->audible_frame();
if (session->get_play_loop()) {
session->request_play_loop (false);
- }
+ }
if (session->get_play_range ()) {
session->request_play_range (0);
session->timecode_time (where, *((Timecode::Time *) &timecode));
}
-void
+void
BasicUI::timecode_to_sample (Timecode::Time& timecode, framepos_t & sample, bool use_offset, bool use_subframes) const
{
session->timecode_to_sample (*((Timecode::Time*)&timecode), sample, use_offset, use_subframes);
}
-void
+void
BasicUI::sample_to_timecode (framepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const
{
session->sample_to_timecode (sample, *((Timecode::Time*)&timecode), use_offset, use_subframes);
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it
and/or modify it under the terms of the GNU Lesser
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it
and/or modify it under the terms of the GNU Lesser
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it
and/or modify it under the terms of the GNU Lesser
static PBD::Signal1<void,uint32_t> RemoveRouteFromSelection;
static PBD::Signal0<void> ClearRouteSelection;
- /* signals that one UI (e.g. the GUI) can emit to get all other UI's to
+ /* signals that one UI (e.g. the GUI) can emit to get all other UI's to
respond. Typically this will always be GUI->"others" - the GUI pays
no attention to these signals.
*/
we imagine most control surfaces being able to control
from 1 to N tracks at a time, with a session that may
contain 1 to M tracks, where M may be smaller, larger or
- equal to N.
+ equal to N.
the control surface has a fixed set of physical controllers
which can potentially be mapped onto different tracks/busses
XMLNode& get_state ();
int set_state (XMLNode const &, int version);
-
+
static const std::string state_node_name;
protected:
bool (*probe)(ControlProtocolDescriptor*);
ControlProtocol* (*initialize)(ControlProtocolDescriptor*,Session*);
void (*destroy)(ControlProtocolDescriptor*,ControlProtocol*);
-
+
};
}
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it
and/or modify it under the terms of the GNU Lesser
#define LIBCONTROLCP_API LIBCONTROLCP_DLL_EXPORT
#else
#define LIBCONTROLCP_API LIBCONTROLCP_DLL_IMPORT
-#endif
+#endif
#define LIBCONTROLCP_LOCAL LIBCONTROLCP_DLL_LOCAL
/* These should be used by surfaces/control interfaces. They use (probably)
#define ARDOURSURFACE_API LIBCONTROLCP_DLL_EXPORT
#else
#define ARDOURSURFACE_API LIBCONTROLCP_DLL_IMPORT
-#endif
+#endif
#define ARDOURSURFACE_LOCAL LIBCONTROLCP_DLL_LOCAL
if (val < 0) {
printf("errno: %d\n",errno);
switch(errno) {
- case ENOENT: ;
+ case ENOENT: ;
case ECONNRESET: ;
case ESHUTDOWN: printf("dying\n"); exit(1); break;
}
*
* Copyright (C) 2004 Greg Kroah-Hartman (greg@kroah.com)
* Copyright (C) 2005 Michael Hund <mhund@ld-didactic.de>
- *
+ *
* The ldusb driver was, in turn, derived from Lego USB Tower driver
* Copyright (C) 2003 David Glance <advidgsf@sourceforge.net>
* 2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
*/
/* Note: this currently uses a dumb ringbuffer for reads and writes.
- * A more optimal driver would cache and kill off outstanding urbs that are
+ * A more optimal driver would cache and kill off outstanding urbs that are
* now invalid, and ignore ones that already were in the queue but valid
* as we only have 17 commands for the tranzport. In particular this is
- * key for getting lights to flash in time as otherwise many commands
+ * key for getting lights to flash in time as otherwise many commands
* can be buffered up before the light change makes it to the interface.
*/
module_param(write_buffer_size, int, S_IRUGO);
MODULE_PARM_DESC(write_buffer_size, "Write buffer size");
-/*
+/*
* Increase the interval for debugging purposes.
* or set to 1 to use the standard interval from the endpoint descriptors.
*/
int event; /* alternate interface to events */
int wheel; /* - for negative, 0 for none, + for positive */
- int lights;
+ int lights;
unsigned char dump_state; /* 0 if disabled 1 if enabled */
unsigned char enable; /* 0 if disabled 1 if enabled */
unsigned char offline; /* if the device is out of range or asleep */
goto resubmit; /* maybe we can recover */
}
}
-
+
if (urb->actual_length != 8) {
dev_warn(&dev->intf->dev,
- "Urb length was %d bytes!! Do something intelligent \n", urb->actual_length);
+ "Urb length was %d bytes!! Do something intelligent \n", urb->actual_length);
} else {
dbg_info(&dev->intf->dev, "%s: received: %02x%02x%02x%02x%02x%02x%02x%02x\n",
__FUNCTION__, dev->interrupt_in_buffer[0],dev->interrupt_in_buffer[1],dev->interrupt_in_buffer[2],dev->interrupt_in_buffer[3],dev->interrupt_in_buffer[4],dev->interrupt_in_buffer[5],dev->interrupt_in_buffer[6],dev->interrupt_in_buffer[7]);
if(dev->offline > 0 && dev->interrupt_in_buffer[1] != 0xff) { dev->offline = 0; }
if(dev->offline == 0 && dev->interrupt_in_buffer[1] == 0xff) { dev->offline = 1; }
-#endif
+#endif
dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail);
next_ring_head = (dev->ring_head+1) % ring_buffer_size;
urb->actual_length);
memset(dev->interrupt_in_buffer, 0, urb->actual_length);
}
- }
+ }
resubmit:
/* resubmit if we're still running */
if (dev->interrupt_in_running && dev->intf) {
- retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
+ retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
if (retval)
dev_err(&dev->intf->dev,
"usb_submit_urb failed (%d)\n", retval);
}
-
+
exit:
dev->interrupt_in_done = 1;
wake_up_interruptible(&dev->read_wait);
retval = wait_event_interruptible(dev->read_wait, dev->interrupt_in_done);
if (retval < 0) {
goto unlock_exit;
- }
+ }
}
dbg_info(&dev->intf->dev, "%s: copying to userspace: %02x%02x%02x%02x%02x%02x%02x%02x\n",
while((c < count) && (dev->ring_tail != dev->ring_head)) {
/* This started off in the lower level service routine, and I moved it here. Then my brain died. Not done yet. */
-#if COMPRESS_WHEEL_EVENTS
+#if COMPRESS_WHEEL_EVENTS
next_tail = (dev->ring_tail+1) % ring_buffer_size;
if(dev->compress_wheel) cancompress = 1;
- while(dev->ring_head != next_tail && cancompress == 1 ) {
+ while(dev->ring_head != next_tail && cancompress == 1 ) {
newwheel = (*dev->ring_buffer)[next_tail].cmd[6];
oldwheel = (*dev->ring_buffer)[dev->ring_tail].cmd[6];
// if both are wheel events, and no buttons have changes (FIXME, do I have to check?),
__FUNCTION__, (*dev->ring_buffer)[dev->ring_tail].cmd[0],(*dev->ring_buffer)[dev->ring_tail].cmd[1],(*dev->ring_buffer)[dev->ring_tail].cmd[2],(*dev->ring_buffer)[dev->ring_tail].cmd[3],(*dev->ring_buffer)[dev->ring_tail].cmd[4],(*dev->ring_buffer)[dev->ring_tail].cmd[5],(*dev->ring_buffer)[dev->ring_tail].cmd[6],(*dev->ring_buffer)[dev->ring_tail].cmd[7]);
- if(((*dev->ring_buffer)[dev->ring_tail].cmd[6] != 0 &&
- (*dev->ring_buffer)[next_tail].cmd[6] != 0 ) &&
- ((newwheel > 0 && oldwheel > 0) ||
+ if(((*dev->ring_buffer)[dev->ring_tail].cmd[6] != 0 &&
+ (*dev->ring_buffer)[next_tail].cmd[6] != 0 ) &&
+ ((newwheel > 0 && oldwheel > 0) ||
(newwheel < 0 && oldwheel < 0)) &&
((*dev->ring_buffer)[dev->ring_tail].cmd[2] == (*dev->ring_buffer)[next_tail].cmd[2]) &&
((*dev->ring_buffer)[dev->ring_tail].cmd[3] == (*dev->ring_buffer)[next_tail].cmd[3]) &&
newwheel += oldwheel;
if(oldwheel > 0 && !(newwheel > 0)) {
- newwheel = 0x7f;
+ newwheel = 0x7f;
cancompress = 0;
}
if(oldwheel < 0 && !(newwheel < 0)) {
- newwheel = 0x80;
+ newwheel = 0x80;
cancompress = 0;
}
- (*dev->ring_buffer)[next_tail].cmd[6] = newwheel;
+ (*dev->ring_buffer)[next_tail].cmd[6] = newwheel;
dev->ring_tail = next_tail;
next_tail = (dev->ring_tail+1) % ring_buffer_size;
} else {
dbg_info(&dev->intf->dev, "%s: head, tail are %x, %x\n", __FUNCTION__,dev->ring_head,dev->ring_tail);
}
retval = c;
-
+
#else
if (copy_to_user(buffer, &(*dev->ring_buffer)[dev->ring_tail], 8)) {
retval = -EFAULT;
true_size = min(ring_buffer_size,RING_BUFFER_SIZE);
/* FIXME - there are more usb_alloc routines for dma correctness. Needed? */
- dev->ring_buffer = kmalloc((true_size*sizeof(struct tranzport_cmd))+8, GFP_KERNEL);
+ dev->ring_buffer = kmalloc((true_size*sizeof(struct tranzport_cmd))+8, GFP_KERNEL);
if (!dev->ring_buffer) {
dev_err(&intf->dev, "Couldn't allocate ring_buffer of size %d\n",true_size);
goto error;
}
- dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
+ dev->interrupt_in_buffer = kmalloc(dev->interrupt_in_endpoint_size, GFP_KERNEL);
if (!dev->interrupt_in_buffer) {
dev_err(&intf->dev, "Couldn't allocate interrupt_in_buffer\n");
goto error;
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
extern "C" {
-ControlProtocolDescriptor*
+ControlProtocolDescriptor*
protocol_descriptor () {
return &tranzport_descriptor;
}
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-/* Design notes: The tranzport is a unique device, basically a
- 20 lcd gui with 22 shift keys and 8 blinking lights.
+/* Design notes: The tranzport is a unique device, basically a
+ 20 lcd gui with 22 shift keys and 8 blinking lights.
As such it has several unique constraints. The device exerts flow control
by having a usb write fail. It is pointless to retry madly at that point,
- the device is busy, and it's not going to become unbusy very quickly.
+ the device is busy, and it's not going to become unbusy very quickly.
- So writes need to be either "mandatory" or "unreliable", and therein
+ So writes need to be either "mandatory" or "unreliable", and therein
lies the rub, as the kernel can also drop writes, and missing an
interrupt in userspace is also generally bad.
static const uint8_t cmd_light_off[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
static const uint8_t cmd_write_screen[] = { 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00 };
-static inline double
+static inline double
gain_to_slider_position (ARDOUR::gain_t g)
{
if (g == 0) return 0;
}
-static inline ARDOUR::gain_t
+static inline ARDOUR::gain_t
slider_position_to_gain (double pos)
{
/* XXX Marcus writes: this doesn't seem right to me. but i don't have a better answer ... */
print(1,0,"!Peace through Music!");
}
-void TranzportControlProtocol::light_validate (LightID light)
+void TranzportControlProtocol::light_validate (LightID light)
{
lights_invalid[light] = 0;
}
-void TranzportControlProtocol::light_invalidate (LightID light)
+void TranzportControlProtocol::light_invalidate (LightID light)
{
lights_invalid[light] = 1;
}
-void TranzportControlProtocol::lights_validate ()
+void TranzportControlProtocol::lights_validate ()
{
- memset (lights_invalid, 0, sizeof (lights_invalid));
+ memset (lights_invalid, 0, sizeof (lights_invalid));
}
-void TranzportControlProtocol::lights_invalidate ()
+void TranzportControlProtocol::lights_invalidate ()
{
- memset (lights_invalid, 1, sizeof (lights_invalid));
+ memset (lights_invalid, 1, sizeof (lights_invalid));
}
void TranzportControlProtocol::lights_init()
{
for (uint32_t i = 0; i < sizeof(lights_current)/sizeof(lights_current[0]); i++) {
- lights_invalid[i] = lights_current[i] =
+ lights_invalid[i] = lights_current[i] =
lights_pending[i] = lights_flash[i] = false;
}
}
// Figure out iterators one day soon
// for (LightID i = i.start(), i = i.end(); i++) {
// if (lights_pending[i] != lights_current[i] || lights_invalid[i]) {
- // if (light_set(i, lights_pending[i])) {
+ // if (light_set(i, lights_pending[i])) {
// return i-1;
- // }
+ // }
// }
//}
if ((lights_pending[LightRecord] != lights_current[LightRecord]) || lights_invalid[LightRecord]) {
TranzportControlProtocol::screen_clear ()
{
const char *blank = " ";
- print(0,0,blank);
+ print(0,0,blank);
print(1,0,blank);
}
for (row = 0; row < 2 && pending == 0; row++) {
for (col_base = 0, col = 0; col < 20 && pending == 0; ) {
- if ((screen_pending[row][col] != screen_current[row][col])
+ if ((screen_pending[row][col] != screen_current[row][col])
|| screen_invalid[row][col]) {
/* something in this cell is different, so dump the cell to the device. */
- uint8_t cmd[8];
- cmd[0] = 0x00;
- cmd[1] = 0x01;
- cmd[2] = cell;
- cmd[3] = screen_pending[row][col_base];
+ uint8_t cmd[8];
+ cmd[0] = 0x00;
+ cmd[1] = 0x01;
+ cmd[2] = cell;
+ cmd[3] = screen_pending[row][col_base];
cmd[4] = screen_pending[row][col_base+1];
- cmd[5] = screen_pending[row][col_base+2];
+ cmd[5] = screen_pending[row][col_base+2];
cmd[6] = screen_pending[row][col_base+3];
cmd[7] = 0x00;
if(write(cmd) != 0) {
/* try to update this cell on the next go-round */
#if DEBUG_TRANZPORT > 4
- printf("usb screen update failed for some reason... why? \ncmd and data were %02x %02x %02x %02x %02x %02x %02x %02x\n",
- cmd[0],cmd[1],cmd[2], cmd[3], cmd[4], cmd[5],cmd[6],cmd[7]);
+ printf("usb screen update failed for some reason... why? \ncmd and data were %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ cmd[0],cmd[1],cmd[2], cmd[3], cmd[4], cmd[5],cmd[6],cmd[7]);
#endif
pending += 1;
// Shouldn't need to do this
- // screen_invalid[row][col_base] = screen_invalid[row][col_base+1] =
+ // screen_invalid[row][col_base] = screen_invalid[row][col_base+1] =
// screen_invalid[row][col_base+2] = screen_invalid[row][col_base+3] = true;
} else {
/* successful write: copy to current cached display */
- screen_invalid[row][col_base] = screen_invalid[row][col_base+1] =
+ screen_invalid[row][col_base] = screen_invalid[row][col_base+1] =
screen_invalid[row][col_base+2] = screen_invalid[row][col_base+3] = false;
memcpy (&screen_current[row][col_base], &screen_pending[row][col_base], 4);
}
// Tranzport specific
-void TranzportControlProtocol::invalidate()
+void TranzportControlProtocol::invalidate()
{
lcd_damage(); lights_invalidate(); screen_invalidate(); // one of these days lcds can be fine but screens not
}
close ();
_active = false;
cerr << "End tranzport shutdown\n";
- }
+ }
}
return 0;
if (route_table[0]) {
gain_t g = route_get_gain (0);
if ((g != last_track_gain) || lcd_isdamaged(0,9,8)) {
- char buf[16];
+ char buf[16];
snprintf (buf, sizeof (buf), "%6.1fdB", coefficient_to_dB (route_get_effective_gain (0)));
- print (0, 9, buf);
+ print (0, 9, buf);
last_track_gain = g;
}
} else {
- print (0, 9, " ");
+ print (0, 9, " ");
}
}
enter_big_meter_mode();
break;
- case DisplayConfig:
+ case DisplayConfig:
case DisplayBling:
case DisplayBlingMeter:
enter_normal_display_mode();
def = (db + 20.0f) * 2.5f + 50.0f;
}
- /* 115 is the deflection %age that would be
+ /* 115 is the deflection %age that would be
when db=6.0. this is an arbitrary
endpoint for our scaling.
*/
if (route_table[0] == 0) {
// Principle of least surprise
print (0, 0, "No audio to meter!!!");
- print (1, 0, "Select another track");
+ print (1, 0, "Select another track");
return;
}
for (i = 0; i < fill; ++i) {
buf[i] = 0x07; /* tranzport special code for 4 quadrant LCD block */
- }
+ }
/* add a possible half-step */
void
TranzportControlProtocol::show_bbt (framepos_t where)
-{
+{
if ((where != last_where) || lcd_isdamaged(1,9,8)) {
char buf[16];
Timecode::BBT_Time bbt;
print (1, 15, buf);
sprintf (buf, "%02" PRIu32, smpte.frames);
- print_noretry (1, 18, buf);
+ print_noretry (1, 18, buf);
last_where = where;
}
return static_cast<TranzportControlProtocol*>(arg)->monitor_work ();
}
-// I note that these usb specific open, close, probe, read routines are basically
+// I note that these usb specific open, close, probe, read routines are basically
// pure boilerplate and could easily be abstracted elsewhere
#if !HAVE_TRANZPORT_KERNEL_DRIVER
for(dev = bus->devices; dev; dev = dev->next) {
if (dev->descriptor.idVendor == VENDORID && dev->descriptor.idProduct == PRODUCTID) {
- return true;
+ return true;
}
}
}
error << _("Tranzport: cannot open USB transport") << endmsg;
return -1;
}
-
+
if (usb_claim_interface (udev, 0) < 0) {
error << _("Tranzport: cannot claim USB interface") << endmsg;
usb_close (udev);
return ret;
}
-int TranzportControlProtocol::read(uint8_t *buf, uint32_t timeout_override)
+int TranzportControlProtocol::read(uint8_t *buf, uint32_t timeout_override)
{
int val;
// Get smarter about handling usb errors soon. Like disconnect
val = usb_interrupt_read (udev, READ_ENDPOINT, (char *) buf, 8, 10);
// pthread_testcancel();
return val;
-}
+}
int
// We have a state "Unknown" - STOP USING SPACES FOR IT - switching to arrow character
// We have another state - no_retry. Misleading, as we still retry on the next pass
-// I think it's pointless to keep no_retry and instead we should throttle writes
+// I think it's pointless to keep no_retry and instead we should throttle writes
// We have an "displayed" screen
// We always draw into the pending screen, which could be any of several screens
// We have an active screen
-// Print arg - we have
+// Print arg - we have
// setactive
// so someday I think we need a screen object.
/*
screen_flash.clear();
screen_flash.print(0,0,"Undone:"); // Someday pull the undo stack from somewhere
-screen_flash.print(1,0,"Nextup:");
+screen_flash.print(1,0,"Nextup:");
if(flash_messages && lcd.getactive() != screen_flash) lcd.setactive(screen_flash,2000);
{
int pending = 0;
if(!(pending = lights_flush())) {
- pending = screen_flush();
- }
+ pending = screen_flush();
+ }
return pending;
}
// doing these functions made me realize that screen_invalid should be lcd_isdamaged FIXME soon
-bool TranzportControlProtocol::lcd_damage()
+bool TranzportControlProtocol::lcd_damage()
{
screen_invalidate();
return true;
{
bool result = false;
int endcol = col+length-1;
- if((endcol > 19)) { endcol = 19; }
+ if((endcol > 19)) { endcol = 19; }
if((row >= 0 && row < 2) && (col >=0 && col < 20)) {
for(int c = col; c < endcol; c++) {
screen_invalid[row][c] = true;
// Gotta switch to bitfields, this is collossally dumb
// Still working on the layering, arguably screen_invalid should be lcd_invalid
-bool TranzportControlProtocol::lcd_isdamaged ()
+bool TranzportControlProtocol::lcd_isdamaged ()
{
for(int r = 0; r < 2; r++) {
for(int c = 0; c < 20; c++) {
{
bool result = 0;
int endcol = col+length;
- if((endcol > 19)) { endcol = 19; }
+ if((endcol > 19)) { endcol = 19; }
if((row >= 0 && row < 2) && (col >=0 && col < 20)) {
for(int c = col; c < endcol; c++) {
if(screen_invalid[row][c]) {
int
TranzportControlProtocol::lcd_flush ()
{
- return 0;
+ return 0;
}
-int
+int
TranzportControlProtocol::lcd_write(uint8_t* cmd, uint32_t timeout_override)
{
return write(cmd,timeout_override);
}
-void
-TranzportControlProtocol::lcd_fill (uint8_t fill_char)
+void
+TranzportControlProtocol::lcd_fill (uint8_t fill_char)
{
}
-void
-TranzportControlProtocol::lcd_print (int row, int col, const char* text)
+void
+TranzportControlProtocol::lcd_print (int row, int col, const char* text)
{
print(row,col,text);
}
void
TranzportControlProtocol::lights_on ()
{
- lights_pending[LightRecord] = lights_pending[LightTrackrec] =
- lights_pending[LightTrackmute] = lights_pending[LightTracksolo] =
- lights_pending[LightAnysolo] = lights_pending[LightLoop] =
+ lights_pending[LightRecord] = lights_pending[LightTrackrec] =
+ lights_pending[LightTrackmute] = lights_pending[LightTracksolo] =
+ lights_pending[LightAnysolo] = lights_pending[LightLoop] =
lights_pending[LightPunch] = true;
}
void
TranzportControlProtocol::lights_off ()
{
- lights_pending[LightRecord] = lights_pending[LightTrackrec] =
- lights_pending[LightTrackmute] = lights_pending[LightTracksolo] =
- lights_pending[LightAnysolo] = lights_pending[LightLoop] =
+ lights_pending[LightRecord] = lights_pending[LightTrackrec] =
+ lights_pending[LightTrackmute] = lights_pending[LightTracksolo] =
+ lights_pending[LightAnysolo] = lights_pending[LightLoop] =
lights_pending[LightPunch] = false;
}
}
}
-int TranzportControlProtocol::rtpriority_set(int priority)
+int TranzportControlProtocol::rtpriority_set(int priority)
{
struct sched_param rtparam;
int err;
char *a = (char*) alloca(4096*2); a[0] = 'a'; a[4096] = 'b';
memset (&rtparam, 0, sizeof (rtparam));
rtparam.sched_priority = priority; /* XXX should be relative to audio (JACK) thread */
- // Note - try SCHED_RR with a low limit
+ // Note - try SCHED_RR with a low limit
// - we don't care if we can't write everything this ms
// and it will help if we lose the device
if ((err = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
PBD::info << string_compose (_("%1: thread not running with realtime scheduling (%2)"), name(), strerror (errno)) << endmsg;
return 1;
- }
+ }
return 0;
}
// Running with realtime privs is bad when you have problems
-int TranzportControlProtocol::rtpriority_unset(int priority)
+int TranzportControlProtocol::rtpriority_unset(int priority)
{
struct sched_param rtparam;
int err;
if ((err = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
PBD::info << string_compose (_("%1: can't stop realtime scheduling (%2)"), name(), strerror (errno)) << endmsg;
return 1;
- }
+ }
PBD::info << string_compose (_("%1: realtime scheduling stopped (%2)"), name(), strerror (errno)) << endmsg;
return 0;
}
if (_device_status == STATUS_OFFLINE) {
first_time = true;
- if(offline++ == 1) {
+ if(offline++ == 1) {
cerr << "Transport has gone offline\n";
}
- } else {
+ } else {
offline = 0; // hate writing this
}
// pending = flush();
if(pending == 0) {
- pending = flush();
+ pending = flush();
} else {
if(inflight > 0) {
pending = --inflight; // we just did a whole bunch of writes so wait
}
}
// pending = 0;
- }
+ }
}
return (void*) 0;
}
-int TranzportControlProtocol::lights_show_recording()
+int TranzportControlProtocol::lights_show_recording()
{
// FIXME, flash recording light when recording and transport is moving
return lights_show_normal();
// gotta do bling next!
-int TranzportControlProtocol::lights_show_bling()
+int TranzportControlProtocol::lights_show_bling()
{
switch (bling_mode) {
case BlingOff: break;
return 0;
}
-int TranzportControlProtocol::lights_show_normal()
+int TranzportControlProtocol::lights_show_normal()
{
/* Track only */
if (route_table[0]) {
boost::shared_ptr<AudioTrack> at = boost::dynamic_pointer_cast<AudioTrack> (route_table[0]);
lights_pending[LightTrackrec] = at && at->record_enabled();
- lights_pending[LightTrackmute] = route_get_muted(0);
+ lights_pending[LightTrackmute] = route_get_muted(0);
lights_pending[LightTracksolo] = route_get_soloed(0);
} else {
lights_pending[LightTrackrec] = false;
/* Global settings */
- lights_pending[LightLoop] = session->get_play_loop();
+ lights_pending[LightLoop] = session->get_play_loop();
lights_pending[LightPunch] = Config->get_punch_in() || Config->get_punch_out();
lights_pending[LightRecord] = session->get_record_enabled();
lights_pending[LightAnysolo] = session->soloing();
return 0;
}
-int TranzportControlProtocol::lights_show_tempo()
+int TranzportControlProtocol::lights_show_tempo()
{
- // someday soon fiddle with the lights based on the tempo
+ // someday soon fiddle with the lights based on the tempo
return lights_show_normal();
}
case DisplayRecording:
lights_show_recording();
- normal_update();
+ normal_update();
break;
case DisplayRecordingMeter:
lights_show_recording();
- show_meter();
+ show_meter();
break;
case DisplayBling:
// SHIFT + STOP + PLAY for bling mode?
// if (button_changes & ButtonPlay & ButtonStop) {
- // bling_mode_toggle();
+ // bling_mode_toggle();
// } or something like that
TRANZPORT_BUTTON_HANDLER(button_event_battery,ButtonBattery);
lcd_clear();
last_where += 1; /* force time redisplay */
last_track_gain = FLT_MAX;
- normal_update(); // redraw_screen();
+ normal_update(); // redraw_screen();
}
}
}
XMLNode&
-TranzportControlProtocol::get_state ()
+TranzportControlProtocol::get_state ()
{
return ControlProtocol::get_state();
}
}
int
-TranzportControlProtocol::save (char *name)
+TranzportControlProtocol::save (char *name)
{
// Presently unimplemented
return 0;
}
int
-TranzportControlProtocol::load (char *name)
+TranzportControlProtocol::load (char *name)
{
// Presently unimplemented
return 0;
WheelIncrSecond,
WheelIncrMinute
};
-
+
enum DisplayMode {
DisplayNormal,
DisplayRecording,
void screen_invalidate();
int screen_flush();
void screen_clear();
- // bool screen_isuptodate(); // think on this -
+ // bool screen_isuptodate(); // think on this -
- // Commands to write to the lcd
+ // Commands to write to the lcd
int lcd_init();
bool lcd_damage();
/*
Copyright (C) 2006 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
_feedback_interval = ms;
}
-void
+void
GenericMidiControlProtocol::send_feedback ()
{
/* This is executed in RT "process" context", so no blocking calls
last_feedback_time = now;
}
-void
+void
GenericMidiControlProtocol::_send_feedback ()
{
/* This is executed in RT "process" context", so no blocking calls
}
XMLNode&
-GenericMidiControlProtocol::get_state ()
+GenericMidiControlProtocol::get_state ()
{
XMLNode& node (ControlProtocol::get_state());
char buf[32];
prop = node.property (X_("action"));
MIDIAction* ma = new MIDIAction (*_input_port->parser());
-
+
if (ma->init (*this, prop->value(), data, data_size)) {
delete ma;
return 0;
/*
Copyright (C) 2006 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
#include "i18n.h"
-class GMCPGUI : public Gtk::VBox
+class GMCPGUI : public Gtk::VBox
{
public:
GMCPGUI (GenericMidiControlProtocol&);
threshold_adjustment.signal_value_changed().connect (sigc::mem_fun (*this, &GMCPGUI::threshold_changed));
- Gtkmm2ext::UI::instance()->set_tip (threshold_spinner,
+ Gtkmm2ext::UI::instance()->set_tip (threshold_spinner,
string_compose (_("Controls how %1 behaves if the MIDI controller sends discontinuous values"), PROGRAM_NAME));
label = manage (new Label (_("Smoothing:")));
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
/*
Copyright (C) 2009-2010 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
#include "midiinvokable.h"
-namespace Gtk {
+namespace Gtk {
class Action;
}
if (controllable) {
controllable->Destroyed.connect (controllable_death_connection, MISSING_INVALIDATOR,
- boost::bind (&MIDIControllable::drop_controllable, this),
+ boost::bind (&MIDIControllable::drop_controllable, this),
MidiControlUI::instance());
}
}
void
MIDIControllable::midi_sense_note (Parser &, EventTwoBytes *msg, bool /*is_on*/)
{
- if (!controllable) {
+ if (!controllable) {
if (lookup_controllable()) {
return;
}
void
MIDIControllable::midi_sense_controller (Parser &, EventTwoBytes *msg)
{
- if (!controllable) {
+ if (!controllable) {
if (lookup_controllable ()) {
return;
}
void
MIDIControllable::midi_sense_program_change (Parser &, MIDI::byte msg)
{
- if (!controllable) {
+ if (!controllable) {
if (lookup_controllable ()) {
return;
}
void
MIDIControllable::midi_sense_pitchbend (Parser &, pitchbend_t pb)
{
- if (!controllable) {
+ if (!controllable) {
if (lookup_controllable ()) {
return;
}
if (_momentary) {
_parser.channel_note_on[chn_i].connect_same_thread (midi_sense_connection[1], boost::bind (&MIDIControllable::midi_sense_note_on, this, _1, _2));
- }
+ }
_control_description = "MIDI control: NoteOff";
break;
/*
Copyright (C) 1998-2006 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
class MIDIFunction : public MIDIInvokable
{
public:
- enum Function {
+ enum Function {
NextBank,
PrevBank,
TransportRoll,
Select,
SetBank,
/* 2 argument functions: RID, value */
- TrackSetSolo,
+ TrackSetSolo,
TrackSetMute,
TrackSetGain,
TrackSetRecordEnable,
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
_global_buttons[Button::UserA] = GlobalButtonInfo ("Rear Panel User Switch 1", "user", 0x66);
_global_buttons[Button::UserB] = GlobalButtonInfo ("Rear Panel User Switch 2", "user", 0x67);
- //TODO Implement "rear panel external control": a connection for a resistive
- //TODO element expression pedal . Message: 0xb0 0x2e 0xVV where 0xVV = external
+ //TODO Implement "rear panel external control": a connection for a resistive
+ //TODO element expression pedal . Message: 0xb0 0x2e 0xVV where 0xVV = external
//TODO controller position value (0x00 to 0x7f)
_strip_buttons[Button::RecEnable] = StripButtonInfo (0x0, "Rec");
std::ostream& operator<< (std::ostream& os, const Mackie::DeviceInfo& di)
{
- os << di.name() << ' '
+ os << di.name() << ' '
<< di.strip_cnt() << ' '
<< di.extenders() << ' '
<< di.master_position() << ' '
std::string label; // visible to user
std::string group; // in case we want to present in a GUI
int32_t id; // value sent by device
-
+
GlobalButtonInfo () : id (-1) {}
GlobalButtonInfo (const std::string& l, const std::string& g, uint32_t i)
: label (l), group (g), id (i) {}
};
-
+
struct StripButtonInfo {
int32_t base_id;
std::string name;
-
+
StripButtonInfo () : base_id (-1) {}
StripButtonInfo (uint32_t i, const std::string& n)
: base_id (i), name (n) {}
};
-class DeviceInfo
+class DeviceInfo
{
public:
enum DeviceType {
uint32_t strip_cnt () const;
uint32_t extenders() const;
uint32_t master_position() const;
- bool has_two_character_display() const;
+ bool has_two_character_display() const;
bool has_master_fader () const;
bool has_timecode_display() const;
bool has_global_controls() const;
}
/* name is mandatory */
-
+
if ((child = node.child ("Name")) == 0 || (prop = child->property ("value")) == 0) {
return -1;
} else {
MackieControlProtocolGUI::build_available_action_menu ()
{
/* build a model of all available actions (needs to be tree structured
- * more)
+ * more)
*/
available_action_model = TreeStore::create (available_action_columns);
function_key_editor.set_model (function_key_model);
}
-void
+void
MackieControlProtocolGUI::action_changed (const Glib::ustring &sPath, const Glib::ustring &text, TreeModelColumnBase col)
{
// Remove Binding is not in the action map but still valid
/*
Copyright (C) 2010-2012 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Gtk::TreeModelColumn<std::string> name;
Gtk::TreeModelColumn<std::string> path;
};
-
+
struct FunctionKeyColumns : public Gtk::TreeModel::ColumnRecord {
FunctionKeyColumns() {
add (name);
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <deque>
#include <queue>
-namespace ArdourSurface {
+namespace ArdourSurface {
class MackieControlProtocol;
return l;
}
-MidiByteArray
+MidiByteArray
Led::set_state (LedState new_state)
{
state = new_state;
switch (state.state()) {
case LedState::on:
- msg = 0x7f;
+ msg = 0x7f;
break;
case LedState::off:
- msg = 0x00;
+ msg = 0x00;
break;
case LedState::flashing:
- msg = 0x01;
+ msg = 0x01;
break;
case LedState::none:
return MidiByteArray ();
/*
Copyright (C) 2006,2007 John Anderson
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
~MackieControlUIRequest () {}
};
-class MackieControlProtocol
+class MackieControlProtocol
: public ARDOUR::ControlProtocol
, public AbstractUI<MackieControlUIRequest>
{
/// this is called to generate the midi to send in response to a button press.
void update_led(Mackie::Surface&, Mackie::Button & button, Mackie::LedState);
-
+
void update_global_button (int id, Mackie::LedState);
void update_global_led (int id, Mackie::LedState);
protected:
// shut down the surface
void close();
-
+
// This sets up the notifications and sets the
// controls to the correct values
void update_surfaces();
*/
typedef std::vector<boost::shared_ptr<ARDOUR::Route> > Sorted;
Sorted get_sorted_routes();
-
+
// bank switching
void switch_banks (uint32_t first_remote_id, bool force = false);
void prev_track ();
void next_track ();
-
+
// also called from poll_automation to update timecode display
void update_timecode_display();
struct ButtonHandlers {
Mackie::LedState (MackieControlProtocol::*press) (Mackie::Button&);
Mackie::LedState (MackieControlProtocol::*release) (Mackie::Button&);
-
+
ButtonHandlers (Mackie::LedState (MackieControlProtocol::*p) (Mackie::Button&),
- Mackie::LedState (MackieControlProtocol::*r) (Mackie::Button&))
+ Mackie::LedState (MackieControlProtocol::*r) (Mackie::Button&))
: press (p)
, release (r) {}
};
typedef std::set<uint32_t> DownButtonList;
typedef std::map<ARDOUR::AutomationType,DownButtonList> DownButtonMap;
DownButtonMap _down_buttons;
- DownButtonList _down_select_buttons;
+ DownButtonList _down_select_buttons;
void pull_route_range (DownButtonList&, ARDOUR::RouteList&);
Mackie::LedState view_release (Mackie::Button&);
};
-} // namespace
+} // namespace
#endif // ardour_mackie_control_protocol_h
#include "i18n.h"
/* handlers for all buttons, broken into a separate file to avoid clutter in
- * mackie_control_protocol.cc
+ * mackie_control_protocol.cc
*/
using std::string;
return off;
}
-LedState
+LedState
MackieControlProtocol::left_press (Button &)
{
Sorted sorted = get_sorted_routes();
- uint32_t strip_cnt = n_strips ();
+ uint32_t strip_cnt = n_strips ();
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("bank left with current initial = %1 nstrips = %2 tracks/busses = %3\n",
_current_initial_bank, strip_cnt, sorted.size()));
return on;
}
-LedState
+LedState
MackieControlProtocol::left_release (Button &)
{
return off;
}
-LedState
+LedState
MackieControlProtocol::right_press (Button &)
{
Sorted sorted = get_sorted_routes();
return on;
}
-LedState
+LedState
MackieControlProtocol::right_release (Button &)
{
if (zoom_mode()) {
return off;
}
-LedState
+LedState
MackieControlProtocol::channel_left_press (Button &)
{
Sorted sorted = get_sorted_routes();
}
}
-LedState
+LedState
MackieControlProtocol::channel_left_release (Button &)
{
return off;
}
-LedState
+LedState
MackieControlProtocol::channel_right_press (Button &)
{
Sorted sorted = get_sorted_routes();
}
}
-LedState
+LedState
MackieControlProtocol::channel_right_release (Button &)
{
return off;
}
-Mackie::LedState
+Mackie::LedState
MackieControlProtocol::zoom_press (Mackie::Button &)
{
return none;
}
-Mackie::LedState
+Mackie::LedState
MackieControlProtocol::zoom_release (Mackie::Button &)
{
if (_modifier_state & MODIFIER_ZOOM) {
return (zoom_mode() ? on : off);
}
-Mackie::LedState
+Mackie::LedState
MackieControlProtocol::scrub_press (Mackie::Button &)
{
if (!surfaces.empty()) {
return none;
}
-Mackie::LedState
+Mackie::LedState
MackieControlProtocol::scrub_release (Mackie::Button &)
{
return none;
return off;
}
-LedState
+LedState
MackieControlProtocol::drop_press (Button &)
{
session->remove_last_capture();
return on;
}
-LedState
+LedState
MackieControlProtocol::drop_release (Button &)
{
return off;
}
-LedState
+LedState
MackieControlProtocol::save_press (Button &)
{
session->save_state ("");
return on;
}
-LedState
+LedState
MackieControlProtocol::save_release (Button &)
{
return off;
}
-LedState
+LedState
MackieControlProtocol::timecode_beats_press (Button &)
{
switch (_timecode_type) {
return on;
}
-LedState
+LedState
MackieControlProtocol::timecode_beats_release (Button &)
{
return off;
/////////////////////////////////////
// Functions
/////////////////////////////////////
-LedState
+LedState
MackieControlProtocol::marker_press (Button &)
{
string markername;
return on;
}
-LedState
+LedState
MackieControlProtocol::marker_release (Button &)
{
return off;
// Transport Buttons
/////////////////////////////////////
-LedState
+LedState
MackieControlProtocol::stop_press (Button &)
{
transport_stop ();
return on;
}
-LedState
+LedState
MackieControlProtocol::stop_release (Button &)
{
return session->transport_stopped();
}
-LedState
+LedState
MackieControlProtocol::play_press (Button &)
{
/* if we're already rolling at normal speed, and we're pressed
return none;
}
-LedState
+LedState
MackieControlProtocol::play_release (Button &)
{
return none;
}
-LedState
+LedState
MackieControlProtocol::record_press (Button &)
{
rec_enable_toggle ();
return none;
}
-LedState
+LedState
MackieControlProtocol::record_release (Button &)
{
return none;
}
-LedState
+LedState
MackieControlProtocol::rewind_press (Button &)
{
if (main_modifier_state() == MODIFIER_CONTROL) {
return none;
}
-LedState
+LedState
MackieControlProtocol::rewind_release (Button &)
{
return none;
}
-LedState
+LedState
MackieControlProtocol::ffwd_press (Button &)
{
if (main_modifier_state() == MODIFIER_CONTROL) {
return none;
}
-LedState
+LedState
MackieControlProtocol::ffwd_release (Button &)
{
return none;
}
-LedState
+LedState
MackieControlProtocol::loop_press (Button &)
{
if (main_modifier_state() & MODIFIER_CONTROL) {
}
}
-LedState
+LedState
MackieControlProtocol::loop_release (Button &)
{
return none;
}
-LedState
+LedState
MackieControlProtocol::clicking_press (Button &)
{
bool state = !Config->get_clicking();
return state;
}
-LedState
+LedState
MackieControlProtocol::clicking_release (Button &)
{
return Config->get_clicking();
}
LedState
-MackieControlProtocol::enter_press (Button &)
-{
+MackieControlProtocol::enter_press (Button &)
+{
Enter(); /* EMIT SIGNAL */
return off;
}
LedState
-MackieControlProtocol::enter_release (Button &)
-{
+MackieControlProtocol::enter_release (Button &)
+{
return off;
}
LedState
-MackieControlProtocol::F1_press (Button &)
-{
- return off;
+MackieControlProtocol::F1_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F1_release (Button &)
-{
- return off;
+MackieControlProtocol::F1_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F2_press (Button &)
-{
- return off;
+MackieControlProtocol::F2_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F2_release (Button &)
-{
- return off;
+MackieControlProtocol::F2_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F3_press (Button &)
-{
- return off;
+MackieControlProtocol::F3_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F3_release (Button &)
-{
- return off;
+MackieControlProtocol::F3_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F4_press (Button &)
-{
- return off;
+MackieControlProtocol::F4_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F4_release (Button &)
-{
- return off;
+MackieControlProtocol::F4_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F5_press (Button &)
-{
- return off;
+MackieControlProtocol::F5_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F5_release (Button &)
-{
- return off;
+MackieControlProtocol::F5_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F6_press (Button &)
-{
- return off;
+MackieControlProtocol::F6_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F6_release (Button &)
-{
- return off;
+MackieControlProtocol::F6_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F7_press (Button &)
-{
- return off;
+MackieControlProtocol::F7_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F7_release (Button &)
-{
- return off;
+MackieControlProtocol::F7_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::F8_press (Button &)
-{
+MackieControlProtocol::F8_press (Button &)
+{
CloseDialog (); /* EMIT SIGNAL */
- return off;
+ return off;
}
LedState
-MackieControlProtocol::F8_release (Button &)
-{
- return off;
+MackieControlProtocol::F8_release (Button &)
+{
+ return off;
}
/* UNIMPLEMENTED */
LedState
-MackieControlProtocol::pan_press (Button &)
-{
- return off;
+MackieControlProtocol::pan_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::pan_release (Button &)
-{
- return none;
+MackieControlProtocol::pan_release (Button &)
+{
+ return none;
}
LedState
-MackieControlProtocol::plugin_press (Button &)
-{
- return off;
+MackieControlProtocol::plugin_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::plugin_release (Button &)
-{
- return none;
+MackieControlProtocol::plugin_release (Button &)
+{
+ return none;
}
LedState
-MackieControlProtocol::eq_press (Button &)
-{
+MackieControlProtocol::eq_press (Button &)
+{
//set_view_mode (EQ);
// not implemented yet, turn off (see comments for send button)
return off;
}
LedState
-MackieControlProtocol::eq_release (Button &)
-{
+MackieControlProtocol::eq_release (Button &)
+{
return none;
}
LedState
-MackieControlProtocol::dyn_press (Button &)
-{
+MackieControlProtocol::dyn_press (Button &)
+{
//set_view_mode (Dynamics);
// same as send
return off;
}
LedState
-MackieControlProtocol::dyn_release (Button &)
-{
+MackieControlProtocol::dyn_release (Button &)
+{
return none;
}
LedState
-MackieControlProtocol::flip_press (Button &)
-{
+MackieControlProtocol::flip_press (Button &)
+{
if (_flip_mode != Normal) {
set_flip_mode (Normal);
} else {
return ((_flip_mode != Normal) ? on : off);
}
LedState
-MackieControlProtocol::flip_release (Button &)
-{
+MackieControlProtocol::flip_release (Button &)
+{
return none;
}
LedState
-MackieControlProtocol::name_value_press (Button &)
-{
- return off;
+MackieControlProtocol::name_value_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::name_value_release (Button &)
-{
- return off;
+MackieControlProtocol::name_value_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::touch_press (Button &)
-{
- return off;
+MackieControlProtocol::touch_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::touch_release (Button &)
-{
- return off;
+MackieControlProtocol::touch_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::cancel_press (Button &)
-{
- return off;
+MackieControlProtocol::cancel_press (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::cancel_release (Button &)
-{
- return off;
+MackieControlProtocol::cancel_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::user_a_press (Button &)
-{
+MackieControlProtocol::user_a_press (Button &)
+{
transport_play (session->transport_speed() == 1.0);
- return off;
+ return off;
}
LedState
-MackieControlProtocol::user_a_release (Button &)
-{
- return off;
+MackieControlProtocol::user_a_release (Button &)
+{
+ return off;
}
LedState
-MackieControlProtocol::user_b_press (Button &)
-{
+MackieControlProtocol::user_b_press (Button &)
+{
transport_stop();
- return off;
+ return off;
}
LedState
-MackieControlProtocol::user_b_release (Button &)
-{
- return off;
+MackieControlProtocol::user_b_release (Button &)
+{
+ return off;
}
LedState
return none;
}
-Mackie::LedState
-MackieControlProtocol::read_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::read_press (Mackie::Button&)
{
_metering_active = !_metering_active;
notify_metering_state_changed ();
return _metering_active;
}
-Mackie::LedState
-MackieControlProtocol::read_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::read_release (Mackie::Button&)
{
return _metering_active;
}
-Mackie::LedState
-MackieControlProtocol::write_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::write_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::write_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::write_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::clearsolo_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::clearsolo_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::clearsolo_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::clearsolo_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::track_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::track_press (Mackie::Button&)
{
return off;
}
-Mackie::LedState
-MackieControlProtocol::track_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::track_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::send_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::send_press (Mackie::Button&)
{
// code moved here from "sends_press"
//set_view_mode (Sends);
//return on;
return off;
}
-Mackie::LedState
-MackieControlProtocol::send_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::send_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::miditracks_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::miditracks_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::miditracks_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::miditracks_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::inputs_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::inputs_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::inputs_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::inputs_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::audiotracks_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::audiotracks_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::audiotracks_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::audiotracks_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::audioinstruments_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::audioinstruments_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::audioinstruments_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::audioinstruments_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::aux_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::aux_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::aux_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::aux_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::busses_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::busses_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::busses_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::busses_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::outputs_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::outputs_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::outputs_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::outputs_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::user_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::user_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::user_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::user_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::trim_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::trim_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::trim_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::trim_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::latch_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::latch_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::latch_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::latch_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::grp_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::grp_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::grp_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::grp_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::nudge_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::nudge_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::nudge_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::nudge_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::replace_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::replace_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::replace_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::replace_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::click_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::click_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::click_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::click_release (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::view_press (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::view_press (Mackie::Button&)
{
return none;
}
-Mackie::LedState
-MackieControlProtocol::view_release (Mackie::Button&)
+Mackie::LedState
+MackieControlProtocol::view_release (Mackie::Button&)
{
return none;
}
return m;
}
-void
+void
Meter::notify_metering_state_changed(Surface& surface, bool transport_is_rolling, bool metering_active)
{
MidiByteArray msg;
MidiByteArray zero();
static Control* factory (Surface&, int id, const char*, Group&);
-
+
void notify_metering_state_changed(Surface& surface, bool transport_is_rolling, bool metering_active);
private:
for (map<Button::ID,StripButtonInfo>::const_iterator b = strip_buttons.begin(); b != strip_buttons.end(); ++b) {
Button* bb = dynamic_cast<Button*> (Button::factory (*_surface, b->first, b->second.base_id + index, b->second.name, *this));
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("surface %1 strip %2 new button BID %3 id %4 from base %5\n",
- _surface->number(), index, Button::id_to_name (bb->bid()),
+ _surface->number(), index, Button::id_to_name (bb->bid()),
bb->id(), b->second.base_id));
}
}
/* surface is responsible for deleting all controls */
}
-void
+void
Strip::add (Control & control)
{
Button* button;
}
}
-void
+void
Strip::notify_all()
{
if (!_route) {
notify_record_enable_changed ();
}
-void
+void
Strip::notify_solo_changed ()
{
if (_route && _solo) {
}
}
-void
+void
Strip::notify_mute_changed ()
{
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Strip %1 mute changed\n", _index));
}
}
-void
+void
Strip::notify_record_enable_changed ()
{
if (_route && _recenable) {
}
}
-void
+void
Strip::notify_active_changed ()
{
_surface->mcp().refresh_current_bank();
}
-void
+void
Strip::notify_route_deleted ()
{
_surface->mcp().refresh_current_bank();
}
-void
+void
Strip::notify_gain_changed (bool force_update)
{
if (_route) {
}
}
-void
+void
Strip::notify_property_changed (const PropertyChange& what_changed)
{
if (!what_changed.contains (ARDOUR::Properties::name)) {
}
}
-void
+void
Strip::notify_panner_azi_changed (bool force_update)
{
if (_route) {
}
}
-void
+void
Strip::notify_panner_width_changed (bool force_update)
{
if (_route) {
}
}
-void
+void
Strip::update_automation ()
{
ARDOUR::AutoState gain_state = _route->gain_control()->automation_state();
clear_display_reset ();
}
-
+
struct RouteCompareByName {
bool operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b) {
return a->name().compare (b->name()) < 0;
}
-void
+void
Strip::notify_metering_state_changed()
{
if (!_route || !_meter) {
bool locked() const { return _controls_locked; }
void gui_selection_changed (const ARDOUR::StrongRouteNotificationList&);
-
+
void notify_metering_state_changed();
private:
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
return 0;
}
-const MidiByteArray&
+const MidiByteArray&
Surface::sysex_hdr() const
{
switch (_stype) {
{ "", 0, Led::factory, "" }
};
-void
+void
Surface::init_controls()
{
Group* group;
}
}
-void
+void
Surface::init_strips (uint32_t n)
{
const map<Button::ID,StripButtonInfo>& strip_buttons (_mcp.device_info().strip_buttons());
if ((m = _mcp.get_session().monitor_out()) == 0) {
m = _mcp.get_session().master_out();
- }
+ }
if (!m) {
return;
_last_master_gain_written = normalized_position;
}
-float
+float
Surface::scaled_delta (float delta, float current_speed)
{
/* XXX needs work before use */
return ((sign * std::pow (delta + 1.0, 2.0)) + current_speed) / 100.0;
}
-void
+void
Surface::display_bank_start (uint32_t current_bank)
{
if (current_bank == 0) {
}
}
-void
+void
Surface::blank_jog_ring ()
{
Control* control = controls_by_device_independent_id[Jog::ID];
return 100.0;
}
-void
+void
Surface::connect_to_signals ()
{
if (!_connected) {
- DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 connecting to signals on port %2\n",
+ DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface %1 connecting to signals on port %2\n",
number(), _port->input_port().name()));
MIDI::Parser* p = _port->input_port().parser();
* from the MIDI::Parser conveys the fader ID, which was given by the
* channel ID in the status byte.
*
- * Instead, we have used bind() to supply the fader-within-strip ID
+ * Instead, we have used bind() to supply the fader-within-strip ID
* when we connected to the per-channel pitchbend events.
*/
}
}
-void
+void
Surface::handle_midi_note_on_message (MIDI::Parser &, MIDI::EventTwoBytes* ev)
{
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("Surface::handle_midi_note_on_message %1 = %2\n", (int) ev->note_number, (int) ev->velocity));
if (_mcp.device_info().no_handshake()) {
turn_it_on ();
- }
+ }
if (_mcp.device_info().device_type() == DeviceInfo::HUI && ev->note_number == 0 && ev->velocity == 127) {
turn_it_on ();
}
/* fader touch sense is given by "buttons" 0xe..0xe7 and 0xe8 for the
- * master.
+ * master.
*/
if (ev->note_number >= 0xE0 && ev->note_number <= 0xE8) {
}
}
-void
+void
Surface::handle_midi_controller_message (MIDI::Parser &, MIDI::EventTwoBytes* ev)
{
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("SurfacePort::handle_midi_controller %1 = %2\n", (int) ev->controller_number, (int) ev->value));
Pot* pot = pots[ev->controller_number];
// bit 6 gives the sign
- float sign = (ev->value & 0x40) == 0 ? 1.0 : -1.0;
+ float sign = (ev->value & 0x40) == 0 ? 1.0 : -1.0;
// bits 0..5 give the velocity. we interpret this as "ticks
// moved before this message was sent"
float ticks = (ev->value & 0x3f);
Strip* strip = dynamic_cast<Strip*> (&pot->group());
if (strip) {
strip->handle_pot (*pot, delta);
- }
+ }
}
-void
+void
Surface::handle_midi_sysex (MIDI::Parser &, MIDI::byte * raw_bytes, size_t count)
{
MidiByteArray bytes (count, raw_bytes);
}
/* always save the device type ID so that our outgoing sysex messages
- * are correct
+ * are correct
*/
if (_stype == mcu) {
switch (bytes[5]) {
case 0x01:
- /* MCP: Device Ready
- LCP: Connection Challenge
+ /* MCP: Device Ready
+ LCP: Connection Challenge
*/
if (bytes[4] == 0x10 || bytes[4] == 0x11) {
DEBUG_TRACE (DEBUG::MackieControl, "Logic Control Device connection challenge\n");
}
}
-static MidiByteArray
+static MidiByteArray
calculate_challenge_response (MidiByteArray::iterator begin, MidiByteArray::iterator end)
{
MidiByteArray l;
}
// not used right now
-MidiByteArray
+MidiByteArray
Surface::host_connection_query (MidiByteArray & bytes)
{
MidiByteArray response;
}
// not used right now
-MidiByteArray
+MidiByteArray
Surface::host_connection_confirmation (const MidiByteArray & bytes)
{
DEBUG_TRACE (DEBUG::MackieControl, string_compose ("host_connection_confirmation: %1\n", bytes));
}
}
-void
+void
Surface::write_sysex (const MidiByteArray & mba)
{
if (mba.empty()) {
_port->write (buf);
}
-void
+void
Surface::write_sysex (MIDI::byte msg)
{
MidiByteArray buf;
{
if (with_locked_strips) {
return strips.size();
- }
+ }
uint32_t n = 0;
}
void
-Surface::write (const MidiByteArray& data)
+Surface::write (const MidiByteArray& data)
{
if (_active) {
_port->write (data);
}
-static char
+static char
translate_seven_segment (char achar)
{
achar = toupper (achar);
}
// pad to 10 characters
- while (local_timecode.length() < 10) {
+ while (local_timecode.length() < 10) {
local_timecode += " ";
}
return false;
}
-void
+void
Surface::notify_metering_state_changed()
{
for (Strips::const_iterator s = strips.begin(); s != strips.end(); ++s) {
if (_port) {
/* reset msg for Mackie Control */
MidiByteArray msg (8, MIDI::sysex, 0x00, 0x00, 0x66, 0x14, 0x08, 0x00, MIDI::eox);
- _port->write (msg);
+ _port->write (msg);
msg[4] = 0x15; /* reset Mackie XT */
_port->write (msg);
msg[4] = 0x10; /* reset Logic Control */
if (_port) {
int onoff = random() %2;
MidiByteArray msg (8, MIDI::sysex, 0x00, 0x00, 0x66, 0x14, 0x0a, onoff, MIDI::eox);
- _port->write (msg);
+ _port->write (msg);
msg[4] = 0x15; /* reset Mackie XT */
_port->write (msg);
msg[4] = 0x10; /* reset Logic Control */
{
if (_port) {
MidiByteArray msg (8, MIDI::sysex, 0x00, 0x00, 0x66, 0x14, 0x09, 0x00, MIDI::eox);
- _port->write (msg);
+ _port->write (msg);
msg[4] = 0x15; /* reset Mackie XT */
_port->write (msg);
msg[4] = 0x10; /* reset Logic Control */
for (int fader = 0; fader < 9; ++fader) {
msg[6] = fader;
- _port->write (msg);
+ _port->write (msg);
msg[4] = 0x15; /* reset Mackie XT */
_port->write (msg);
msg[4] = 0x10; /* reset Logic Control */
void next_jog_mode ();
void set_jog_mode (Mackie::JogWheel::Mode);
-
+
void notify_metering_state_changed();
void turn_it_on ();
return msg;
}
-int
+int
SurfacePort::write (const MidiByteArray & mba)
{
if (mba.empty()) {
return 0;
}
-ostream &
+ostream &
Mackie::operator << (ostream & os, const SurfacePort & port)
{
os << "{ ";
Make a relationship between a midi port and a Mackie device.
*/
-class SurfacePort
+class SurfacePort
{
public:
SurfacePort (Mackie::Surface&);
virtual ~SurfacePort();
-
+
/// an easier way to output bytes via midi
int write (const MidiByteArray&);
/*
Copyright (C) 1998, 1999, 2000, 2007 John Anderson
-
+
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU Library General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
/*
- Copyright (C) 2012 Paul Davis
+ Copyright (C) 2012 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
namespace ArdourSurface {
namespace Mackie {
-enum surface_type_t {
- mcu,
- ext,
+enum surface_type_t {
+ mcu,
+ ext,
};
/**
/*
- * Copyright (C) 2009 Paul Davis
+ * Copyright (C) 2009 Paul Davis
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include "ardour/rc_configuration.h"
/*
* Copyright (C) 2006-2009 Paul Davis
- *
+ *
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
- *
+ *
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
- *
+ *
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- *
+ *
*/
#ifndef ardour_osc_h
name (argv[0]->arg1type, argv[1]->arg2type,argv[2]->arg3type,argv[3]->arg4type); \
} \
return 0; \
- }
+ }
PATH_CALLBACK2(locate,i,i);
PATH_CALLBACK2(loop_location,i,i);
PATH_CALLBACK3(route_set_send_gain_abs,i,i,f);
PATH_CALLBACK3(route_set_send_gain_dB,i,i,f);
PATH_CALLBACK4(route_plugin_parameter,i,i,i,f);
- PATH_CALLBACK3(route_plugin_parameter_print,i,i,i);
+ PATH_CALLBACK3(route_plugin_parameter_print,i,i,i);
int route_mute (int rid, int yn);
int route_solo (int rid, int yn);
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*------------------------------------------------------------*/
-OSCRouteControllable::OSCRouteControllable (lo_address a, const std::string& p,
+OSCRouteControllable::OSCRouteControllable (lo_address a, const std::string& p,
boost::shared_ptr<Controllable> c, boost::shared_ptr<Route> r)
: OSCControllable (a, p, c)
, _route (r)
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
{
public:
- OSCRouteControllable (lo_address addr, const std::string& path,
- boost::shared_ptr<PBD::Controllable>,
+ OSCRouteControllable (lo_address addr, const std::string& path,
+ boost::shared_ptr<PBD::Controllable>,
boost::shared_ptr<ARDOUR::Route>);
~OSCRouteControllable ();
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
Copyright (C) 2009 Paul Davis
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
-/* The Bling class theoretically knows nothing about the device it's blinging
+/* The Bling class theoretically knows nothing about the device it's blinging
and depends on the overlying implementation to tell it about the format of the
device. Maybe this will become a template or people will inherit from it */
// make absolutely sure we have the pointer to the interface
// something like this
-#define BLING_INTFA(a) (intf)? 0:intf->a
-#define BLING_INTF(a) { if (intf) { intf->a; } else { return 0; } }
+#define BLING_INTFA(a) (intf)? 0:intf->a
+#define BLING_INTF(a) { if (intf) { intf->a; } else { return 0; } }
// Should any of these bother to return a status code?
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <tranzport_common.h>
{
prev_track ();
// not really the right layer for this
- if(display_mode == DisplayBigMeter) {
+ if(display_mode == DisplayBigMeter) {
if (route_table[0] != 0) {
notify(route_get_name (0).substr (0, 15).c_str());
}
void
TranzportControlProtocol::button_event_trackright_press (bool shifted)
{
- next_track ();
+ next_track ();
// not really the right layer for this
- if(display_mode == DisplayBigMeter) {
+ if(display_mode == DisplayBigMeter) {
if (route_table[0] != 0) {
notify(route_get_name (0).substr (0, 15).c_str());
}
void button_event_mute (bool pressed, bool shifted)
{
static int was_pressed = 0;
- if((!pressed && !was_pressed) || pressed) {
+ if((!pressed && !was_pressed) || pressed) {
was_pressed = 1;
- }
+ }
was_pressed = 0;
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* placeholder for button definitions for user edits like yes/no */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include "tranzport_control_protocol.h"
_device_status = buf[1];
-#if DEBUG_TRANZPORT > 10
+#if DEBUG_TRANZPORT > 10
// Perhaps the device can go offline due to flow control, print command bits to see if we have anything interesting
if(_device_status == STATUS_ONLINE) {
- printf("ONLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
- buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
+ printf("ONLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
}
if(_device_status == STATUS_OFFLINE) {
- printf("OFFLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
- buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
+ printf("OFFLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
}
if(_device_status != STATUS_OK) { return 1; }
// SHIFT + STOP + PLAY for bling mode?
// if (button_changes & ButtonPlay & ButtonStop) {
- // bling_mode_toggle();
+ // bling_mode_toggle();
// } or something like that
TRANZPORT_BUTTON_HANDLER(button_event_battery,ButtonBattery);
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <tranzport_common.h>
#include <slider_gain.h>
// FIXME, flash recording light when recording and transport is moving
-int TranzportControlProtocol::lights_show_recording()
+int TranzportControlProtocol::lights_show_recording()
{
return lights_show_normal();
}
// Need more bling!
-int TranzportControlProtocol::lights_show_bling()
+int TranzportControlProtocol::lights_show_bling()
{
switch (bling_mode) {
case BlingOff: break;
case BlingRows: break; // light each row in sequence
case BlingFlashAll: break; // Flash everything randomly
case BlingEnter: lights_on(); // Show intro
- case BlingExit:
+ case BlingExit:
lights_off();
break;
}
return 0;
}
-int TranzportControlProtocol::screen_show_bling()
+int TranzportControlProtocol::screen_show_bling()
{
switch (bling_mode) {
case BlingOff: break;
print(0,0,"!!Welcome to Ardour!");
print(1,0,"Peace through Music!");
break;
- case BlingExit:
+ case BlingExit:
break;
}
return 0;
}
-int TranzportControlProtocol::lights_show_normal()
+int TranzportControlProtocol::lights_show_normal()
{
/* Track only */
if (route_table[0]) {
boost::shared_ptr<AudioTrack> at = boost::dynamic_pointer_cast<AudioTrack> (route_table[0]);
lights_pending[LightTrackrec] = at && at->record_enabled();
- lights_pending[LightTrackmute] = route_get_muted(0);
+ lights_pending[LightTrackmute] = route_get_muted(0);
lights_pending[LightTracksolo] = route_get_soloed(0);
} else {
lights_pending[LightTrackrec] = false;
/* Global settings */
- lights_pending[LightLoop] = session->get_play_loop();
+ lights_pending[LightLoop] = session->get_play_loop();
lights_pending[LightPunch] = session->config.get_punch_in() || session->config.get_punch_out();
lights_pending[LightRecord] = session->get_record_enabled();
lights_pending[LightAnysolo] = session->soloing();
return 0;
}
-int TranzportControlProtocol::lights_show_tempo()
+int TranzportControlProtocol::lights_show_tempo()
{
- // someday soon fiddle with the lights more sanely based on the tempo
+ // someday soon fiddle with the lights more sanely based on the tempo
return lights_show_normal();
}
case DisplayRecordingMeter:
lights_show_recording();
- show_meter();
+ show_meter();
break;
case DisplayBling:
session->goto_start ();
notify("START");
}
-
+
}
void
screen_invalid = mask;
}
-void TranzportControlProtocol::invalidate()
+void TranzportControlProtocol::invalidate()
{
lcd_damage(); lights_invalidate(); screen_invalidate(); // one of these days lcds can be fine but screens not
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
*/
#include <tranzport_common.h>
set_active (false);
}
-int TranzportControlProtocol::rtpriority_set(int priority)
+int TranzportControlProtocol::rtpriority_set(int priority)
{
struct sched_param rtparam;
int err;
char *a = (char*) alloca(4096*2); a[0] = 'a'; a[4096] = 'b';
memset (&rtparam, 0, sizeof (rtparam));
rtparam.sched_priority = priority; /* XXX should be relative to audio (JACK) thread */
- // Note - try SCHED_RR with a low limit
+ // Note - try SCHED_RR with a low limit
// - we don't care if we can't write everything this ms
// and it will help if we lose the device
if ((err = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
PBD::info << string_compose (_("%1: thread not running with realtime scheduling (%2)"), name(), strerror (errno)) << endmsg;
return 1;
- }
+ }
return 0;
}
// Running with realtime privs is bad when you have problems
-int TranzportControlProtocol::rtpriority_unset(int priority)
+int TranzportControlProtocol::rtpriority_unset(int priority)
{
struct sched_param rtparam;
int err;
if ((err = pthread_setschedparam (pthread_self(), SCHED_FIFO, &rtparam)) != 0) {
PBD::info << string_compose (_("%1: can't stop realtime scheduling (%2)"), name(), strerror (errno)) << endmsg;
return 1;
- }
+ }
PBD::info << string_compose (_("%1: realtime scheduling stopped (%2)"), name(), strerror (errno)) << endmsg;
return 0;
}
/* bInterval for this beastie is 10ms */
if (_device_status == STATUS_OFFLINE) {
- first_time = true; offline++;
+ first_time = true; offline++;
#if TRANZPORT_DEBUG > 3
- if(offline == 1) {
+ if(offline == 1) {
cerr << "Transport has gone offline\n";
}
#endif
- } else {
+ } else {
offline = 0; // hate writing this
}
unsigned int s = (last_write_error == 0) | ((last_read_error == 0) << 1);
#if DEBUG_TRANZPORT_BITS > 99
if (val != 8) {
printf("val = %d errno = %d\n",val,errno);
- buf[0] = buf[1] = buf[2] = buf[3] =
- buf[4] = buf[5] = buf[6] = buf[7] =
+ buf[0] = buf[1] = buf[2] = buf[3] =
+ buf[4] = buf[5] = buf[6] = buf[7] =
buf[8] = 0;
}
#endif
#if DEBUG_TRANZPORT_BITS > 10
// Perhaps an online message indicates something
- if(_device_status != buf[1]) {
- printf("WTF- val: %d, device status != buf! %d != %d \n",val,_device_status,buf[1]); _device_status = buf[1];
+ if(_device_status != buf[1]) {
+ printf("WTF- val: %d, device status != buf! %d != %d \n",val,_device_status,buf[1]); _device_status = buf[1];
}
#endif
-
+
}
-
+
#if DEBUG_TRANZPORT_BITS > 10
if(val == 8) {
if(_device_status == STATUS_ONLINE) {
- printf("ONLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
- buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
+ printf("ONLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
}
if(_device_status == STATUS_OFFLINE) {
- printf("OFFLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
- buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
+ printf("OFFLINE : %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
}
if(_device_status == STATUS_OK) {
- printf("OK : %02x %02x %02x %02x %02x %02x %02x %02x\n",
- buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
+ printf("OK : %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ buf[0],buf[1],buf[2], buf[3], buf[4], buf[5],buf[6],buf[7]);
}
-
+
}
-
+
#endif
-
+
/* update whatever needs updating */
- if(last_write_error == 0 && (_device_status == STATUS_ONLINE || _device_status == STATUS_OK)) {
+ if(last_write_error == 0 && (_device_status == STATUS_ONLINE || _device_status == STATUS_OK)) {
update_state ();
-
+
/* still struggling with a good means of exerting flow control without having to create threads */
// pending = flush();
-
+
if(pending == 0) {
- pending = flush();
+ pending = flush();
} else {
if(inflight > 0) {
pending = --inflight; // we just did a whole bunch of writes so wait
}
}
// pending = 0;
- }
+ }
return (void*) 0;
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include "control_protocol/control_protocol.h"
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* The routines in here should know absolutely nothing about how io is actually done */
std::bitset<LIGHTS> light_state;
light_state = lights_pending ^ lights_current;
if ( (light_state.none() || lights_invalid.none()))
- {
- return (0);
+ {
+ return (0);
}
#if DEBUG_TRANZPORT_LIGHTS
if ( _device_status == STATUS_OK || _device_status == STATUS_ONLINE) {
for (i = 0; i<LIGHTS; i++) {
- if(light_state[i]) {
+ if(light_state[i]) {
if(light_set ((LightID)i,lights_pending[i])) {
#if DEBUG_TRANZPORT_LIGHTS > 2
printf("Did %d light writes\n",i);
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#if HAVE_TRANZPORT_KERNEL_DRIVER
{
if((udev = ::open(TRANZPORT_DEVICE,O_RDWR))> 0) {
::close(udev);
- return true;
- }
+ return true;
+ }
error << _("Tranzport: Can't open device for Read/Write: ") << endmsg;
return false;
}
{
if((udev=::open(TRANZPORT_DEVICE,O_RDWR))> 0) {
return(udev);
- }
+ }
error << _("Tranzport: no device detected") << endmsg;
return udev;
}
// someday do buffered reads, presently this does blocking reads, which is bad...
-int TranzportControlProtocol::read(uint8_t *buf, uint32_t timeout_override)
+int TranzportControlProtocol::read(uint8_t *buf, uint32_t timeout_override)
{
last_read_error = ::read (udev, (char *) buf, 8);
switch(errno) {
case -ENOENT:
case -ENXIO:
case -ECONNRESET:
- case -ESHUTDOWN:
- case -ENODEV:
+ case -ESHUTDOWN:
+ case -ENODEV:
cerr << "Tranzport disconnected, errno: " << last_read_error;
set_active(false);
break;
case -ETIMEDOUT: // This is not normal, but lets see what happened
cerr << "Tranzport read timed out, errno: " << last_read_error;
break;
- default:
+ default:
#if DEBUG_TRANZPORT
cerr << "Got an unknown error on read:" << last_read_error "\n";
#endif
}
return last_read_error;
-}
+}
int
case -ENOENT:
case -ENXIO:
case -ECONNRESET:
- case -ESHUTDOWN:
- case -ENODEV:
+ case -ESHUTDOWN:
+ case -ENODEV:
cerr << "Tranzport disconnected, errno: " << last_write_error;
set_active(false);
break;
case -ETIMEDOUT: // This is not normal but
cerr << "Tranzport disconnected, errno: " << last_write_error;
break;
- default:
+ default:
#if DEBUG_TRANZPORT
cerr << "Got an unknown error on read:" << last_write_error "\n";
#endif
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* io_midi: Implements reading and writing tranzport events via the normal
tranzport midi specification */
-/* One day
+/* One day
#include <tranzport_control_protocol.h>
*/
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <iostream>
#include <pbd/abstract_ui.cc>
-// I note that these usb specific open, close, probe, read routines are basically
+// I note that these usb specific open, close, probe, read routines are basically
// pure boilerplate and could easily be abstracted elsewhere
bool
for(dev = bus->devices; dev; dev = dev->next) {
if (dev->descriptor.idVendor == VENDORID && dev->descriptor.idProduct == PRODUCTID) {
- return true;
+ return true;
}
}
}
cerr << _("Tranzport: cannot open USB transport") << endmsg;
return -1;
}
-
+
if (usb_claim_interface (udev, 0) < 0) {
cerr << _("Tranzport: cannot claim USB interface") << endmsg;
usb_close (udev);
return ret;
}
-int TranzportControlProtocol::read(uint8_t *buf, uint32_t timeout_override)
+int TranzportControlProtocol::read(uint8_t *buf, uint32_t timeout_override)
{
last_read_error = usb_interrupt_read (udev, READ_ENDPOINT, (char *) buf, 8, timeout_override);
switch(last_read_error) {
case -ENOENT:
case -ENXIO:
case -ECONNRESET:
- case -ESHUTDOWN:
- case -ENODEV:
+ case -ESHUTDOWN:
+ case -ENODEV:
cerr << "Tranzport disconnected, errno: " << last_read_error;
set_active(false);
case -ETIMEDOUT: // This is normal
break;
- default:
+ default:
#if DEBUG_TRANZPORT
cerr << "Got an unknown error on read:" << last_read_error "\n";
#endif
}
return last_read_error;
-}
+}
int
case -ENOENT:
case -ENXIO:
case -ECONNRESET:
- case -ESHUTDOWN:
- case -ENODEV:
+ case -ESHUTDOWN:
+ case -ENODEV:
cerr << "Tranzport disconnected, errno: " << last_write_error;
set_active(false);
case -ETIMEDOUT: // This is normal
break;
- default:
+ default:
#if DEBUG_TRANZPORT
cerr << "Got an unknown error on read:" << last_write_error "\n";
#endif
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <tranzport_control_protocol.h>
// doing these functions made me realize that screen_invalid should be lcd_isdamaged FIXME soon
-bool TranzportControlProtocol::lcd_damage()
+bool TranzportControlProtocol::lcd_damage()
{
screen_invalidate();
return true;
// Still working on the layering, arguably screen_invalid should be lcd_invalid
// or vice versa
-bool TranzportControlProtocol::lcd_isdamaged ()
+bool TranzportControlProtocol::lcd_isdamaged ()
{
if(screen_invalid.any()) {
#if DEBUG_TRANZPORT > 5
#endif
return true;
}
- return false;
+ return false;
}
// lcd_clear would be a separate function for a smart display
int
TranzportControlProtocol::lcd_flush ()
{
- return 0;
+ return 0;
}
-int
+int
TranzportControlProtocol::lcd_write(uint8_t* cmd, uint32_t timeout_override)
{
int result;
#if (DEBUG_TRANZPORT_SCREEN > 0)
- printf("VALID : %s\n", (screen_invalid.to_string()).c_str());
+ printf("VALID : %s\n", (screen_invalid.to_string()).c_str());
#endif
if ((result = write(cmd,timeout_override))) {
#if DEBUG_TRANZPORT > 4
- printf("usb screen update failed for some reason... why? \nresult, cmd and data were %d %02x %02x %02x %02x %02x %02x %02x %02x\n",
- result, cmd[0],cmd[1],cmd[2], cmd[3], cmd[4], cmd[5],cmd[6],cmd[7]);
+ printf("usb screen update failed for some reason... why? \nresult, cmd and data were %d %02x %02x %02x %02x %02x %02x %02x %02x\n",
+ result, cmd[0],cmd[1],cmd[2], cmd[3], cmd[4], cmd[5],cmd[6],cmd[7]);
#endif
}
return result;
}
-void
-TranzportControlProtocol::lcd_fill (uint8_t fill_char)
+void
+TranzportControlProtocol::lcd_fill (uint8_t fill_char)
{
}
-void
-TranzportControlProtocol::lcd_print (int row, int col, const char* text)
+void
+TranzportControlProtocol::lcd_print (int row, int col, const char* text)
{
print(row,col,text);
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <tranzport_control_protocol.h>
void TranzportControlProtocol::lights_init()
{
lights_invalid.set();
- lights_flash = lights_pending = lights_current.reset();
+ lights_flash = lights_pending = lights_current.reset();
}
-// Now that all this is bitsets, I don't see much
+// Now that all this is bitsets, I don't see much
// need for these 4 to remain in the API
-void TranzportControlProtocol::light_validate (LightID light)
+void TranzportControlProtocol::light_validate (LightID light)
{
lights_invalid.reset(light);
}
-void TranzportControlProtocol::light_invalidate (LightID light)
+void TranzportControlProtocol::light_invalidate (LightID light)
{
lights_invalid.set(light);
}
-void TranzportControlProtocol::lights_validate ()
+void TranzportControlProtocol::lights_validate ()
{
lights_invalid.reset();
}
-void TranzportControlProtocol::lights_invalidate ()
+void TranzportControlProtocol::lights_invalidate ()
{
lights_invalid.set();
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* Generic support for character based metering on a track */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <tranzport_control_protocol.h>
enter_big_meter_mode();
break;
- case DisplayConfig:
+ case DisplayConfig:
case DisplayBling:
case DisplayBlingMeter:
enter_normal_display_mode();
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* placeholder for Marker Mode: Edit Markers, Setup Loops, and Punch in points */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* Placeholder for a tuner mode at some point */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
*/
#include <tranzport_common.h>
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <cstring>
TranzportControlProtocol::screen_clear ()
{
const char *blank = " ";
- print(0,0,blank);
+ print(0,0,blank);
print(1,0,blank);
}
screen_invalidate();
}
-// FIXME: Switch to a column oriented flush to make the redraw of the
+// FIXME: Switch to a column oriented flush to make the redraw of the
// meters look better
int
#endif
if(cell > 4) { row = 1; } else { row = 0; }
col_base = (cell*4)%COLUMNS;
-
- uint8_t cmd[8];
- cmd[0] = 0x00;
- cmd[1] = 0x01;
- cmd[2] = cell;
- cmd[3] = screen_pending[row][col_base];
+
+ uint8_t cmd[8];
+ cmd[0] = 0x00;
+ cmd[1] = 0x01;
+ cmd[2] = cell;
+ cmd[3] = screen_pending[row][col_base];
cmd[4] = screen_pending[row][col_base+1];
- cmd[5] = screen_pending[row][col_base+2];
+ cmd[5] = screen_pending[row][col_base+2];
cmd[6] = screen_pending[row][col_base+3];
cmd[7] = 0x00;
if((pending = lcd_write(cmd)) == 0) {
/* successful write: copy to current cached display */
- screen_invalid &= mask.flip();
+ screen_invalid &= mask.flip();
memcpy (&screen_current[row][col_base], &screen_pending[row][col_base], 4);
}
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <iostream>
def = (db + 20.0f) * 2.5f + 50.0f;
}
- /* 115 is the deflection %age that would be
+ /* 115 is the deflection %age that would be
when db=6.0. this is an arbitrary
endpoint for our scaling.
*/
}
#define TRANZ_U 0x1 /* upper */
-#define TRANZ_BL 0x2 /* lower left */
+#define TRANZ_BL 0x2 /* lower left */
#define TRANZ_Q2 0x3 /* 2 quadrant block */
-#define TRANZ_ULB 0x4 /* Upper + lower left */
-#define TRANZ_L 0x5 /* lower */
-#define TRANZ_UBL 0x6 /* upper left + bottom all */
-#define TRANZ_Q4 0x7 /* 4 quadrant block */
+#define TRANZ_ULB 0x4 /* Upper + lower left */
+#define TRANZ_L 0x5 /* lower */
+#define TRANZ_UBL 0x6 /* upper left + bottom all */
+#define TRANZ_Q4 0x7 /* 4 quadrant block */
#define TRANZ_UL 0x08 /* upper left */
// Shift Space - switches your "view"
// Currently defined views are:
// BigMeter
-//
+//
// Shift Record - SAVE SNAPSHOT
// Somewhere I was rewriting this
// Other meters
// Inverted - show meters "inside out" For example 4 meters covering 2 cells each, and the
-//
+//
// each 4 character cell could be an 8 bar meter = 10 meters!
// Dual Meter mode - master and current track
// We have 16 rows of pixels so we COULD do a vertical meter
-// BEAT BLOCKS - For each beat, flash a 8 block (could use the center for vertical meters)
+// BEAT BLOCKS - For each beat, flash a 8 block (could use the center for vertical meters)
// Could have something generic that could handle up to /20 time
// Odd times could flash the whole top bar for the first beat
-// Vertical Meter _ .colon - + ucolon A P R I H FULLBLACK
+// Vertical Meter _ .colon - + ucolon A P R I H FULLBLACK
// MV@$%&*()-
// 3 char block rotating beat `\'/
// 1 char rotating beat {/\}
// 4 char in block rotating beat {/\}
// {\/)
-
+
void TranzportControlProtocol::show_mini_meter()
{
// FIXME - show the current marker in passing
- const int meter_buf_size = 41;
+ const int meter_buf_size = 41;
static uint32_t last_meter_fill_l = 0;
static uint32_t last_meter_fill_r = 0;
uint32_t meter_size;
float speed = fabsf(session->transport_speed());
char buf[meter_buf_size];
- if (speed == 1.0) {
- meter_size = 32;
+ if (speed == 1.0) {
+ meter_size = 32;
}
-
- if (speed == 0.0) {
+
+ if (speed == 0.0) {
meter_size = 20; // not actually reached
}
-
- if (speed > 0.0 && (speed < 1.0)) {
+
+ if (speed > 0.0 && (speed < 1.0)) {
meter_size = 20; // may shrink more one day
}
- if (speed > 1.0 && (speed < 2.0)) {
+ if (speed > 1.0 && (speed < 2.0)) {
meter_size = 20;
}
-
+
if (speed >= 2.0) {
- meter_size = 24;
- }
+ meter_size = 24;
+ }
// you only seem to get a route_table[0] == 0 on moving forward - bug in next_track?
light_on (LightTrackrec);
}
- const uint8_t char_map[16] = { ' ', TRANZ_UL,
+ const uint8_t char_map[16] = { ' ', TRANZ_UL,
TRANZ_U, TRANZ_U,
- TRANZ_BL, TRANZ_Q2,
+ TRANZ_BL, TRANZ_Q2,
TRANZ_Q2, TRANZ_ULB,
- TRANZ_L, TRANZ_UBL,
+ TRANZ_L, TRANZ_UBL,
' ',' ',
TRANZ_L, TRANZ_UBL,
TRANZ_Q4,TRANZ_Q4
- };
+ };
unsigned int val,j,i;
for(j = 1, i = 0; i < meter_size/2; i++, j+=2) {
- val = (fill_left >= j) | ((fill_left >= j+1) << 1) |
+ val = (fill_left >= j) | ((fill_left >= j+1) << 1) |
((fill_right >=j) << 2) | ((fill_right >= j+1) << 3);
buf[i] = char_map[val];
}
// char peak[2]; peak[0] = ' '; peak[1] = '\0';
// if(fraction_l == 1.0 || fraction_r == 1.0) peak[0] = 'P';
- // print (1,8,peak); // Put a peak meter - P in if we peaked.
+ // print (1,8,peak); // Put a peak meter - P in if we peaked.
}
if (route_table[0] == 0) {
// Principle of least surprise
print (0, 0, "No audio to meter!!!");
- print (1, 0, "Select another track");
+ print (1, 0, "Select another track");
return;
}
for (i = 0; i < fill; ++i) {
buf[i] = 0x07; /* tranzport special code for 4 quadrant LCD block */
- }
+ }
/* add a possible half-step */
void
TranzportControlProtocol::show_bbt (framepos_t where)
-{
+{
if (where != last_where) {
char buf[16];
Timecode::BBT_Time bbt;
float speed = fabsf(session->transport_speed());
- if (speed == 1.0) {
+ if (speed == 1.0) {
sprintf (buf, "%03" PRIu32 "%1" PRIu32, bbt.bars,bbt.beats); // switch to hex one day
- print (1, 16, buf);
+ print (1, 16, buf);
}
- if (speed == 0.0) {
+ if (speed == 0.0) {
sprintf (buf, "%03" PRIu32 "|%1" PRIu32 "|%04" PRIu32, bbt.bars,bbt.beats,bbt.ticks);
- print (1, 10, buf);
+ print (1, 10, buf);
}
- if (speed > 0.0 && (speed < 1.0)) {
+ if (speed > 0.0 && (speed < 1.0)) {
sprintf (buf, "%03" PRIu32 "|%1" PRIu32 "|%04" PRIu32, bbt.bars,bbt.beats,bbt.ticks);
- print (1, 10, buf);
+ print (1, 10, buf);
}
- if (speed > 1.0 && (speed < 2.0)) {
+ if (speed > 1.0 && (speed < 2.0)) {
sprintf (buf, "%03" PRIu32 "|%1" PRIu32 "|%04" PRIu32, bbt.bars,bbt.beats,bbt.ticks);
- print (1, 10, buf);
+ print (1, 10, buf);
}
if (speed >= 2.0) {
- sprintf (buf, "%03" PRIu32 "|%1" PRIu32 "|%02" PRIu32, bbt.bars,bbt.beats,bbt.ticks);
- print (1, 12, buf);
- }
+ sprintf (buf, "%03" PRIu32 "|%1" PRIu32 "|%02" PRIu32, bbt.bars,bbt.beats,bbt.ticks);
+ print (1, 12, buf);
+ }
TempoMap::Metric m (session->tempo_map().metric_at (where));
-
+
// the lights stop working well at above 100 bpm so don't bother
if(m.tempo().beats_per_minute() < 101.0 && (speed > 0.0)) {
print (1, 15, buf);
sprintf (buf, "%02" PRIu32, timecode.frames);
- print_noretry (1, 18, buf);
+ print_noretry (1, 18, buf);
last_where = where;
}
if (route_table[0]) {
gain_t g = route_get_gain (0);
if ((g != last_track_gain) || lcd_isdamaged(0,12,8)) {
- char buf[16];
+ char buf[16];
snprintf (buf, sizeof (buf), "%6.1fdB", coefficient_to_dB (route_get_effective_gain (0)));
- print (0, 12, buf);
+ print (0, 12, buf);
last_track_gain = g;
}
} else {
- print (0, 9, " ");
+ print (0, 9, " ");
}
}
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#ifndef ardour_slider_gain
#define ardour_slider_gain
-static inline double
+static inline double
gain_to_slider_position (ARDOUR::gain_t g)
{
if (g == 0) return 0;
}
-static inline ARDOUR::gain_t
+static inline ARDOUR::gain_t
slider_position_to_gain (double pos)
{
/* XXX Marcus writes: this doesn't seem right to me. but i don't have a better answer ... */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
*/
#include <iostream>
// FIXME: How to handle multiple tranzports in a system?
XMLNode&
-TranzportControlProtocol::get_state ()
+TranzportControlProtocol::get_state ()
{
return ControlProtocol::get_state();
}
return -1;
}
}
-#endif
+#endif
return retval;
// And perhaps we could load up sessions this way, too
int
-TranzportControlProtocol::save (char *name)
+TranzportControlProtocol::save (char *name)
{
// Presently unimplemented
return 0;
}
int
-TranzportControlProtocol::load (char *name)
+TranzportControlProtocol::load (char *name)
{
// Presently unimplemented
return 0;
}
int
-TranzportControlProtocol::save_config (char *name)
+TranzportControlProtocol::save_config (char *name)
{
// Presently unimplemented
return 0;
}
int
-TranzportControlProtocol::load_config (char *name)
+TranzportControlProtocol::load_config (char *name)
{
// Presently unimplemented
return 0;
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* This header file is basically where all the tranzport debuggable options go.
Try to only check it in with minimal debugging enabled so production
systems don't have to fiddle with it. */
-/* Design notes: The tranzport is a unique device, basically a
- 20x2 character lcd gui with (almost) 22 shift keys and 8 blinking lights.
+/* Design notes: The tranzport is a unique device, basically a
+ 20x2 character lcd gui with (almost) 22 shift keys and 8 blinking lights.
As such it has several unique constraints. In the libusb driver,
the device exerts flow control
by having a usb write fail. It is pointless to retry madly at that point,
- the device is busy, and it's not going to become unbusy very quickly.
+ the device is busy, and it's not going to become unbusy very quickly.
- So writes need to be either "mandatory" or "unreliable", and therein
+ So writes need to be either "mandatory" or "unreliable", and therein
lies the rub, as the kernel can also drop writes, and missing an
- interrupt in userspace is also generally bad.
+ interrupt in userspace is also generally bad.
- However, the kernel driver retries writes for you and also buffers and
+ However, the kernel driver retries writes for you and also buffers and
compresses incoming wheel events - it will rarely, if ever, drop data.
A more complex surface might have hundreds of lights and several displays.
// for now, this is what the device is called
#define TRANZPORT_DEVICE "/dev/tranzport0"
-#if DEBUG_TRANZPORT > 0
+#if DEBUG_TRANZPORT > 0
#define DEBUG_TRANZPORT_SCREEN 10
#define DEBUG_TRANZPORT_BITS 10
#define DEBUG_TRANZPORT_LIGHTS 10
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* The most common header files that the tranzport uses */
#ifndef ardour_tranzport_common
-#define ardour_tranzport_common
+#define ardour_tranzport_common
#include <iostream>
-#include <algorithm>
-#include <cmath>
-
+#include <algorithm>
+#include <cmath>
+
#define __STDC_FORMAT_MACROS
#include <inttypes.h>
#include <float.h>
/*
- Copyright (C) 2006 Paul Davis
+ Copyright (C) 2006 Paul Davis
Copyright (C) 2007 Mike Taht
This program is free software; you can redistribute it and/or modify
const static int STATUS_OFFLINE = 0xff;
const static int STATUS_ONLINE = 0x01;
const static int STATUS_OK = 0x00;
-
+
const static int LIGHTS = 7;
const static int ROWS = 2;
const static int COLUMNS = 20;
ButtonPlay = 0x00100000,
ButtonRecord = 0x00000100,
ButtonShift = 0x08000000,
- ButtonFootswitch = 0x00001000
+ ButtonFootswitch = 0x00001000
};
enum WheelShiftMode {
WheelIncrSecond,
WheelIncrMinute
};
-
+
enum DisplayMode {
DisplayNormal,
DisplayRecording,
std::bitset<LIGHTS> lights_flash;
int32_t last_notify;
- char last_notify_msg[COLUMNS+1];
+ char last_notify_msg[COLUMNS+1];
uint32_t last_bars;
uint32_t last_beats;
uint32_t last_ticks;
void screen_invalidate();
int screen_flush();
void screen_clear();
- // bool screen_isuptodate(); // think on this -
+ // bool screen_isuptodate(); // think on this -
int screen_show_bling();
- // Commands to write to the lcd
+ // Commands to write to the lcd
int lcd_init();
bool lcd_damage();
void enter_bling_mode();
void next_marker (); // basicui doesn't give me enough info
- void prev_marker ();
+ void prev_marker ();
void next_display_mode ();
void normal_update ();
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/* ultimately this view will let you: rotate layers (takes) on the currently selected track/region, do cross fades, and the like */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
* */
#include <iostream>
/*
- * Copyright (C) 2006 Paul Davis
+ * Copyright (C) 2006 Paul Davis
* Copyright (C) 2007 Michael Taht
*
* This program is free software; you can redistribute it and/or modify
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
+ *
*/
#include <iostream>
// if ? greater. dont
if(session->transport_speed() != 0) {
- show_mini_meter();
+ show_mini_meter();
} else {
switch (wheel_mode) {
}
print (1, 0, text.c_str());
- }
+ }
}
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
timecode.negative = false;
return SECONDS;
}
-
+
timecode.negative = false;
wrap = decrement (timecode, subframes_per_frame);
if (!Timecode_IS_ZERO (timecode)) {
}
break;
}
-
+
if (wrap == SECONDS) {
if (timecode.seconds == 59) {
timecode.seconds = 0;
} else {
timecode.frames++;
}
-
+
return wrap;
}
decrement (Time& timecode, uint32_t subframes_per_frame)
{
Wrap wrap = NONE;
-
+
if (timecode.negative || Timecode_IS_ZERO (timecode)) {
timecode.negative = false;
wrap = increment (timecode, subframes_per_frame);
timecode.negative = true;
return SECONDS;
}
-
+
switch ((int)ceil (timecode.rate)) {
case 24:
if (timecode.frames == 0) {
}
break;
}
-
+
if (wrap == SECONDS) {
if (timecode.seconds == 0) {
timecode.seconds = 59;
} else {
timecode.frames--;
}
-
+
if (Timecode_IS_ZERO (timecode)) {
timecode.negative = false;
}
-
+
return wrap;
}
increment_subframes (Time& timecode, uint32_t subframes_per_frame)
{
Wrap wrap = NONE;
-
+
if (timecode.negative) {
timecode.negative = false;
wrap = decrement_subframes (timecode, subframes_per_frame);
}
return wrap;
}
-
+
timecode.subframes++;
if (timecode.subframes >= subframes_per_frame) {
timecode.subframes = 0;
decrement_subframes (Time& timecode, uint32_t subframes_per_frame)
{
Wrap wrap = NONE;
-
+
if (timecode.negative) {
timecode.negative = false;
wrap = increment_subframes (timecode, subframes_per_frame);
timecode.negative = true;
return wrap;
}
-
+
if (timecode.subframes <= 0) {
timecode.subframes = 0;
if (Timecode_IS_ZERO (timecode)) {
increment_seconds (Time& timecode, uint32_t subframes_per_frame)
{
Wrap wrap = NONE;
-
+
// Clear subframes
frames_floor (timecode);
-
+
if (timecode.negative) {
// Wrap second if on second boundary
wrap = increment (timecode, subframes_per_frame);
timecode.frames = 59;
break;
}
-
+
// Increment by one frame
wrap = increment (timecode, subframes_per_frame);
}
-
+
return wrap;
}
{
// Clear subframes
frames_floor (timecode);
-
+
// Go to lowest possible frame in this second
switch ((int)ceil (timecode.rate)) {
case 24:
}
break;
}
-
+
if (Timecode_IS_ZERO (timecode)) {
timecode.negative = false;
}
increment_minutes (Time& timecode, uint32_t subframes_per_frame)
{
Wrap wrap = NONE;
-
+
// Clear subframes
frames_floor (timecode);
-
+
if (timecode.negative) {
// Wrap if on minute boundary
wrap = increment_seconds (timecode, subframes_per_frame);
// Wrap minute by incrementing second
wrap = increment_seconds (timecode, subframes_per_frame);
}
-
+
return wrap;
}
increment_hours (Time& timecode, uint32_t subframes_per_frame)
{
Wrap wrap = NONE;
-
+
// Clear subframes
frames_floor (timecode);
-
+
if (timecode.negative) {
// Wrap if on hour boundary
wrap = increment_minutes (timecode, subframes_per_frame);
timecode.minutes = 59;
wrap = increment_minutes (timecode, subframes_per_frame);
}
-
+
return wrap;
}
timecode.seconds = 0;
timecode.frames = 0;
timecode.subframes = 0;
-
+
if (Timecode_IS_ZERO (timecode)) {
timecode.negative = false;
}
} // namespace Timecode
-std::ostream&
-operator<<(std::ostream& ostr, const Timecode::Time& t)
+std::ostream&
+operator<<(std::ostream& ostr, const Timecode::Time& t)
{
return t.print (ostr);
}
under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at your
option) any later version.
-
+
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#define LIBTIMECODE_API LIBTIMECODE_DLL_EXPORT
#else
#define LIBTIMECODE_API LIBTIMECODE_DLL_IMPORT
-#endif
+#endif
#define LIBTIMECODE_LOCAL LIBTIMECODE_DLL_LOCAL
#endif /* __libtimecode_visibility_h__ */
Centre for Digital Music, Queen Mary, University of London.
This file copyright 2006 Dan Stowell.
-
+
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
Centre for Digital Music, Queen Mary, University of London.
This file copyright 2006 Chris Cannam.
-
+
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
Centre for Digital Music, Queen Mary, University of London.
Copyright 2006 Chris Cannam.
-
+
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
Centre for Digital Music, Queen Mary, University of London.
Copyright 2006 Chris Cannam.
-
+
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
Centre for Digital Music, Queen Mary, University of London.
Copyright 2006 Chris Cannam.
-
+
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
exit (0);
}
- return 0;
+ return 0;
}
/**
but based on ...
*/
-/* REAPER OMF plug-in
+/* REAPER OMF plug-in
Copyright (C) 2009 Hannes Breul
Provides OMF import.
-
+
Based on the m3u example included in the Reaper SDK,
Copyright (C) 2005-2008 Cockos Incorporated
-
+
Original source available at:
http://www.reaper.fm/sdk/plugin/plugin.php#ext_dl
-
+
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
-
+
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
-
+
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
using namespace PBD;
//#define DEBUG(fmt,...) fprintf (stderr, fmt, ## __VA_ARGS__)
-#define DEBUG(fmt,...)
+#define DEBUG(fmt,...)
#define INFO(fmt,...) fprintf (stdout, fmt, ## __VA_ARGS__)
#define MB_OK 0
fprintf (stderr, msg);
}
-void
-OMF::name_types ()
+void
+OMF::name_types ()
{
/* Add built-in types */
sqlite3_exec(db, "INSERT INTO lookup VALUES (1, 'TOC property 1')", 0, 0, 0);
sqlite3_exec(db, "DROP TABLE lookup", 0, 0, 0);
}
-int
+int
OMF::load (const string& path)
-{
+{
if ((file = fopen(path.c_str(), "rb")) == 0) {
MessageBox(NULL, "Cannot open file","OMF Error", MB_OK);
return -1;
sqlite3_exec(db, "BEGIN", 0, 0, 0);
sqlite3_exec(db, "CREATE TABLE data (object, property, type, value, offset, length)", 0, 0, 0);
sqlite3_exec(db, "CREATE TABLE lookup (key, name)", 0, 0, 0);
-
+
uint8_t magic[8];
fseek(file, -24, SEEK_END);
fread(magic, 8, 1, file);
fseek(file, -14, SEEK_END);
fread(&bSize, 2, 1, file);
bSize = e16(bSize);
-
+
fseek(file, -8, SEEK_END);
fread(&tocStart, 4, 1, file);
tocStart = e32(tocStart);
fread(&tocSize, 4, 1, file);
tocSize = e32(tocSize);
DEBUG ("block size: %d\n toc start: %d\n toc size: %d\n", bSize, tocStart, tocSize);
-
-
+
+
/* Calculate number of TOC blocks */
uint32_t tocBlocks = tocSize / (bSize * 1024) + 1;
DEBUG ("toc blocks: %d\n", tocBlocks);
char cByte; // TOC control byte
fseek(file, currentPos, SEEK_SET);
fread(&cByte, 1, 1, file);
-
+
/* New object */
if (cByte == 1) {
fseek(file, currentPos + 1, SEEK_SET);
currentPos += 12; // Skip the bytes that were just read
}
/* ---------- */
-
-
+
+
/* New property */
else if (cByte == 2) {
fseek(file, currentPos + 1, SEEK_SET);
currentPos += 8;
}
/* ------------ */
-
-
+
+
/* New type */
else if (cByte == 3) {
fseek(file, currentPos + 1, SEEK_SET);
currentPos += 4;
}
/* -------- */
-
-
+
+
/* (unused) */
else if (cByte == 4) {
currentPos += 4;
}
/* -------- */
-
-
+
+
/* Reference to a value - 4/8 byte offset, 4/8 byte size */
else if ((cByte == 5) | (cByte == 6) | (cByte == 7) | (cByte == 8)) {
if (!skip) {
}
DEBUG(" offset: %d\n", dataOffset);
DEBUG(" length: %d\n", dataLength);
-
+
if (currentType == 21) {
char* string = (char*) malloc((uint32_t) dataLength);
fseek(file, dataOffset, SEEK_SET);
}
}
/* ----------------------------------------------------- */
-
-
+
+
/* Zero byte value */
else if (cByte == 9) {
if (!skip) {
sqlite3_exec(db, query, 0, 0, 0);
sqlite3_free(query);
DEBUG(" value: %d\n", data);
-
+
}
currentPos += 4;
}
/* --------------- */
-
-
+
+
/* Reference list */
else if (cByte == 15) {
uint32_t data = 0;
else {
break;
}
-
+
}
}
/* --------------------- */
time(&endtime);
INFO("done. (%ld seconds)\n", endtime - starttime);
starttime = endtime;
-
+
INFO("Assigning type and property names... ");
name_types ();
time(&endtime);
INFO("Resolving ObjRefArrays ");
sqlite3_get_table(db, "SELECT * FROM data WHERE type LIKE 'omfi:ObjRefArray' AND value = ''", &arrays, &arrayCount, 0, 0);
INFO("(%d to be processed)... ", arrayCount);
- sqlite3_exec(db,"DELETE FROM data WHERE type LIKE 'omfi:ObjRefArray' AND value = ''",0,0,0);
+ sqlite3_exec(db,"DELETE FROM data WHERE type LIKE 'omfi:ObjRefArray' AND value = ''",0,0,0);
for (l = 6; l <= arrayCount * 6; l+=6) {
uint16_t counter;
uint32_t arrOffs = atoi(arrays[l+4]);
}
sqlite3_free_table(refs);
printf("temporary table deleted\n"); */
-
+
if (!isAvid) {
INFO("Resolving ObjRefs ");
sqlite3_exec(db,"CREATE TABLE reference (object1, property1, value1)",0,0,0);
char **refs;
int refCount;
int currentRef;
-
+
sqlite3_get_table(db,"SELECT * FROM reference", &refs, &refCount, 0, 0);
INFO ("(%d to be processed)... ", refCount);
for (currentRef = 3; currentRef <= refCount * 3; currentRef += 3) {
sqlite3_free_table(refs);
}
DEBUG("temporary table deleted\n");
-
+
/*sqlite3_get_table(db,"SELECT object, property, value FROM data WHERE type LIKE 'omfi:ObjRef'", &refs, &refCount, 0, 0);
printf("%d\n", refCount);
for (currentRef = 3; currentRef <= refCount * 3; currentRef += 3) {
time(&endtime);
INFO("done. (%ld seconds)\n", endtime - starttime);
starttime = endtime;
-
+
//return -1;
-
+
/* extract media data */
printf("Extracting media data...\n");
char **objects;
strncpy(clsString, (char *) &clsID, 4);
clsString[4] = 0;
DEBUG("%d -> %s\n", clsID, clsString);
-
+
sqlite3_exec(db,sqlite3_mprintf("INSERT INTO data VALUES (%s, '%s', 'omfi:ClassID', '%s', -1, -1)", classID[currentClsID], classID[currentClsID + 1], clsString),0,0,0);
}
sqlite3_free_table(classID);
/*time(&endtime);
printf("Took %ld seconds\n", endtime - starttime);
starttime = endtime;*/
-
+
time(&endtime);
INFO("done. (%ld seconds)\n", endtime - starttime);
but based on ...
*/
-/* REAPER OMF plug-in
+/* REAPER OMF plug-in
Copyright (C) 2009 Hannes Breul
Provides OMF import.
-
+
Based on the m3u example included in the Reaper SDK,
Copyright (C) 2005-2008 Cockos Incorporated
-
+
Original source available at:
http://www.reaper.fm/sdk/plugin/plugin.php#ext_dl
-
+
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
-
+
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
-
+
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
#include "omftool.h"
//#define DEBUG(fmt,...) fprintf (stderr, fmt, ## __VA_ARGS__)
-#define DEBUG(fmt,...)
+#define DEBUG(fmt,...)
#define INFO(fmt,...) fprintf (stdout, fmt, ## __VA_ARGS__)
using namespace std;
XMLNode* source = new_source_node();
- known_sources.insert (pair<string,SourceInfo*>
+ known_sources.insert (pair<string,SourceInfo*>
(Glib::path_get_basename (path),
new SourceInfo (sf_info.channels,
sf_info.samplerate,
route->add_child_nocopy (*extra);
XMLNode* gui = new XMLNode ("GUI");
extra->add_child_nocopy (*gui);
- snprintf (sbuf, sizeof (sbuf), "%d:%d:%d",
+ snprintf (sbuf, sizeof (sbuf), "%d:%d:%d",
random() % 65536,
random() % 65536,
random() % 65536);
KnownSources::iterator i = known_sources.find (s);
if (i != known_sources.end()) {
return i->second;
- }
+ }
return 0;
}
sqlite3_free_table(fallbackFile);
}
-
+
if (sinfo) {
sqlite3_get_table(db, sqlite3_mprintf("SELECT value FROM data WHERE object = %s AND property = 'OMFI:SCLP:StartTime' LIMIT 1", items[j]), &startTime, &startTimeCount, 0, 0);
if (startTimeCount > 0) {
start = atoi(startTime[1]);
- }
+ }
sqlite3_free_table(startTime);
char **sourceFile;
int sourceFileCount;
//sqlite3_get_table(db, sqlite3_mprintf("SELECT d10.offset, d10.length FROM data d3, data d4, data d5, data d6, data d7, data d8, data d9, data d10 WHERE d3.object LIKE '%s' AND d3.property LIKE 'OMFI:SCLP:SourceID' AND d4.value LIKE d3.value AND d4.property LIKE 'OMFI:MOBJ:MobID' AND d5.object LIKE d4.object AND d5.property LIKE 'OMFI:MOBJ:Slots' AND d6.object LIKE d5.value AND d7.object LIKE d6.value AND d7.property LIKE 'OMFI:MSLT:Segment' AND d8.object LIKE d7.value AND d8.property LIKE 'OMFI:SCLP:SourceID' AND d9.value LIKE d8.value AND d9.property LIKE 'OMFI:MOBJ:MobID' AND d10.object LIKE d9.object AND d10.property LIKE 'OMFI:MOBJ:Name' LIMIT 1", items[j]), &sourceFile, &sourceFileCount, 0, 0);
sqlite3_get_table(db, sqlite3_mprintf("SELECT offset, length FROM data WHERE object IN (SELECT object FROM data WHERE value IN (SELECT value FROM data WHERE object IN (SELECT value FROM data WHERE object IN (SELECT value FROM data WHERE object IN (SELECT value FROM data WHERE object IN (SELECT object FROM data WHERE value IN (SELECT value FROM data WHERE object = %s AND property = 'OMFI:SCLP:SourceID' LIMIT 1) AND property = 'OMFI:MOBJ:MobID' LIMIT 1) AND property = 'OMFI:MOBJ:Slots' LIMIT 1) LIMIT 1) AND property = 'OMFI:MSLT:Segment' LIMIT 1) AND property = 'OMFI:SCLP:SourceID' LIMIT 1) AND property = 'OMFI:MOBJ:MobID' LIMIT 1) AND property LIKE 'OMFI:MOBJ:Name' LIMIT 1", items[j]), &sourceFile, &sourceFileCount, 0, 0);
-
+
if (sourceFileCount > 0) {
uint32_t sfOffs;
uint32_t sfLen;
}
sqlite3_free_table(fallbackFile);
}
-
+
if (sinfo) {
region = new_region_node ();
}
-static void
+static void
print_help (const char* execname)
{
- cout << execname
+ cout << execname
<< " [ -r sample-rate ]"
<< " [ -n session-name ]"
<< " [ -v ardour-session-version ]"
uint32_t e32(uint32_t x)
{
if (bigEndian)
- return (x>>24) |
+ return (x>>24) |
((x<<8) & 0x00FF0000) |
((x>>8) & 0x0000FF00) |
(x<<24);
uint64_t e64(uint64_t x)
{
if (bigEndian)
- return (x>>56) |
+ return (x>>56) |
((x<<40) & 0x00FF000000000000) |
((x<<24) & 0x0000FF0000000000) |
((x<<8) & 0x000000FF00000000) |
* GPL, yabbadabba
*
* Set of functions to gather system information for the jack setup wizard.
- *
+ *
* @author Florian Faber, faber@faberman.de
- *
+ *
* @version 0.1 (2009-01-15) [FF]
* - initial version
*
/**
- * This function checks for the existence of known frequency scaling mechanisms
+ * This function checks for the existence of known frequency scaling mechanisms
* in this system.
*
* @returns 0 if the system has no frequency scaling capabilities non-0 otherwise.
/**
- * This function determines wether the CPU has a variable clock speed if frequency
- * scaling is available.
+ * This function determines wether the CPU has a variable clock speed if frequency
+ * scaling is available.
*
* @returns 0 if system doesn't use frequency scaling at the moment, non-0 otherwise
**/
extern int ardour_main(int argc, char* argv[]);
int
-main (int argc, char* argv[])
+main (int argc, char* argv[])
{
return ardour_main(argc, argv);
}
projects / ardour.git / commitdiff