#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"
#include "pbd/basename.h"
#include "ardour/session_metadata.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace std;
using namespace PBD;
ExportTimespanPtr
ExportElementFactory::add_timespan ()
{
- return ExportTimespanPtr (new ExportTimespan (session.get_export_status(), session.frame_rate()));
+ return ExportTimespanPtr (new ExportTimespan (session.get_export_status(), session.sample_rate()));
}
ExportChannelConfigPtr
, session (session)
, graph_builder (new ExportGraphBuilder (session))
, export_status (session.get_export_status ())
- , normalizing (false)
+ , post_processing (false)
, cue_tracknum (0)
, cue_indexnum (0)
{
for (ConfigMap::iterator it = config_map.begin(); it != config_map.end(); ++it) {
bool new_timespan = timespan_set.insert (it->first).second;
if (new_timespan) {
- export_status->total_frames += it->first->get_length();
+ export_status->total_samples += it->first->get_length();
}
}
export_status->total_timespans = timespan_set.size();
*/
current_timespan = config_map.begin()->first;
- export_status->total_frames_current_timespan = current_timespan->get_length();
+ export_status->total_samples_current_timespan = current_timespan->get_length();
export_status->timespan_name = current_timespan->name();
- export_status->processed_frames_current_timespan = 0;
+ export_status->processed_samples_current_timespan = 0;
/* Register file configurations to graph builder */
graph_builder->reset ();
graph_builder->set_current_timespan (current_timespan);
handle_duplicate_format_extensions();
+ bool realtime = current_timespan->realtime ();
+ bool region_export = true;
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;
+ }
+ 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);
}
void
ExtCountMap counts;
for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
- counts[it->second.format->extension()]++;
+ if (it->second.filename->include_channel_config && it->second.channel_config) {
+ /* stem-export has multiple files in the same timestamp, but a different channel_config for each.
+ * However channel_config is only set in ExportGraphBuilder::Encoder::init_writer()
+ * so we cannot yet use it->second.filename->get_path(it->second.format).
+ * We have to explicily check uniqueness of "channel-config + extension" here:
+ */
+ counts[it->second.channel_config->name() + it->second.format->extension()]++;
+ } else {
+ counts[it->second.format->extension()]++;
+ }
}
bool duplicates_found = false;
}
int
-ExportHandler::process (framecnt_t frames)
+ExportHandler::process (samplecnt_t samples)
{
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);
+ return process_timespan (samples);
}
}
int
-ExportHandler::process_timespan (framecnt_t frames)
+ExportHandler::process_timespan (samplecnt_t samples)
{
export_status->active_job = ExportStatus::Exporting;
/* update position */
- framecnt_t frames_to_read = 0;
- framepos_t const end = current_timespan->get_end();
+ samplecnt_t samples_to_read = 0;
+ samplepos_t const end = current_timespan->get_end();
- bool const last_cycle = (process_position + frames >= end);
+ bool const last_cycle = (process_position + samples >= end);
if (last_cycle) {
- frames_to_read = end - process_position;
+ samples_to_read = end - process_position;
export_status->stop = true;
} else {
- frames_to_read = frames;
+ samples_to_read = samples;
}
- process_position += frames_to_read;
- export_status->processed_frames += frames_to_read;
- export_status->processed_frames_current_timespan += frames_to_read;
+ process_position += samples_to_read;
+ export_status->processed_samples += samples_to_read;
+ export_status->processed_samples_current_timespan += samples_to_read;
/* Do actual processing */
- int ret = graph_builder->process (frames_to_read, last_cycle);
+ int ret = graph_builder->process (samples_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;
}
}
if (!fmt->command().empty()) {
+ SessionMetadata const & metadata (*SessionMetadata::Metadata());
-#if 0 // would be nicer with C++11 initialiser...
+#if 0 // would be nicer with C++11 initialiser...
std::map<char, std::string> subs {
{ 'f', filename },
{ 'd', Glib::path_get_dirname(filename) + G_DIR_SEPARATOR },
export_status->active_job = ExportStatus::Command;
PBD::ScopedConnection command_connection;
std::map<char, std::string> subs;
- subs.insert (std::pair<char, std::string> ('f', filename));
- subs.insert (std::pair<char, std::string> ('d', Glib::path_get_dirname (filename) + G_DIR_SEPARATOR));
+
+ std::stringstream track_number;
+ track_number << metadata.track_number ();
+ std::stringstream total_tracks;
+ total_tracks << metadata.total_tracks ();
+ std::stringstream year;
+ year << metadata.year ();
+
+ subs.insert (std::pair<char, std::string> ('a', metadata.artist ()));
subs.insert (std::pair<char, std::string> ('b', PBD::basename_nosuffix (filename)));
- subs.insert (std::pair<char, std::string> ('s', session.path ()));
+ subs.insert (std::pair<char, std::string> ('c', metadata.copyright ()));
+ subs.insert (std::pair<char, std::string> ('d', Glib::path_get_dirname (filename) + G_DIR_SEPARATOR));
+ subs.insert (std::pair<char, std::string> ('f', filename));
+ subs.insert (std::pair<char, std::string> ('l', metadata.lyricist ()));
subs.insert (std::pair<char, std::string> ('n', session.name ()));
+ subs.insert (std::pair<char, std::string> ('s', session.path ()));
+ subs.insert (std::pair<char, std::string> ('o', metadata.conductor ()));
+ subs.insert (std::pair<char, std::string> ('t', metadata.title ()));
+ subs.insert (std::pair<char, std::string> ('z', metadata.organization ()));
+ subs.insert (std::pair<char, std::string> ('A', metadata.album ()));
+ subs.insert (std::pair<char, std::string> ('C', metadata.comment ()));
+ subs.insert (std::pair<char, std::string> ('E', metadata.engineer ()));
+ subs.insert (std::pair<char, std::string> ('G', metadata.genre ()));
+ subs.insert (std::pair<char, std::string> ('L', total_tracks.str ()));
+ subs.insert (std::pair<char, std::string> ('M', metadata.mixer ()));
+ subs.insert (std::pair<char, std::string> ('N', current_timespan->name())); // =?= config_map.begin()->first->name ()
+ subs.insert (std::pair<char, std::string> ('O', metadata.composer ()));
+ subs.insert (std::pair<char, std::string> ('P', metadata.producer ()));
+ subs.insert (std::pair<char, std::string> ('S', metadata.disc_subtitle ()));
+ subs.insert (std::pair<char, std::string> ('T', track_number.str ()));
+ subs.insert (std::pair<char, std::string> ('Y', year.str ()));
+ subs.insert (std::pair<char, std::string> ('Z', metadata.country ()));
ARDOUR::SystemExec *se = new ARDOUR::SystemExec(fmt->command(), subs);
info << "Post-export command line : {" << se->to_s () << "}" << endmsg;
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);
start_timespan ();
}
+void
+ExportHandler::reset ()
+{
+ config_map.clear ();
+ graph_builder->reset ();
+}
+
/*** CD Marker stuff ***/
struct LocationSortByStart {
/* Start actual marker stuff */
- framepos_t last_end_time = timespan->get_start();
+ samplepos_t last_end_time = timespan->get_start();
status.track_position = 0;
for (i = temp.begin(); i != temp.end(); ++i) {
/* A track, defined by a cd range marker or a cd location marker outside of a cd range */
status.track_position = last_end_time - timespan->get_start();
- status.track_start_frame = (*i)->start() - timespan->get_start(); // everything before this is the pregap
+ status.track_start_sample = (*i)->start() - timespan->get_start(); // everything before this is the pregap
status.track_duration = 0;
if ((*i)->is_mark()) {
status.out << " SONGWRITER " << cue_escape_cdtext (status.marker->cd_info["composer"]) << endl;
}
- if (status.track_position != status.track_start_frame) {
- frames_to_cd_frames_string (buf, status.track_position);
+ if (status.track_position != status.track_start_sample) {
+ samples_to_cd_samples_string (buf, status.track_position);
status.out << " INDEX 00" << buf << endl;
}
- frames_to_cd_frames_string (buf, status.track_start_frame);
+ samples_to_cd_samples_string (buf, status.track_start_sample);
status.out << " INDEX 01" << buf << endl;
status.index_number = 2;
status.out << " }" << endl << "}" << endl;
- frames_to_cd_frames_string (buf, status.track_position);
+ samples_to_cd_samples_string (buf, status.track_position);
status.out << "FILE " << toc_escape_filename (status.filename) << ' ' << buf;
- frames_to_cd_frames_string (buf, status.track_duration);
+ samples_to_cd_samples_string (buf, status.track_duration);
status.out << buf << endl;
- frames_to_cd_frames_string (buf, status.track_start_frame - status.track_position);
+ samples_to_cd_samples_string (buf, status.track_start_sample - status.track_position);
status.out << "START" << buf << endl;
}
{
gchar buf[18];
- frames_to_chapter_marks_string(buf, status.track_start_frame);
+ samples_to_chapter_marks_string(buf, status.track_start_sample);
status.out << buf << " " << status.marker->name() << endl;
}
snprintf (buf, sizeof(buf), " INDEX %02d", cue_indexnum);
status.out << buf;
- frames_to_cd_frames_string (buf, status.index_position);
+ samples_to_cd_samples_string (buf, status.index_position);
status.out << buf << endl;
cue_indexnum++;
{
gchar buf[18];
- frames_to_cd_frames_string (buf, status.index_position - status.track_position);
+ samples_to_cd_samples_string (buf, status.index_position - status.track_position);
status.out << "INDEX" << buf << endl;
}
}
void
-ExportHandler::frames_to_cd_frames_string (char* buf, framepos_t when)
+ExportHandler::samples_to_cd_samples_string (char* buf, samplepos_t when)
{
- framecnt_t remainder;
- framecnt_t fr = session.nominal_frame_rate();
- int mins, secs, frames;
+ samplecnt_t remainder;
+ samplecnt_t fr = session.nominal_sample_rate();
+ int mins, secs, samples;
mins = when / (60 * fr);
remainder = when - (mins * 60 * fr);
secs = remainder / fr;
remainder -= secs * fr;
- frames = remainder / (fr / 75);
- sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
+ samples = remainder / (fr / 75);
+ sprintf (buf, " %02d:%02d:%02d", mins, secs, samples);
}
void
-ExportHandler::frames_to_chapter_marks_string (char* buf, framepos_t when)
+ExportHandler::samples_to_chapter_marks_string (char* buf, samplepos_t when)
{
- framecnt_t remainder;
- framecnt_t fr = session.nominal_frame_rate();
+ samplecnt_t remainder;
+ samplecnt_t fr = session.nominal_sample_rate();
int hours, mins, secs, msecs;
hours = when / (3600 * fr);
char buf[5];
try {
- latin1_txt = Glib::convert (txt, "ISO-8859-1", "UTF-8");
+ latin1_txt = Glib::convert_with_fallback (txt, "ISO-8859-1", "UTF-8", "_");
} catch (Glib::ConvertError& err) {
throw Glib::ConvertError (err.code(), string_compose (_("Cannot convert %1 to Latin-1 text"), txt));
}
projects / ardour.git / blobdiff