2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include "libardour-config.h"
35 #include <samplerate.h>
37 #include "pbd/gstdio_compat.h"
40 #include <boost/scoped_array.hpp>
41 #include <boost/scoped_ptr.hpp>
42 #include <boost/shared_array.hpp>
44 #include "pbd/basename.h"
45 #include "pbd/convert.h"
47 #include "evoral/SMF.hpp"
49 #include "ardour/analyser.h"
50 #include "ardour/ardour.h"
51 #include "ardour/audioengine.h"
52 #include "ardour/audioregion.h"
53 #include "ardour/import_status.h"
54 #include "ardour/region_factory.h"
55 #include "ardour/resampled_source.h"
56 #include "ardour/runtime_functions.h"
57 #include "ardour/session.h"
58 #include "ardour/session_directory.h"
59 #include "ardour/smf_source.h"
60 #include "ardour/sndfile_helpers.h"
61 #include "ardour/sndfileimportable.h"
62 #include "ardour/sndfilesource.h"
63 #include "ardour/source_factory.h"
64 #include "ardour/tempo.h"
67 #include "ardour/caimportable.h"
73 using namespace ARDOUR;
76 static boost::shared_ptr<ImportableSource>
77 open_importable_source (const string& path, samplecnt_t samplerate, ARDOUR::SrcQuality quality)
79 /* try libsndfile first, because it can get BWF info from .wav, which ExtAudioFile cannot.
80 We don't necessarily need that information in an ImportableSource, but it keeps the
81 logic the same as in SourceFactory::create()
85 boost::shared_ptr<SndFileImportableSource> source(new SndFileImportableSource(path));
87 if (source->samplerate() == samplerate) {
91 /* rewrap as a resampled source */
93 return boost::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
100 /* libsndfile failed, see if we can use CoreAudio to handle the IO */
102 CAImportableSource* src = new CAImportableSource(path);
103 boost::shared_ptr<CAImportableSource> source (src);
105 if (source->samplerate() == samplerate) {
109 /* rewrap as a resampled source */
111 return boost::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
121 Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels,
122 vector<string> const & smf_track_names)
125 vector<string> new_paths;
126 const string basename = basename_nosuffix (import_file_path);
128 for (uint32_t n = 0; n < channels; ++n) {
130 const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
135 assert (smf_track_names.empty() || smf_track_names.size() == channels);
138 if (smf_track_names.empty() || smf_track_names[n].empty()) {
139 mchn_name = string_compose ("%1-t%2", basename, n);
141 mchn_name = string_compose ("%1-%2", basename, smf_track_names[n]);
143 filepath = new_midi_source_path (mchn_name);
145 filepath = new_midi_source_path (basename);
148 case DataType::AUDIO:
149 filepath = new_audio_source_path (basename, channels, n, false, false);
153 if (filepath.empty()) {
154 error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg;
155 return vector<string>();
158 new_paths.push_back (filepath);
165 map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
166 uint32_t /*samplerate*/, vector<boost::shared_ptr<Source> >& newfiles, Session *session)
168 for (vector<string>::const_iterator i = new_paths.begin();
169 i != new_paths.end(); ++i)
171 boost::shared_ptr<Source> source = session->audio_source_by_path_and_channel(*i, 0);
174 error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
178 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
184 create_mono_sources_for_writing (const vector<string>& new_paths,
185 Session& sess, uint32_t samplerate,
186 vector<boost::shared_ptr<Source> >& newfiles,
187 samplepos_t timeline_position)
189 for (vector<string>::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) {
191 boost::shared_ptr<Source> source;
194 const DataType type = SMFSource::safe_midi_file_extension (*i) ? DataType::MIDI : DataType::AUDIO;
196 source = SourceFactory::createWritable (type, sess,
198 false, // destructive
202 catch (const failed_constructor& err) {
203 error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg;
207 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
209 /* for audio files, reset the timeline position so that any BWF-ish
210 information in the original files we are importing from is maintained.
213 boost::shared_ptr<AudioFileSource> afs;
214 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
215 afs->set_timeline_position(timeline_position);
222 compose_status_message (const string& path,
223 uint32_t file_samplerate,
224 uint32_t session_samplerate,
225 uint32_t /* current_file */,
226 uint32_t /* total_files */)
228 if (file_samplerate != session_samplerate) {
229 return string_compose (_("Resampling %1 from %2kHz to %3kHz"),
230 Glib::path_get_basename (path),
231 file_samplerate/1000.0f,
232 session_samplerate/1000.0f);
235 return string_compose (_("Copying %1"), Glib::path_get_basename (path));
239 write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
240 vector<boost::shared_ptr<Source> >& newfiles)
242 const samplecnt_t nframes = ResampledImportableSource::blocksize;
243 boost::shared_ptr<AudioFileSource> afs;
244 uint32_t channels = source->channels();
249 boost::scoped_array<float> data(new float[nframes * channels]);
250 vector<boost::shared_array<Sample> > channel_data;
252 for (uint32_t n = 0; n < channels; ++n) {
253 channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
258 boost::shared_ptr<AudioSource> s = boost::dynamic_pointer_cast<AudioSource> (newfiles[0]);
261 status.progress = 0.0f;
262 float progress_multiplier = 1;
263 float progress_base = 0;
264 const float progress_length = source->ratio() * source->length();
266 if (!source->clamped_at_unity() && s->clamped_at_unity()) {
268 /* The source we are importing from can return sample values with a magnitude greater than 1,
269 and the file we are writing the imported data to cannot handle such values. Compute the gain
270 factor required to normalize the input sources to have a magnitude of less than 1.
274 uint32_t read_count = 0;
276 while (!status.cancel) {
277 samplecnt_t const nread = source->read (data.get(), nframes * channels);
282 peak = compute_peak (data.get(), nread, peak);
284 read_count += nread / channels;
285 status.progress = 0.5 * read_count / progress_length;
289 /* we are out of range: compute a gain to fix it */
290 gain = (1 - FLT_EPSILON) / peak;
294 progress_multiplier = 0.5;
298 samplecnt_t read_count = 0;
300 while (!status.cancel) {
302 samplecnt_t nread, nfread;
306 if ((nread = source->read (data.get(), nframes * channels)) == 0) {
307 #ifdef PLATFORM_WINDOWS
308 /* Flush the data once we've finished importing the file. Windows can */
309 /* cache the data for very long periods of time (perhaps not writing */
310 /* it to disk until Ardour closes). So let's force it to flush now. */
311 for (chn = 0; chn < channels; ++chn)
312 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0)
319 /* here is the gain fix for out-of-range sample values that we computed earlier */
320 apply_gain_to_buffer (data.get(), nread, gain);
323 nfread = nread / channels;
327 for (chn = 0; chn < channels; ++chn) {
330 for (x = chn, n = 0; n < nfread; x += channels, ++n) {
331 channel_data[chn][n] = (Sample) data[x];
337 for (chn = 0; chn < channels; ++chn) {
338 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0) {
339 afs->write (channel_data[chn].get(), nfread);
343 read_count += nfread;
344 status.progress = progress_base + progress_multiplier * read_count / progress_length;
349 write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
350 vector<boost::shared_ptr<Source> >& newfiles,
353 uint32_t buf_size = 4;
354 uint8_t* buf = (uint8_t*) malloc (buf_size);
356 status.progress = 0.0f;
358 bool type0 = source->is_type0 () && split_type0;
359 const std::set<uint8_t>& chn = source->channels ();
362 num_tracks = source->channels().size();
364 num_tracks = source->num_tracks();
366 assert (newfiles.size() == num_tracks);
369 vector<boost::shared_ptr<Source> >::iterator s = newfiles.begin();
370 std::set<uint8_t>::const_iterator cur_chan = chn.begin();
372 for (unsigned i = 1; i <= num_tracks; ++i) {
374 boost::shared_ptr<SMFSource> smfs = boost::dynamic_pointer_cast<SMFSource> (*s);
376 Glib::Threads::Mutex::Lock source_lock(smfs->mutex());
378 smfs->drop_model (source_lock);
380 source->seek_to_start ();
382 source->seek_to_track (i);
386 uint32_t delta_t = 0;
390 while (!status.cancel) {
391 gint note_id_ignored; // imported files either don't have NoteID's or we ignore them.
395 int ret = source->read_event (&delta_t, &size, &buf, ¬e_id_ignored);
397 if (size > buf_size) {
401 if (ret < 0) { // EOT
407 if (ret == 0) { // Meta
411 // type-0 files separate by channel
413 uint8_t type = buf[0] & 0xf0;
414 uint8_t chan = buf[0] & 0x0f;
415 if (type >= 0x80 && type <= 0xE0) {
416 if (chan != *cur_chan) {
423 smfs->mark_streaming_write_started (source_lock);
427 smfs->append_event_beats(
429 Evoral::Event<Temporal::Beats>(
431 Temporal::Beats::ticks_at_rate(t, source->ppqn()),
435 if (status.progress < 0.99) {
436 status.progress += 0.01;
442 /* we wrote something */
444 const samplepos_t pos = 0;
445 const Temporal::Beats length_beats = Temporal::Beats::ticks_at_rate(t, source->ppqn());
446 BeatsSamplesConverter converter(smfs->session().tempo_map(), pos);
447 smfs->update_length(pos + converter.to(length_beats.round_up_to_beat()));
448 smfs->mark_streaming_write_completed (source_lock);
454 info << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, num_tracks) << endmsg;
463 } catch (exception& e) {
464 error << string_compose (_("MIDI file could not be written (best guess: %1)"), e.what()) << endmsg;
473 remove_file_source (boost::shared_ptr<Source> source)
475 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
477 fs->DropReferences ();
480 ::g_unlink (fs->path().c_str());
484 // This function is still unable to cleanly update an existing source, even though
485 // it is possible to set the ImportStatus flag accordingly. The functinality
486 // is disabled at the GUI until the Source implementations are able to provide
487 // the necessary API.
489 Session::import_files (ImportStatus& status)
491 typedef vector<boost::shared_ptr<Source> > Sources;
492 Sources all_new_sources;
493 boost::shared_ptr<AudioFileSource> afs;
494 boost::shared_ptr<SMFSource> smfs;
495 uint32_t channels = 0;
496 vector<string> smf_names;
498 status.sources.clear ();
500 for (vector<string>::const_iterator p = status.paths.begin();
501 p != status.paths.end() && !status.cancel;
504 boost::shared_ptr<ImportableSource> source;
506 const DataType type = SMFSource::safe_midi_file_extension (*p) ? DataType::MIDI : DataType::AUDIO;
507 boost::scoped_ptr<Evoral::SMF> smf_reader;
509 if (type == DataType::AUDIO) {
511 source = open_importable_source (*p, sample_rate(), status.quality);
512 channels = source->channels();
513 } catch (const failed_constructor& err) {
514 error << string_compose(_("Import: cannot open input sound file \"%1\""), (*p)) << endmsg;
515 status.done = status.cancel = true;
521 smf_reader.reset (new Evoral::SMF());
523 if (smf_reader->open(*p)) {
524 throw Evoral::SMF::FileError (*p);
527 if (smf_reader->is_type0 () && status.split_midi_channels) {
528 channels = smf_reader->channels().size();
530 channels = smf_reader->num_tracks();
531 switch (status.midi_track_name_source) {
535 smf_reader->track_names (smf_names);
537 case SMFInstrumentName:
538 smf_reader->instrument_names (smf_names);
543 error << _("Import: error opening MIDI file") << endmsg;
544 status.done = status.cancel = true;
550 error << _("Import: file contains no channels.") << endmsg;
554 vector<string> new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, channels, smf_names);
556 samplepos_t natural_position = source ? source->natural_position() : 0;
559 if (status.replace_existing_source) {
560 fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg;
561 status.cancel = !map_existing_mono_sources (new_paths, *this, sample_rate(), newfiles, this);
563 status.cancel = !create_mono_sources_for_writing (new_paths, *this, sample_rate(), newfiles, natural_position);
566 // copy on cancel/failure so that any files that were created will be removed below
567 std::copy (newfiles.begin(), newfiles.end(), std::back_inserter(all_new_sources));
573 for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) {
574 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*i)) != 0) {
575 afs->prepare_for_peakfile_writes ();
579 if (source) { // audio
580 status.doing_what = compose_status_message (*p, source->samplerate(),
581 sample_rate(), status.current, status.total);
582 write_audio_data_to_new_files (source.get(), status, newfiles);
583 } else if (smf_reader) { // midi
584 status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
585 write_midi_data_to_new_files (smf_reader.get(), status, newfiles, status.split_midi_channels);
592 if (!status.cancel) {
596 now = localtime (&xnow);
597 status.freeze = true;
599 /* flush the final length(s) to the header(s) */
601 for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
603 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
604 afs->update_header((*x)->natural_position(), *now, xnow);
605 afs->done_with_peakfile_writes ();
607 /* now that there is data there, requeue the file for analysis */
609 if (Config->get_auto_analyse_audio()) {
610 Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
614 /* imported, copied files cannot be written or removed
617 boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource>(*x);
619 /* Only audio files should be marked as
620 immutable - we may need to rewrite MIDI
623 if (boost::dynamic_pointer_cast<AudioFileSource> (fs)) {
624 fs->mark_immutable ();
626 fs->mark_immutable_except_write ();
628 fs->mark_nonremovable ();
631 /* don't create tracks for empty MIDI sources (channels) */
633 if ((smfs = boost::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
634 x = all_new_sources.erase(x);
640 /* save state so that we don't lose these new Sources */
644 std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
647 std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
649 error << _("Failed to remove some files after failed/cancelled import operation") << endmsg;