From 244098cb400da1666147363d6959eeee3f6595bf Mon Sep 17 00:00:00 2001 From: Damien Zammit Date: Wed, 10 Oct 2018 20:19:12 +1100 Subject: PT import: Add new import_pt.cc session methods --- libs/ardour/import_pt.cc | 474 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 474 insertions(+) create mode 100644 libs/ardour/import_pt.cc diff --git a/libs/ardour/import_pt.cc b/libs/ardour/import_pt.cc new file mode 100644 index 0000000000..6a56bb9451 --- /dev/null +++ b/libs/ardour/import_pt.cc @@ -0,0 +1,474 @@ +/* + Copyright (C) 2018 Paul Davis + Author: Damien Zammit + + 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., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include "pbd/pthread_utils.h" +#include "pbd/basename.h" +#include "pbd/shortpath.h" +#include "pbd/stateful_diff_command.h" + +#include "ardour/audioengine.h" +#include "ardour/audio_track.h" +#include "ardour/audiofilesource.h" +#include "ardour/audioregion.h" +#include "ardour/import_status.h" +#include "ardour/midi_region.h" +#include "ardour/midi_track.h" +#include "ardour/midi_model.h" +#include "ardour/operations.h" +#include "ardour/region_factory.h" +#include "ardour/smf_source.h" +#include "ardour/source_factory.h" +#include "ardour/utils.h" +#include "ardour/playlist.h" +#include "ardour/session.h" +#include "pbd/memento_command.h" + +#include + +#include "pbd/i18n.h" + +using namespace std; +using namespace ARDOUR; +using namespace PBD; +using namespace Glib; +using std::string; + +/* Functions supporting the incorporation of PT sessions into ardour */ + +struct midipair { + midipair (uint16_t idx, string n) + : ptfindex (idx) + , trname (n) + {} + uint16_t ptfindex; + string trname; +}; + +typedef struct ptflookup { + uint16_t index1; + uint16_t index2; + PBD::ID id; + + bool operator ==(const struct ptflookup& other) { + return (this->index1 == other.index1); + } +} ptflookup_t; + + +bool +Session::import_sndfile_as_region (string path, SrcQuality quality, samplepos_t& pos, SourceList& sources, ImportStatus& status) +{ + /* Import the source */ + status.paths.clear(); + status.paths.push_back(path); + status.current = 1; + status.total = 1; + status.freeze = false; + status.quality = quality; + status.replace_existing_source = false; + status.split_midi_channels = false; + status.done = false; + status.cancel = false; + + import_files(status); + sources.clear(); + + /* FIXME: There is no way to tell if cancel button was pressed + * or if the file failed to import, just that one of these occurred. + * We want status.cancel to reflect the user's choice only + */ + if (status.cancel && status.current > 1) { + /* Succeeded to import file, assume user hit cancel */ + return false; + } else if (status.cancel && status.current == 1) { + /* Failed to import file, assume user did not hit cancel */ + status.cancel = false; + return false; + } + + sources.push_back(status.sources.front()); + + /* Put the source on a region */ + vector > regions; + string region_name; + bool use_timestamp; + + use_timestamp = (pos == -1); + + /* take all the sources we have and package them up as a region */ + + region_name = region_name_from_path (status.paths.front(), (sources.size() > 1), false); + + /* we checked in import_sndfiles() that there were not too many */ + + while (RegionFactory::region_by_name (region_name)) { + region_name = bump_name_once (region_name, '.'); + } + + PropertyList plist; + + plist.add (ARDOUR::Properties::start, 0); + plist.add (ARDOUR::Properties::length, sources[0]->length (pos)); + plist.add (ARDOUR::Properties::name, region_name); + plist.add (ARDOUR::Properties::layer, 0); + plist.add (ARDOUR::Properties::whole_file, true); + plist.add (ARDOUR::Properties::external, true); + + boost::shared_ptr r = RegionFactory::create (sources, plist); + + if (use_timestamp && boost::dynamic_pointer_cast(r)) { + boost::dynamic_pointer_cast(r)->special_set_position(sources[0]->natural_position()); + } + + regions.push_back (r); + + /* if we're creating a new track, name it after the cleaned-up + * and "merged" region name. + */ + + int n = 0; + + for (vector >::iterator r = regions.begin(); r != regions.end(); ++r, ++n) { + boost::shared_ptr ar = boost::dynamic_pointer_cast (*r); + + if (use_timestamp) { + if (ar) { + + /* get timestamp for this region */ + + const boost::shared_ptr s (ar->sources().front()); + const boost::shared_ptr as = boost::dynamic_pointer_cast (s); + + assert (as); + + if (as->natural_position() != 0) { + pos = as->natural_position(); + } else { + pos = 0; + } + } else { + /* should really get first position in MIDI file, but for now, use 0 */ + pos = 0; + } + } + } + + for (SourceList::iterator x = sources.begin(); x != sources.end(); ++x) { + SourceFactory::setup_peakfile (*x, true); + } + + return true; +} + + +void +Session::import_pt (PTFFormat& ptf, ImportStatus& status) +{ + vector > regions; + boost::shared_ptr track; + ARDOUR::PluginInfoPtr instrument; + vector to_import; + string fullpath; + bool ok = false; + bool onefailed = false; + samplepos_t pos = -1; + uint32_t srate = sample_rate (); + + vector ptfwavpair; + vector ptfregpair; + vector::iterator w; + + SourceList just_one_src; + SourceList imported; + + boost::shared_ptr existing_track; + uint16_t nth = 0; + vector usedtracks; + ptflookup_t utr; + + Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock (), Glib::Threads::NOT_LOCK); + + for (w = ptf.audiofiles.begin (); w != ptf.audiofiles.end () && !status.cancel; ++w) { + ptflookup_t p; + ok = false; + /* Try audio file */ + fullpath = Glib::build_filename (Glib::path_get_dirname (ptf.path), "Audio Files"); + fullpath = Glib::build_filename (fullpath, w->filename); + if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS)) { + just_one_src.clear(); + ok = import_sndfile_as_region (fullpath, SrcBest, pos, just_one_src, status); + } else { + /* Try fade file */ + fullpath = Glib::build_filename (Glib::path_get_dirname (ptf.path), "Fade Files"); + fullpath = Glib::build_filename (fullpath, w->filename); + if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS)) { + just_one_src.clear(); + ok = import_sndfile_as_region (fullpath, SrcBest, pos, just_one_src, status); + } else { + onefailed = true; + + /* ptformat knows length of sources *in PT sample rate* + * BUT if ardour user later resolves missing file, + * it won't be resampled, so we can only do this + * when sample rates are matching + */ + if (sample_rate () == ptf.sessionrate) { + /* Insert reference to missing source */ + samplecnt_t sourcelen = w->length; + XMLNode srcxml (X_("Source")); + srcxml.set_property ("name", w->filename); + srcxml.set_property ("type", "audio"); + srcxml.set_property ("id", PBD::ID ().to_s ()); + boost::shared_ptr source = SourceFactory::createSilent (*this, srcxml, sourcelen, sample_rate ()); + p.index1 = w->index; + p.id = source->id (); + ptfwavpair.push_back (p); + imported.push_back (source); + warning << string_compose (_("PT Import : MISSING `%1`, inserting ref to missing source"), fullpath) << endmsg; + } else { + warning << string_compose (_("PT Import : MISSING `%1`, please check Audio Files"), fullpath) << endmsg; + } + } + } + if (ok) { + p.index1 = w->index; + p.id = just_one_src.back ()->id (); + + ptfwavpair.push_back (p); + imported.push_back (just_one_src.back ()); + } + } + + if (imported.empty ()) { + error << _("Failed to find any audio for PT import") << endmsg; + goto trymidi; + } else if (onefailed) { + warning << _("Failed to load one or more of the audio files for PT import, see above list") << endmsg; + } else { + info << _("All audio files found for PT import!") << endmsg; + } + + lx.acquire(); + save_state(""); + + for (vector::iterator a = ptf.regions.begin (); + a != ptf.regions.end (); ++a) { + for (vector::iterator p = ptfwavpair.begin (); + p != ptfwavpair.end (); ++p) { + if ((p->index1 == a->wave.index) && (strcmp (a->wave.filename.c_str (), "") != 0)) { + for (SourceList::iterator x = imported.begin (); x != imported.end (); ++x) { + if ((*x)->id () == p->id) { + /* Matched an uncreated ptf region to ardour region */ + ptflookup_t rp; + PropertyList plist; + + plist.add (ARDOUR::Properties::start, a->sampleoffset); + plist.add (ARDOUR::Properties::position, 0); + plist.add (ARDOUR::Properties::length, a->length); + plist.add (ARDOUR::Properties::name, a->name); + plist.add (ARDOUR::Properties::layer, 0); + plist.add (ARDOUR::Properties::whole_file, false); + plist.add (ARDOUR::Properties::external, true); + + just_one_src.clear (); + just_one_src.push_back (*x); + + boost::shared_ptr r = RegionFactory::create (just_one_src, plist); + regions.push_back (r); + + rp.id = regions.back ()->id (); + rp.index1 = a->index; + ptfregpair.push_back (rp); + } + } + } + } + } + + for (vector::iterator a = ptf.tracks.begin (); a != ptf.tracks.end (); ++a) { + for (vector::iterator p = ptfregpair.begin (); + p != ptfregpair.end (); ++p) { + + if (p->index1 == a->reg.index) { + + /* Matched a ptf active region to an ardour region */ + utr.index1 = a->index; + utr.index2 = nth; + utr.id = p->id; + boost::shared_ptr r = RegionFactory::region_by_id (p->id); + vector::iterator lookuptr = usedtracks.begin (); + vector::iterator found; + if ((found = std::find (lookuptr, usedtracks.end (), utr)) != usedtracks.end ()) { + DEBUG_TRACE (DEBUG::FileUtils, string_compose ("\twav(%1) reg(%2) ptf_tr(%3) ard_tr(%4)\n", a->reg.wave.filename.c_str (), a->reg.index, found->index1, found->index2)); + + /* Use existing track if possible */ + existing_track = get_nth_audio_track (found->index2 + 1); + if (!existing_track) { + lx.release(); + list > at (new_audio_track (1, 2, 0, 1, "", PresentationInfo::max_order, Normal)); + if (at.empty ()) { + return; + } + lx.acquire(); + existing_track = at.back (); + } + /* Put on existing track */ + boost::shared_ptr playlist = existing_track->playlist (); + boost::shared_ptr copy (RegionFactory::create (r, true)); + playlist->clear_changes (); + playlist->add_region (copy, a->reg.startpos); + //add_command (new StatefulDiffCommand (playlist)); + } else { + lx.release(); + /* Put on a new track */ + DEBUG_TRACE (DEBUG::FileUtils, string_compose ("\twav(%1) reg(%2) new_tr(%3)\n", a->reg.wave.filename.c_str (), a->reg.index, nth)); + list > at (new_audio_track (1, 2, 0, 1, "", PresentationInfo::max_order, Normal)); + if (at.empty ()) { + return; + } + lx.acquire(); + existing_track = at.back (); + std::string trackname; + try { + trackname = Glib::convert_with_fallback (a->name, "UTF-8", "UTF-8", "_"); + } catch (Glib::ConvertError& err) { + trackname = string_compose ("Invalid %1", a->index); + } + /* generate a unique name by adding a number if needed */ + uint32_t id = 0; + if (!find_route_name (trackname.c_str (), id, trackname, false)) { + fatal << _("PTImport: UINT_MAX routes? impossible!") << endmsg; + abort(); /*NOTREACHED*/ + } + existing_track->set_name (trackname); + boost::shared_ptr playlist = existing_track->playlist(); + boost::shared_ptr copy (RegionFactory::create (r, true)); + playlist->clear_changes (); + playlist->add_region (copy, a->reg.startpos); + //add_command (new StatefulDiffCommand (playlist)); + nth++; + } + usedtracks.push_back (utr); + + save_state(""); + } + } + } + + lx.release(); + +trymidi: + status.paths.clear(); + status.paths.push_back(ptf.path); + status.current = 1; + status.total = 1; + status.freeze = false; + status.done = false; + status.cancel = false; + status.progress = 0; + + /* MIDI - Find list of unique midi tracks first */ + + vector uniquetr; + + for (vector::iterator a = ptf.miditracks.begin (); a != ptf.miditracks.end (); ++a) { + bool found = false; + for (vector::iterator b = uniquetr.begin (); b != uniquetr.end (); ++b) { + if (b->trname == a->name) { + found = true; + break; + } + } + if (!found) { + uniquetr.push_back (midipair (a->index, a->name)); + //printf(" : %d : %s\n", a->index, a->name.c_str()); + } + } + + std::map > midi_tracks; + /* MIDI - Create unique midi tracks and a lookup table for used tracks */ + for (vector::iterator a = uniquetr.begin (); a != uniquetr.end (); ++a) { + ptflookup_t miditr; + list > mt (new_midi_track ( + ChanCount (DataType::MIDI, 1), + ChanCount (DataType::MIDI, 1), + true, + instrument, (Plugin::PresetRecord*) 0, + (RouteGroup*) 0, + 1, + a->trname, + PresentationInfo::max_order, + Normal)); + assert (mt.size () == 1); + midi_tracks[a->ptfindex] = mt.front (); + } + + /* MIDI - Add midi regions one-by-one to corresponding midi tracks */ + for (vector::iterator a = ptf.miditracks.begin (); a != ptf.miditracks.end (); ++a) { + + boost::shared_ptr midi_track = midi_tracks[a->index]; + assert (midi_track); + boost::shared_ptr playlist = midi_track->playlist (); + samplepos_t f = (samplepos_t)a->reg.startpos * srate / 1920000.; + samplecnt_t length = (samplecnt_t)a->reg.length * srate / 1920000.; + MusicSample pos (f, 0); + boost::shared_ptr src = create_midi_source_by_stealing_name (midi_track); + PropertyList plist; + plist.add (ARDOUR::Properties::start, 0); + plist.add (ARDOUR::Properties::length, length); + plist.add (ARDOUR::Properties::name, PBD::basename_nosuffix (src->name ())); + //printf(" : %d - trackname: (%s)\n", a->index, src->name ().c_str ()); + boost::shared_ptr region = (RegionFactory::create (src, plist)); + /* sets beat position */ + region->set_position (pos.sample, pos.division); + midi_track->playlist ()->add_region (region, pos.sample, 1.0, false, pos.division); + + boost::shared_ptr mr = boost::dynamic_pointer_cast(region); + boost::shared_ptr mm = mr->midi_source (0)->model (); + MidiModel::NoteDiffCommand *midicmd; + midicmd = mm->new_note_diff_command ("Import ProTools MIDI"); + + for (vector::iterator j = a->reg.midi.begin (); j != a->reg.midi.end (); ++j) { + //printf(" : MIDI : pos=%f len=%f\n", (float)j->pos / 960000., (float)j->length / 960000.); + Temporal::Beats start = (Temporal::Beats)(j->pos / 960000.); + Temporal::Beats len = (Temporal::Beats)(j->length / 960000.); + /* PT C-2 = 0, Ardour C-1 = 0, subtract twelve to convert ? */ + midicmd->add (boost::shared_ptr > (new Evoral::Note ((uint8_t)1, start, len, j->note, j->velocity))); + } + mm->apply_command (this, midicmd); + boost::shared_ptr copy (RegionFactory::create (mr, true)); + playlist->clear_changes (); + playlist->add_region (copy, f); + } + + status.progress = 1.0; + status.done = true; + save_state(""); + status.sources.clear (); + status.all_done = true; +} -- cgit v1.2.3