Use a C++ bool constant

[ardour.git] / session_utils / common.cc

diff --git a/session_utils/common.cc b/session_utils/common.cc
index d7f92871b9e04a2e0247155263f3a7d21d920eb3..8d1cdec950d8afb39c3b9c8650701b23ef9b6efb 100644 (file)
--- a/session_utils/common.cc
+++ b/session_utils/common.cc
@@ -1,6 +1,6 @@
 #include <iostream>
 #include <cstdlib>
-
+#include <glibmm.h>
 
 #include "pbd/debug.h"
 #include "pbd/event_loop.h"
@@ -9,6 +9,8 @@
 #include "pbd/pthread_utils.h"
 
 #include "ardour/audioengine.h"
+#include "ardour/filename_extensions.h"
+#include "ardour/types.h"
 
 #include "common.h"
 
@@ -84,23 +86,26 @@ class MyEventLoop : public sigc::trackable, public EventLoop
 static MyEventLoop *event_loop;
 
 void
-SessionUtils::init ()
+SessionUtils::init (bool print_log)
 {
        if (!ARDOUR::init (false, true, localedir)) {
                cerr << "Ardour failed to initialize\n" << endl;
-               ::exit (1);
+               ::exit (EXIT_FAILURE);
        }
 
        event_loop = new MyEventLoop ("util");
        EventLoop::set_event_loop_for_thread (event_loop);
        SessionEvent::create_per_thread_pool ("util", 512);
 
-       test_receiver.listen_to (error);
-       test_receiver.listen_to (info);
-       test_receiver.listen_to (fatal);
-       test_receiver.listen_to (warning);
+       if (print_log) {
+               test_receiver.listen_to (error);
+               test_receiver.listen_to (info);
+               test_receiver.listen_to (fatal);
+               test_receiver.listen_to (warning);
+       }
 }
 
+// TODO return NULL, rather than exit() ?!
 static Session * _load_session (string dir, string state)
 {
        AudioEngine* engine = AudioEngine::create ();
@@ -110,11 +115,28 @@ static Session * _load_session (string dir, string state)
                ::exit (EXIT_FAILURE);
        }
 
+       engine->set_input_channels (256);
+       engine->set_output_channels (256);
+
+       float sr;
+       SampleFormat sf;
+
+       std::string s = Glib::build_filename (dir, state + statefile_suffix);
+       if (Session::get_info_from_path (s, sr, sf) == 0) {
+               if (engine->set_sample_rate (sr)) {
+                       std::cerr << "Cannot set session's samplerate.\n";
+                       return 0;
+               }
+       } else {
+               std::cerr << "Cannot get samplerate from session.\n";
+               return 0;
+       }
+
        init_post_engine ();
 
        if (engine->start () != 0) {
                std::cerr << "Cannot start Audio/MIDI engine\n";
-               ::exit (EXIT_FAILURE);
+               return 0;
        }
 
        Session* session = new Session (*engine, dir, state);
@@ -123,23 +145,26 @@ static Session * _load_session (string dir, string state)
 }
 
 Session *
-SessionUtils::load_session (string dir, string state)
+SessionUtils::load_session (string dir, string state, bool exit_at_failure)
 {
        Session* s = 0;
        try {
                s = _load_session (dir, state);
        } catch (failed_constructor& e) {
                cerr << "failed_constructor: " << e.what() << "\n";
-               exit (EXIT_FAILURE);
+               ::exit (EXIT_FAILURE);
        } catch (AudioEngine::PortRegistrationFailure& e) {
                cerr << "PortRegistrationFailure: " << e.what() << "\n";
-               exit (EXIT_FAILURE);
+               ::exit (EXIT_FAILURE);
        } catch (exception& e) {
                cerr << "exception: " << e.what() << "\n";
-               exit (EXIT_FAILURE);
+               ::exit (EXIT_FAILURE);
        } catch (...) {
                cerr << "unknown exception.\n";
-               exit (EXIT_FAILURE);
+               ::exit (EXIT_FAILURE);
+       }
+       if (!s && exit_at_failure) {
+               ::exit (EXIT_FAILURE);
        }
        return s;
 }