#include "pbd/convert.h"
+#include "ardour/audioengine.h"
#include "ardour/audiofile_tagger.h"
+#include "ardour/audio_port.h"
#include "ardour/debug.h"
#include "ardour/export_graph_builder.h"
#include "ardour/export_timespan.h"
, session (session)
, graph_builder (new ExportGraphBuilder (session))
, export_status (session.get_export_status ())
- , normalizing (false)
+ , post_processing (false)
, cue_tracknum (0)
, cue_indexnum (0)
{
graph_builder->reset ();
graph_builder->set_current_timespan (current_timespan);
handle_duplicate_format_extensions();
+ bool realtime = current_timespan->realtime ();
+ bool region_export = true;
+ bool incl_master_bus = false;
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);
+ switch (spec.channel_config->region_processing_type ()) {
+ case RegionExportChannelFactory::None:
+ case RegionExportChannelFactory::Processed:
+ region_export = false;
+ break;
+ default:
+ break;
+ }
+#if 1 // hack alert -- align master bus, compensate master latency
+
+ /* there's no easier way to get this information here.
+ * Ports are configured in the PortExportChannelSelector GUI,
+ * This ExportHandler has no context of routes.
+ */
+ boost::shared_ptr<Route> master_bus = session.master_out ();
+ if (master_bus) {
+ const PortSet& ps = master_bus->output ()->ports();
+
+ const ExportChannelConfiguration::ChannelList& channels = spec.channel_config->get_channels ();
+ for (ExportChannelConfiguration::ChannelList::const_iterator it = channels.begin(); it != channels.end(); ++it) {
+
+ boost::shared_ptr <PortExportChannel> pep = boost::dynamic_pointer_cast<PortExportChannel> (*it);
+ if (!pep) {
+ continue;
+ }
+ PortExportChannel::PortSet const& ports = pep->get_ports ();
+ for (PortExportChannel::PortSet::const_iterator it = ports.begin(); it != ports.end(); ++it) {
+ boost::shared_ptr<AudioPort> ap = (*it).lock();
+ if (ps.contains (ap)) {
+ incl_master_bus = true;
+ }
+ }
+ }
+ }
+#endif
+ graph_builder->add_config (spec, realtime);
}
+ // ExportDialog::update_realtime_selection does not allow this
+ assert (!region_export || !realtime);
+
/* start export */
- normalizing = false;
+ post_processing = 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);
+ // TODO check if it's a RegionExport.. set flag to skip process_without_events()
+ session.start_audio_export (process_position, realtime, region_export, incl_master_bus);
}
void
{
if (!export_status->running ()) {
return 0;
- } else if (normalizing) {
+ } else if (post_processing) {
Glib::Threads::Mutex::Lock l (export_status->lock());
- return process_normalize ();
+ if (AudioEngine::instance()->freewheeling ()) {
+ return post_process ();
+ } else {
+ // wait until we're freewheeling
+ return 0;
+ }
} else {
Glib::Threads::Mutex::Lock l (export_status->lock());
return process_timespan (frames);
/* Do actual processing */
int ret = graph_builder->process (frames_to_read, last_cycle);
- /* Start normalizing if necessary */
+ /* Start post-processing/normalizing if necessary */
if (last_cycle) {
- normalizing = graph_builder->will_normalize();
- if (normalizing) {
- export_status->total_normalize_cycles = graph_builder->get_normalize_cycle_count();
- export_status->current_normalize_cycle = 0;
+ post_processing = graph_builder->need_postprocessing ();
+ if (post_processing) {
+ export_status->total_postprocessing_cycles = graph_builder->get_postprocessing_cycle_count();
+ export_status->current_postprocessing_cycle = 0;
} else {
finish_timespan ();
return 0;
}
int
-ExportHandler::process_normalize ()
+ExportHandler::post_process ()
{
- if (graph_builder->process_normalize ()) {
+ if (graph_builder->post_process ()) {
finish_timespan ();
export_status->active_job = ExportStatus::Exporting;
} else {
- export_status->active_job = ExportStatus::Normalizing;
+ if (graph_builder->realtime ()) {
+ export_status->active_job = ExportStatus::Encoding;
+ } else {
+ export_status->active_job = ExportStatus::Normalizing;
+ }
}
- export_status->current_normalize_cycle++;
+ export_status->current_postprocessing_cycle++;
return 0;
}
delete (se);
}
+ // XXX THIS IS IN REALTIME CONTEXT, CALLED FROM
+ // AudioEngine::process_callback()
+ // freewheeling, yes, but still uploading here is NOT
+ // a good idea.
+ //
+ // even less so, since SoundcloudProgress is using
+ // connect_same_thread() - GUI updates from the RT thread
+ // will cause crashes. http://pastebin.com/UJKYNGHR
if (fmt->soundcloud_upload()) {
SoundcloudUploader *soundcloud_uploader = new SoundcloudUploader;
std::string token = soundcloud_uploader->Get_Auth_Token(soundcloud_username, soundcloud_password);