ExportMainDialog::~ExportMainDialog ()
{
- if (session) {
- session->release_export_handler();
- }
}
void
/* Init handler and profile manager */
handler = session->get_export_handler ();
+ status = session->get_export_status ();
profile_manager.reset (new ExportProfileManager (*session));
/* Selection range */
timespan_selector.CriticalSelectionChanged.connect (sigc::mem_fun (*this, &ExportMainDialog::update_warnings));
channel_selector.CriticalSelectionChanged.connect (sigc::mem_fun (*this, &ExportMainDialog::update_warnings));
+ status->Aborting.connect (sigc::mem_fun (*this, &ExportMainDialog::notify_errors));
update_warnings ();
}
}
void
-ExportMainDialog::close_dialog ()
+ExportMainDialog::notify_errors ()
{
- ExportStatus & status = session->export_status;
+ if (status->errors()) {
+ Glib::ustring txt = _("Export has been aborted due to an error!\nSee the Log for details.");
+ Gtk::MessageDialog msg (txt, false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
+ msg.run();
+ }
+}
- if (status.running) {
- status.abort();
+void
+ExportMainDialog::close_dialog ()
+{
+ if (status->running) {
+ status->abort();
}
hide_all ();
void
ExportMainDialog::show_progress ()
{
- ARDOUR::ExportStatus & status = session->export_status;
- status.running = true;
+ status->running = true;
cancel_button->set_label (_("Stop Export"));
rt_export_button->set_sensitive (false);
progress_connection = Glib::signal_timeout().connect (mem_fun(*this, &ExportMainDialog::progress_timeout), 100);
gtk_main_iteration ();
- while (status.running) {
+ while (status->running) {
if (gtk_events_pending()) {
gtk_main_iteration ();
} else {
gint
ExportMainDialog::progress_timeout ()
{
- ARDOUR::ExportStatus & status = session->export_status;
-
- switch (status.stage) {
+ switch (status->stage) {
case export_None:
progress_label.set_text ("");
break;
case export_ReadTimespan:
- progress_label.set_text (string_compose (_("Reading timespan %1 of %2"), status.timespan, status.total_timespans));
+ progress_label.set_text (string_compose (_("Reading timespan %1 of %2"), status->timespan, status->total_timespans));
break;
case export_PostProcess:
progress_label.set_text (string_compose (_("Processing file %2 of %3 (%1) from timespan %4 of %5"),
- get_nth_format_name (status.format),
- status.format, status.total_formats,
- status.timespan, status.total_timespans));
+ get_nth_format_name (status->format),
+ status->format, status->total_formats,
+ status->timespan, status->total_timespans));
break;
case export_Write:
progress_label.set_text (string_compose (_("Encoding file %2 of %3 (%1) from timespan %4 of %5"),
- get_nth_format_name (status.format),
- status.format, status.total_formats,
- status.timespan, status.total_timespans));
+ get_nth_format_name (status->format),
+ status->format, status->total_formats,
+ status->timespan, status->total_timespans));
break;
}
- progress_bar.set_fraction (status.progress);
+ progress_bar.set_fraction (status->progress);
return TRUE;
}
#ifndef __export_main_dialog_h__
#define __export_main_dialog_h__
+#include <boost/shared_ptr.hpp>
+
#include <ardour/export_handler.h>
#include <ardour/export_profile_manager.h>
class ExportFilename;
class ExportFormatSpecification;
class ExportChannelConfiguration;
+ class ExportStatus;
}
class ExportTimespanSelector;
};
private:
-
+
+ void notify_errors ();
void close_dialog ();
void sync_with_manager ();
typedef boost::shared_ptr<ARDOUR::ExportHandler> HandlerPtr;
typedef boost::shared_ptr<ARDOUR::ExportFormatSpecification> FormatPtr;
typedef boost::shared_ptr<ARDOUR::ExportProfileManager> ManagerPtr;
+ typedef boost::shared_ptr<ARDOUR::ExportStatus> StatusPtr;
void export_rt ();
void export_fw ();
PublicEditor & editor;
HandlerPtr handler;
ManagerPtr profile_manager;
+ StatusPtr status;
/*** GUI components ***/
private:
friend class ExportElementFactory;
- ExportChannelConfiguration (ExportStatus & status, Session & session);
+ ExportChannelConfiguration (Session & session);
public:
XMLNode & get_state ();
private:
+ typedef boost::shared_ptr<ExportStatus> ExportStatusPtr;
+
Session & session;
// processor has to be prepared before doing this.
static void * _write_files (void *arg);
WriterThread writer_thread;
ProcessorPtr processor;
- ExportStatus & status;
+ ExportStatusPtr status;
bool files_written;
class ExportFailed : public std::exception
{
public:
- ExportFailed (std::string const & reason, std::string const & description) :
- reason (reason.c_str()),
- description (description.c_str())
+ ExportFailed (std::string const & reason) :
+ reason (reason.c_str())
{
error << string_compose (_("Export failed: %1"), reason) << endmsg;
}
const char* what() const throw()
{
- return description;
+ return reason;
}
private:
const char * reason;
- const char * description;
};
#ifndef __ardour_export_file_io_h__
#define __ardour_export_file_io_h__
-#include <sndfile.h>
+#include <stdint.h>
+#include <utility>
+
+#include <boost/shared_ptr.hpp>
+#include <glibmm/ustring.h>
+#include <ardour/sndfile_helpers.h>
#include <ardour/graph.h>
#include <ardour/types.h>
#include <ardour/ardour.h>
+#include <ardour/export_format_specification.h>
+#include <ardour/export_utilities.h>
+
+using Glib::ustring;
namespace ARDOUR
{
class ExportFileWriter
{
public:
- ExportFileWriter (string filename) : _filename (filename) {}
virtual ~ExportFileWriter () {}
-
+
string filename () const { return _filename; }
nframes_t position () const { return _position; }
void set_position (nframes_t position) { _position = position; }
protected:
+ ExportFileWriter (string filename) : _filename (filename) {}
+
string _filename;
nframes_t _position;
};
class SndfileWriterBase : public ExportFileWriter
{
public:
- SndfileWriterBase (int channels, nframes_t samplerate, int format, string const & path);
- virtual ~SndfileWriterBase ();
SNDFILE * get_sndfile () const { return sndfile; }
protected:
+ SndfileWriterBase (int channels, nframes_t samplerate, int format, string const & path);
+ virtual ~SndfileWriterBase ();
+
SF_INFO sf_info;
SNDFILE * sndfile;
};
template <typename T>
class SndfileWriter : public SndfileWriterBase, public GraphSink<T>
{
- public:
+ protected:
+ // Should only be created vie ExportFileFactory and derived classes
+ friend class ExportFileFactory;
SndfileWriter (int channels, nframes_t samplerate, int format, string const & path);
- virtual ~SndfileWriter () {}
-
+
+ public:
nframes_t write (T * data, nframes_t frames);
-
+ virtual ~SndfileWriter () {}
+
protected:
+
sf_count_t (*write_func)(SNDFILE *, const T *, sf_count_t);
private:
};
+class ExportFileFactory
+{
+ public:
+ typedef boost::shared_ptr<ExportFormatSpecification const> FormatPtr;
+ typedef GraphSink<float> FloatSink;
+ typedef boost::shared_ptr<FloatSink> FloatSinkPtr;
+ typedef boost::shared_ptr<ExportFileWriter> FileWriterPtr;
+
+ typedef std::pair<FloatSinkPtr, FileWriterPtr> FilePair;
+
+ static FilePair create (FormatPtr format, uint32_t channels, ustring const & filename);
+ static bool check (FormatPtr format, uint32_t channels);
+
+ private:
+
+ static FilePair create_sndfile (FormatPtr format, unsigned int channels, ustring const & filename);
+ static bool check_sndfile (FormatPtr format, unsigned int channels);
+};
+
} // namespace ARDOUR
#endif /* __ardour_export_file_io_h__ */
ExportFormatOggVorbis ();
~ExportFormatOggVorbis () {};
+ static bool check_system_compatibility ();
+
bool set_compatibility_state (ExportFormatCompatibility const & compatibility);
Type get_type () const { return T_Sndfile; }
SampleFormat get_explicit_sample_format () const { return SF_Vorbis; }
ExportFormatFLAC ();
~ExportFormatFLAC () {};
+ static bool check_system_compatibility ();
+
bool set_compatibility_state (ExportFormatCompatibility const & compatibility);
Type get_type () const { return T_Sndfile; }
typedef std::multimap<TimespanPtr, FileSpec> ConfigMap;
typedef boost::shared_ptr<ExportProcessor> ProcessorPtr;
+ typedef boost::shared_ptr<ExportStatus> StatusPtr;
private:
/* Session::get_export_handler() should be used to obtain an export handler
Session & session;
ProcessorPtr processor;
+ StatusPtr export_status;
ConfigMap config_map;
bool realtime;
typedef boost::shared_ptr<Normalizer> NormalizerPtr;
typedef boost::shared_ptr<ExportTempFile> TempFilePtr;
- typedef boost::shared_ptr<SampleFormatConverter<short> > ShortConverterPtr;
- typedef boost::shared_ptr<SampleFormatConverter<int> > IntConverterPtr;
- typedef boost::shared_ptr<SampleFormatConverter<float> > FloatConverterPtr;
-
- typedef boost::shared_ptr<SndfileWriter<short> > ShortWriterPtr;
- typedef boost::shared_ptr<SndfileWriter<int> > IntWriterPtr;
- typedef boost::shared_ptr<SndfileWriter<float> > FloatWriterPtr;
-
typedef GraphSink<float> FloatSink;
typedef boost::shared_ptr<FloatSink> FloatSinkPtr;
typedef std::vector<FloatSinkPtr> FloatSinkVect;
private:
void reset ();
- FloatSinkPtr prepare_sndfile_writer (FormatPtr format, uint32_t channels, ustring const & filename);
- Session & session;
- ExportStatus & status;
+ Session & session;
+ boost::shared_ptr<ExportStatus> status;
/* these are initalized in prepare() */
volatile bool running;
sigc::signal<void> Aborting;
- void abort () { _aborted = true; Aborting(); }
+ void abort (bool error_occurred = false);
bool aborted () const { return _aborted; }
+ bool errors () const { return _errors; }
+
+ sigc::signal<void> Finished;
+ void finish ();
+ bool finished () const { return _aborted; }
/* Progress info */
private:
volatile bool _aborted;
+ volatile bool _errors;
+ volatile bool _finished;
+
};
} // namespace ARDOUR
typedef boost::shared_ptr<ExportTempFile> TempFilePtr;
typedef std::pair<ExportChannel const, TempFilePtr> ChannelFilePair;
typedef std::map<ExportChannel const, TempFilePtr> TempFileMap;
+ typedef boost::shared_ptr<ExportStatus> ExportStatusPtr;
private:
friend class ExportElementFactory;
- ExportTimespan (ExportStatus & status, nframes_t frame_rate);
+ ExportTimespan (ExportStatusPtr status, nframes_t frame_rate);
public:
~ExportTimespan ();
private:
- ExportStatus & status;
+ ExportStatusPtr status;
nframes_t start_frame;
nframes_t end_frame;
#include <ardour/ardour.h>
#include <ardour/configuration.h>
-#include <ardour/export_status.h>
#include <ardour/location.h>
#include <ardour/gain.h>
#include <ardour/io.h>
class SessionDirectory;
class SessionMetadata;
class ExportHandler;
+class ExportStatus;
struct RouteGroup;
bool sample_rate_convert (import_status&, string infile, string& outfile);
string build_tmp_convert_name (string file);
- /* Export stuff */
-
- SlaveSource post_export_slave;
- nframes_t post_export_position;
-
- ExportStatus export_status;
-
boost::shared_ptr<ExportHandler> get_export_handler ();
- void release_export_handler ();
+ boost::shared_ptr<ExportStatus> get_export_status ();
- int pre_export ();
- int start_audio_export (nframes_t position, bool realtime);
- int stop_audio_export ();
- void finalize_audio_export ();
- void abort_audio_export ();
+ int start_audio_export (nframes_t position, bool realtime);
sigc::signal<int, nframes_t> ProcessExport;
- sigc::signal<void> ExportFinished;
+ sigc::signal<void> ExportReadFinished;
static sigc::signal<void, std::string, std::string> Exported;
- sigc::connection export_freewheel_connection;
- sigc::connection export_abort_connection;
void add_source (boost::shared_ptr<Source>);
void remove_source (boost::weak_ptr<Source>);
bool follow_slave (nframes_t, nframes_t);
void set_slave_source (SlaveSource);
+ SlaveSource post_export_slave;
+ nframes_t post_export_position;
+
bool _exporting;
bool _exporting_realtime;
+
boost::shared_ptr<ExportHandler> export_handler;
+ boost::shared_ptr<ExportStatus> export_status;
+
+ int pre_export ();
+ int stop_audio_export ();
+ void finalize_audio_export ();
+
+ sigc::connection export_freewheel_connection;
+ sigc::connection export_abort_connection;
void prepare_diskstreams ();
void commit_diskstreams (nframes_t, bool& session_requires_butler);
/* ExportChannelConfiguration */
-ExportChannelConfiguration::ExportChannelConfiguration (ExportStatus & status, Session & session) :
+ExportChannelConfiguration::ExportChannelConfiguration (Session & session) :
session (session),
writer_thread (*this),
- status (status),
+ status (session.get_export_status ()),
files_written (false),
split (false)
{
files_written = true;
if (!timespan) {
- throw ExportFailed (_("Export failed due to a programming error"), _("No timespan registered to channel configuration when requesting files to be written"));
+ throw ExportFailed (X_("Programming error: No timespan registered to channel configuration when requesting files to be written"));
}
/* Take a local copy of the processor to be used in the thread that is created below */
uint32_t channel;
do {
- if (status.aborted()) { break; }
+ if (status->aborted()) { break; }
channel = 0;
for (ChannelList::iterator it = channels.begin(); it != channels.end(); ++it) {
}
progress += frames_read;
- status.progress = (float) progress / timespan_length;
+ status->progress = (float) progress / timespan_length;
} while (processor->process (file_buffer, frames_read) > 0);
// cc can be trated like 'this'
WriterThread & cc (*((WriterThread *) arg));
- for (FileConfigList::iterator it = cc->file_configs.begin(); it != cc->file_configs.end(); ++it) {
- if (cc->status.aborted()) {
- break;
+ try {
+ for (FileConfigList::iterator it = cc->file_configs.begin(); it != cc->file_configs.end(); ++it) {
+ if (cc->status->aborted()) {
+ break;
+ }
+ cc->processor->prepare (it->first, it->second, cc->channels.size(), cc->split, cc->timespan->get_start());
+ cc->write_file (); // Writes tempfile
+ cc->processor->prepare_post_processors ();
+ cc->processor->write_files();
}
- cc->processor->prepare (it->first, it->second, cc->channels.size(), cc->split, cc->timespan->get_start());
- cc->write_file (); // Writes tempfile
- cc->processor->prepare_post_processors ();
- cc->processor->write_files();
+ } catch (ExportFailed & e) {
+ cc->status->abort (true);
}
cc.running = false;
#include <string.h>
#include <ardour/export_file_io.h>
+
#include <ardour/export_failed.h>
#include <pbd/failed_constructor.h>
sf_info.format = format;
if (!sf_format_check (&sf_info)) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid format given for SndfileWriter!");
+ throw ExportFailed (X_("Invalid format given for SndfileWriter!"));
}
if (path.length() == 0) {
- throw ExportFailed (_("Export failed due to a programming error"), "No output file specified for SndFileWriter");
+ throw ExportFailed (X_("No output file specified for SndFileWriter"));
}
/* TODO add checks that the directory path exists, and also
if (path.compare ("temp")) {
if ((sndfile = sf_open (path.c_str(), SFM_WRITE, &sf_info)) == 0) {
sf_error_str (0, errbuf, sizeof (errbuf) - 1);
- throw ExportFailed (string_compose(_("Export: cannot open output file \"%1\""), path),
- string_compose(_("Export: cannot open output file \"%1\" for SndFileWriter (%2)"), path, errbuf));
+ throw ExportFailed (string_compose(X_("Cannot open output file \"%1\" for SndFileWriter (%2)"), path, errbuf));
}
} else {
FILE * file;
if (!(file = tmpfile ())) {
- throw ExportFailed (_("Export failed due to a programming error"), "Cannot open tempfile");
+ throw ExportFailed (X_("Cannot open tempfile"));
}
sndfile = sf_open_fd (fileno(file), SFM_RDWR, &sf_info, true);
}
nframes_t written = (*write_func) (sndfile, data, frames);
if (written != frames) {
sf_error_str (sndfile, errbuf, sizeof (errbuf) - 1);
- throw ExportFailed (_("Writing export file failed"), string_compose(_("Could not write data to output file (%1)"), errbuf));
+ throw ExportFailed (string_compose(_("Could not write data to output file (%1)"), errbuf));
}
if (GraphSink<T>::end_of_input) {
/* Check for errors */
if (read_status != to_read) {
- throw ExportFailed (_("Reading export file failed"), _("Error reading temporary export file, export might not be complete!"));
+ throw ExportFailed (X_("Error reading temporary export file, export might not be complete!"));
}
/* Add silence at end */
return sf_readf_float (sndfile, data, frames);
}
-};
+ExportFileFactory::FilePair
+ExportFileFactory::create (FormatPtr format, uint32_t channels, ustring const & filename)
+{
+ switch (format->type()) {
+ case ExportFormatBase::T_Sndfile:
+ return create_sndfile (format, channels, filename);
+
+ default:
+ throw ExportFailed (X_("Invalid format given for ExportFileFactory::create!"));
+ }
+}
+
+bool
+ExportFileFactory::check (FormatPtr format, uint32_t channels)
+{
+ switch (format->type()) {
+ case ExportFormatBase::T_Sndfile:
+ return check_sndfile (format, channels);
+
+ default:
+ throw ExportFailed (X_("Invalid format given for ExportFileFactory::check!"));
+ }
+}
+
+ExportFileFactory::FilePair
+ExportFileFactory::create_sndfile (FormatPtr format, unsigned int channels, ustring const & filename)
+{
+ typedef boost::shared_ptr<SampleFormatConverter<short> > ShortConverterPtr;
+ typedef boost::shared_ptr<SampleFormatConverter<int> > IntConverterPtr;
+ typedef boost::shared_ptr<SampleFormatConverter<float> > FloatConverterPtr;
+
+ typedef boost::shared_ptr<SndfileWriter<short> > ShortWriterPtr;
+ typedef boost::shared_ptr<SndfileWriter<int> > IntWriterPtr;
+ typedef boost::shared_ptr<SndfileWriter<float> > FloatWriterPtr;
+
+ FilePair ret;
+
+ int real_format = format->format_id() | format->sample_format() | format->endianness();
+
+ uint32_t data_width = sndfile_data_width (real_format);
+
+ if (data_width == 8 || data_width == 16) {
+
+ ShortConverterPtr sfc = ShortConverterPtr (new SampleFormatConverter<short> (channels, format->dither_type(), data_width));
+ ShortWriterPtr sfw = ShortWriterPtr (new SndfileWriter<short> (channels, format->sample_rate(), real_format, filename));
+ sfc->pipe_to (sfw);
+
+ return std::make_pair (boost::static_pointer_cast<FloatSink> (sfc), boost::static_pointer_cast<ExportFileWriter> (sfw));
+
+ } else if (data_width == 24 || data_width == 32) {
+
+ IntConverterPtr sfc = IntConverterPtr (new SampleFormatConverter<int> (channels, format->dither_type(), data_width));
+ IntWriterPtr sfw = IntWriterPtr (new SndfileWriter<int> (channels, format->sample_rate(), real_format, filename));
+ sfc->pipe_to (sfw);
+
+ return std::make_pair (boost::static_pointer_cast<FloatSink> (sfc), boost::static_pointer_cast<ExportFileWriter> (sfw));
+
+ } else {
+
+ FloatConverterPtr sfc = FloatConverterPtr (new SampleFormatConverter<float> (channels, format->dither_type(), data_width));
+ FloatWriterPtr sfw = FloatWriterPtr (new SndfileWriter<float> (channels, format->sample_rate(), real_format, filename));
+ sfc->pipe_to (sfw);
+
+ return std::make_pair (boost::static_pointer_cast<FloatSink> (sfc), boost::static_pointer_cast<ExportFileWriter> (sfw));;
+ }
+}
+
+bool
+ExportFileFactory::check_sndfile (FormatPtr format, unsigned int channels)
+{
+ SF_INFO sf_info;
+ sf_info.channels = channels;
+ sf_info.samplerate = format->sample_rate ();
+ sf_info.format = format->format_id () | format->sample_format ();
+
+ return (sf_format_check (&sf_info) == SF_TRUE ? true : false);
+}
+
+} // namespace ARDOUR
fl_ptr->set_extension ("raw");
add_format (f_ptr);
- f_ptr.reset (new ExportFormatOggVorbis ());
- add_format (f_ptr);
+ if (ExportFormatOggVorbis::check_system_compatibility()) {
+ f_ptr.reset (new ExportFormatOggVorbis ());
+ add_format (f_ptr);
+ }
- f_ptr.reset (new ExportFormatFLAC ());
- add_format (f_ptr);
+ if (ExportFormatFLAC::check_system_compatibility()) {
+ f_ptr.reset (new ExportFormatFLAC ());
+ add_format (f_ptr);
+ }
}
void
set_quality (Q_LossyCompression);
}
+bool
+ExportFormatOggVorbis::check_system_compatibility ()
+{
+ SF_INFO sf_info;
+ sf_info.channels = 2;
+ sf_info.samplerate = SR_44_1;
+ sf_info.format = F_Ogg | SF_Vorbis;
+
+ return (sf_format_check (&sf_info) == SF_TRUE ? true : false);
+}
+
bool
ExportFormatOggVorbis::set_compatibility_state (ExportFormatCompatibility const & compatibility)
{
set_quality (Q_LosslessCompression);
}
+bool
+ExportFormatFLAC::check_system_compatibility ()
+{
+ SF_INFO sf_info;
+ sf_info.channels = 2;
+ sf_info.samplerate = SR_44_1;
+ sf_info.format = F_FLAC | SF_16;
+
+ return (sf_format_check (&sf_info) == SF_TRUE ? true : false);
+}
+
bool
ExportFormatFLAC::set_compatibility_state (ExportFormatCompatibility const & compatibility)
{
ExportElementFactory::TimespanPtr
ExportElementFactory::add_timespan ()
{
- return TimespanPtr (new ExportTimespan (session.export_status, session.frame_rate()));
+ return TimespanPtr (new ExportTimespan (session.get_export_status(), session.frame_rate()));
}
ExportElementFactory::ChannelConfigPtr
ExportElementFactory::add_channel_config ()
{
- return ChannelConfigPtr (new ExportChannelConfiguration (session.export_status, session));
+ return ChannelConfigPtr (new ExportChannelConfiguration (session));
}
ExportElementFactory::FormatPtr
ExportHandler::ExportHandler (Session & session) :
ExportElementFactory (session),
session (session),
+ export_status (session.get_export_status ()),
realtime (false)
{
processor.reset (new ExportProcessor (session));
ExportHandler::~ExportHandler ()
{
- if (session.export_status.aborted()) {
+ if (export_status->aborted()) {
for (std::list<Glib::ustring>::iterator it = files_written.begin(); it != files_written.end(); ++it) {
sys::remove (sys::path (*it));
}
* 1. Session is prepared in do_export
* 2. start_timespan is called, which then registers all necessary channel configs to a timespan
* 3. The timespan reads each unique channel into a tempfile and calls Session::stop_export when the end is reached
- * 4. stop_export emits ExportFinished after stopping the transport, this ends up calling finish_timespan
+ * 4. stop_export emits ExportReadFinished after stopping the transport, this ends up calling finish_timespan
* 5. finish_timespan registers all the relevant formats and filenames to relevant channel configurations
* 6. finish_timespan does a manual call to timespan_thread_finished, which gets the next channel configuration
* for the current timespan, calling write_files for it
{
/* Count timespans */
- ExportStatus & status = session.export_status;
- status.init();
+ export_status->init();
std::set<TimespanPtr> timespan_set;
for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) {
timespan_set.insert (it->first);
}
- status.total_timespans = timespan_set.size();
+ export_status->total_timespans = timespan_set.size();
/* Start export */
realtime = rt;
- session.ExportFinished.connect (sigc::mem_fun (*this, &ExportHandler::finish_timespan));
- session.pre_export ();
+ session.ExportReadFinished.connect (sigc::mem_fun (*this, &ExportHandler::finish_timespan));
start_timespan ();
}
void
ExportHandler::start_timespan ()
{
- session.export_status.timespan++;
+ export_status->timespan++;
if (config_map.empty()) {
- session.finalize_audio_export();
+ export_status->finish ();
return;
}
/* Register formats and filenames to relevant channel configs */
- session.export_status.total_formats = 0;
- session.export_status.format = 0;
+ export_status->total_formats = 0;
+ export_status->format = 0;
for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
- session.export_status.total_formats++;
+ export_status->total_formats++;
/* Setup filename */
TimespanNodePtr ts_node;
if (!(ts_node = boost::dynamic_pointer_cast<TimespanNode> (*tsl_it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
TimespanListPtr ts_list = ts_node->data()->timespans;
ChannelConfigNode * cc_node;
if (!(cc_node = dynamic_cast<ChannelConfigNode *> (*cc_it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
ChannelConfigPtr channel_config = cc_node->data()->config;
FormatNode * f_node;
if (!(f_node = dynamic_cast<FormatNode *> (*f_it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
FormatPtr format = f_node->data()->format;
FilenameNode * fn_node;
if (!(fn_node = dynamic_cast<FilenameNode *> (*fn_it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
FilenamePtr filename = fn_node->data()->filename;
ChannelConfigNode * node_insertion_ptr;
if (!insertion_point) { insertion_point = source->last_child(); }
if (!(node_insertion_ptr = dynamic_cast<ChannelConfigNode *> (insertion_point))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
node_insertion_point = node_insertion_ptr->self_ptr();
ChannelConfigNodePtr new_node;
if (!(node = dynamic_cast<ChannelConfigNode *> (*it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
new_node = duplicate_channel_config_node (node->self_ptr());
FormatNode * node_insertion_ptr;
if (!insertion_point) { insertion_point = source->last_child(); }
if (!(node_insertion_ptr = dynamic_cast<FormatNode *> (insertion_point))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
node_insertion_point = node_insertion_ptr->self_ptr();
FormatNodePtr new_node;
if (!(node = dynamic_cast<FormatNode *> (*it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
new_node = duplicate_format_node (node->self_ptr());
FilenameNode * node_insertion_ptr;
if (!insertion_point) { insertion_point = source->last_child(); }
if (!(node_insertion_ptr = dynamic_cast<FilenameNode *> (insertion_point))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
node_insertion_point = node_insertion_ptr->self_ptr();
FilenameNodePtr new_node;
if (!(node = dynamic_cast<FilenameNode *> (*it))) {
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid pointer cast in ExportProfileManager");
+ throw ExportFailed (X_("Programming error, Invalid pointer cast in ExportProfileManager"));
}
new_node = duplicate_filename_node (node->self_ptr());
#include <ardour/export_filename.h>
#include <ardour/export_status.h>
#include <ardour/export_format_specification.h>
-#include <ardour/sndfile_helpers.h>
#include "i18n.h"
ExportProcessor::ExportProcessor (Session & session) :
session (session),
- status (session.export_status),
+ status (session.get_export_status()),
blocksize (session.get_block_size()),
frame_rate (session.frame_rate())
{
int
ExportProcessor::prepare (FormatPtr format, FilenamePtr fname, uint32_t chans, bool split, nframes_t start)
{
- session.export_status.format++;
+ status->format++;
temp_file_length = 0;
/* Reset just to be sure all references are dropped */
/* Construct export pipe to temp file */
- status.stage = export_PostProcess;
+ status->stage = export_PostProcess;
if (normalize) {
/* Normalizing => we need a normalizer, peak reader and tempfile */
src->pipe_to (temp_file);
}
- /* File writer(s) */
-
- FloatSinkPtr (ExportProcessor::*prep_function) (FormatPtr, uint32_t, ustring const &);
-
- switch (format->type()) {
- case ExportFormatBase::T_Sndfile:
- prep_function = &ExportProcessor::prepare_sndfile_writer;
- break;
-
- default:
- throw ExportFailed (_("Export failed due to a programming error"), "Invalid format given for ExportProcessor::prepare!");
- break;
-
- }
-
/* Ensure directory exists */
sys::path folder (filename->get_folder());
if (!sys::exists (folder)) {
if (!sys::create_directory (folder)) {
- throw ExportFailed ("Export could not create the directory you requested for", "sys::create_directory failed for export dir");
+ throw ExportFailed (X_("sys::create_directory failed for export dir"));
}
}
filename->include_channel = true;
for (uint32_t chn = 1; chn <= channels; ++chn) {
filename->set_channel (chn);
- file_sinks.push_back ((this->*prep_function) (format, 1, filename->get_path (format)));
+ ExportFileFactory::FilePair pair = ExportFileFactory::create (format, 1, filename->get_path (format));
+ file_sinks.push_back (pair.first);
+ writer_list.push_back (pair.second);
WritingFile (filename->get_path (format));
}
} else {
- file_sinks.push_back ((this->*prep_function) (format, channels, filename->get_path (format)));
+ ExportFileFactory::FilePair pair = ExportFileFactory::create (format, channels, filename->get_path (format));
+ file_sinks.push_back (pair.first);
+ writer_list.push_back (pair.second);
WritingFile (filename->get_path (format));
}
{
/* Write to disk */
- status.stage = export_Write;
+ status->stage = export_Write;
temp_file_position = 0;
uint32_t buffer_size = 4096; // TODO adjust buffer size?
disk_sink->write (chan_bufs[channel], frames_read);
}
- if (status.aborted()) { break; }
+ if (status->aborted()) { break; }
temp_file_position += frames_read;
- status.progress = (float) temp_file_position / temp_file_length;
+ status->progress = (float) temp_file_position / temp_file_length;
}
/* Clean up */
while ((frames_read = temp_file->read (buf, buffer_size)) > 0) {
disk_sink->write (buf, frames_read);
- if (status.aborted()) { break; }
+ if (status->aborted()) { break; }
temp_file_position += frames_read;
- status.progress = (float) temp_file_position / temp_file_length;
+ status->progress = (float) temp_file_position / temp_file_length;
}
}
}
}
-ExportProcessor::FloatSinkPtr
-ExportProcessor::prepare_sndfile_writer (FormatPtr format, uint32_t channels, ustring const & filename)
-{
- int real_format = format->format_id() | format->sample_format() | format->endianness();
-
- uint32_t data_width = sndfile_data_width (real_format);
-
- if (data_width == 8 || data_width == 16) {
-
- ShortConverterPtr sfc = ShortConverterPtr (new SampleFormatConverter<short> (channels, format->dither_type(), data_width));
- ShortWriterPtr sfw = ShortWriterPtr (new SndfileWriter<short> (channels, format->sample_rate(), real_format, filename));
-
- writer_list.push_back (boost::static_pointer_cast<ExportFileWriter> (sfw));
-
- sfc->pipe_to (sfw);
- return boost::static_pointer_cast<FloatSink> (sfc);
-
- } else if (data_width == 24 || data_width == 32) {
-
- IntConverterPtr sfc = IntConverterPtr (new SampleFormatConverter<int> (channels, format->dither_type(), data_width));
- IntWriterPtr sfw = IntWriterPtr (new SndfileWriter<int> (channels, format->sample_rate(), real_format, filename));
-
- writer_list.push_back (boost::static_pointer_cast<ExportFileWriter> (sfw));
-
- sfc->pipe_to (sfw);
- return boost::static_pointer_cast<FloatSink> (sfc);
-
- } else {
-
- FloatConverterPtr sfc = FloatConverterPtr (new SampleFormatConverter<float> (channels, format->dither_type(), data_width));
- FloatWriterPtr sfw = FloatWriterPtr (new SndfileWriter<float> (channels, format->sample_rate(), real_format, filename));
-
- writer_list.push_back (boost::static_pointer_cast<ExportFileWriter> (sfw));
-
- sfc->pipe_to (sfw);
- return boost::static_pointer_cast<FloatSink> (sfc);
- }
-
-}
-
}; // namespace ARDOUR
#include <pbd/convert.h>
#include <ardour/export_failed.h>
+#include <ardour/export_file_io.h>
#include <ardour/export_format_specification.h>
#include <ardour/export_timespan.h>
#include <ardour/export_channel_configuration.h>
/* Check format and maximum channel count */
if (!format || !format->type()) {
warnings->errors.push_back (_("No format selected!"));
+ } else if (!ExportFileFactory::check (format, channel_config->get_n_chans())) {
+ warnings->errors.push_back (_("One or more of the selected formats is not compatible with this system!"));
} else if (format->channel_limit() < channel_config->get_n_chans()) {
warnings->errors.push_back
(string_compose (_("%1 supports only %2 channels, but you have %3 channels in your channel configuration"),
stop = false;
running = false;
_aborted = false;
+ _finished = false;
+ _errors = false;
stage = export_None;
progress = 0.0;
format = 0;
}
+void
+ExportStatus::abort (bool error_occurred)
+{
+ _aborted = true;
+ _finished = true;
+ _errors = _errors || error_occurred;
+ Aborting ();
+}
+
+void
+ExportStatus::finish ()
+{
+ _finished = true;
+ Finished();
+}
+
} // namespace ARDOUR
namespace ARDOUR
{
-ExportTimespan::ExportTimespan (ExportStatus & status, nframes_t frame_rate) :
+ExportTimespan::ExportTimespan (ExportStatusPtr status, nframes_t frame_rate) :
status (status),
start_frame (0),
end_frame (0),
{
TempFileMap::iterator it = filemap.find (channel);
if (it == filemap.end()) {
- throw ExportFailed (_("Export failed due to programming error"), _("Trying to get data from ExportTimespan for channel that was never registered!"));
+ throw ExportFailed (X_("Trying to get data from ExportTimespan for channel that was never registered!"));
}
return it->second->read (data, frames);
int
ExportTimespan::process (nframes_t frames)
{
- status.stage = export_ReadTimespan;
+ status->stage = export_ReadTimespan;
/* update position */
frames_to_read = frames;
} else {
frames_to_read = end_frame - position;
- status.stop = true;
+ status->stop = true;
}
position += frames_to_read;
- status.progress = (float) (position - start_frame) / (end_frame - start_frame);
+ status->progress = (float) (position - start_frame) / (end_frame - start_frame);
/* Read channels from ports and save to tempfiles */
int err;
if ((src_state = src_new (quality, channels, &err)) == 0) {
- throw ExportFailed (string_compose (_("cannot initialize sample rate conversion: %1"), src_strerror (err)), "Cannot initialize sample rate conversion");
+ throw ExportFailed (string_compose (X_("Cannot initialize sample rate conversion: %1"), src_strerror (err)));
}
src_data.src_ratio = out_rate / (double) in_rate;
max_leftover_frames = 4 * frames;
leftover_data = (float *) realloc (leftover_data, max_leftover_frames * channels * sizeof (float));
if (!leftover_data) {
- throw ExportFailed (_("A memory allocation error occured during sample rate conversion"), "Samplerate conversion failed");
+ throw ExportFailed (X_("A memory allocation error occured during sample rate conversion"));
}
data_out_size = out_samples_max;
++cnt;
if ((err = src_process (src_state, &src_data)) != 0) {
- throw ExportFailed (_("an error occured during sample rate conversion"), string_compose ("an error occured during sample rate conversion: %1", src_strerror (err)));
+ throw ExportFailed (string_compose ("An error occured during sample rate conversion: %1", src_strerror (err)));
}
frames_out = src_data.output_frames_gen;
#include <ardour/export_file_io.h>
#include <ardour/export_utilities.h>
#include <ardour/export_handler.h>
+#include <ardour/export_status.h>
#include <ardour/timestamps.h>
#include <ardour/ardour.h>
#include <ardour/session.h>
return export_handler;
}
-void
-Session::release_export_handler ()
+boost::shared_ptr<ExportStatus>
+Session::get_export_status ()
{
- if (!_exporting) {
- export_handler.reset();
+ if (!export_status) {
+ export_status.reset (new ExportStatus ());
}
+
+ return export_status;
}
int
Session::pre_export ()
{
+ get_export_status (); // Init export_status
wait_till_butler_finished ();
Config->set_slave_source (None);
_exporting = true;
- export_status.running = true;
- export_abort_connection = export_status.Aborting.connect (sigc::mem_fun (*this, &Session::abort_audio_export));
+ export_status->running = true;
+ export_abort_connection = export_status->Aborting.connect (sigc::hide_return (sigc::mem_fun (*this, &Session::stop_audio_export)));
return 0;
}
int
Session::start_audio_export (nframes_t position, bool realtime)
{
+ if (!_exporting) {
+ pre_export ();
+ }
+
/* get everyone to the right position */
{
_transport_frame = position;
_exporting_realtime = realtime;
- export_status.stop = false;
+ export_status->stop = false;
/* get transport ready. note how this is calling butler functions
from a non-butler thread. we waited for the butler to stop
{
try {
- if (export_status.stop) {
+ if (export_status->stop) {
stop_audio_export ();
return;
}
ProcessExport (nframes);
} catch (ExportFailed e) {
-
- std::cerr << e.what() << std::endl;
- stop_audio_export();
- finalize_audio_export();
-
+ export_status->abort (true);
}
}
realtime_stop (true);
schedule_butler_transport_work ();
- if (!export_status.aborted()) {
- ExportFinished ();
+ if (!export_status->aborted()) {
+ ExportReadFinished ();
+ }
+
+ if (export_status->finished()) {
+ finalize_audio_export ();
}
return 0;
Session::finalize_audio_export ()
{
_exporting = false;
- export_status.running = false;
+ export_status->running = false;
if (!_exporting_realtime) {
_engine.freewheel (false);
/* Clean up */
ProcessExport.clear();
- ExportFinished.clear();
+ ExportReadFinished.clear();
export_freewheel_connection.disconnect();
export_abort_connection.disconnect();
export_handler.reset();
+ export_status.reset();
/* restart slaving */
locate (post_export_position, false, false, false);
}
}
-
-void
-Session::abort_audio_export ()
-{
- stop_audio_export ();
- finalize_audio_export ();
-}
projects / ardour.git / commitdiff