/*
- Copyright (C) 2008 Paul Davis
+ Copyright (C) 2008-2009 Paul Davis
Author: Sakari Bergen
This program is free software; you can redistribute it and/or modify
#include "ardour/ardour.h"
#include "ardour/configuration.h"
+#include "ardour/export_graph_builder.h"
#include "ardour/export_timespan.h"
#include "ardour/export_channel_configuration.h"
#include "ardour/export_status.h"
#include "ardour/export_format_specification.h"
#include "ardour/export_filename.h"
-#include "ardour/export_processor.h"
#include "ardour/export_failed.h"
+#include "i18n.h"
+
using namespace std;
using namespace PBD;
/*** ExportHandler ***/
-ExportHandler::ExportHandler (Session & session)
- : ExportElementFactory (session)
- , session (session)
- , export_status (session.get_export_status ())
- , realtime (false)
+ExportHandler::ExportHandler (Session & session)
+ : ExportElementFactory (session)
+ , session (session)
+ , graph_builder (new ExportGraphBuilder (session))
+ , export_status (session.get_export_status ())
+ , realtime (false)
+ , normalizing (false)
+ , cue_tracknum (0)
+ , cue_indexnum (0)
{
- processor.reset (new ExportProcessor (session));
-
- ExportProcessor::WritingFile.connect_same_thread (files_written_connection, boost::bind (&ExportHandler::add_file, this, _1));
}
ExportHandler::~ExportHandler ()
{
- if (export_status->aborted()) {
- for (std::list<Glib::ustring>::iterator it = files_written.begin(); it != files_written.end(); ++it) {
- sys::remove (sys::path (*it));
- }
- }
-
- channel_config_connection.disconnect();
- files_written_connection.disconnect();
-}
-
-void
-ExportHandler::add_file (const Glib::ustring& str)
-{
- files_written.push_back (str);
+ // TODO remove files that were written but not finsihed
}
bool
-ExportHandler::add_export_config (TimespanPtr timespan, ChannelConfigPtr channel_config, FormatPtr format, FilenamePtr filename)
+ExportHandler::add_export_config (TimespanPtr timespan, ChannelConfigPtr channel_config, FormatPtr format, FilenamePtr filename, boost::shared_ptr<AudioGrapher::BroadcastInfo> broadcast_info)
{
- FileSpec spec (channel_config, format, filename);
+ FileSpec spec (channel_config, format, filename, broadcast_info);
ConfigPair pair (timespan, spec);
config_map.insert (pair);
-
+
return true;
}
-/// Starts exporting the registered configurations
-/** The following happens, when do_export is called:
- * 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 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
- * 7. write_files writes the actual export files, composing them from the individual channels from tempfiles and
- * emits FilesWritten when it is done, which ends up calling timespan_thread_finished
- * 8. Once all channel configs are written, a new timespan is started by calling start_timespan
- * 9. When all timespans are written the session is taken out of export.
- */
-
void
ExportHandler::do_export (bool rt)
{
/* Start export */
realtime = rt;
+ start_timespan ();
+}
+
+void
+ExportHandler::start_timespan ()
+{
+ export_status->timespan++;
+
+ if (config_map.empty()) {
+ // freewheeling has to be stopped from outside the process cycle
+ export_status->running = false;
+ return;
+ }
+
+ current_timespan = config_map.begin()->first;
+
+ /* Register file configurations to graph builder */
+
+ timespan_bounds = config_map.equal_range (current_timespan);
+ graph_builder->reset ();
+ for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
+ // Filenames can be shared across timespans
+ FileSpec & spec = it->second;
+ spec.filename->set_timespan (it->first);
+ graph_builder->add_config (spec);
+ }
+
+ /* start export */
+
+ normalizing = false;
+ session.ProcessExport.connect_same_thread (process_connection, boost::bind (&ExportHandler::process, this, _1));
+ process_position = current_timespan->get_start();
+ session.start_audio_export (process_position, realtime);
+}
+
+int
+ExportHandler::process (framecnt_t frames)
+{
+ if (!export_status->running) {
+ return 0;
+ } else if (normalizing) {
+ return process_normalize ();
+ } else {
+ return process_timespan (frames);
+ }
+}
+
+int
+ExportHandler::process_timespan (framecnt_t frames)
+{
+ /* update position */
+
+ framecnt_t frames_to_read = 0;
+ framepos_t const start = current_timespan->get_start();
+ framepos_t const end = current_timespan->get_end();
+
+ bool const last_cycle = (process_position + frames >= end);
+
+ if (last_cycle) {
+ frames_to_read = end - process_position;
+ export_status->stop = true;
+ normalizing = true;
+ } else {
+ frames_to_read = frames;
+ }
+
+ process_position += frames_to_read;
+ export_status->progress = (float) (process_position - start) / (end - start);
+
+ /* Do actual processing */
+
+ return graph_builder->process (frames_to_read, last_cycle);
+}
+
+int
+ExportHandler::process_normalize ()
+{
+ if (graph_builder->process_normalize ()) {
+ finish_timespan ();
+ }
+
+ return 0;
+}
+
+void
+ExportHandler::finish_timespan ()
+{
+ while (config_map.begin() != timespan_bounds.second) {
+ config_map.erase (config_map.begin());
+ }
- session.ExportReadFinished.connect_same_thread (export_read_finished_connection, boost::bind (&ExportHandler::finish_timespan, this));
start_timespan ();
}
+/*** CD Marker sutff ***/
+
struct LocationSortByStart {
bool operator() (Location *a, Location *b) {
return a->start() < b->start();
Locations::LocationList temp;
for (i = locations.begin(); i != locations.end(); ++i) {
- if ((*i)->start() >= timespan->get_start() && (*i)->end() <= timespan->get_end() && (*i)->is_cd_marker() && !(*i)->is_end()) {
+ if ((*i)->start() >= timespan->get_start() && (*i)->end() <= timespan->get_end() && (*i)->is_cd_marker() && !(*i)->is_session_range()) {
temp.push_back (*i);
}
}
/* Start actual marker stuff */
- nframes_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
+ framepos_t last_end_time = timespan->get_start(), last_start_time = timespan->get_start();
status.track_position = last_start_time - timespan->get_start();
for (i = temp.begin(); i != temp.end(); ++i) {
void
ExportHandler::write_cue_header (CDMarkerStatus & status)
{
- Glib::ustring title = status.timespan->name().compare ("Session") ? status.timespan->name() : (Glib::ustring) session.name();
+ string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
status.out << "REM Cue file generated by Ardour" << endl;
status.out << "TITLE \"" << title << "\"" << endl;
status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
if (!status.format->format_name().compare ("WAV")) {
status.out << "WAVE";
- } else if (status.format->format_name() == ExportFormatBase::F_RAW &&
+ } else if (status.format->format_id() == ExportFormatBase::F_RAW &&
status.format->sample_format() == ExportFormatBase::SF_16 &&
status.format->sample_rate() == ExportFormatBase::SR_44_1) {
// Format is RAW 16bit 44.1kHz
void
ExportHandler::write_toc_header (CDMarkerStatus & status)
{
- Glib::ustring title = status.timespan->name().compare ("Session") ? status.timespan->name() : (Glib::ustring) session.name();
+ string title = status.timespan->name().compare ("Session") ? status.timespan->name() : (string) session.name();
status.out << "CD_DA" << endl;
status.out << "CD_TEXT {" << endl << " LANGUAGE_MAP {" << endl << " 0 : EN" << endl << " }" << endl;
}
void
-ExportHandler::frames_to_cd_frames_string (char* buf, nframes_t when)
+ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when)
{
- nframes_t remainder;
- nframes_t fr = session.nominal_frame_rate();
+ framecnt_t remainder;
+ framecnt_t fr = session.nominal_frame_rate();
int mins, secs, frames;
mins = when / (60 * fr);
sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
}
-void
-ExportHandler::start_timespan ()
-{
- export_status->timespan++;
-
- if (config_map.empty()) {
- export_status->finish ();
- return;
- }
-
- current_timespan = config_map.begin()->first;
-
- /* Register channel configs with timespan */
-
- timespan_bounds = config_map.equal_range (current_timespan);
-
- for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
- it->second.channel_config->register_with_timespan (current_timespan);
- }
-
- /* connect stuff and start export */
-
- session.ProcessExport.connect_same_thread (current_timespan->process_connection, boost::bind (&ExportTimespan::process, current_timespan, _1));
- session.start_audio_export (current_timespan->get_start(), realtime);
-}
-
-void
-ExportHandler::finish_timespan ()
-{
- current_timespan->process_connection.disconnect ();
-
- /* Register formats and filenames to relevant channel configs */
-
- export_status->total_formats = 0;
- export_status->format = 0;
-
- for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
-
- export_status->total_formats++;
-
- /* Setup filename */
-
- it->second.filename->set_timespan (current_timespan);
- it->second.filename->set_channel_config (it->second.channel_config);
-
- /* Do actual registration */
-
- ChannelConfigPtr chan_config = it->second.channel_config;
- chan_config->register_file_config (it->second.format, it->second.filename);
- }
-
- /* Start writing files by doing a manual call to timespan_thread_finished */
-
- current_map_it = timespan_bounds.first;
- timespan_thread_finished ();
-}
-
-void
-ExportHandler::timespan_thread_finished ()
-{
- channel_config_connection.disconnect();
- export_read_finished_connection.disconnect ();
-
- if (current_map_it != timespan_bounds.second) {
-
- /* Get next configuration as long as no new export process is started */
-
- ChannelConfigPtr cc = current_map_it->second.channel_config;
- while (!cc->write_files(processor)) {
-
- ++current_map_it;
-
- if (current_map_it == timespan_bounds.second) {
-
- /* reached end of bounds, this call will end up in the else block below */
-
- timespan_thread_finished ();
- return;
- }
-
- cc = current_map_it->second.channel_config;
- }
-
- cc->FilesWritten.connect_same_thread (channel_config_connection, boost::bind (&ExportHandler::timespan_thread_finished, this));
- ++current_map_it;
-
- } else { /* All files are written from current timespan, reset timespan and start new */
-
- /* Unregister configs and remove configs with this timespan */
-
- for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second;) {
- it->second.channel_config->unregister_all ();
-
- ConfigMap::iterator to_erase = it;
- ++it;
- config_map.erase (to_erase);
- }
-
- /* Start new timespan */
-
- start_timespan ();
-
- }
-}
-
} // namespace ARDOUR
projects / ardour.git / blobdiff