*/
-#include <ardour/export_handler.h>
+#include "ardour/export_handler.h"
-#include <pbd/convert.h>
-#include <pbd/filesystem.h>
+#include <glibmm.h>
-#include <ardour/ardour.h>
-#include <ardour/configuration.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 "pbd/convert.h"
+#include "pbd/filesystem.h"
+#include "ardour/ardour.h"
+#include "ardour/configuration.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"
+
+using namespace std;
using namespace PBD;
-using std::ofstream;
namespace ARDOUR
{
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::ExportHandler (Session & session) :
- ExportElementFactory (session),
- session (session),
- realtime (false)
+ExportHandler::ExportHandler (Session & session)
+ : ExportElementFactory (session)
+ , session (session)
+ , export_status (session.get_export_status ())
+ , realtime (false)
{
processor.reset (new ExportProcessor (session));
- files_written_connection = ExportProcessor::WritingFile.connect (sigc::mem_fun (files_written, &std::list<Glib::ustring>::push_back));
+ ExportProcessor::WritingFile.connect (files_written_connection, boost::bind (&ExportHandler::add_file, this, _1));
}
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));
}
}
-
+
channel_config_connection.disconnect();
files_written_connection.disconnect();
}
+void
+ExportHandler::add_file (const Glib::ustring& str)
+{
+ files_written.push_back (str);
+}
+
bool
ExportHandler::add_export_config (TimespanPtr timespan, ChannelConfigPtr channel_config, FormatPtr format, FilenamePtr filename)
{
FileSpec spec (channel_config, format, filename);
ConfigPair pair (timespan, spec);
config_map.insert (pair);
-
+
return true;
}
* 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 (export_read_finished_connection, boost::bind (&ExportHandler::finish_timespan, this));
start_timespan ();
}
ExportHandler::export_cd_marker_file (TimespanPtr timespan, FormatPtr file_format, std::string filename, CDMarkerFormat format)
{
string filepath;
+ string basename = Glib::path_get_basename(filename);
+
+ size_t ext_pos = basename.rfind('.');
+ if (ext_pos != string::npos) {
+ basename = basename.substr(0, ext_pos); /* strip file extension, if there is one */
+ }
+
void (ExportHandler::*header_func) (CDMarkerStatus &);
void (ExportHandler::*track_func) (CDMarkerStatus &);
void (ExportHandler::*index_func) (CDMarkerStatus &);
switch (format) {
case CDMarkerTOC:
- filepath = filename + ".toc";
+ filepath = Glib::build_filename(Glib::path_get_dirname(filename), basename + ".toc");
header_func = &ExportHandler::write_toc_header;
track_func = &ExportHandler::write_track_info_toc;
index_func = &ExportHandler::write_index_info_toc;
break;
case CDMarkerCUE:
- filepath = filename + ".cue";
+ filepath = Glib::build_filename(Glib::path_get_dirname(filename), basename + ".cue");
header_func = &ExportHandler::write_cue_header;
track_func = &ExportHandler::write_track_info_cue;
index_func = &ExportHandler::write_index_info_cue;
default:
return;
}
-
+
CDMarkerStatus status (filepath, timespan, file_format, filename);
if (!status.out) {
error << string_compose(_("Editor: cannot open \"%1\" as export file for CD marker file"), filepath) << endmsg;
return;
}
-
+
(this->*header_func) (status);
-
+
/* Get locations and sort */
-
+
Locations::LocationList const & locations (session.locations()->list());
Locations::LocationList::const_iterator i;
Locations::LocationList temp;
// TODO One index marker for whole thing
return;
}
-
+
LocationSortByStart cmp;
temp.sort (cmp);
Locations::LocationList::const_iterator nexti;
if ((*i)->start() < last_end_time) {
if ((*i)->is_mark()) {
/* Index within track */
-
+
status.index_position = (*i)->start() - timespan->get_start();
(this->*index_func) (status);
}
-
+
continue;
}
/* 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_duration = 0;
-
+
if ((*i)->is_mark()) {
// a mark track location needs to look ahead to the next marker's start to determine length
nexti = i;
++nexti;
-
+
if (nexti != temp.end()) {
status.track_duration = (*nexti)->start() - last_end_time;
-
+
last_start_time = (*i)->start();
last_end_time = (*nexti)->start();
} else {
// this was the last marker, use timespan end
status.track_duration = timespan->get_end() - last_end_time;
-
+
last_start_time = (*i)->start();
last_end_time = timespan->get_end();
}
} else {
// range
status.track_duration = (*i)->end() - last_end_time;
-
+
last_start_time = (*i)->start();
last_end_time = (*i)->end();
}
-
+
(this->*track_func) (status);
}
}
status.out << "REM Cue file generated by Ardour" << endl;
status.out << "TITLE \"" << title << "\"" << endl;
- // TODO
+ /* The cue sheet syntax has originally five file types:
+ WAVE : 44.1 kHz, 16 Bit (little endian)
+ AIFF : 44.1 kHz, 16 Bit (big endian)
+ BINARY : 44.1 kHz, 16 Bit (little endian)
+ MOTOROLA : 44.1 kHz, 16 Bit (big endian)
+ MP3
+
+ We want to use cue sheets not only as CD images but also as general playlyist
+ format, thus for WAVE and AIFF we don't care if it's really 44.1 kHz/16 Bit, the
+ soundfile's header shows it anyway. But for the raw formats, i.e. BINARY
+ and MOTOROLA we do care, because no header would tell us about a different format.
+
+ For all other formats we just make up our own file type. MP3 is not supported
+ at the moment.
+ */
+
+ status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
if (!status.format->format_name().compare ("WAV")) {
- status.out << "FILE " << status.filename << " WAVE" << endl;
+ status.out << "WAVE";
+ } else if (status.format->format_name() == ExportFormatBase::F_RAW &&
+ status.format->sample_format() == ExportFormatBase::SF_16 &&
+ status.format->sample_rate() == ExportFormatBase::SR_44_1) {
+ // Format is RAW 16bit 44.1kHz
+ if (status.format->endianness() == ExportFormatBase::E_Little) {
+ status.out << "BINARY";
+ } else {
+ status.out << "MOTOROLA";
+ }
} else {
- status.out << "FILE " << status.filename << ' ' << status.format->format_name() << endl;
+ // AIFF should return "AIFF"
+ status.out << status.format->format_name();
}
+ status.out << endl;
}
void
{
gchar buf[18];
- status.out << endl << "TRACK " << status.track_number << " AUDIO" << endl;
- status.out << "FLAGS " ;
-
+ snprintf (buf, sizeof(buf), " TRACK %02d AUDIO", status.track_number);
+ status.out << buf << endl;
+
+ status.out << " FLAGS" ;
if (status.marker->cd_info.find("scms") != status.marker->cd_info.end()) {
- status.out << "SCMS ";
+ status.out << " SCMS ";
} else {
- status.out << "DCP ";
+ status.out << " DCP ";
}
-
+
if (status.marker->cd_info.find("preemph") != status.marker->cd_info.end()) {
- status.out << "PRE";
+ status.out << " PRE";
}
status.out << endl;
-
+
if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
- status.out << "ISRC " << status.marker->cd_info["isrc"] << endl;
-
+ status.out << " ISRC " << status.marker->cd_info["isrc"] << endl;
+
}
if (status.marker->name() != "") {
- status.out << "TITLE \"" << status.marker->name() << "\"" << endl;
+ status.out << " TITLE \"" << status.marker->name() << "\"" << endl;
}
-
+
if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) {
- status.out << "PERFORMER \"" << status.marker->cd_info["performer"] << "\"" << endl;
+ status.out << " PERFORMER \"" << status.marker->cd_info["performer"] << "\"" << endl;
}
-
+
if (status.marker->cd_info.find("string_composer") != status.marker->cd_info.end()) {
- status.out << "SONGWRITER \"" << status.marker->cd_info["string_composer"] << "\"" << endl;
+ status.out << " SONGWRITER \"" << status.marker->cd_info["string_composer"] << "\"" << endl;
+ }
+
+ if (status.track_position != status.track_start_frame) {
+ frames_to_cd_frames_string (buf, status.track_position);
+ status.out << " INDEX 00" << buf << endl;
}
- frames_to_cd_frames_string (buf, status.track_position);
- status.out << "INDEX 00" << buf << endl;
-
frames_to_cd_frames_string (buf, status.track_start_frame);
- status.out << "INDEX 01" << buf << endl;
-
+ status.out << " INDEX 01" << buf << endl;
+
status.index_number = 2;
status.track_number++;
}
gchar buf[18];
status.out << endl << "TRACK AUDIO" << endl;
-
+
if (status.marker->cd_info.find("scms") != status.marker->cd_info.end()) {
status.out << "NO ";
}
status.out << "COPY" << endl;
-
+
if (status.marker->cd_info.find("preemph") != status.marker->cd_info.end()) {
status.out << "PRE_EMPHASIS" << endl;
} else {
status.out << "NO PRE_EMPHASIS" << endl;
}
-
+
if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
status.out << "ISRC \"" << status.marker->cd_info["isrc"] << "\"" << endl;
}
-
+
status.out << "CD_TEXT {" << endl << " LANGUAGE 0 {" << endl << " TITLE \"" << status.marker->name() << "\"" << endl;
if (status.marker->cd_info.find("performer") != status.marker->cd_info.end()) {
status.out << " PERFORMER \"" << status.marker->cd_info["performer"] << "\"" << endl;
if (status.marker->cd_info.find("string_composer") != status.marker->cd_info.end()) {
status.out << " COMPOSER \"" << status.marker->cd_info["string_composer"] << "\"" << endl;
}
-
- if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
+
+ if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
status.out << " ISRC \"";
status.out << status.marker->cd_info["isrc"].substr(0,2) << "-";
status.out << status.marker->cd_info["isrc"].substr(2,3) << "-";
status.out << status.marker->cd_info["isrc"].substr(5,2) << "-";
status.out << status.marker->cd_info["isrc"].substr(7,5) << "\"" << endl;
}
-
+
status.out << " }" << endl << "}" << endl;
-
+
frames_to_cd_frames_string (buf, status.track_position);
status.out << "FILE \"" << status.filename << "\" " << buf;
-
+
frames_to_cd_frames_string (buf, status.track_duration);
status.out << buf << endl;
-
+
frames_to_cd_frames_string (buf, status.track_start_frame - status.track_position);
status.out << "START" << buf << endl;
}
{
gchar buf[18];
- snprintf (buf, sizeof(buf), "INDEX %02d", cue_indexnum);
+ snprintf (buf, sizeof(buf), " INDEX %02d", cue_indexnum);
status.out << buf;
frames_to_cd_frames_string (buf, status.index_position);
status.out << buf << endl;
-
+
cue_indexnum++;
}
void
ExportHandler::start_timespan ()
{
- session.export_status.timespan++;
+ export_status->timespan++;
if (config_map.empty()) {
- session.finalize_audio_export();
+ 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 */
- current_timespan->process_connection = session.ProcessExport.connect (sigc::mem_fun (*current_timespan, &ExportTimespan::process));
+ session.ProcessExport.connect (current_timespan->process_connection, boost::bind (&ExportTimespan::process, current_timespan, _1));
session.start_audio_export (current_timespan->get_start(), realtime);
}
ExportHandler::finish_timespan ()
{
current_timespan->process_connection.disconnect ();
-
+
/* 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 */
-
+
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 ();
}
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;
}
-
- channel_config_connection = cc->FilesWritten.connect (sigc::mem_fun (*this, &ExportHandler::timespan_thread_finished));
+
+ cc->FilesWritten.connect (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 ();
-
+
}
}
projects / ardour.git / blobdiff