2008-06-02 17:41:35 -04:00
|
|
|
/*
|
2019-08-02 22:01:25 -04:00
|
|
|
* Copyright (C) 2000-2017 Paul Davis <paul@linuxaudiosystems.com>
|
|
|
|
* Copyright (C) 2006-2016 David Robillard <d@drobilla.net>
|
|
|
|
* Copyright (C) 2007-2012 Tim Mayberry <mojofunk@gmail.com>
|
|
|
|
* Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
|
|
|
|
* Copyright (C) 2014-2018 Robin Gareus <robin@gareus.org>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-07-12 20:26:28 -04:00
|
|
|
#ifdef WAF_BUILD
|
|
|
|
#include "libardour-config.h"
|
|
|
|
#endif
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <cstdio>
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <string>
|
|
|
|
#include <climits>
|
|
|
|
#include <cerrno>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <time.h>
|
2009-05-17 20:21:17 -04:00
|
|
|
#include <stdint.h>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
#include <sndfile.h>
|
|
|
|
#include <samplerate.h>
|
|
|
|
|
2015-10-05 16:10:58 -04:00
|
|
|
#include "pbd/gstdio_compat.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <glibmm.h>
|
|
|
|
|
|
|
|
#include <boost/scoped_array.hpp>
|
2017-10-26 15:43:49 -04:00
|
|
|
#include <boost/scoped_ptr.hpp>
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <boost/shared_array.hpp>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/basename.h"
|
|
|
|
#include "pbd/convert.h"
|
|
|
|
|
2019-10-25 15:13:51 -04:00
|
|
|
#include "evoral/SMF.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
|
2009-10-30 11:30:22 -04:00
|
|
|
#include "ardour/analyser.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/ardour.h"
|
|
|
|
#include "ardour/audioengine.h"
|
|
|
|
#include "ardour/audioregion.h"
|
2021-06-07 18:45:51 -04:00
|
|
|
#include "ardour/ffmpegfileimportable.h"
|
2009-10-30 11:30:22 -04:00
|
|
|
#include "ardour/import_status.h"
|
2021-11-19 10:14:15 -05:00
|
|
|
#include "ardour/midi_region.h"
|
|
|
|
#include "ardour/midi_source.h"
|
2019-12-06 12:18:33 -05:00
|
|
|
#include "ardour/mp3fileimportable.h"
|
2021-11-19 10:14:15 -05:00
|
|
|
#include "ardour/playlist.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/region_factory.h"
|
|
|
|
#include "ardour/resampled_source.h"
|
2012-05-24 02:09:29 -04:00
|
|
|
#include "ardour/runtime_functions.h"
|
2009-10-30 11:30:22 -04:00
|
|
|
#include "ardour/session.h"
|
|
|
|
#include "ardour/session_directory.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/smf_source.h"
|
2009-10-30 11:30:22 -04:00
|
|
|
#include "ardour/sndfile_helpers.h"
|
|
|
|
#include "ardour/sndfileimportable.h"
|
|
|
|
#include "ardour/sndfilesource.h"
|
|
|
|
#include "ardour/source_factory.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/tempo.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
#ifdef HAVE_COREAUDIO
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/caimportable.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
#endif
|
|
|
|
|
2016-07-14 14:44:52 -04:00
|
|
|
#include "pbd/i18n.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
using namespace std;
|
2008-06-02 17:41:35 -04:00
|
|
|
using namespace ARDOUR;
|
|
|
|
using namespace PBD;
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
static std::shared_ptr<ImportableSource>
|
2017-09-18 12:39:17 -04:00
|
|
|
open_importable_source (const string& path, samplecnt_t samplerate, ARDOUR::SrcQuality quality)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2010-03-13 14:22:34 -05:00
|
|
|
/* try libsndfile first, because it can get BWF info from .wav, which ExtAudioFile cannot.
|
2019-12-06 12:06:13 -05:00
|
|
|
* We don't necessarily need that information in an ImportableSource, but it keeps the
|
|
|
|
* logic the same as in SourceFactory::create()
|
|
|
|
*/
|
2010-03-13 14:22:34 -05:00
|
|
|
|
2011-04-04 18:46:48 -04:00
|
|
|
try {
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<SndFileImportableSource> source(new SndFileImportableSource(path));
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (source->samplerate() == samplerate) {
|
|
|
|
return source;
|
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* rewrap as a resampled source */
|
2023-02-16 18:33:28 -05:00
|
|
|
return std::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
|
2019-12-06 12:06:13 -05:00
|
|
|
} catch (...) { }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2019-12-06 12:06:13 -05:00
|
|
|
/* libsndfile failed, see if we can use CoreAudio to handle the IO */
|
2010-03-13 14:22:34 -05:00
|
|
|
#ifdef HAVE_COREAUDIO
|
2019-12-06 12:06:13 -05:00
|
|
|
try {
|
2010-03-13 14:22:34 -05:00
|
|
|
CAImportableSource* src = new CAImportableSource(path);
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<CAImportableSource> source (src);
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2010-03-13 14:22:34 -05:00
|
|
|
if (source->samplerate() == samplerate) {
|
|
|
|
return source;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2010-03-13 14:22:34 -05:00
|
|
|
/* rewrap as a resampled source */
|
2023-02-16 18:33:28 -05:00
|
|
|
return std::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
|
2019-12-06 12:06:13 -05:00
|
|
|
} catch (...) { }
|
2010-03-13 14:22:34 -05:00
|
|
|
#endif
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2019-12-06 12:18:33 -05:00
|
|
|
/* libsndfile and CoreAudioFile failed, try minimp3-decoder */
|
|
|
|
try {
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<Mp3FileImportableSource> source(new Mp3FileImportableSource(path));
|
2019-12-06 12:18:33 -05:00
|
|
|
|
|
|
|
if (source->samplerate() == samplerate) {
|
|
|
|
return source;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* rewrap as a resampled source */
|
2023-02-16 18:33:28 -05:00
|
|
|
return std::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
|
2019-12-06 12:18:33 -05:00
|
|
|
} catch (...) { }
|
|
|
|
|
2021-06-07 18:45:51 -04:00
|
|
|
/* finally try FFMPEG */
|
|
|
|
try {
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<FFMPEGFileImportableSource> source(new FFMPEGFileImportableSource(path));
|
2021-06-07 18:45:51 -04:00
|
|
|
|
|
|
|
if (source->samplerate() == samplerate) {
|
|
|
|
return source;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* rewrap as a resampled source */
|
2023-02-16 18:33:28 -05:00
|
|
|
return std::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
|
2021-06-07 18:45:51 -04:00
|
|
|
} catch (...) { }
|
|
|
|
|
2019-12-06 12:06:13 -05:00
|
|
|
throw failed_constructor ();
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2014-06-02 11:20:37 -04:00
|
|
|
vector<string>
|
2016-12-14 06:44:40 -05:00
|
|
|
Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels,
|
2021-11-13 16:51:20 -05:00
|
|
|
vector<string> const & smf_names)
|
2016-12-14 06:44:40 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
vector<string> new_paths;
|
|
|
|
const string basename = basename_nosuffix (import_file_path);
|
|
|
|
|
2013-07-11 12:05:37 -04:00
|
|
|
for (uint32_t n = 0; n < channels; ++n) {
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-05-19 19:36:18 -04:00
|
|
|
const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
|
2014-06-02 11:20:37 -04:00
|
|
|
string filepath;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2014-06-02 11:20:37 -04:00
|
|
|
switch (type) {
|
2016-12-14 06:44:40 -05:00
|
|
|
case DataType::MIDI:
|
|
|
|
if (channels > 1) {
|
2021-11-13 16:51:20 -05:00
|
|
|
assert (smf_names.size() == channels);
|
|
|
|
string mchn_name = string_compose ("%1.%2", basename, smf_names[n]);
|
2016-12-14 06:44:40 -05:00
|
|
|
filepath = new_midi_source_path (mchn_name);
|
|
|
|
} else {
|
|
|
|
filepath = new_midi_source_path (basename);
|
|
|
|
}
|
2014-06-02 11:20:37 -04:00
|
|
|
break;
|
|
|
|
case DataType::AUDIO:
|
2020-02-25 23:35:07 -05:00
|
|
|
filepath = new_audio_source_path (basename, channels, n, false);
|
2014-06-02 11:20:37 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filepath.empty()) {
|
|
|
|
error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg;
|
|
|
|
return vector<string>();
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
new_paths.push_back (filepath);
|
|
|
|
}
|
|
|
|
|
|
|
|
return new_paths;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2009-07-21 11:55:17 -04:00
|
|
|
map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
|
2023-02-16 18:33:28 -05:00
|
|
|
uint32_t /*samplerate*/, vector<std::shared_ptr<Source> >& newfiles, Session *session)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
for (vector<string>::const_iterator i = new_paths.begin();
|
2011-04-04 18:46:48 -04:00
|
|
|
i != new_paths.end(); ++i)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<Source> source = session->audio_source_by_path_and_channel(*i, 0);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
if (source == 0) {
|
|
|
|
error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
newfiles.push_back(std::dynamic_pointer_cast<Source>(source));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
2013-03-30 14:02:26 -04:00
|
|
|
create_mono_sources_for_writing (const vector<string>& new_paths,
|
2013-07-11 12:05:37 -04:00
|
|
|
Session& sess, uint32_t samplerate,
|
2023-02-16 18:33:28 -05:00
|
|
|
vector<std::shared_ptr<Source> >& newfiles,
|
2023-08-22 13:00:42 -04:00
|
|
|
samplepos_t natural_position, bool announce)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2010-11-09 13:19:53 -05:00
|
|
|
for (vector<string>::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) {
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<Source> source;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-11-09 13:19:53 -05:00
|
|
|
try {
|
2010-05-19 19:36:18 -04:00
|
|
|
const DataType type = SMFSource::safe_midi_file_extension (*i) ? DataType::MIDI : DataType::AUDIO;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2023-08-22 13:00:42 -04:00
|
|
|
source = SourceFactory::createWritable (type, sess, i->c_str(), samplerate, announce);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2010-11-09 13:19:53 -05:00
|
|
|
|
|
|
|
catch (const failed_constructor& err) {
|
2008-06-02 17:41:35 -04:00
|
|
|
error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
newfiles.push_back(std::dynamic_pointer_cast<Source>(source));
|
2010-03-16 11:33:04 -04:00
|
|
|
|
2011-04-04 18:46:48 -04:00
|
|
|
/* for audio files, reset the timeline position so that any BWF-ish
|
|
|
|
information in the original files we are importing from is maintained.
|
|
|
|
*/
|
2010-03-16 11:33:04 -04:00
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<AudioFileSource> afs;
|
|
|
|
if ((afs = std::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
|
2020-09-20 18:34:09 -04:00
|
|
|
afs->set_natural_position (timepos_t (natural_position));
|
2011-04-04 18:46:48 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-09-14 11:45:21 -04:00
|
|
|
static string
|
2008-06-02 17:41:35 -04:00
|
|
|
compose_status_message (const string& path,
|
2013-07-11 12:05:37 -04:00
|
|
|
uint32_t file_samplerate,
|
|
|
|
uint32_t session_samplerate,
|
|
|
|
uint32_t /* current_file */,
|
|
|
|
uint32_t /* total_files */)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
if (file_samplerate != session_samplerate) {
|
2010-04-14 18:16:46 -04:00
|
|
|
return string_compose (_("Resampling %1 from %2kHz to %3kHz"),
|
2011-04-04 18:46:48 -04:00
|
|
|
Glib::path_get_basename (path),
|
|
|
|
file_samplerate/1000.0f,
|
|
|
|
session_samplerate/1000.0f);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2010-04-14 18:16:46 -04:00
|
|
|
return string_compose (_("Copying %1"), Glib::path_get_basename (path));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-10-30 11:30:22 -04:00
|
|
|
write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
|
2023-02-16 18:33:28 -05:00
|
|
|
vector<std::shared_ptr<Source> >& newfiles)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2017-09-18 12:39:17 -04:00
|
|
|
const samplecnt_t nframes = ResampledImportableSource::blocksize;
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<AudioFileSource> afs;
|
2013-07-11 12:05:37 -04:00
|
|
|
uint32_t channels = source->channels();
|
2014-11-18 02:29:50 -05:00
|
|
|
if (channels == 0) {
|
|
|
|
return;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
boost::scoped_array<float> data(new float[nframes * channels]);
|
|
|
|
vector<boost::shared_array<Sample> > channel_data;
|
|
|
|
|
2013-07-11 12:05:37 -04:00
|
|
|
for (uint32_t n = 0; n < channels; ++n) {
|
2008-06-02 17:41:35 -04:00
|
|
|
channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-04-09 10:11:47 -04:00
|
|
|
float gain = 1;
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<AudioSource> s = std::dynamic_pointer_cast<AudioSource> (newfiles[0]);
|
2010-04-09 10:11:47 -04:00
|
|
|
assert (s);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
status.progress = 0.0f;
|
2010-04-09 10:11:47 -04:00
|
|
|
float progress_multiplier = 1;
|
|
|
|
float progress_base = 0;
|
2018-12-06 22:41:22 -05:00
|
|
|
const float progress_length = source->ratio() * source->length();
|
2010-04-09 10:11:47 -04:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2010-04-09 10:11:47 -04:00
|
|
|
float peak = 0;
|
2013-07-11 12:05:37 -04:00
|
|
|
uint32_t read_count = 0;
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2010-04-09 10:11:47 -04:00
|
|
|
while (!status.cancel) {
|
2017-09-18 12:39:17 -04:00
|
|
|
samplecnt_t const nread = source->read (data.get(), nframes * channels);
|
2010-04-09 10:11:47 -04:00
|
|
|
if (nread == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-12-06 22:15:55 -05:00
|
|
|
peak = compute_peak (data.get(), nread, peak);
|
2010-04-09 10:11:47 -04:00
|
|
|
|
2016-06-17 16:17:19 -04:00
|
|
|
read_count += nread / channels;
|
2018-12-06 22:41:22 -05:00
|
|
|
status.progress = 0.5 * read_count / progress_length;
|
2010-04-09 10:11:47 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (peak >= 1) {
|
|
|
|
/* we are out of range: compute a gain to fix it */
|
|
|
|
gain = (1 - FLT_EPSILON) / peak;
|
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2010-04-09 10:11:47 -04:00
|
|
|
source->seek (0);
|
|
|
|
progress_multiplier = 0.5;
|
|
|
|
progress_base = 0.5;
|
|
|
|
}
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
samplecnt_t read_count = 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
while (!status.cancel) {
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
samplecnt_t nread, nfread;
|
2013-07-11 12:05:37 -04:00
|
|
|
uint32_t x;
|
|
|
|
uint32_t chn;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-06-17 16:17:19 -04:00
|
|
|
if ((nread = source->read (data.get(), nframes * channels)) == 0) {
|
2013-08-09 12:56:14 -04:00
|
|
|
#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)
|
2023-02-16 18:33:28 -05:00
|
|
|
if ((afs = std::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0)
|
2013-08-09 12:56:14 -04:00
|
|
|
afs->flush ();
|
|
|
|
#endif
|
2008-06-02 17:41:35 -04:00
|
|
|
break;
|
|
|
|
}
|
2010-04-09 10:11:47 -04:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
nfread = nread / channels;
|
|
|
|
|
|
|
|
/* de-interleave */
|
|
|
|
|
|
|
|
for (chn = 0; chn < channels; ++chn) {
|
|
|
|
|
2017-09-18 12:39:17 -04:00
|
|
|
samplecnt_t n;
|
2008-06-02 17:41:35 -04:00
|
|
|
for (x = chn, n = 0; n < nfread; x += channels, ++n) {
|
|
|
|
channel_data[chn][n] = (Sample) data[x];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* flush to disk */
|
|
|
|
|
|
|
|
for (chn = 0; chn < channels; ++chn) {
|
2023-02-16 18:33:28 -05:00
|
|
|
if ((afs = std::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0) {
|
2008-06-02 17:41:35 -04:00
|
|
|
afs->write (channel_data[chn].get(), nfread);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-06 22:41:22 -05:00
|
|
|
read_count += nfread;
|
|
|
|
status.progress = progress_base + progress_multiplier * read_count / progress_length;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2009-10-30 11:30:22 -04:00
|
|
|
write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
|
2023-02-16 18:33:28 -05:00
|
|
|
vector<std::shared_ptr<Source> >& newfiles,
|
2021-11-13 16:51:20 -05:00
|
|
|
bool split_midi_channels)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2009-02-14 15:52:15 -05:00
|
|
|
uint32_t buf_size = 4;
|
2011-04-02 17:59:14 -04:00
|
|
|
uint8_t* buf = (uint8_t*) malloc (buf_size);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
status.progress = 0.0f;
|
2021-11-13 16:51:20 -05:00
|
|
|
|
|
|
|
bool type0 = source->smf_format()==0;
|
|
|
|
|
|
|
|
int total_files = newfiles.size();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-04-02 17:59:14 -04:00
|
|
|
try {
|
2023-02-16 18:33:28 -05:00
|
|
|
vector<std::shared_ptr<Source> >::iterator s = newfiles.begin();
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2021-11-13 16:51:20 -05:00
|
|
|
int cur_chan = 0;
|
|
|
|
|
|
|
|
for (int i = 0; i < total_files; ++i) {
|
|
|
|
|
|
|
|
int cur_track = i+1; //first Track of a type-1 file is metadata only. Start importing sourcefiles at Track index 1
|
|
|
|
|
|
|
|
if (split_midi_channels) { //if splitting channels we will need to fill 16x sources. empties will be disposed-of later
|
|
|
|
cur_track = 1 + (int) floor((float)i/16.f); //calculate the Track needed for this sourcefile (offset by 1)
|
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<SMFSource> smfs = std::dynamic_pointer_cast<SMFSource> (*s);
|
2021-11-13 16:51:20 -05:00
|
|
|
if (!smfs) {
|
|
|
|
continue; //should never happen. The calling code should provide exactly the number of tracks&channels we need
|
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2022-03-30 14:56:04 -04:00
|
|
|
Source::WriterLock source_lock(smfs->mutex());
|
2014-12-17 16:05:27 -05:00
|
|
|
|
|
|
|
smfs->drop_model (source_lock);
|
2016-10-05 14:09:36 -04:00
|
|
|
if (type0) {
|
|
|
|
source->seek_to_start ();
|
|
|
|
} else {
|
2021-11-13 16:51:20 -05:00
|
|
|
source->seek_to_track (cur_track);
|
2016-10-05 14:09:36 -04:00
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
|
|
|
|
uint64_t t = 0;
|
|
|
|
uint32_t delta_t = 0;
|
|
|
|
uint32_t size = 0;
|
|
|
|
bool first = true;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-11-13 16:51:20 -05:00
|
|
|
/* if requested by user, each sourcefile gets only a single channel's data */
|
|
|
|
if (split_midi_channels) {
|
2016-10-05 14:09:36 -04:00
|
|
|
uint8_t type = buf[0] & 0xf0;
|
|
|
|
uint8_t chan = buf[0] & 0x0f;
|
|
|
|
if (type >= 0x80 && type <= 0xE0) {
|
2021-11-13 16:51:20 -05:00
|
|
|
if (chan != cur_chan) {
|
2016-10-05 14:09:36 -04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-04 18:46:48 -04:00
|
|
|
if (first) {
|
2014-12-17 16:05:27 -05:00
|
|
|
smfs->mark_streaming_write_started (source_lock);
|
2011-04-04 18:46:48 -04:00
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
|
2014-12-17 16:05:27 -05:00
|
|
|
smfs->append_event_beats(
|
|
|
|
source_lock,
|
2017-09-24 12:03:54 -04:00
|
|
|
Evoral::Event<Temporal::Beats>(
|
2016-11-07 05:14:55 -05:00
|
|
|
Evoral::MIDI_EVENT,
|
2017-09-24 12:03:54 -04:00
|
|
|
Temporal::Beats::ticks_at_rate(t, source->ppqn()),
|
2014-11-22 04:05:42 -05:00
|
|
|
size,
|
|
|
|
buf));
|
2011-04-04 18:46:48 -04:00
|
|
|
|
|
|
|
if (status.progress < 0.99) {
|
|
|
|
status.progress += 0.01;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!first) {
|
|
|
|
|
|
|
|
/* we wrote something */
|
|
|
|
|
2022-01-01 22:20:22 -05:00
|
|
|
/* try to guess at the meter, for 5/4 midi loop oddballs */
|
|
|
|
int pulses_per_bar = 4;
|
|
|
|
Evoral::SMF::Tempo *tempo = source->nth_tempo (0);
|
|
|
|
if (tempo && (tempo->numerator>0) ) {
|
|
|
|
pulses_per_bar = tempo->numerator;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* extend the length of the region to the end of a bar */
|
2017-09-24 12:03:54 -04:00
|
|
|
const Temporal::Beats length_beats = Temporal::Beats::ticks_at_rate(t, source->ppqn());
|
2022-01-28 17:52:27 -05:00
|
|
|
smfs->update_length (timepos_t (length_beats.round_up_to_multiple(Temporal::Beats(pulses_per_bar,0))));
|
2022-01-01 22:20:22 -05:00
|
|
|
|
2014-12-17 16:05:27 -05:00
|
|
|
smfs->mark_streaming_write_completed (source_lock);
|
Change the type of reference held by a MidiModel to its MidiSource
This also requires a change in the type of reference held by
a MidiAutomationListBinder.
Both the MidiSource and MidiModel have a reference to each other, and it is
important that we avoid circular references to avoid problems with object
destruction. We had been accomplishing this by having the Model hold a
weak_ptr<MidiSource>. However, the lifetime of a MidiSource and its MidiModel
are coincident and there's really no need to use a smart ptr at all. A normal
reference is just fine. However, due to constructors that accept a serialized
state, we cannot use an actual reference (we cannot set the constructor in the
initializer list), so we use a bare ptr instead.
This forces a similar change in MidiAutomationListBinder, which also maintains
a reference to the Source. However, the only purpose of this object is to
ensure that if the Source is destroyed, relevant commands will be removed from
the undo/redo history, and so all that matters here is that the binder connects
to the Destroyed signal of the source, and arranges for its own destruction
when received.
Note that the previous construction of the binder, actually holding a
shared_ptr<MidiSource> would appear have prevented the Destroyed signal from
ever being emitted (from ~Destructible), and so this may also be a bug fix that
allows MidiSources to actually be deleted (the memory object, not the file).
2022-03-30 14:49:00 -04:00
|
|
|
|
|
|
|
/* the streaming write that we've just finished
|
|
|
|
* only wrote data to the SMF object, which is
|
|
|
|
* ultimately an on-disk data structure. So now
|
|
|
|
* we pull the data back from disk to build our
|
|
|
|
* in-memory MidiModel version.
|
|
|
|
*/
|
|
|
|
|
2021-12-17 21:23:55 -05:00
|
|
|
smfs->load_model (source_lock, true);
|
2011-04-04 18:46:48 -04:00
|
|
|
|
2022-12-14 10:14:47 -05:00
|
|
|
/* Now that there is a model, we can set interpolation of parameters. */
|
|
|
|
smfs->mark_streaming_write_completed (source_lock);
|
|
|
|
|
2011-04-04 18:46:48 -04:00
|
|
|
if (status.cancel) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2021-11-13 16:51:20 -05:00
|
|
|
info << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, total_files) << endmsg;
|
2011-04-04 18:46:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
++s; // next source
|
2021-11-13 16:51:20 -05:00
|
|
|
|
|
|
|
++cur_chan;
|
|
|
|
if (cur_chan > 15) {
|
|
|
|
cur_chan=0;
|
2016-10-05 14:09:36 -04:00
|
|
|
}
|
2011-04-04 18:46:48 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-04-20 15:44:20 -04:00
|
|
|
} catch (exception& e) {
|
|
|
|
error << string_compose (_("MIDI file could not be written (best guess: %1)"), e.what()) << endmsg;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2011-04-02 17:59:14 -04:00
|
|
|
|
2011-04-04 18:46:48 -04:00
|
|
|
if (buf) {
|
|
|
|
free (buf);
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2023-02-16 18:33:28 -05:00
|
|
|
remove_file_source (std::shared_ptr<Source> source)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<FileSource> fs = std::dynamic_pointer_cast<FileSource> (source);
|
2011-05-13 15:55:39 -04:00
|
|
|
|
2014-10-15 21:12:19 -04:00
|
|
|
fs->DropReferences ();
|
|
|
|
|
2011-05-13 15:55:39 -04:00
|
|
|
if (fs) {
|
2013-07-15 14:29:00 -04:00
|
|
|
::g_unlink (fs->path().c_str());
|
2011-05-13 15:55:39 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2021-11-19 10:14:15 -05:00
|
|
|
void
|
2023-02-16 18:33:28 -05:00
|
|
|
Session::deinterlace_midi_region (std::shared_ptr<MidiRegion> mr)
|
2021-11-19 10:14:15 -05:00
|
|
|
{
|
2023-02-16 18:33:28 -05:00
|
|
|
typedef vector<std::shared_ptr<Source> > Sources;
|
2021-11-19 10:14:15 -05:00
|
|
|
Sources newfiles;
|
|
|
|
|
|
|
|
try {
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<SMFSource> smf = std::dynamic_pointer_cast<SMFSource> (mr->midi_source(0)); //ToDo: handle compound sources?
|
2021-11-19 10:14:15 -05:00
|
|
|
string source_path = smf->path();
|
|
|
|
|
2023-08-22 13:00:42 -04:00
|
|
|
/* Write_midi_data_to_new_files expects to find raw midi on-disk (SMF*).
|
|
|
|
* this means that a split looks like a no-op if the file wasn't written to disk yet.
|
|
|
|
* I've chosen to flush the file to disk, rather than reimplement
|
|
|
|
* write_midi_data_to_new_files for a Source
|
|
|
|
*/
|
|
|
|
smf->session_saved(); //TODO: should we just expose flush_midi() instead?
|
2021-11-19 10:14:15 -05:00
|
|
|
|
|
|
|
/* open the SMF file for reading */
|
|
|
|
boost::scoped_ptr<Evoral::SMF> smf_reader;
|
|
|
|
smf_reader.reset (new Evoral::SMF());
|
2023-08-22 13:00:42 -04:00
|
|
|
if (smf_reader->open (source_path)) {
|
2021-11-19 10:14:15 -05:00
|
|
|
throw Evoral::SMF::FileError (source_path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create new file paths for 16 potential channels of midi data */
|
|
|
|
vector<string> smf_names;
|
|
|
|
for (int i = 0; i<16; i++) {
|
|
|
|
smf_names.push_back(string_compose("-ch%1", i+1));
|
|
|
|
}
|
|
|
|
vector<string> new_paths = get_paths_for_new_sources (false, source_path, 16, smf_names);
|
|
|
|
|
|
|
|
/* create source files and write 1 channel of midi data to each of them */
|
2023-08-22 13:00:42 -04:00
|
|
|
if (create_mono_sources_for_writing (new_paths, *this, sample_rate(), newfiles, 0, false)) {
|
2021-11-19 10:14:15 -05:00
|
|
|
ImportStatus status;
|
|
|
|
write_midi_data_to_new_files (smf_reader.get(), status, newfiles, true /*split*/);
|
|
|
|
} else {
|
|
|
|
error << _("deinterlace_midi_region: failed to create sources") << endmsg;
|
|
|
|
}
|
|
|
|
|
|
|
|
} catch (...) {
|
|
|
|
error << _("deinterlace_midi_region: error opening MIDI file for splitting") << endmsg;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-08-22 13:00:42 -04:00
|
|
|
/* not all 16 channels will have midi data; delete any sources that turned up empty */
|
2021-11-19 10:14:15 -05:00
|
|
|
for (Sources::iterator x = newfiles.begin(); x != newfiles.end(); ) {
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<SMFSource> smfs;
|
|
|
|
if ((smfs = std::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
|
2021-11-19 10:14:15 -05:00
|
|
|
x = newfiles.erase(x);
|
|
|
|
} else {
|
|
|
|
++x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* insert new regions with the properties of the source region */
|
|
|
|
for (Sources::iterator x = newfiles.begin(); x != newfiles.end(); x++) {
|
|
|
|
|
|
|
|
/* hand over the new Source to the session*/
|
|
|
|
add_source(*x);
|
|
|
|
|
|
|
|
/* create a whole-file region for this new source, so it shows up in the Source List...*/
|
2022-09-19 14:07:32 -04:00
|
|
|
PropertyList plist (mr->properties ());
|
2021-11-19 10:14:15 -05:00
|
|
|
plist.add (Properties::whole_file, true);
|
2022-12-14 10:14:47 -05:00
|
|
|
plist.add (Properties::opaque, true);
|
2021-11-19 10:14:15 -05:00
|
|
|
plist.add (Properties::name, (*x)->name());
|
2022-11-04 13:54:10 -04:00
|
|
|
plist.add (Properties::tags, string_compose ("%1%2%3", _("(split-chans)"), mr->tags ().empty() ? "" : " ", mr->tags ()));
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<Region> whole = RegionFactory::create (*x, plist);
|
2021-11-19 10:14:15 -05:00
|
|
|
|
|
|
|
/* ... and insert a discrete copy into the playlist*/
|
|
|
|
PropertyList plist2;
|
|
|
|
plist2.add (ARDOUR::Properties::whole_file, false);
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<Region> copy (RegionFactory::create (whole, plist2));
|
2021-11-19 10:14:15 -05:00
|
|
|
mr->playlist()->add_region (copy, mr->position());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-14 18:29:50 -05:00
|
|
|
static vector<string>
|
|
|
|
unique_track_names (const vector<string>& n)
|
|
|
|
{
|
|
|
|
set<string> uniq;
|
|
|
|
vector<string> rv;
|
|
|
|
|
|
|
|
for (auto tn : n) {
|
|
|
|
while (uniq.find (tn) != uniq.end()) {
|
|
|
|
if (tn.empty ()) {
|
|
|
|
tn = "MIDI";
|
|
|
|
}
|
|
|
|
/* not not use '-' as separator because that is used by
|
|
|
|
* new_midi_source_path, new_audio_source_path
|
|
|
|
* when checking for existing files.
|
|
|
|
*/
|
|
|
|
tn = bump_name_once (tn, '.');
|
|
|
|
}
|
|
|
|
uniq.insert (tn);
|
|
|
|
rv.push_back (tn);
|
|
|
|
}
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
// This function is still unable to cleanly update an existing source, even though
|
2022-05-08 20:20:45 -04:00
|
|
|
// it is possible to set the ImportStatus flag accordingly. The functionality
|
2008-06-02 17:41:35 -04:00
|
|
|
// is disabled at the GUI until the Source implementations are able to provide
|
|
|
|
// the necessary API.
|
|
|
|
void
|
2012-06-09 11:04:11 -04:00
|
|
|
Session::import_files (ImportStatus& status)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2023-02-16 18:33:28 -05:00
|
|
|
typedef vector<std::shared_ptr<Source> > Sources;
|
2008-06-02 17:41:35 -04:00
|
|
|
Sources all_new_sources;
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<AudioFileSource> afs;
|
|
|
|
std::shared_ptr<SMFSource> smfs;
|
2021-11-13 16:51:20 -05:00
|
|
|
uint32_t num_channels = 0;
|
2016-12-14 06:44:40 -05:00
|
|
|
vector<string> smf_names;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
status.sources.clear ();
|
2009-08-01 20:32:26 -04:00
|
|
|
|
2020-04-17 14:39:39 -04:00
|
|
|
for (vector<string>::const_iterator p = status.paths.begin(); p != status.paths.end() && !status.cancel; ++p) {
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<ImportableSource> source;
|
2017-10-26 15:43:49 -04:00
|
|
|
|
2010-05-19 19:36:18 -04:00
|
|
|
const DataType type = SMFSource::safe_midi_file_extension (*p) ? DataType::MIDI : DataType::AUDIO;
|
2017-10-26 15:43:49 -04:00
|
|
|
boost::scoped_ptr<Evoral::SMF> smf_reader;
|
2009-08-01 20:32:26 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (type == DataType::AUDIO) {
|
|
|
|
try {
|
2017-09-18 12:39:17 -04:00
|
|
|
source = open_importable_source (*p, sample_rate(), status.quality);
|
2021-11-13 16:51:20 -05:00
|
|
|
num_channels = source->channels();
|
2008-06-02 17:41:35 -04:00
|
|
|
} 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 {
|
2017-10-26 15:43:49 -04:00
|
|
|
smf_reader.reset (new Evoral::SMF());
|
2016-12-14 06:44:40 -05:00
|
|
|
|
|
|
|
if (smf_reader->open(*p)) {
|
|
|
|
throw Evoral::SMF::FileError (*p);
|
|
|
|
}
|
2016-10-05 14:09:36 -04:00
|
|
|
|
2021-11-13 16:51:20 -05:00
|
|
|
if (smf_reader->smf_format()==0) {
|
|
|
|
/* Type0: we should prepare filenames for up to 16 channels in the file; we will throw out the empty ones later */
|
|
|
|
if (status.split_midi_channels) {
|
|
|
|
num_channels = 16;
|
|
|
|
for (uint32_t i = 0; i<num_channels; i++) {
|
|
|
|
smf_names.push_back( string_compose ("ch%1", 1+i ) ); //chanX
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
num_channels = 1;
|
|
|
|
smf_names.push_back("");
|
|
|
|
}
|
2016-10-05 14:09:36 -04:00
|
|
|
} else {
|
2021-11-13 16:51:20 -05:00
|
|
|
/* we should prepare filenames for up to 16 channels in each Track; we will throw out the empty ones later*/
|
|
|
|
num_channels = status.split_midi_channels ? smf_reader->num_tracks()*16 : smf_reader->num_tracks();
|
2016-12-14 06:44:40 -05:00
|
|
|
switch (status.midi_track_name_source) {
|
|
|
|
case SMFTrackNumber:
|
2021-11-13 16:51:20 -05:00
|
|
|
if (status.split_midi_channels) {
|
|
|
|
for (uint32_t i = 0; i<num_channels; i++) {
|
|
|
|
smf_names.push_back( string_compose ("t%1.ch%2", 1+i/16, 1+i%16 ) ); //trackX.chanX
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (uint32_t i = 0; i<num_channels;i++) {
|
|
|
|
smf_names.push_back( string_compose ("t%1", i+1 ) ); //trackX
|
|
|
|
}
|
|
|
|
}
|
2016-12-14 06:44:40 -05:00
|
|
|
break;
|
|
|
|
case SMFTrackName:
|
2021-11-13 16:51:20 -05:00
|
|
|
if (status.split_midi_channels) {
|
|
|
|
vector<string> temp;
|
|
|
|
smf_reader->track_names (temp);
|
2022-12-14 18:29:50 -05:00
|
|
|
temp = unique_track_names (temp);
|
2021-11-13 16:51:20 -05:00
|
|
|
for (uint32_t i = 0; i<num_channels;i++) {
|
|
|
|
smf_names.push_back( string_compose ("%1.ch%2", temp[i/16], 1+i%16 ) ); //trackname.chanX
|
|
|
|
}
|
|
|
|
} else {
|
2022-12-14 18:29:50 -05:00
|
|
|
vector<string> temp;
|
|
|
|
smf_reader->track_names (temp);
|
|
|
|
smf_names = unique_track_names (temp);
|
2021-11-13 16:51:20 -05:00
|
|
|
}
|
2016-12-14 06:44:40 -05:00
|
|
|
break;
|
|
|
|
case SMFInstrumentName:
|
2021-11-13 16:51:20 -05:00
|
|
|
if (status.split_midi_channels) {
|
|
|
|
vector<string> temp;
|
|
|
|
smf_reader->instrument_names (temp);
|
|
|
|
for (uint32_t i = 0; i<num_channels;i++) {
|
|
|
|
smf_names.push_back( string_compose ("%1.ch%2", temp[i/16], 1+i%16 ) ); //instrument.chanX
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
smf_reader->instrument_names (smf_names);
|
|
|
|
}
|
2016-12-14 06:44:40 -05:00
|
|
|
break;
|
|
|
|
}
|
2016-10-05 14:09:36 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
} catch (...) {
|
2009-02-14 15:52:15 -05:00
|
|
|
error << _("Import: error opening MIDI file") << endmsg;
|
2008-06-02 17:41:35 -04:00
|
|
|
status.done = status.cancel = true;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2021-11-13 16:51:20 -05:00
|
|
|
if (num_channels == 0) {
|
2014-06-15 14:46:06 -04:00
|
|
|
error << _("Import: file contains no channels.") << endmsg;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-11-13 16:51:20 -05:00
|
|
|
vector<string> new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, num_channels, smf_names);
|
2008-06-02 17:41:35 -04:00
|
|
|
Sources newfiles;
|
2017-09-18 12:39:17 -04:00
|
|
|
samplepos_t natural_position = source ? source->natural_position() : 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-04-02 17:59:14 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (status.replace_existing_source) {
|
2009-11-30 08:16:38 -05:00
|
|
|
fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg;
|
2017-09-18 12:39:17 -04:00
|
|
|
status.cancel = !map_existing_mono_sources (new_paths, *this, sample_rate(), newfiles, this);
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
2023-08-22 13:00:42 -04:00
|
|
|
status.cancel = !create_mono_sources_for_writing (new_paths, *this, sample_rate(), newfiles, natural_position, true);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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));
|
|
|
|
|
2009-08-01 20:32:26 -04:00
|
|
|
if (status.cancel) {
|
|
|
|
break;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) {
|
2023-02-16 18:33:28 -05:00
|
|
|
if ((afs = std::dynamic_pointer_cast<AudioFileSource>(*i)) != 0) {
|
2008-06-02 17:41:35 -04:00
|
|
|
afs->prepare_for_peakfile_writes ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (source) { // audio
|
|
|
|
status.doing_what = compose_status_message (*p, source->samplerate(),
|
2017-09-18 12:39:17 -04:00
|
|
|
sample_rate(), status.current, status.total);
|
2008-06-02 17:41:35 -04:00
|
|
|
write_audio_data_to_new_files (source.get(), status, newfiles);
|
2017-10-26 15:43:49 -04:00
|
|
|
} else if (smf_reader) { // midi
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
|
2016-10-05 14:53:22 -04:00
|
|
|
write_midi_data_to_new_files (smf_reader.get(), status, newfiles, status.split_midi_channels);
|
2022-11-21 19:46:00 -05:00
|
|
|
|
|
|
|
if (status.import_markers) {
|
|
|
|
smf_reader->load_markers ();
|
|
|
|
for (auto const& m : smf_reader->markers ()) {
|
|
|
|
Temporal::Beats beats = Temporal::Beats::from_double (m.time_pulses / (double) smf_reader->ppqn ());
|
|
|
|
// XXX import to all sources (in case split_midi_channels is set)?
|
|
|
|
newfiles.front()->add_cue_marker (CueMarker (m.text, timepos_t (beats)));
|
|
|
|
}
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2010-04-09 21:35:11 -04:00
|
|
|
|
|
|
|
++status.current;
|
2010-04-14 18:16:46 -04:00
|
|
|
status.progress = 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!status.cancel) {
|
|
|
|
struct tm* now;
|
|
|
|
time_t xnow;
|
|
|
|
time (&xnow);
|
|
|
|
now = localtime (&xnow);
|
|
|
|
status.freeze = true;
|
|
|
|
|
|
|
|
/* flush the final length(s) to the header(s) */
|
|
|
|
|
|
|
|
for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
|
2012-05-20 16:52:54 -04:00
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
if ((afs = std::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
|
2020-09-20 18:34:09 -04:00
|
|
|
afs->update_header((*x)->natural_position().samples(), *now, xnow);
|
2008-06-02 17:41:35 -04:00
|
|
|
afs->done_with_peakfile_writes ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
/* now that there is data there, requeue the file for analysis */
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
if (Config->get_auto_analyse_audio()) {
|
2023-02-16 18:33:28 -05:00
|
|
|
Analyser::queue_source_for_analysis (std::static_pointer_cast<Source>(*x), false);
|
2008-09-10 11:03:30 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2012-05-20 16:52:54 -04:00
|
|
|
/* imported, copied files cannot be written or removed
|
|
|
|
*/
|
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
std::shared_ptr<FileSource> fs = std::dynamic_pointer_cast<FileSource>(*x);
|
2012-05-20 16:52:54 -04:00
|
|
|
if (fs) {
|
2012-07-16 10:48:07 -04:00
|
|
|
/* Only audio files should be marked as
|
|
|
|
immutable - we may need to rewrite MIDI
|
|
|
|
files at any time.
|
|
|
|
*/
|
2023-02-16 18:33:28 -05:00
|
|
|
if (std::dynamic_pointer_cast<AudioFileSource> (fs)) {
|
2012-07-16 10:48:07 -04:00
|
|
|
fs->mark_immutable ();
|
|
|
|
} else {
|
|
|
|
fs->mark_immutable_except_write ();
|
|
|
|
}
|
2012-05-20 16:52:54 -04:00
|
|
|
fs->mark_nonremovable ();
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* don't create tracks for empty MIDI sources (channels) */
|
2008-09-10 11:03:30 -04:00
|
|
|
|
2023-02-16 18:33:28 -05:00
|
|
|
if ((smfs = std::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
|
2008-06-02 17:41:35 -04:00
|
|
|
x = all_new_sources.erase(x);
|
|
|
|
} else {
|
|
|
|
++x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
2012-05-20 16:59:38 -04:00
|
|
|
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;
|
|
|
|
}
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
status.done = true;
|
|
|
|
}
|