X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fimport.cc;h=431b1d75e79d8ef299f9f024ad0dc408fff2d1b5;hb=b23d7d9170a12cbcd788e1c2cbcf688f376752ed;hp=7c0deccca1a750fe6ed507fcfda63a62dab00669;hpb=99904735e066804358f1d0bd138a84f1e9ecda91;p=ardour.git diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc index 7c0deccca1..431b1d75e7 100644 --- a/libs/ardour/import.cc +++ b/libs/ardour/import.cc @@ -1,22 +1,26 @@ /* - 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 + #include #include #include @@ -25,359 +29,626 @@ #include #include #include +#include #include #include +#include "pbd/gstdio_compat.h" #include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -#include "i18n.h" - +#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/runtime_functions.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 "ardour/caimportable.h" +#endif + +#include "pbd/i18n.h" + +using namespace std; using namespace ARDOUR; using namespace PBD; -#define BLOCKSIZE 4096U - -class ImportableSource { - public: - ImportableSource (SNDFILE* sf, SF_INFO* info) : in (sf), sf_info (info) {} - virtual ~ImportableSource() {} - - virtual nframes_t read (Sample* buffer, nframes_t nframes) { - nframes_t per_channel = nframes / sf_info->channels; - per_channel = sf_readf_float (in, buffer, per_channel); - return per_channel * sf_info->channels; - } - - virtual float ratio() const { return 1.0f; } - -protected: - SNDFILE* in; - SF_INFO* sf_info; -}; - -class ResampledImportableSource : public ImportableSource { - public: - ResampledImportableSource (SNDFILE* sf, SF_INFO* info, nframes_t rate) : ImportableSource (sf, info) { - int err; - - sf_seek (in, 0, SEEK_SET) ; - - /* Initialize the sample rate converter. */ - - if ((src_state = src_new (SRC_SINC_BEST_QUALITY, sf_info->channels, &err)) == 0) { - error << string_compose(_("Import: src_new() failed : %1"), src_strerror (err)) << endmsg ; - throw failed_constructor (); - } - - src_data.end_of_input = 0 ; /* Set this later. */ - - /* Start with zero to force load in while loop. */ - - src_data.input_frames = 0 ; - src_data.data_in = input ; - - src_data.src_ratio = ((float) rate) / sf_info->samplerate ; - - } - - ~ResampledImportableSource () { - src_state = src_delete (src_state) ; - } - - nframes_t read (Sample* buffer, nframes_t nframes); - - float ratio() const { return src_data.src_ratio; } - - private: - float input[BLOCKSIZE]; - SRC_STATE* src_state; - SRC_DATA src_data; -}; - -int -Session::import_audiofile (import_status& status) +static boost::shared_ptr +open_importable_source (const string& path, framecnt_t samplerate, ARDOUR::SrcQuality quality) { - SNDFILE *in; - vector > newfiles; - SourceList sources; - SF_INFO info; - float *data = 0; - Sample **channel_data = 0; - long nfiles = 0; - string basepath; - string sounds_dir; - nframes_t so_far; - char buf[PATH_MAX+1]; - int ret = -1; - vector new_paths; - struct tm* now; - ImportableSource* importable = 0; - const nframes_t nframes = BLOCKSIZE; + /* 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() + */ - status.new_regions.clear (); + try { + boost::shared_ptr source(new SndFileImportableSource(path)); - if ((in = sf_open (status.paths.front().c_str(), SFM_READ, &info)) == 0) { - error << string_compose(_("Import: cannot open input sound file \"%1\""), status.paths.front()) << endmsg; - status.done = 1; - status.cancel = 1; - return -1; - } + if (source->samplerate() == samplerate) { + return source; + } - if ((nframes_t) info.samplerate != frame_rate()) { - importable = new ResampledImportableSource (in, &info, frame_rate()); - } else { - importable = new ImportableSource (in, &info); + /* rewrap as a resampled source */ + + return boost::shared_ptr(new ResampledImportableSource(source, samplerate, quality)); } - for (int n = 0; n < info.channels; ++n) { - newfiles.push_back (boost::shared_ptr()); + catch (...) { + +#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 + throw; // rethrow +#endif + } +} - sounds_dir = discover_best_sound_dir (); - basepath = PBD::basename_nosuffix (status.paths.front()); +vector +Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels, + vector const & smf_track_names) - for (int n = 0; n < info.channels; ++n) { +{ + vector new_paths; + const string basename = basename_nosuffix (import_file_path); - bool goodfile = false; + for (uint32_t n = 0; n < channels; ++n) { - do { - if (info.channels == 2) { - if (n == 0) { - snprintf (buf, sizeof(buf), "%s/%s-L.wav", sounds_dir.c_str(), basepath.c_str()); + 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 { - snprintf (buf, sizeof(buf), "%s/%s-R.wav", sounds_dir.c_str(), basepath.c_str()); + mchn_name = string_compose ("%1-%2", basename, smf_track_names[n]); } - } else if (info.channels > 1) { - snprintf (buf, sizeof(buf), "%s/%s-c%d.wav", sounds_dir.c_str(), basepath.c_str(), n+1); + filepath = new_midi_source_path (mchn_name); } else { - snprintf (buf, sizeof(buf), "%s/%s.wav", sounds_dir.c_str(), basepath.c_str()); + filepath = new_midi_source_path (basename); } + break; + case DataType::AUDIO: + filepath = new_audio_source_path (basename, channels, n, false, false); + break; + } - if (Glib::file_test (buf, Glib::FILE_TEST_EXISTS)) { + if (filepath.empty()) { + error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg; + return vector(); + } - /* if the file already exists, we must come up with - * a new name for it. for now we just keep appending - * _ to basepath - */ - - basepath += "_"; + new_paths.push_back (filepath); + } - } else { + return new_paths; +} - goodfile = true; - } +static bool +map_existing_mono_sources (const vector& new_paths, Session& /*sess*/, + uint32_t /*samplerate*/, vector >& newfiles, Session *session) +{ + for (vector::const_iterator i = new_paths.begin(); + i != new_paths.end(); ++i) + { + 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; + return false; + } + + newfiles.push_back(boost::dynamic_pointer_cast(source)); + } + return true; +} + +static bool +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) { - } while ( !goodfile); + boost::shared_ptr source; - try { - newfiles[n] = boost::dynamic_pointer_cast ( - SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate())); + 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); } - catch (failed_constructor& err) { - error << string_compose(_("Session::import_audiofile: cannot open new file source for channel %1"), n+1) << endmsg; - goto out; + catch (const failed_constructor& err) { + error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg; + return false; } - new_paths.push_back (buf); - nfiles++; + 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); + } } - - data = new float[nframes * info.channels]; - channel_data = new Sample * [ info.channels ]; - - for (int n = 0; n < info.channels; ++n) { - channel_data[n] = new Sample[nframes]; + return true; +} + +static string +compose_status_message (const string& path, + 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); } - so_far = 0; + return string_compose (_("Copying %1"), Glib::path_get_basename (path)); +} + +static void +write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status, + vector >& newfiles) +{ + const framecnt_t nframes = ResampledImportableSource::blocksize; + boost::shared_ptr afs; + uint32_t channels = source->channels(); + if (channels == 0) { + return; + } + + boost::scoped_array data(new float[nframes * channels]); + vector > channel_data; + + for (uint32_t n = 0; n < channels; ++n) { + channel_data.push_back(boost::shared_array(new Sample[nframes])); + } + + 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. + */ - status.doing_what = _("converting audio"); - status.progress = 0.0; + float peak = 0; + uint32_t read_count = 0; + + while (!status.cancel) { + framecnt_t const nread = source->read (data.get(), nframes * channels); + if (nread == 0) { + break; + } + + peak = compute_peak (data.get(), nread * channels, peak); + + read_count += nread / channels; + 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; + } + + framecnt_t read_count = 0; while (!status.cancel) { - nframes_t nread, nfread; - long x; - long chn; - - if ((nread = importable->read (data, 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; } - nfread = nread / info.channels; + + 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 < info.channels; ++chn) { - nframes_t n; - for (x = chn, n = 0; n < nfread; x += info.channels, ++n) { + for (chn = 0; chn < channels; ++chn) { + + framecnt_t n; + for (x = chn, n = 0; n < nfread; x += channels, ++n) { channel_data[chn][n] = (Sample) data[x]; } } /* flush to disk */ - for (chn = 0; chn < info.channels; ++chn) { - newfiles[chn]->write (channel_data[chn], nfread); + for (chn = 0; chn < channels; ++chn) { + if ((afs = boost::dynamic_pointer_cast(newfiles[chn])) != 0) { + afs->write (channel_data[chn].get(), nfread); + } } - so_far += nread; - status.progress = so_far / (importable->ratio () * info.frames * info.channels); + read_count += nread; + status.progress = progress_base + progress_multiplier * read_count / (source->ratio () * source->length() * channels); } +} - if (status.cancel) { - goto out; - } +static void +write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status, + vector >& newfiles, + bool split_type0) +{ + uint32_t buf_size = 4; + 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 (status.multichan) { - status.doing_what = _("building region"); + if (type0) { + num_tracks = source->channels().size(); } else { - status.doing_what = _("building regions"); + num_tracks = source->num_tracks(); } + assert (newfiles.size() == num_tracks); - status.freeze = true; + try { + vector >::iterator s = newfiles.begin(); + std::set::const_iterator cur_chan = chn.begin(); - time_t xnow; - time (&xnow); - now = localtime (&xnow); + for (unsigned i = 1; i <= num_tracks; ++i) { - if (status.multichan) { - /* all sources are used in a single multichannel region */ + boost::shared_ptr smfs = boost::dynamic_pointer_cast (*s); - for (int n = 0; n < nfiles && !status.cancel; ++n) { - /* flush the final length to the header */ - newfiles[n]->update_header(0, *now, xnow); - sources.push_back(newfiles[n]); - } + Glib::Threads::Mutex::Lock source_lock(smfs->mutex()); - bool strip_paired_suffixes = (newfiles.size() > 1); + smfs->drop_model (source_lock); + if (type0) { + source->seek_to_start (); + } else { + source->seek_to_track (i); + } - boost::shared_ptr r (boost::dynamic_pointer_cast - (RegionFactory::create (sources, 0, - newfiles[0]->length(), - region_name_from_path (basepath, strip_paired_suffixes), - 0, AudioRegion::Flag (AudioRegion::DefaultFlags | AudioRegion::WholeFile)))); - - status.new_regions.push_back (r); + uint64_t t = 0; + uint32_t delta_t = 0; + uint32_t size = 0; + bool first = true; - } else { - for (int n = 0; n < nfiles && !status.cancel; ++n) { + 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; + + 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) { - /* flush the final length to the header */ + /* we wrote something */ - newfiles[n]->update_header(0, *now, xnow); + 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); - /* The sources had zero-length when created, which means that the Session - did not bother to create whole-file AudioRegions for them. Do it now. + if (status.cancel) { + break; + } + } else { + info << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, num_tracks) << endmsg; + } - Note: leave any trailing paired indicators from the file names as part - of the region name. - */ - - status.new_regions.push_back (boost::dynamic_pointer_cast - (RegionFactory::create (boost::static_pointer_cast (newfiles[n]), 0, newfiles[n]->length(), - region_name_from_path (newfiles[n]->name(), false), - 0, AudioRegion::Flag (AudioRegion::DefaultFlags | AudioRegion::WholeFile | AudioRegion::Import)))); + ++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; } - - /* save state so that we don't lose these new Sources */ - if (!status.cancel) { - save_state (_name); + if (buf) { + free (buf); } +} - ret = 0; +static void +remove_file_source (boost::shared_ptr source) +{ + boost::shared_ptr fs = boost::dynamic_pointer_cast (source); - out: + fs->DropReferences (); - if (data) { - delete [] data; + if (fs) { + ::g_unlink (fs->path().c_str()); } - - if (channel_data) { - for (int n = 0; n < info.channels; ++n) { - delete [] channel_data[n]; +} + +// This function is still unable to cleanly update an existing source, even though +// 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_files (ImportStatus& status) +{ + typedef vector > Sources; + Sources all_new_sources; + boost::shared_ptr afs; + boost::shared_ptr smfs; + uint32_t channels = 0; + vector smf_names; + + status.sources.clear (); + + for (vector::const_iterator p = status.paths.begin(); + p != status.paths.end() && !status.cancel; + ++p) + { + boost::shared_ptr source; + 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); + channels = source->channels(); + } catch (const failed_constructor& err) { + error << string_compose(_("Import: cannot open input sound file \"%1\""), (*p)) << endmsg; + status.done = status.cancel = true; + return; + } + + } else { + try { + smf_reader = std::auto_ptr(new Evoral::SMF()); + + 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; + return; + } } - delete [] channel_data; - } - if (status.cancel) { - status.new_regions.clear (); + 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; + - for (vector::iterator i = new_paths.begin(); i != new_paths.end(); ++i) { - unlink ((*i).c_str()); + 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); } - } - if (importable) { - delete importable; + // 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; + } + + for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) { + if ((afs = boost::dynamic_pointer_cast(*i)) != 0) { + afs->prepare_for_peakfile_writes (); + } + } + + if (source) { // audio + status.doing_what = compose_status_message (*p, source->samplerate(), + 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, status.split_midi_channels); + } + + ++status.current; + status.progress = 0; } - sf_close (in); - status.done = true; + if (!status.cancel) { + struct tm* now; + time_t xnow; + time (&xnow); + now = localtime (&xnow); + status.freeze = true; - return ret; -} + /* flush the final length(s) to the header(s) */ -nframes_t -ResampledImportableSource::read (Sample* output, nframes_t nframes) -{ - int err; + 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->done_with_peakfile_writes (); + + /* now that there is data there, requeue the file for analysis */ - /* If the input buffer is empty, refill it. */ - - if (src_data.input_frames == 0) { + if (Config->get_auto_analyse_audio()) { + Analyser::queue_source_for_analysis (boost::static_pointer_cast(*x), false); + } + } + + /* 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 (); + } - src_data.input_frames = ImportableSource::read (input, BLOCKSIZE); + /* don't create tracks for empty MIDI sources (channels) */ - /* The last read will not be a full buffer, so set end_of_input. */ + if ((smfs = boost::dynamic_pointer_cast(*x)) != 0 && smfs->is_empty()) { + x = all_new_sources.erase(x); + } else { + ++x; + } + } - if ((nframes_t) src_data.input_frames < BLOCKSIZE) { - src_data.end_of_input = SF_TRUE ; - } + /* save state so that we don't lose these new Sources */ - src_data.input_frames /= sf_info->channels; - src_data.data_in = input ; - } - - src_data.data_out = output; + save_state (_name); - if (!src_data.end_of_input) { - src_data.output_frames = nframes / sf_info->channels ; + std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources)); } else { - src_data.output_frames = src_data.input_frames; - } + 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; + } - if ((err = src_process (src_state, &src_data))) { - error << string_compose(_("Import: %1"), src_strerror (err)) << endmsg ; - return 0 ; - } - - /* Terminate if at end */ - - if (src_data.end_of_input && src_data.output_frames_gen == 0) { - return 0; } - - src_data.data_in += src_data.input_frames_used * sf_info->channels ; - src_data.input_frames -= src_data.input_frames_used ; - return src_data.output_frames_gen * sf_info->channels; + status.done = true; }