X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fimport.cc;h=deba3efb05f916c1e19ba0e220fac3e4a5e393d8;hb=0bee288b5d6c6ca1fb33b8bc3b584c6d2c3d3364;hp=9bf7033c0b4829406fc86ee1c1c29978e1a665ce;hpb=cb413146428ce5db5e281d70f2b3b7df27c1aaab;p=ardour.git diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc index 9bf7033c0b..deba3efb05 100644 --- a/libs/ardour/import.cc +++ b/libs/ardour/import.cc @@ -1,5 +1,5 @@ /* - 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 @@ -17,6 +17,11 @@ */ + +#ifdef WAF_BUILD +#include "libardour-config.h" +#endif + #include #include #include @@ -25,6 +30,7 @@ #include #include #include +#include #include #include @@ -34,127 +40,139 @@ #include #include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "pbd/basename.h" +#include "pbd/convert.h" + +#include "evoral/SMF.hpp" + +#include "ardour/analyser.h" +#include "ardour/ardour.h" +#include "ardour/audio_diskstream.h" +#include "ardour/audioengine.h" +#include "ardour/audioregion.h" +#include "ardour/import_status.h" +#include "ardour/region_factory.h" +#include "ardour/resampled_source.h" +#include "ardour/session.h" +#include "ardour/session_directory.h" +#include "ardour/smf_source.h" +#include "ardour/sndfile_helpers.h" +#include "ardour/sndfileimportable.h" +#include "ardour/sndfilesource.h" +#include "ardour/source_factory.h" +#include "ardour/tempo.h" #ifdef HAVE_COREAUDIO -#include +#include "ardour/caimportable.h" #endif #include "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) { -#ifdef HAVE_COREAUDIO + /* 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() + */ - /* see if we can use CoreAudio to handle the IO */ - try { - boost::shared_ptr source(new CAImportableSource(path)); + 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)); } catch (...) { - /* fall back to SndFile */ - -#endif - - try { - boost::shared_ptr source(new SndFileImportableSource(path)); - - if (source->samplerate() == samplerate) { - return source; - } +#ifdef HAVE_COREAUDIO - /* rewrap as a resampled source */ - - return boost::shared_ptr(new ResampledImportableSource(source, samplerate, quality)); - } + /* libsndfile failed, see if we can use CoreAudio to handle the IO */ + + CAImportableSource* src = new CAImportableSource(path); + boost::shared_ptr source (src); - catch (...) { - throw; // rethrow + if (source->samplerate() == samplerate) { + return source; } -#ifdef HAVE_COREAUDIO - } + /* rewrap as a resampled source */ + + return boost::shared_ptr(new ResampledImportableSource(source, samplerate, quality)); + +#else + throw; // rethrow #endif + + } } static std::string -get_non_existent_filename (DataType type, const bool allow_replacing, const std::string destdir, const std::string& basename, uint channel, uint channels) +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); - const char* ext = (type == DataType::AUDIO) ? "wav" : "mid"; + string base = basename; + string ext = native_header_format_extension (hf, type); + uint32_t cnt = 1; do { if (type == DataType::AUDIO && channels == 2) { if (channel == 0) { - snprintf (buf, sizeof(buf), "%s-L.wav", base.c_str()); + if (cnt == 1) { + snprintf (buf, sizeof(buf), "%s-L%s", base.c_str(), ext.c_str()); + } else { + snprintf (buf, sizeof(buf), "%s-%d-L%s", base.c_str(), cnt, ext.c_str()); + } } else { - snprintf (buf, sizeof(buf), "%s-R.wav", base.c_str()); + if (cnt == 1) { + snprintf (buf, sizeof(buf), "%s-R%s", base.c_str(), ext.c_str()); + } else { + snprintf (buf, sizeof(buf), "%s-%d-R%s", base.c_str(), cnt, ext.c_str()); + } } } else if (channels > 1) { - snprintf (buf, sizeof(buf), "%s-c%d.%s", base.c_str(), channel, ext); + if (cnt == 1) { + snprintf (buf, sizeof(buf), "%s-c%d%s", base.c_str(), channel, ext.c_str()); + } else { + snprintf (buf, sizeof(buf), "%s-%d-c%d%s", base.c_str(), cnt, channel, ext.c_str()); + } } else { - snprintf (buf, sizeof(buf), "%s.%s", base.c_str(), ext); + if (cnt == 1) { + snprintf (buf, sizeof(buf), "%s%s", base.c_str(), ext.c_str()); + } else { + snprintf (buf, sizeof(buf), "%s-%d%s", base.c_str(), cnt, 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 += "_"; + + cnt++; } else { goodfile = true; } - } while ( !goodfile); + } while (!goodfile); return buf; } static vector -get_paths_for_new_sources (const bool allow_replacing, const string& import_file_path, const string& session_dir, uint channels) +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); @@ -163,17 +181,13 @@ get_paths_for_new_sources (const bool allow_replacing, const string& import_file for (uint n = 0; n < channels; ++n) { - const DataType type = (import_file_path.rfind(".mid") != string::npos) - ? DataType::MIDI : DataType::AUDIO; + const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO; std::string filepath = (type == DataType::MIDI) ? sdir.midi_path().to_string() : sdir.sound_path().to_string(); - filepath += '/'; - filepath += get_non_existent_filename (type, allow_replacing, filepath, basename, n, channels); - - cout << "NEW SOURCE PATH: " << filepath << endl; - + filepath = Glib::build_filename (filepath, + get_non_existent_filename (hf, type, allow_replacing, filepath, basename, n, channels)); new_paths.push_back (filepath); } @@ -181,8 +195,8 @@ get_paths_for_new_sources (const bool allow_replacing, const string& import_file } static bool -map_existing_mono_sources (const vector& new_paths, Session& sess, - uint samplerate, vector >& newfiles, Session *session) +map_existing_mono_sources (const vector& new_paths, Session& /*sess*/, + uint /*samplerate*/, vector >& newfiles, Session *session) { for (vector::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) @@ -200,63 +214,67 @@ 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) +create_mono_sources_for_writing (const string& origin, + const vector& new_paths, + Session& sess, uint 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 - { - const DataType type = ((*i).rfind(".mid") != string::npos) - ? DataType::MIDI : DataType::AUDIO; - - source = SourceFactory::createWritable ( - type, - sess, - i->c_str(), - false, // destructive - samplerate - ); + try { + const DataType type = SMFSource::safe_midi_file_extension (*i) ? DataType::MIDI : DataType::AUDIO; + + source = SourceFactory::createWritable (type, sess, + i->c_str(), + origin, + 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. + */ + + boost::shared_ptr afs; + if ((afs = boost::dynamic_pointer_cast(source)) != 0) { + afs->set_timeline_position(timeline_position); + } } return true; } -static Glib::ustring +static string compose_status_message (const string& path, uint file_samplerate, uint session_samplerate, - uint current_file, - uint total_files) + uint /* current_file */, + uint /* total_files */) { if (file_samplerate != session_samplerate) { - return string_compose (_("converting %1\n(resample from %2KHz to %3KHz)\n(%4 of %5)"), + return string_compose (_("Resampling %1 from %2kHz to %3kHz"), Glib::path_get_basename (path), file_samplerate/1000.0f, - session_samplerate/1000.0f, - current_file, total_files); + session_samplerate/1000.0f); } - - return string_compose (_("converting %1\n(%2 of %3)"), - Glib::path_get_basename (path), - current_file, total_files); + + return string_compose (_("Copying %1"), Glib::path_get_basename (path)); } static void -write_audio_data_to_new_files (ImportableSource* source, Session::import_status& status, +write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, vector >& newfiles) { - const nframes_t nframes = ResampledImportableSource::blocksize; + const framecnt_t nframes = ResampledImportableSource::blocksize; boost::shared_ptr afs; uint channels = source->channels(); @@ -266,26 +284,72 @@ write_audio_data_to_new_files (ImportableSource* source, Session::import_status& for (uint n = 0; n < channels; ++n) { channel_data.push_back(boost::shared_array(new Sample[nframes])); } - - uint read_count = 0; + + float gain = 1; + + boost::shared_ptr s = boost::dynamic_pointer_cast (newfiles[0]); + assert (s); + status.progress = 0.0f; + float progress_multiplier = 1; + float progress_base = 0; + + if (!source->clamped_at_unity() && s->clamped_at_unity()) { + + /* The source we are importing from can return sample values with a magnitude greater than 1, + 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; + + while (!status.cancel) { + framecnt_t const nread = source->read (data.get(), nframes); + if (nread == 0) { + break; + } + + peak = compute_peak (data.get(), nread, peak); + + read_count += nread; + status.progress = 0.5 * read_count / (source->ratio() * source->length() * channels); + } + + if (peak >= 1) { + /* 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; while (!status.cancel) { - nframes_t nread, nfread; + framecnt_t nread, nfread; uint x; uint chn; if ((nread = source->read (data.get(), nframes)) == 0) { break; } + + if (gain != 1) { + /* 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]; } @@ -300,63 +364,79 @@ write_audio_data_to_new_files (ImportableSource* source, Session::import_status& } read_count += nread; - status.progress = read_count / (source->ratio () * source->length() * channels); + status.progress = progress_base + progress_multiplier * read_count / (source->ratio () * source->length() * channels); } } static void -write_midi_data_to_new_files (SMFReader* source, Session::import_status& status, - vector >& newfiles) +write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status, + vector >& newfiles) { - MIDI::Event ev(0.0, 4, NULL, true); + uint32_t buf_size = 4; + uint8_t* buf = (uint8_t*)malloc(buf_size); status.progress = 0.0f; try { for (unsigned i = 1; i <= source->num_tracks(); ++i) { - boost::shared_ptr smfs = boost::dynamic_pointer_cast(newfiles[i-1]); - + smfs->drop_model(); + source->seek_to_track(i); - + uint64_t t = 0; uint32_t delta_t = 0; uint32_t size = 0; - + bool first = true; + while (!status.cancel) { + gint 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, &ignored); + if (size > buf_size) + buf_size = size; - if (source->read_event(4, ev.buffer(), &size, &delta_t) < 0) + if (ret < 0) { // EOT break; + } t += delta_t; - ev.time() = (double)t / (double)source->ppqn(); - ev.size() = size; - smfs->append_event_unlocked(Beats, ev); + if (ret == 0) { // Meta + continue; + } + + 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; } - - nframes_t timeline_position = 0; // FIXME: ? - - // FIXME: kluuuuudge: assumes tempo never changes after start - const double frames_per_beat = smfs->session().tempo_map().tempo_at( - timeline_position).frames_per_beat( - smfs->session().engine().frame_rate(), - smfs->session().tempo_map().meter_at(timeline_position)); - - smfs->update_length(0, (nframes_t) floor ((t * source->ppqn()) * frames_per_beat)); - smfs->flush_header(); - smfs->flush_footer(); + const framepos_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 (status.cancel) + if (status.cancel) { break; + } } } catch (...) { - error << "Corrupt MIDI file " << source->filename() << endl; + error << "Corrupt MIDI file " << source->file_path() << endl; } } @@ -367,30 +447,28 @@ remove_file_source (boost::shared_ptr source) } // This function is still unable to cleanly update an existing source, even though -// it is possible to set the import_status flag accordingly. The functinality +// it is possible to set the ImportStatus flag accordingly. The functinality // is disabled at the GUI until the Source implementations are able to provide // the necessary API. void -Session::import_audiofiles (import_status& status) +Session::import_audiofiles (ImportStatus& status) { - uint32_t cnt = 1; typedef vector > Sources; Sources all_new_sources; boost::shared_ptr afs; + boost::shared_ptr smfs; uint channels = 0; status.sources.clear (); - - for (vector::iterator p = status.paths.begin(); - p != status.paths.end() && !status.cancel; - ++p, ++cnt) - { + for (vector::iterator p = status.paths.begin(); + p != status.paths.end() && !status.cancel; + ++p) + { boost::shared_ptr source; - std::auto_ptr smf_reader; - const DataType type = ((*p).rfind(".mid") != string::npos) ? - DataType::MIDI : DataType::AUDIO; - + std::auto_ptr smf_reader; + const DataType type = SMFSource::safe_midi_file_extension (*p) ? DataType::MIDI : DataType::AUDIO; + if (type == DataType::AUDIO) { try { source = open_importable_source (*p, frame_rate(), status.quality); @@ -403,35 +481,36 @@ Session::import_audiofiles (import_status& status) } else { try { - smf_reader = std::auto_ptr(new SMFReader(*p)); + smf_reader = std::auto_ptr(new Evoral::SMF()); + smf_reader->open(*p); channels = smf_reader->num_tracks(); - } catch (const SMFReader::UnsupportedTime& err) { - error << _("Import: unsupported MIDI time stamp format") << endmsg; - status.done = status.cancel = true; - return; } catch (...) { - error << _("Import: error reading MIDI file") << endmsg; + error << _("Import: error opening MIDI file") << endmsg; status.done = status.cancel = true; return; } } - vector new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, + 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); 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!" << endl; + 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); + status.cancel = !create_mono_sources_for_writing (*p, new_paths, *this, frame_rate(), newfiles, natural_position); } // copy on cancel/failure so that any files that were created will be removed below std::copy (newfiles.begin(), newfiles.end(), std::back_inserter(all_new_sources)); - if (status.cancel) break; + if (status.cancel) { + break; + } for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) { if ((afs = boost::dynamic_pointer_cast(*i)) != 0) { @@ -441,12 +520,15 @@ Session::import_audiofiles (import_status& status) if (source) { // audio status.doing_what = compose_status_message (*p, source->samplerate(), - frame_rate(), cnt, status.paths.size()); + 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); + status.doing_what = string_compose(_("Loading MIDI file %1"), *p); write_midi_data_to_new_files (smf_reader.get(), status, newfiles); } + + ++status.current; + status.progress = 0; } if (!status.cancel) { @@ -458,19 +540,24 @@ Session::import_audiofiles (import_status& status) /* flush the final length(s) to the header(s) */ - for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ++x) - { - cout << "NEW SOURCE: " << (*x)->path() << endl; - + for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) { if ((afs = boost::dynamic_pointer_cast(*x)) != 0) { - afs->update_header(0, *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 */ + + if (Config->get_auto_analyse_audio()) { + Analyser::queue_source_for_analysis (boost::static_pointer_cast(*x), false); + } } - - /* now that there is data there, requeue the file for analysis */ - - if (Config->get_auto_analyse_audio()) { - Analyser::queue_source_for_analysis (boost::static_pointer_cast(*x), false); + + /* don't create tracks for empty MIDI sources (channels) */ + + if ((smfs = boost::dynamic_pointer_cast(*x)) != 0 && smfs->is_empty()) { + x = all_new_sources.erase(x); + } else { + ++x; } } @@ -478,8 +565,7 @@ Session::import_audiofiles (import_status& status) save_state (_name); - std::copy (all_new_sources.begin(), all_new_sources.end(), - std::back_inserter(status.sources)); + 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);