| blob | 5e56b82e689b7dfa8990d2f1871009516421152b |
1 /*
2 Copyright (C) 1999-2010 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
20 #define __STDC_LIMIT_MACROS
21 #include <stdint.h>
23 #include <algorithm>
24 #include <string>
25 #include <vector>
26 #include <sstream>
27 #include <fstream>
29 #include <cmath>
30 #include <cerrno>
31 #include <unistd.h>
32 #include <limits.h>
34 #include <glibmm/thread.h>
35 #include <glibmm/miscutils.h>
36 #include <glibmm/fileutils.h>
134 string mix_template)
160 {
167 }
180 }
181 }
186 }
194 Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, false));
195 config.ParameterChanged.connect_same_thread (*this, boost::bind (&Session::config_changed, this, _1, true));
199 }
202 }
205 {
207 }
209 void
211 {
214 /* if we got to here, leaving pending capture state around
215 is a mistake.
216 */
224 /* clear history so that no references to objects are held any more */
228 /* clear state tree so that no references to objects are held any more */
232 /* reset dynamic state version back to default */
242 }
246 }
250 /* clear out any pending dead wood from RCU managed objects */
257 /* tell everyone who is still standing that we're about to die */
260 /* tell everyone to drop references and delete objects as we go */
270 /* reset these three references to special routes before we do the usual route delete thing */
276 {
281 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for route %1 ; pre-ref = %2\n", (*i)->name(), (*i).use_count()));
283 }
286 /* writer goes out of scope and updates master */
287 }
294 DEBUG_TRACE(DEBUG::Destruction, string_compose ("Dropping for source %1 ; pre-ref = %2\n", i->second->path(), i->second.use_count()));
296 }
304 }
310 /* not strictly necessary, but doing it here allows the shared_ptr debugging to work */
316 }
318 void
320 {
326 }
333 }
334 }
336 void
338 {
339 string first_physical_output;
348 boost::function<void (std::string)> ff (boost::bind (&Session::config_changed, this, _1, false));
349 boost::function<void (std::string)> ft (boost::bind (&Session::config_changed, this, _1, true));
354 /* every time we reconnect, recompute worst case output latencies */
356 _engine.Running.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies, this));
360 }
364 }
375 /* existing state for Click */
379 c = _click_io->set_state_2X (*child->children().front(), Stateful::loading_state_version, false);
382 }
392 }
397 /* default state for Click: dual-mono to first 2 physical outputs */
404 // relax, even though its an error
405 }
406 }
407 }
411 }
412 }
413 }
417 }
424 // XXX HOW TO ALERT UI TO THIS ? DO WE NEED TO?
425 }
429 /* Create a set of Bundle objects that map
430 to the physical I/O currently available. We create both
431 mono and stereo bundles, so that the common cases of mono
432 and stereo tracks get bundles to put in their mixer strip
433 in / out menus. There may be a nicer way of achieving that;
434 it doesn't really scale that well to higher channel counts
435 */
437 /* mono output bundles */
448 }
450 /* stereo output bundles */
463 }
464 }
466 /* mono input bundles */
477 }
479 /* stereo input bundles */
493 }
494 }
502 /* don't connect the master bus outputs if there is a monitor bus */
506 /* if requested auto-connect the outputs to the first N physical ports.
507 */
520 }
521 }
522 }
523 }
527 /* AUDIO ONLY as of june 29th 2009, because listen semantics for anything else
528 are undefined, at best.
529 */
531 /* control out listens to master bus (but ignores it
532 under some conditions)
533 */
548 }
549 }
550 }
551 }
553 /* if control out is not connected, connect control out to physical outs
554 */
568 }
588 }
589 }
590 }
591 }
592 }
593 }
594 }
595 }
597 /* catch up on send+insert cnts */
601 /* hook us up to the engine */
606 }
608 void
610 {
611 /* stop graph reordering notifications from
612 causing resorts, etc.
613 */
620 /* we delay creating the auditioner till now because
621 it makes its own connections to ports.
622 */
629 }
632 }
636 }
637 }
639 /* load bundles, which we may have postponed earlier on */
643 }
645 /* Tell all IO objects to connect themselves together */
650 /* Now reset all panners */
654 /* Connect tracks to monitor/listen bus if there is one.
655 Note that in an existing session, the internal sends will
656 already exist, but we want the routes to notice that
657 they connect to the control out specifically.
658 */
666 /* relax */
670 /* relax */
677 }
678 }
679 }
681 /* Anyone who cares about input state, wake up and do something */
687 /* now handle the whole enchilada as if it was one
688 graph reorder event.
689 */
693 /* update the full solo state, which can't be
694 correctly determined on a per-route basis, but
695 needs the global overview that only the session
696 has.
697 */
700 }
702 void
704 {
706 }
708 void
710 {
714 }
719 playlist->LengthChanged.connect_same_thread (*this, boost::bind (&Session::playlist_length_changed, this));
720 }
723 }
725 bool
727 {
728 /* this used to be in here, but survey says.... we don't need to restrict it */
729 // if (record_status() == Recording) {
730 // return false;
731 // }
735 }
737 }
739 void
741 {
748 //cerr << "switching to input = " << !auto_input << __FILE__ << __LINE__ << endl << endl;
749 tr->monitor_input (Config->get_monitoring_model() == HardwareMonitoring && !config.get_auto_input());
750 }
751 }
759 //cerr << "switching to input = " << !Config->get_auto_input() << __FILE__ << __LINE__ << endl << endl;
761 }
762 }
763 }
764 }
766 void
768 {
772 /* capture start has been changed, so save new pending state */
774 }
775 }
777 void
779 {
781 // when_to_stop += _worst_output_latency + _worst_input_latency;
783 }
785 void
787 {
791 //when_to_stop += _worst_output_latency + _worst_input_latency;
793 }
795 void
797 {
803 // if (_transport_frame > location->end()) {
806 // relocate to beginning of loop
811 }
814 // schedule a locate-roll to refill the diskstreams at the
815 // previous loop end
820 SessionEvent *ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, last_loopend, last_loopend, 0, true);
822 }
824 }
825 }
828 }
830 void
832 {
841 }
847 }
852 }
856 location->start_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_start_changed, this, _1));
857 location->end_changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_end_changed, this, _1));
858 location->changed.connect_same_thread (punch_connections, boost::bind (&Session::auto_punch_changed, this, _1));
865 }
867 void
869 {
877 }
883 }
888 }
894 location->start_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
895 location->end_changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
896 location->changed.connect_same_thread (loop_connections, boost::bind (&Session::auto_loop_changed, this, _1));
900 /* take care of our stuff first */
904 /* now tell everyone else */
907 }
909 void
911 {
913 }
915 void
917 {
919 }
921 void
923 {
936 }
940 }
944 }
945 }
949 }
952 }
955 }
957 void
959 {
965 }
979 }
980 }
981 }
985 }
986 }
987 }
989 void
991 {
992 RecordState rs;
1002 }
1003 }
1012 }
1013 }
1014 }
1020 }
1021 }
1022 }
1024 void
1026 {
1034 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
1036 }
1037 }
1038 }
1039 }
1040 }
1042 void
1044 {
1047 /* this function is currently called from somewhere other than an RT thread.
1048 this save_state() call therefore doesn't impact anything.
1049 */
1056 }
1060 }
1063 }
1065 nframes64_t
1067 {
1068 nframes64_t ret;
1069 nframes64_t tf;
1070 nframes_t offset;
1072 /* the first of these two possible settings for "offset"
1073 mean that the audible frame is stationary until
1074 audio emerges from the latency compensation
1075 "pseudo-pipeline".
1077 the second means that the audible frame is stationary
1078 until audio would emerge from a physical port
1079 in the absence of any plugin latency compensation
1080 */
1087 /* XXX is this correct? if we have no external
1088 physical connections and everything is internal
1089 then surely this is zero? still, how
1090 likely is that anyway?
1091 */
1093 }
1099 }
1105 /* MOVING */
1107 /* Check to see if we have passed the first guaranteed
1108 audible frame past our last start position. if not,
1109 return that last start point because in terms
1110 of audible frames, we have not moved yet.
1112 `Start position' in this context means the time we last
1113 either started or changed transport direction.
1114 */
1121 }
1122 }
1125 /* forwards */
1130 /* XXX wot? no backward looping? */
1135 /* backwards */
1137 }
1138 }
1139 }
1142 }
1144 void
1146 {
1147 /** \fn void Session::set_frame_size(nframes_t)
1148 the AudioEngine object that calls this guarantees
1149 that it will not be called while we are also in
1150 ::process(). Its fine to do things that block
1151 here.
1152 */
1158 Automatable::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
1162 // XXX we need some equivalent to this, somehow
1163 // SndFileSource::setup_standard_crossfades (frames_per_second);
1167 /* XXX need to reset/reinstantiate all LADSPA plugins */
1168 }
1170 void
1172 {
1173 /* the AudioEngine guarantees
1174 that it will not be called while we are also in
1175 ::process(). It is therefore fine to do things that block
1176 here.
1177 */
1179 {
1188 }
1195 }
1196 }
1199 }
1200 }
1202 void
1204 {
1205 #if 0
1206 nframes_t fade_frames;
1208 /* Don't allow fade of less 1 frame */
1219 }
1224 {
1225 // jlc, WTF is this!
1228 }
1232 /* XXX have to do this at some point */
1233 /* foreach region using default fade, reset, then
1234 refill_all_diskstream_buffers ();
1235 */
1236 #endif
1237 }
1248 /* no ardour-based connections inbound to either route. just use signal order */
1251 /* r2 has connections, r1 does not; run r1 early */
1253 }
1256 }
1257 }
1258 }
1259 };
1261 static void
1263 {
1267 info << string_compose(_("feedback loop setup between %1 and %2"), r1->name(), rbase->name()) << endmsg;
1269 }
1271 /* make a copy of the existing list of routes that feed r1 */
1275 /* for each route that feeds r1, recurse, marking it as feeding
1276 rbase as well.
1277 */
1281 /* (*i) went away, ignore it */
1283 }
1285 /* r2 is a route that feeds r1 which somehow feeds base. mark
1286 base as being fed by r2
1287 */
1293 /* 2nd level feedback loop detection. if r1 feeds or is fed by r2,
1294 stop here.
1295 */
1299 }
1301 /* now recurse, so that we can mark base as being fed by
1302 all routes that feed r2
1303 */
1306 }
1308 }
1309 }
1311 void
1313 {
1314 /* don't do anything here with signals emitted
1315 by Routes while we are being destroyed.
1316 */
1320 }
1322 {
1326 /* writer goes out of scope and forces update */
1327 }
1329 //route_graph->dump(1);
1331 #ifndef NDEBUG
1341 DEBUG_TRACE (DEBUG::Graph, string_compose ("\t%1 (sends only ? %2)\n", sf->name(), f->sends_only));
1342 }
1343 }
1344 }
1345 #endif
1347 }
1348 void
1350 {
1359 /* although routes can feed themselves, it will
1360 cause an endless recursive descent if we
1361 detect it. so don't bother checking for
1362 self-feeding.
1363 */
1367 }
1373 }
1374 }
1375 }
1379 }
1381 RouteSorter cmp;
1386 #ifndef NDEBUG
1391 }
1392 #endif
1394 }
1396 /** Find the route name starting with \a base with the lowest \a id.
1397 *
1398 * Names are constructed like e.g. "Audio 3" for base="Audio" and id=3.
1399 * The available route name with the lowest ID will be used, and \a id
1400 * will be set to the ID.
1401 *
1402 * \return false if a route name could not be found, and \a track_name
1403 * and \a id do not reflect a free route name.
1404 */
1405 bool
1407 {
1413 }
1420 }
1422 void
1424 {
1432 }
1433 }
1434 }
1438 {
1441 ChanCount existing_inputs;
1442 ChanCount existing_outputs;
1443 string port;
1444 RouteList new_routes;
1456 }
1466 }
1476 }
1482 }
1490 }
1492 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1497 }
1502 }
1506 error << string_compose (_("No more JACK ports are available. You will need to stop %1 and restart JACK with ports if you need this many tracks."), PROGRAM_NAME) << endmsg;
1508 }
1511 }
1513 failed:
1517 }
1520 }
1522 void
1525 {
1526 /* If both inputs and outputs are auto-connected to physical ports,
1527 use the max of input and output offsets to ensure auto-connected
1528 port numbers always match up (e.g. the first audio input and the
1529 first audio output of the route will have the same physical
1530 port number). Otherwise just use the lowest input or output
1531 offset possible.
1532 */
1555 string port;
1559 }
1564 }
1565 }
1566 }
1571 string port;
1579 }
1580 }
1585 }
1586 }
1587 }
1588 }
1592 }
1595 Session::new_audio_track (int input_channels, int output_channels, TrackMode mode, RouteGroup* route_group, uint32_t how_many)
1596 {
1599 ChanCount existing_inputs;
1600 ChanCount existing_outputs;
1601 string port;
1602 RouteList new_routes;
1614 }
1624 }
1637 }
1645 }
1651 }
1655 track->DiskstreamChanged.connect_same_thread (*this, boost::bind (&Session::resort_routes, this));
1661 }
1666 }
1672 }
1675 }
1677 failed:
1680 }
1683 }
1685 void
1687 {
1703 //do nothing ... only changes to remote id's are initiated by user
1704 }
1705 }
1709 }
1710 }
1713 RouteList
1714 Session::new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
1715 {
1718 ChanCount existing_inputs;
1719 ChanCount existing_outputs;
1720 string port;
1721 RouteList ret;
1732 }
1740 }
1750 }
1758 }
1764 }
1770 }
1773 }
1779 }
1784 }
1788 }
1790 failure:
1793 }
1797 }
1799 RouteList
1801 {
1803 RouteList ret;
1805 XMLTree tree;
1810 }
1822 /* generate a new name by adding a number to the end of the template name */
1825 /*NOTREACHED*/
1826 }
1828 /* set IO children to use the new name */
1833 }
1834 }
1844 }
1847 /* force input/output change signals so that the new diskstream
1848 picks up the configuration of the route. During session
1849 loading this normally happens in a different way.
1850 */
1853 }
1859 }
1864 }
1869 }
1872 }
1874 out:
1877 }
1880 }
1882 void
1884 {
1885 {
1891 /* if there is no control out and we're not in the middle of loading,
1892 resort the graph here. if there is a control out, we will resort
1893 toward the end of this method. if we are in the middle of loading,
1894 we will resort when done.
1895 */
1899 }
1900 }
1907 r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
1908 r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, _2, wpr));
1909 r->solo_isolated_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_isolated_changed, this, _1, wpr));
1910 r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
1911 r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
1912 r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
1916 }
1920 }
1924 tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
1926 tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
1927 }
1928 }
1934 /* relax */
1936 /* relax */
1941 }
1942 }
1945 }
1951 }
1955 }
1957 void
1959 {
1963 /* only tracks */
1969 }
1970 }
1971 }
1972 }
1974 void
1976 {
1980 /* only tracks */
1986 }
1987 }
1988 }
1989 }
1991 void
1993 {
1997 /* only tracks */
2003 }
2004 }
2005 }
2006 }
2008 void
2010 {
2014 /* only send tracks */
2019 }
2020 }
2023 }
2025 void
2026 Session::add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders)
2027 {
2030 }
2034 }
2040 }
2043 }
2046 }
2048 void
2050 {
2051 if (((route == _master_out) || (route == _monitor_out)) && !Config->get_allow_special_bus_removal()) {
2053 }
2055 {
2061 /* deleting the master out seems like a dumb
2062 idea, but its more of a UI policy issue
2063 than our concern.
2064 */
2068 }
2072 /* cancel control outs for all routes */
2076 }
2079 }
2081 /* writer goes out of scope, forces route list update */
2082 }
2087 // We need to disconnect the route's inputs and outputs
2092 /* if the route had internal sends sending to it, remove them */
2100 }
2101 }
2102 }
2107 /* flush references out of the graph
2108 */
2112 /* get rid of it from the dead wood collection in the route list manager */
2114 /* XXX i think this is unsafe as it currently stands, but i am not sure. (pd, october 2nd, 2006) */
2118 /* try to cause everyone to drop their references */
2126 /* save the new state of the world */
2130 }
2131 }
2133 void
2135 {
2137 }
2139 void
2141 {
2144 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2146 }
2151 /* new listen: disable all other listen */
2154 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2156 }
2158 }
2159 }
2161 _listen_cnt++;
2165 _listen_cnt--;
2166 }
2167 }
2168 void
2170 {
2174 /* should not happen */
2175 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2177 }
2184 }
2185 _solo_isolated_cnt++;
2187 _solo_isolated_cnt--;
2190 }
2191 }
2195 }
2196 }
2198 void
2200 {
2202 // session doesn't care about changes to soloed-by-others
2204 }
2207 // We know already
2209 }
2214 /* should not happen */
2215 error << string_compose (_("programming error: %1"), X_("invalid route weak ptr passed to route_solo_changed")) << endmsg;
2217 }
2226 }
2229 /* new solo: disable all other solos */
2231 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2233 }
2235 }
2236 }
2240 RouteList uninvolved;
2246 if ((*i) == route || (*i)->solo_isolated() || (*i)->is_master() || (*i)->is_monitor() || (*i)->is_hidden()) {
2248 }
2256 }
2258 }
2259 }
2264 }
2268 }
2269 }
2274 /* now notify that the mute state of the routes not involved in the signal
2275 pathway of the just-solo-changed route may have altered.
2276 */
2280 }
2284 }
2286 void
2288 {
2289 /* now figure out if anything that matters is soloed (or is "listening")*/
2297 }
2302 }
2306 listeners++;
2309 }
2310 }
2313 isolated++;
2314 }
2315 }
2320 }
2327 }
2328 }
2332 {
2339 }
2340 }
2342 }
2344 bool
2346 {
2352 }
2356 }
2357 }
2360 }
2364 {
2370 }
2371 }
2374 }
2378 {
2384 }
2385 }
2388 }
2392 {
2398 }
2399 }
2402 }
2404 /** If either end of the session range location marker lies inside the current
2405 * session extent, move it to the corresponding session extent.
2406 */
2407 void
2409 {
2412 }
2417 /* we don't have a session range yet; use this one (provided it is valid) */
2420 }
2422 /* update the existing session range */
2426 }
2431 }
2433 }
2434 }
2436 /** @return Extent of the session's contents; if the session is empty, the first value of
2437 * the pair will equal max_frames.
2438 */
2441 {
2448 // ignore tape tracks when getting extents
2450 }
2455 }
2458 }
2459 }
2462 }
2464 /* Region management */
2468 {
2483 }
2484 }
2485 }
2488 }
2490 int
2492 {
2497 }
2499 cerr << "There are " << relevant_regions.size() << " using " << srcs.size() << " sources" << endl;
2501 for (set<boost::shared_ptr<Region> >::iterator r = relevant_regions.begin(); r != relevant_regions.end(); ) {
2520 }
2524 {
2526 /* remove from the main source list */
2528 }
2534 }
2537 }
2539 int
2541 {
2549 }
2556 }
2557 }
2564 }
2566 /* Source Management */
2568 void
2570 {
2577 {
2580 }
2584 /* yay, new source */
2593 }
2594 }
2595 }
2596 }
2598 void
2600 {
2606 }
2608 {
2613 }
2614 }
2618 /* save state so we don't end up with a session file
2619 referring to non-existent sources.
2620 */
2623 }
2624 }
2628 {
2635 }
2638 }
2642 {
2652 }
2653 }
2655 }
2658 string
2659 Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
2660 {
2661 string look_for;
2665 /* note: we know (or assume) the old path is already valid */
2669 /* destructive file sources have a name of the form:
2671 /path/to/Tnnnn-NAME(%[LR])?.wav
2673 the task here is to replace NAME with the new name.
2674 */
2676 /* find last slash */
2678 string dir;
2679 string prefix;
2685 }
2689 /* '-' is not a legal character for the NAME part of the path */
2693 }
2705 /* non-destructive file sources have a name of the form:
2707 /path/to/NAME-nnnnn(%[LR])?.ext
2709 the task here is to replace NAME with the new name.
2710 */
2712 string dir;
2713 string suffix;
2718 /* find last slash */
2722 }
2726 /* '-' is not a legal character for the NAME part of the path */
2730 }
2734 // Suffix is now everything after the dash. Now we need to eliminate
2735 // the nnnnn part, which is done by either finding a '%' or a '.'
2740 }
2747 }
2759 }
2761 }
2765 }
2767 }
2770 }
2772 /** Return the full path (in some session directory) for a new within-session source.
2773 * \a name must be a session-unique name that does not contain slashes
2774 * (e.g. as returned by new_*_source_name)
2775 */
2776 string
2778 {
2791 }
2795 }
2799 {
2803 }
2805 /** Return a unique name based on \a base for a new internal audio source */
2806 string
2807 Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
2808 {
2809 string spath;
2813 string legalized;
2818 // Find a "version" of the base name that doesn't exist in any of the possible directories.
2842 }
2849 }
2863 }
2868 }
2869 }
2872 existing++;
2873 }
2875 }
2879 }
2887 }
2888 }
2891 }
2893 /** Create a new within-session audio source */
2895 Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
2896 {
2902 }
2904 /** Return a unique name based on \a base for a new internal MIDI source */
2905 string
2907 {
2911 string legalized;
2916 // Find a "version" of the file name that doesn't exist in any of the possible directories.
2932 existing++;
2933 }
2934 }
2938 }
2946 }
2947 }
2950 }
2953 /** Create a new within-session MIDI source */
2956 {
2957 /* try to use the existing write source for the track, to keep numbering sane
2958 */
2961 /*MidiTrack* mt = dynamic_cast<Track*> (track);
2962 assert (mt);
2963 */
2970 }
2971 }
2979 }
2982 void
2984 {
2987 }
2993 }
2996 }
2998 void
3000 {
3003 }
3009 }
3014 }
3016 void
3018 {
3022 }
3024 void
3026 {
3027 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3030 }
3032 void
3034 {
3040 }
3042 }
3044 void
3046 {
3047 SessionEvent* ev = new SessionEvent (SessionEvent::Audition, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
3050 }
3052 void
3054 {
3058 }
3059 }
3061 bool
3062 Session::RoutePublicOrderSorter::operator() (boost::shared_ptr<Route> a, boost::shared_ptr<Route> b)
3063 {
3066 }
3069 }
3071 }
3073 void
3075 {
3082 TapeFileMatcher tape_file_matcher;
3095 try
3096 {
3100 }
3102 {
3104 }
3105 }
3106 }
3107 }
3109 bool
3111 {
3112 /* can be called before we have an auditioner object */
3117 }
3118 }
3120 void
3122 {
3123 /* don't do this stuff if we are setting up connections
3124 from a set_state() call or creating new tracks. Ditto for deletion.
3125 */
3129 }
3131 /* every track/bus asked for this to be handled but it was deferred because
3132 we were connecting. do it now.
3133 */
3139 /* force all diskstreams to update their capture offset values to
3140 reflect any changes in latencies within the graph.
3141 */
3148 }
3149 }
3150 }
3152 nframes_t
3154 {
3171 /* impossible, but keep some gcc versions happy */
3175 /*NOTREACHED*/
3176 }
3182 }
3185 }
3187 void
3189 {
3190 {
3194 }
3199 }
3201 void
3203 {
3206 {
3214 }
3215 }
3219 }
3222 }
3226 {
3232 }
3233 }
3236 }
3238 void
3240 {
3246 }
3248 /** Ensures that all buffers (scratch, send, silent, etc) are allocated for
3249 * the given count with the current block size.
3250 */
3251 void
3253 {
3255 }
3257 void
3259 {
3262 }
3263 }
3265 uint32_t
3267 {
3268 /* this doesn't really loop forever. just think about it */
3276 }
3277 }
3279 /* none available, so resize and try again */
3282 }
3283 }
3285 uint32_t
3287 {
3288 /* this doesn't really loop forever. just think about it */
3296 }
3297 }
3299 /* none available, so resize and try again */
3302 }
3303 }
3305 uint32_t
3307 {
3308 /* this doesn't really loop forever. just think about it */
3316 }
3317 }
3319 /* none available, so resize and try again */
3322 }
3323 }
3325 void
3327 {
3330 }
3333 }
3335 }
3337 void
3339 {
3342 }
3345 }
3347 }
3349 void
3351 {
3354 }
3357 }
3359 }
3361 void
3363 {
3366 }
3367 }
3369 void
3371 {
3374 }
3375 }
3377 void
3379 {
3382 }
3383 }
3386 /* Named Selection management */
3390 {
3392 for (NamedSelectionList::iterator i = named_selections.begin(); i != named_selections.end(); ++i) {
3395 }
3396 }
3398 }
3400 void
3402 {
3403 {
3406 }
3411 }
3413 void
3415 {
3418 {
3421 NamedSelectionList::iterator i = find (named_selections.begin(), named_selections.end(), named_selection);
3427 }
3428 }
3432 }
3433 }
3435 void
3437 {
3443 }
3444 }
3445 }
3447 bool
3449 {
3455 }
3456 }
3459 }
3461 bool
3463 {
3466 }
3470 }
3473 }
3475 int
3477 {
3485 /* XXX this is wrong because itt.progress will keep returning to zero at the start
3486 of every track.
3487 */
3489 }
3490 }
3493 }
3499 {
3506 nframes_t position;
3507 nframes_t this_chunk;
3508 nframes_t to_do;
3509 BufferSet buffers;
3518 }
3522 // block all process callback handling
3526 /* call tree *MUST* hold route_lock */
3530 }
3532 /* external redirects will be a problem */
3536 }
3541 snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1);
3544 }
3545 }
3548 error << string_compose (_("too many bounced versions of playlist \"%1\""), playlist->name()) << endmsg;
3550 }
3555 }
3558 error << string_compose (_("cannot create new audio file \"%1\" for %2"), buf, track.name()) << endmsg;
3560 }
3563 }
3565 /* XXX need to flush all redirects */
3570 /* create a set of reasonably-sized buffers */
3574 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3578 }
3586 }
3589 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src, ++n) {
3595 }
3596 }
3597 }
3604 }
3613 for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
3619 }
3620 }
3622 /* construct a region to represent the bounced material */
3624 PropertyList plist;
3632 }
3634 out:
3636 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3641 }
3644 }
3647 for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
3652 }
3653 }
3658 }
3660 gain_t*
3662 {
3664 }
3666 pan_t**
3668 {
3670 }
3672 BufferSet&
3674 {
3676 #if 0
3683 }
3684 }
3687 #endif
3688 }
3690 BufferSet&
3692 {
3694 #if 0
3700 }
3703 #endif
3704 }
3706 BufferSet&
3708 {
3710 #if 0
3714 #endif
3715 }
3717 uint32_t
3719 {
3726 }
3727 }
3730 }
3732 uint32_t
3734 {
3741 }
3742 }
3745 }
3747 void
3749 {
3751 }
3753 void
3755 {
3758 }
3761 /* leave order keys as they are */
3763 }
3769 }
3773 /* this might not do anything */
3776 }
3778 /** @return true if there is at least one record-enabled track, otherwise false */
3779 bool
3781 {
3783 }
3785 /** Update the state of our rec-enabled tracks flag */
3786 void
3788 {
3796 }
3799 }
3807 }
3808 }
3810 void
3812 {
3813 Placement p;
3823 }
3829 }
3830 }
3832 void
3834 {
3835 /* cancel all solo or all listen when solo control mode changes */
3841 }
3842 }
3844 /** Called when anything about any of our route groups changes (membership, state etc.) */
3845 void
3847 {
3849 }
3853 {
3860 }
3864 }
3867 }
3871 {
3879 }
3884 }
3888 }
3889 }
3892 }
3894 void
3896 {
3901 }
3902 }
3904 void
3906 {
3911 }
3912 }
3914 void
3916 {
3921 }
3922 }
3924 void
3926 {
3931 }
3932 }
3934 nframes_t
3936 {
3938 }
3940 nframes_t
3942 {
3944 }
3946 void
3948 {
3951 }