X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Fimport.cc;h=431b1d75e79d8ef299f9f024ad0dc408fff2d1b5;hb=b23d7d9170a12cbcd788e1c2cbcf688f376752ed;hp=13fb859efe9081311583134e8b9d3e40dcac7a63;hpb=8e00b86ebb0b6e3fd489b4cac58863d7c16465db;p=ardour.git diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc index 13fb859efe..431b1d75e7 100644 --- a/libs/ardour/import.cc +++ b/libs/ardour/import.cc @@ -1,23 +1,22 @@ /* - Copyright (C) 2000 Paul Davis + Copyright (C) 2000 Paul Davis - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ - #ifdef WAF_BUILD #include "libardour-config.h" #endif @@ -35,6 +34,7 @@ #include #include +#include "pbd/gstdio_compat.h" #include #include @@ -53,6 +53,7 @@ #include "ardour/import_status.h" #include "ardour/region_factory.h" #include "ardour/resampled_source.h" +#include "ardour/runtime_functions.h" #include "ardour/session.h" #include "ardour/session_directory.h" #include "ardour/smf_source.h" @@ -66,29 +67,29 @@ #include "ardour/caimportable.h" #endif -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; using namespace PBD; static boost::shared_ptr -open_importable_source (const string& path, nframes_t samplerate, ARDOUR::SrcQuality quality) +open_importable_source (const string& path, framecnt_t samplerate, ARDOUR::SrcQuality quality) { /* try libsndfile first, because it can get BWF info from .wav, which ExtAudioFile cannot. - We don't necessarily need that information in an ImportableSource, but it keeps the - logic the same as in SourceFactory::create() - */ + We don't necessarily need that information in an ImportableSource, but it keeps the + logic the same as in SourceFactory::create() + */ - try { + try { boost::shared_ptr source(new SndFileImportableSource(path)); - + if (source->samplerate() == samplerate) { return source; } - + /* rewrap as a resampled source */ - + return boost::shared_ptr(new ResampledImportableSource(source, samplerate, quality)); } @@ -97,16 +98,16 @@ open_importable_source (const string& path, nframes_t samplerate, ARDOUR::SrcQua #ifdef HAVE_COREAUDIO /* libsndfile failed, see if we can use CoreAudio to handle the IO */ - + CAImportableSource* src = new CAImportableSource(path); boost::shared_ptr source (src); - + if (source->samplerate() == samplerate) { return source; } - + /* rewrap as a resampled source */ - + return boost::shared_ptr(new ResampledImportableSource(source, samplerate, quality)); #else @@ -116,66 +117,44 @@ open_importable_source (const string& path, nframes_t samplerate, ARDOUR::SrcQua } } -static std::string -get_non_existent_filename (HeaderFormat hf, DataType type, const bool allow_replacing, const std::string& destdir, const std::string& basename, uint channel, uint channels) -{ - char buf[PATH_MAX+1]; - bool goodfile = false; - string base(basename); - string ext = native_header_format_extension (hf, type); - - do { - - if (type == DataType::AUDIO && channels == 2) { - if (channel == 0) { - snprintf (buf, sizeof(buf), "%s-L%s", base.c_str(), ext.c_str()); - } else { - snprintf (buf, sizeof(buf), "%s-R%s", base.c_str(), ext.c_str()); - } - } else if (channels > 1) { - snprintf (buf, sizeof(buf), "%s-c%d%s", base.c_str(), channel, ext.c_str()); - } else { - snprintf (buf, sizeof(buf), "%s%s", base.c_str(), ext.c_str()); - } - - - string tempname = destdir + "/" + buf; - if (!allow_replacing && Glib::file_test (tempname, Glib::FILE_TEST_EXISTS)) { - - /* if the file already exists, we must come up with - * a new name for it. for now we just keep appending - * _ to basename - */ - - base += "_"; - - } else { - - goodfile = true; - } - - } while ( !goodfile); - - return buf; -} +vector +Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels, + vector const & smf_track_names) -static vector -get_paths_for_new_sources (HeaderFormat hf, const bool allow_replacing, const string& import_file_path, const string& session_dir, uint channels) { vector new_paths; const string basename = basename_nosuffix (import_file_path); - SessionDirectory sdir(session_dir); - - for (uint n = 0; n < channels; ++n) { + for (uint32_t n = 0; n < channels; ++n) { const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO; + string filepath; + + switch (type) { + case DataType::MIDI: + assert (smf_track_names.empty() || smf_track_names.size() == channels); + if (channels > 1) { + string mchn_name; + if (smf_track_names.empty() || smf_track_names[n].empty()) { + mchn_name = string_compose ("%1-t%2", basename, n); + } else { + mchn_name = string_compose ("%1-%2", basename, smf_track_names[n]); + } + filepath = new_midi_source_path (mchn_name); + } else { + filepath = new_midi_source_path (basename); + } + break; + case DataType::AUDIO: + filepath = new_audio_source_path (basename, channels, n, false, false); + break; + } - std::string filepath = (type == DataType::MIDI) - ? sdir.midi_path().to_string() : sdir.sound_path().to_string(); + if (filepath.empty()) { + error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg; + return vector(); + } - filepath = Glib::build_filename (filepath, - get_non_existent_filename (hf, type, allow_replacing, filepath, basename, n, channels)); new_paths.push_back (filepath); } @@ -184,12 +163,12 @@ get_paths_for_new_sources (HeaderFormat hf, const bool allow_replacing, const st static bool map_existing_mono_sources (const vector& new_paths, Session& /*sess*/, - uint /*samplerate*/, vector >& newfiles, Session *session) + uint32_t /*samplerate*/, vector >& newfiles, Session *session) { for (vector::const_iterator i = new_paths.begin(); - i != new_paths.end(); ++i) + i != new_paths.end(); ++i) { - boost::shared_ptr source = session->source_by_path_and_channel(*i, 0); + boost::shared_ptr source = session->audio_source_by_path_and_channel(*i, 0); if (source == 0) { error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl; @@ -202,72 +181,75 @@ map_existing_mono_sources (const vector& new_paths, Session& /*sess*/, } static bool -create_mono_sources_for_writing (const vector& new_paths, Session& sess, - uint samplerate, vector >& newfiles, - framepos_t timeline_position) +create_mono_sources_for_writing (const vector& new_paths, + Session& sess, uint32_t samplerate, + vector >& newfiles, + framepos_t timeline_position) { - for (vector::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) - { + for (vector::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) { + boost::shared_ptr source; - try - { + try { const DataType type = SMFSource::safe_midi_file_extension (*i) ? DataType::MIDI : DataType::AUDIO; source = SourceFactory::createWritable (type, sess, - i->c_str(), - false, // destructive - samplerate); + i->c_str(), + false, // destructive + samplerate); } - catch (const failed_constructor& err) - { + + catch (const failed_constructor& err) { error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg; return false; } newfiles.push_back(boost::dynamic_pointer_cast(source)); - /* for audio files, reset the timeline position so that any BWF-ish - information in the original files we are importing from is maintained. - */ + /* for audio files, reset the timeline position so that any BWF-ish + information in the original files we are importing from is maintained. + */ - boost::shared_ptr afs; - if ((afs = boost::dynamic_pointer_cast(source)) != 0) { - afs->set_timeline_position(timeline_position); - } + boost::shared_ptr afs; + if ((afs = boost::dynamic_pointer_cast(source)) != 0) { + afs->set_timeline_position(timeline_position); + } } return true; } static string compose_status_message (const string& path, - uint file_samplerate, - uint session_samplerate, - uint /* current_file */, - uint /* total_files */) + uint32_t file_samplerate, + uint32_t session_samplerate, + uint32_t /* current_file */, + uint32_t /* total_files */) { if (file_samplerate != session_samplerate) { return string_compose (_("Resampling %1 from %2kHz to %3kHz"), - Glib::path_get_basename (path), - file_samplerate/1000.0f, - session_samplerate/1000.0f); + Glib::path_get_basename (path), + file_samplerate/1000.0f, + session_samplerate/1000.0f); } - + return string_compose (_("Copying %1"), Glib::path_get_basename (path)); } static void write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, - vector >& newfiles) + vector >& newfiles) { - const nframes_t nframes = ResampledImportableSource::blocksize; + const framecnt_t nframes = ResampledImportableSource::blocksize; boost::shared_ptr afs; - uint channels = source->channels(); + uint32_t channels = source->channels(); + if (channels == 0) { + return; + } boost::scoped_array data(new float[nframes * channels]); vector > channel_data; - for (uint n = 0; n < channels; ++n) { + for (uint32_t n = 0; n < channels; ++n) { channel_data.push_back(boost::shared_array(new Sample[nframes])); } @@ -286,19 +268,19 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, and the file we are writing the imported data to cannot handle such values. Compute the gain factor required to normalize the input sources to have a magnitude of less than 1. */ - + float peak = 0; - uint read_count = 0; - + uint32_t read_count = 0; + while (!status.cancel) { - nframes_t const nread = source->read (data.get(), nframes); + framecnt_t const nread = source->read (data.get(), nframes * channels); if (nread == 0) { break; } - peak = compute_peak (data.get(), nread, peak); + peak = compute_peak (data.get(), nread * channels, peak); - read_count += nread; + read_count += nread / channels; status.progress = 0.5 * read_count / (source->ratio() * source->length() * channels); } @@ -306,21 +288,29 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, /* we are out of range: compute a gain to fix it */ gain = (1 - FLT_EPSILON) / peak; } - + source->seek (0); progress_multiplier = 0.5; progress_base = 0.5; } - uint read_count = 0; + framecnt_t read_count = 0; while (!status.cancel) { - nframes_t nread, nfread; - uint x; - uint chn; - - if ((nread = source->read (data.get(), nframes)) == 0) { + framecnt_t nread, nfread; + uint32_t x; + uint32_t chn; + + if ((nread = source->read (data.get(), nframes * channels)) == 0) { +#ifdef PLATFORM_WINDOWS + /* Flush the data once we've finished importing the file. Windows can */ + /* cache the data for very long periods of time (perhaps not writing */ + /* it to disk until Ardour closes). So let's force it to flush now. */ + for (chn = 0; chn < channels; ++chn) + if ((afs = boost::dynamic_pointer_cast(newfiles[chn])) != 0) + afs->flush (); +#endif break; } @@ -328,14 +318,14 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, /* here is the gain fix for out-of-range sample values that we computed earlier */ apply_gain_to_buffer (data.get(), nread, gain); } - + nfread = nread / channels; /* de-interleave */ for (chn = 0; chn < channels; ++chn) { - nframes_t n; + framecnt_t n; for (x = chn, n = 0; n < nfread; x += channels, ++n) { channel_data[chn][n] = (Sample) data[x]; } @@ -356,80 +346,138 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, static void write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status, - vector >& newfiles) + vector >& newfiles, + bool split_type0) { uint32_t buf_size = 4; - uint8_t* buf = (uint8_t*)malloc(buf_size); + uint8_t* buf = (uint8_t*) malloc (buf_size); status.progress = 0.0f; + uint16_t num_tracks; + bool type0 = source->is_type0 () && split_type0; + const std::set& chn = source->channels (); + + if (type0) { + num_tracks = source->channels().size(); + } else { + num_tracks = source->num_tracks(); + } + assert (newfiles.size() == num_tracks); try { + vector >::iterator s = newfiles.begin(); + std::set::const_iterator cur_chan = chn.begin(); - for (unsigned i = 1; i <= source->num_tracks(); ++i) { - boost::shared_ptr smfs = boost::dynamic_pointer_cast(newfiles[i-1]); - smfs->drop_model(); + for (unsigned i = 1; i <= num_tracks; ++i) { - source->seek_to_track(i); + boost::shared_ptr smfs = boost::dynamic_pointer_cast (*s); - uint64_t t = 0; - uint32_t delta_t = 0; - uint32_t size = 0; - bool first = true; + Glib::Threads::Mutex::Lock source_lock(smfs->mutex()); - while (!status.cancel) { - gint ignored; // imported files either don't have NoteID's or - // we ignore them. + smfs->drop_model (source_lock); + if (type0) { + source->seek_to_start (); + } else { + source->seek_to_track (i); + } - size = buf_size; - - int ret = source->read_event(&delta_t, &size, &buf, &ignored); - if (size > buf_size) - buf_size = size; + uint64_t t = 0; + uint32_t delta_t = 0; + uint32_t size = 0; + bool first = true; - if (ret < 0) { // EOT - break; - } + while (!status.cancel) { + gint note_id_ignored; // imported files either don't have NoteID's or we ignore them. + + size = buf_size; + + int ret = source->read_event (&delta_t, &size, &buf, ¬e_id_ignored); + + if (size > buf_size) { + buf_size = size; + } + + if (ret < 0) { // EOT + break; + } - t += delta_t; + t += delta_t; - if (ret == 0) { // Meta - continue; + if (ret == 0) { // Meta + continue; + } + + // type-0 files separate by channel + if (type0) { + uint8_t type = buf[0] & 0xf0; + uint8_t chan = buf[0] & 0x0f; + if (type >= 0x80 && type <= 0xE0) { + if (chan != *cur_chan) { + continue; + } + } + } + + if (first) { + smfs->mark_streaming_write_started (source_lock); + first = false; + } + + smfs->append_event_beats( + source_lock, + Evoral::Event( + Evoral::MIDI_EVENT, + Evoral::Beats::ticks_at_rate(t, source->ppqn()), + size, + buf)); + + if (status.progress < 0.99) { + status.progress += 0.01; + } } - - if (first) { - smfs->mark_streaming_write_started (); - first = false; - } - - smfs->append_event_unlocked_beats(Evoral::Event(0, - (double)t / (double)source->ppqn(), - size, - buf)); - - if (status.progress < 0.99) - status.progress += 0.01; - } - const nframes64_t pos = 0; - const double length_beats = ceil(t / (double)source->ppqn()); - BeatsFramesConverter converter(smfs->session().tempo_map(), pos); - smfs->update_length(pos, converter.to(length_beats)); - smfs->mark_streaming_write_completed (); + if (!first) { - if (status.cancel) { - break; + /* we wrote something */ + + const framepos_t pos = 0; + const Evoral::Beats length_beats = Evoral::Beats::ticks_at_rate(t, source->ppqn()); + BeatsFramesConverter converter(smfs->session().tempo_map(), pos); + smfs->update_length(pos + converter.to(length_beats.round_up_to_beat())); + smfs->mark_streaming_write_completed (source_lock); + + if (status.cancel) { + break; + } + } else { + info << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, num_tracks) << endmsg; + } + + ++s; // next source + if (type0) { + ++cur_chan; + } } + + } catch (exception& e) { + error << string_compose (_("MIDI file could not be written (best guess: %1)"), e.what()) << endmsg; } - } catch (...) { - error << "Corrupt MIDI file " << source->file_path() << endl; + if (buf) { + free (buf); } } static void remove_file_source (boost::shared_ptr source) { - ::unlink (source->path().c_str()); + boost::shared_ptr fs = boost::dynamic_pointer_cast (source); + + fs->DropReferences (); + + if (fs) { + ::g_unlink (fs->path().c_str()); + } } // This function is still unable to cleanly update an existing source, even though @@ -437,17 +485,18 @@ remove_file_source (boost::shared_ptr source) // is disabled at the GUI until the Source implementations are able to provide // the necessary API. void -Session::import_audiofiles (ImportStatus& status) +Session::import_files (ImportStatus& status) { typedef vector > Sources; Sources all_new_sources; boost::shared_ptr afs; boost::shared_ptr smfs; - uint channels = 0; + uint32_t channels = 0; + vector smf_names; status.sources.clear (); - for (vector::iterator p = status.paths.begin(); + for (vector::const_iterator p = status.paths.begin(); p != status.paths.end() && !status.cancel; ++p) { @@ -468,8 +517,26 @@ Session::import_audiofiles (ImportStatus& status) } else { try { smf_reader = std::auto_ptr(new Evoral::SMF()); - smf_reader->open(*p); - channels = smf_reader->num_tracks(); + + if (smf_reader->open(*p)) { + throw Evoral::SMF::FileError (*p); + } + + if (smf_reader->is_type0 () && status.split_midi_channels) { + channels = smf_reader->channels().size(); + } else { + channels = smf_reader->num_tracks(); + switch (status.midi_track_name_source) { + case SMFTrackNumber: + break; + case SMFTrackName: + smf_reader->track_names (smf_names); + break; + case SMFInstrumentName: + smf_reader->instrument_names (smf_names); + break; + } + } } catch (...) { error << _("Import: error opening MIDI file") << endmsg; status.done = status.cancel = true; @@ -477,18 +544,21 @@ Session::import_audiofiles (ImportStatus& status) } } - vector new_paths = get_paths_for_new_sources (config.get_native_file_header_format(), - status.replace_existing_source, *p, - get_best_session_directory_for_new_source (), - channels); + if (channels == 0) { + error << _("Import: file contains no channels.") << endmsg; + continue; + } + + vector new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, channels, smf_names); Sources newfiles; framepos_t natural_position = source ? source->natural_position() : 0; + if (status.replace_existing_source) { fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg; status.cancel = !map_existing_mono_sources (new_paths, *this, frame_rate(), newfiles, this); } else { - status.cancel = !create_mono_sources_for_writing (new_paths, *this, frame_rate(), newfiles, natural_position); + status.cancel = !create_mono_sources_for_writing (new_paths, *this, frame_rate(), newfiles, natural_position); } // copy on cancel/failure so that any files that were created will be removed below @@ -506,11 +576,11 @@ Session::import_audiofiles (ImportStatus& status) if (source) { // audio status.doing_what = compose_status_message (*p, source->samplerate(), - frame_rate(), status.current, status.total); + frame_rate(), status.current, status.total); write_audio_data_to_new_files (source.get(), status, newfiles); } else if (smf_reader.get()) { // midi status.doing_what = string_compose(_("Loading MIDI file %1"), *p); - write_midi_data_to_new_files (smf_reader.get(), status, newfiles); + write_midi_data_to_new_files (smf_reader.get(), status, newfiles, status.split_midi_channels); } ++status.current; @@ -527,8 +597,9 @@ Session::import_audiofiles (ImportStatus& status) /* flush the final length(s) to the header(s) */ for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) { + if ((afs = boost::dynamic_pointer_cast(*x)) != 0) { - afs->update_header((*x)->natural_position(), *now, xnow); + afs->update_header((*x)->natural_position(), *now, xnow); afs->done_with_peakfile_writes (); /* now that there is data there, requeue the file for analysis */ @@ -538,6 +609,23 @@ Session::import_audiofiles (ImportStatus& status) } } + /* imported, copied files cannot be written or removed + */ + + boost::shared_ptr fs = boost::dynamic_pointer_cast(*x); + if (fs) { + /* Only audio files should be marked as + immutable - we may need to rewrite MIDI + files at any time. + */ + if (boost::dynamic_pointer_cast (fs)) { + fs->mark_immutable (); + } else { + fs->mark_immutable_except_write (); + } + fs->mark_nonremovable (); + } + /* don't create tracks for empty MIDI sources (channels) */ if ((smfs = boost::dynamic_pointer_cast(*x)) != 0 && smfs->is_empty()) { @@ -553,8 +641,12 @@ Session::import_audiofiles (ImportStatus& status) std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources)); } else { - // this can throw...but it seems very unlikely - std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source); + try { + std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source); + } catch (...) { + error << _("Failed to remove some files after failed/cancelled import operation") << endmsg; + } + } status.done = true;