#include "ardour/export_handler.h"
+#include <glib/gstdio.h>
#include <glibmm.h>
#include <glibmm/convert.h>
#include "pbd/convert.h"
-#include "pbd/filesystem.h"
-#include "ardour/ardour.h"
-#include "ardour/configuration.h"
+#include "ardour/audiofile_tagger.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_failed.h"
+#include "ardour/soundcloud_upload.h"
+#include "ardour/system_exec.h"
+#include "pbd/openuri.h"
+#include "pbd/basename.h"
+#include "ardour/session_metadata.h"
#include "i18n.h"
, session (session)
, graph_builder (new ExportGraphBuilder (session))
, export_status (session.get_export_status ())
- , realtime (false)
, normalizing (false)
, cue_tracknum (0)
, cue_indexnum (0)
ExportHandler::~ExportHandler ()
{
- // TODO remove files that were written but not finsihed
+ // TODO remove files that were written but not finished
}
+/** Add an export to the `to-do' list */
bool
ExportHandler::add_export_config (ExportTimespanPtr timespan, ExportChannelConfigPtr channel_config,
ExportFormatSpecPtr format, ExportFilenamePtr filename,
BroadcastInfoPtr broadcast_info)
{
FileSpec spec (channel_config, format, filename, broadcast_info);
- ConfigPair pair (timespan, spec);
- config_map.insert (pair);
+ config_map.insert (make_pair (timespan, spec));
return true;
}
void
-ExportHandler::do_export (bool rt)
+ExportHandler::do_export ()
{
/* Count timespans */
/* Start export */
- realtime = rt;
start_timespan ();
}
return;
}
+ /* finish_timespan pops the config_map entry that has been done, so
+ this is the timespan to do this time
+ */
current_timespan = config_map.begin()->first;
+
+ export_status->total_frames_current_timespan = current_timespan->get_length();
+ export_status->timespan_name = current_timespan->name();
+ export_status->processed_frames_current_timespan = 0;
/* Register file configurations to graph builder */
+ /* Here's the config_map entries that use this timespan */
timespan_bounds = config_map.equal_range (current_timespan);
graph_builder->reset ();
graph_builder->set_current_timespan (current_timespan);
+ handle_duplicate_format_extensions();
for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
// Filenames can be shared across timespans
FileSpec & spec = it->second;
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);
+ session.start_audio_export (process_position);
+}
+
+void
+ExportHandler::handle_duplicate_format_extensions()
+{
+ typedef std::map<std::string, int> ExtCountMap;
+
+ ExtCountMap counts;
+ for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
+ counts[it->second.format->extension()]++;
+ }
+
+ bool duplicates_found = false;
+ for (ExtCountMap::iterator it = counts.begin(); it != counts.end(); ++it) {
+ if (it->second > 1) { duplicates_found = true; }
+ }
+
+ // Set this always, as the filenames are shared...
+ for (ConfigMap::iterator it = timespan_bounds.first; it != timespan_bounds.second; ++it) {
+ it->second.filename->include_format_name = duplicates_found;
+ }
}
int
process_position += frames_to_read;
export_status->processed_frames += frames_to_read;
- export_status->progress = (float) export_status->processed_frames /
- export_status->total_frames;
+ export_status->processed_frames_current_timespan += frames_to_read;
/* Do actual processing */
int ret = graph_builder->process (frames_to_read, last_cycle);
export_status->normalizing = true;
}
- export_status->progress = (float) export_status->current_normalize_cycle /
- export_status->total_normalize_cycles;
export_status->current_normalize_cycle++;
return 0;
}
+void
+ExportHandler::command_output(std::string output, size_t size)
+{
+ std::cerr << "command: " << size << ", " << output << std::endl;
+ info << output << endmsg;
+}
+
void
ExportHandler::finish_timespan ()
{
while (config_map.begin() != timespan_bounds.second) {
ExportFormatSpecPtr fmt = config_map.begin()->second.format;
+ std::string filename = config_map.begin()->second.filename->get_path(fmt);
if (fmt->with_cue()) {
- export_cd_marker_file (current_timespan, fmt, config_map.begin()->second.filename->get_path(fmt), CDMarkerCUE);
- }
+ export_cd_marker_file (current_timespan, fmt, filename, CDMarkerCUE);
+ }
if (fmt->with_toc()) {
- export_cd_marker_file (current_timespan, fmt, config_map.begin()->second.filename->get_path(fmt), CDMarkerTOC);
+ export_cd_marker_file (current_timespan, fmt, filename, CDMarkerTOC);
+ }
+
+ if (fmt->tag()) {
+ AudiofileTagger::tag_file(filename, *SessionMetadata::Metadata());
+ }
+
+ if (!fmt->command().empty()) {
+
+#if 0 // would be nicer with C++11 initialiser...
+ std::map<char, std::string> subs {
+ { 'f', filename },
+ { 'd', Glib::path_get_dirname(filename) },
+ { 'b', PBD::basename_nosuffix(filename) },
+ { 'u', upload_username },
+ { 'p', upload_password}
+ };
+#endif
+
+ 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)));
+ subs.insert (std::pair<char, std::string> ('b', PBD::basename_nosuffix(filename)));
+ subs.insert (std::pair<char, std::string> ('u', upload_username));
+ subs.insert (std::pair<char, std::string> ('p', upload_password));
+
+
+ std::cerr << "running command: " << fmt->command() << "..." << std::endl;
+ ARDOUR::SystemExec *se = new ARDOUR::SystemExec(fmt->command(), subs);
+ se->ReadStdout.connect_same_thread(command_connection, boost::bind(&ExportHandler::command_output, this, _1, _2));
+ if (se->start (2) == 0) {
+ // successfully started
+ std::cerr << "started!" << std::endl;
+ while (se->is_running ()) {
+ // wait for system exec to terminate
+ // std::cerr << "waiting..." << std::endl;
+ usleep (1000);
+ }
+ }
+ std::cerr << "done! deleting..." << std::endl;
+ delete (se);
}
+ if (fmt->upload()) {
+ SoundcloudUploader *soundcloud_uploader = new SoundcloudUploader;
+ std::string token = soundcloud_uploader->Get_Auth_Token(upload_username, upload_password);
+ std::cerr
+ << "uploading "
+ << filename << std::endl
+ << "username = " << upload_username
+ << ", password = " << upload_password
+ << " - token = " << token << " ..."
+ << std::endl;
+ std::string path = soundcloud_uploader->Upload (
+ filename,
+ PBD::basename_nosuffix(filename), // title
+ token,
+ upload_public,
+ this);
+
+ if (path.length() != 0) {
+ if (upload_open) {
+ std::cerr << "opening " << path << " ..." << std::endl;
+ open_uri(path.c_str()); // open the soundcloud website to the new file
+ }
+ } else {
+ error << _("upload to Soundcloud failed. Perhaps your email or password are incorrect?\n") << endmsg;
+ }
+ delete soundcloud_uploader;
+ }
config_map.erase (config_map.begin());
}
start_timespan ();
}
-/*** CD Marker sutff ***/
+/*** CD Marker stuff ***/
struct LocationSortByStart {
bool operator() (Location *a, Location *b) {
} catch (std::exception& e) {
error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
- ::unlink (filepath.c_str());
+ ::g_unlink (filepath.c_str());
} catch (Glib::Exception& e) {
error << string_compose (_("an error occured while writing a TOC/CUE file: %1"), e.what()) << endmsg;
- ::unlink (filepath.c_str());
+ ::g_unlink (filepath.c_str());
}
}
{
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;
-
- /* 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 << "REM Cue file generated by " << PROGRAM_NAME << endl;
+ status.out << "TITLE " << cue_escape_cdtext (title) << endl;
+
+ /* The original cue sheet sepc metions five file types
+ WAVE, AIFF,
+ BINARY = "header-less" audio (44.1 kHz, 16 Bit, little endian),
+ MOTOROLA = "header-less" audio (44.1 kHz, 16 Bit, big endian),
+ and MP3
+
+ We try to use these file types whenever appropriate and
+ default to our own names otherwise.
*/
-
status.out << "FILE \"" << Glib::path_get_basename(status.filename) << "\" ";
- if (!status.format->format_name().compare ("WAV")) {
+ if (!status.format->format_name().compare ("WAV") || !status.format->format_name().compare ("BWF")) {
status.out << "WAVE";
} else if (status.format->format_id() == ExportFormatBase::F_RAW &&
status.format->sample_format() == ExportFormatBase::SF_16 &&
status.out << "MOTOROLA";
}
} else {
- // AIFF should return "AIFF"
+ // no special case for AIFF format it's name is already "AIFF"
status.out << status.format->format_name();
}
status.out << endl;
if (status.marker->cd_info.find("isrc") != status.marker->cd_info.end()) {
status.out << " ISRC " << status.marker->cd_info["isrc"] << endl;
-
}
if (status.marker->name() != "") {
- status.out << " TITLE \"" << status.marker->name() << '"' << endl;
+ status.out << " TITLE " << cue_escape_cdtext (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;
- } else {
- status.out << " PERFORMER \"\"" << endl;
+ status.out << " PERFORMER " << cue_escape_cdtext (status.marker->cd_info["performer"]) << endl;
}
if (status.marker->cd_info.find("composer") != status.marker->cd_info.end()) {
- status.out << " SONGWRITER \"" << status.marker->cd_info["composer"] << '"' << endl;
+ status.out << " SONGWRITER " << cue_escape_cdtext (status.marker->cd_info["composer"]) << endl;
}
if (status.track_position != status.track_start_frame) {
return out;
}
+std::string
+ExportHandler::cue_escape_cdtext (const std::string& txt)
+{
+ std::string latin1_txt;
+ std::string out;
+
+ try {
+ latin1_txt = Glib::convert (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));
+ }
+
+ // does not do much mor than UTF-8 to Latin1 translation yet, but
+ // that may have to change if cue parsers in burning programs change
+ out = '"' + latin1_txt + '"';
+
+ return out;
+}
+
} // namespace ARDOUR
projects / ardour.git / blobdiff