libs/ardour/import.cc

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20
  21 #ifdef WAF_BUILD
  22 #include "libardour-config.h"
  23 #endif
  24
  25 #include <cstdio>
  26 #include <cstdlib>
  27 #include <string>
  28 #include <climits>
  29 #include <cerrno>
  30 #include <unistd.h>
  31 #include <sys/stat.h>
  32 #include <time.h>
  33 #include <stdint.h>
  34
  35 #include <sndfile.h>
  36 #include <samplerate.h>
  37
  38 #include <glibmm.h>
  39
  40 #include <boost/scoped_array.hpp>
  41 #include <boost/shared_array.hpp>
  42
  43 #include "pbd/basename.h"
  44 #include "pbd/convert.h"
  45
  46 #include "evoral/SMF.hpp"
  47
  48 #include "ardour/analyser.h"
  49 #include "ardour/ardour.h"
  50 #include "ardour/audio_diskstream.h"
  51 #include "ardour/audioengine.h"
  52 #include "ardour/audioregion.h"
  53 #include "ardour/import_status.h"
  54 #include "ardour/region_factory.h"
  55 #include "ardour/resampled_source.h"
  56 #include "ardour/session.h"
  57 #include "ardour/session_directory.h"
  58 #include "ardour/smf_source.h"
  59 #include "ardour/sndfile_helpers.h"
  60 #include "ardour/sndfileimportable.h"
  61 #include "ardour/sndfilesource.h"
  62 #include "ardour/source_factory.h"
  63 #include "ardour/tempo.h"
  64
  65 #ifdef HAVE_COREAUDIO
  66 #include "ardour/caimportable.h"
  67 #endif
  68
  69 #include "i18n.h"
  70
  71 using namespace std;
  72 using namespace ARDOUR;
  73 using namespace PBD;
  74
  75 static boost::shared_ptr<ImportableSource>
  76 open_importable_source (const string& path, framecnt_t samplerate, ARDOUR::SrcQuality quality)
  77 {
  78         /* try libsndfile first, because it can get BWF info from .wav, which ExtAudioFile cannot.
  79            We don't necessarily need that information in an ImportableSource, but it keeps the
  80            logic the same as in SourceFactory::create()
  81          */
  82
  83         try {
  84                 boost::shared_ptr<SndFileImportableSource> source(new SndFileImportableSource(path));
  85
  86                 if (source->samplerate() == samplerate) {
  87                         return source;
  88                 }
  89
  90                 /* rewrap as a resampled source */
  91
  92                 return boost::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
  93         }
  94
  95         catch (...) {
  96
  97 #ifdef HAVE_COREAUDIO
  98
  99                 /* libsndfile failed, see if we can use CoreAudio to handle the IO */
 100
 101                 CAImportableSource* src = new CAImportableSource(path);
 102                 boost::shared_ptr<CAImportableSource> source (src);
 103
 104                 if (source->samplerate() == samplerate) {
 105                         return source;
 106                 }
 107
 108                 /* rewrap as a resampled source */
 109
 110                 return boost::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
 111
 112 #else
 113                 throw; // rethrow
 114 #endif
 115
 116         }
 117 }
 118
 119 static std::string
 120 get_non_existent_filename (HeaderFormat hf, DataType type, const bool allow_replacing, const std::string& destdir, const std::string& basename, uint channel, uint channels)
 121 {
 122         char buf[PATH_MAX+1];
 123         bool goodfile = false;
 124         string base = basename;
 125         string ext = native_header_format_extension (hf, type);
 126         uint32_t cnt = 1;
 127
 128         do {
 129
 130                 if (type == DataType::AUDIO && channels == 2) {
 131                         if (channel == 0) {
 132                                 if (cnt == 1) {
 133                                         snprintf (buf, sizeof(buf), "%s-L%s", base.c_str(), ext.c_str());
 134                                 } else {
 135                                         snprintf (buf, sizeof(buf), "%s-%d-L%s", base.c_str(), cnt, ext.c_str());
 136                                 }
 137                         } else {
 138                                 if (cnt == 1) {
 139                                         snprintf (buf, sizeof(buf), "%s-R%s", base.c_str(), ext.c_str());
 140                                 } else {
 141                                         snprintf (buf, sizeof(buf), "%s-%d-R%s", base.c_str(), cnt, ext.c_str());
 142                                 }
 143                         }
 144                 } else if (channels > 1) {
 145                         if (cnt == 1) {
 146                                 snprintf (buf, sizeof(buf), "%s-c%d%s", base.c_str(), channel, ext.c_str());
 147                         } else {
 148                                 snprintf (buf, sizeof(buf), "%s-%d-c%d%s", base.c_str(), cnt, channel, ext.c_str());
 149                         }
 150                 } else {
 151                         if (cnt == 1) {
 152                                 snprintf (buf, sizeof(buf), "%s%s", base.c_str(), ext.c_str());
 153                         } else {
 154                                 snprintf (buf, sizeof(buf), "%s-%d%s", base.c_str(), cnt, ext.c_str());
 155                         }
 156                 }
 157
 158                 string tempname = destdir + "/" + buf;
 159
 160                 if (!allow_replacing && Glib::file_test (tempname, Glib::FILE_TEST_EXISTS)) {
 161
 162                         cnt++;
 163
 164                 } else {
 165
 166                         goodfile = true;
 167                 }
 168
 169         } while (!goodfile);
 170
 171         return buf;
 172 }
 173
 174 static vector<string>
 175 get_paths_for_new_sources (HeaderFormat hf, const bool allow_replacing, const string& import_file_path, const string& session_dir, uint channels)
 176 {
 177         vector<string> new_paths;
 178         const string basename = basename_nosuffix (import_file_path);
 179
 180         SessionDirectory sdir(session_dir);
 181
 182         for (uint n = 0; n < channels; ++n) {
 183
 184                 const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
 185
 186                 std::string filepath = (type == DataType::MIDI)
 187                                 ? sdir.midi_path().to_string() : sdir.sound_path().to_string();
 188
 189                 filepath = Glib::build_filename (filepath,
 190                                                  get_non_existent_filename (hf, type, allow_replacing, filepath, basename, n, channels));
 191                 new_paths.push_back (filepath);
 192         }
 193
 194         return new_paths;
 195 }
 196
 197 static bool
 198 map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
 199                            uint /*samplerate*/, vector<boost::shared_ptr<Source> >& newfiles, Session *session)
 200 {
 201         for (vector<string>::const_iterator i = new_paths.begin();
 202                         i != new_paths.end(); ++i)
 203         {
 204                 boost::shared_ptr<Source> source = session->source_by_path_and_channel(*i, 0);
 205
 206                 if (source == 0) {
 207                         error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
 208                         return false;
 209                 }
 210
 211                 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
 212         }
 213         return true;
 214 }
 215
 216 static bool
 217 create_mono_sources_for_writing (const string& origin,
 218                                  const vector<string>& new_paths,
 219                                  Session& sess, uint samplerate,
 220                                  vector<boost::shared_ptr<Source> >& newfiles,
 221                                  framepos_t timeline_position)
 222 {
 223         for (vector<string>::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) {
 224
 225                 boost::shared_ptr<Source> source;
 226
 227                 try {
 228                         const DataType type = SMFSource::safe_midi_file_extension (*i) ? DataType::MIDI : DataType::AUDIO;
 229
 230                         source = SourceFactory::createWritable (type, sess,
 231                                                                 i->c_str(),
 232                                                                 origin,
 233                                                                 false, // destructive
 234                                                                 samplerate);
 235                 }
 236
 237                 catch (const failed_constructor& err) {
 238                         error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg;
 239                         return false;
 240                 }
 241
 242                 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
 243
 244                 /* for audio files, reset the timeline position so that any BWF-ish
 245                    information in the original files we are importing from is maintained.
 246                 */
 247
 248                 boost::shared_ptr<AudioFileSource> afs;
 249                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
 250                         afs->set_timeline_position(timeline_position);
 251                 }
 252         }
 253         return true;
 254 }
 255
 256 static string
 257 compose_status_message (const string& path,
 258                         uint file_samplerate,
 259                         uint session_samplerate,
 260                         uint /* current_file */,
 261                         uint /* total_files */)
 262 {
 263         if (file_samplerate != session_samplerate) {
 264                 return string_compose (_("Resampling %1 from %2kHz to %3kHz"),
 265                                        Glib::path_get_basename (path),
 266                                        file_samplerate/1000.0f,
 267                                        session_samplerate/1000.0f);
 268         }
 269
 270         return string_compose (_("Copying %1"), Glib::path_get_basename (path));
 271 }
 272
 273 static void
 274 write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
 275                                vector<boost::shared_ptr<Source> >& newfiles)
 276 {
 277         const framecnt_t nframes = ResampledImportableSource::blocksize;
 278         boost::shared_ptr<AudioFileSource> afs;
 279         uint channels = source->channels();
 280
 281         boost::scoped_array<float> data(new float[nframes * channels]);
 282         vector<boost::shared_array<Sample> > channel_data;
 283
 284         for (uint n = 0; n < channels; ++n) {
 285                 channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
 286         }
 287
 288         float gain = 1;
 289
 290         boost::shared_ptr<AudioSource> s = boost::dynamic_pointer_cast<AudioSource> (newfiles[0]);
 291         assert (s);
 292
 293         status.progress = 0.0f;
 294         float progress_multiplier = 1;
 295         float progress_base = 0;
 296
 297         if (!source->clamped_at_unity() && s->clamped_at_unity()) {
 298
 299                 /* The source we are importing from can return sample values with a magnitude greater than 1,
 300                    and the file we are writing the imported data to cannot handle such values.  Compute the gain
 301                    factor required to normalize the input sources to have a magnitude of less than 1.
 302                 */
 303
 304                 float peak = 0;
 305                 uint read_count = 0;
 306
 307                 while (!status.cancel) {
 308                         framecnt_t const nread = source->read (data.get(), nframes);
 309                         if (nread == 0) {
 310                                 break;
 311                         }
 312
 313                         peak = compute_peak (data.get(), nread, peak);
 314
 315                         read_count += nread;
 316                         status.progress = 0.5 * read_count / (source->ratio() * source->length() * channels);
 317                 }
 318
 319                 if (peak >= 1) {
 320                         /* we are out of range: compute a gain to fix it */
 321                         gain = (1 - FLT_EPSILON) / peak;
 322                 }
 323
 324                 source->seek (0);
 325                 progress_multiplier = 0.5;
 326                 progress_base = 0.5;
 327         }
 328
 329         uint read_count = 0;
 330
 331         while (!status.cancel) {
 332
 333                 framecnt_t nread, nfread;
 334                 uint x;
 335                 uint chn;
 336
 337                 if ((nread = source->read (data.get(), nframes)) == 0) {
 338                         break;
 339                 }
 340
 341                 if (gain != 1) {
 342                         /* here is the gain fix for out-of-range sample values that we computed earlier */
 343                         apply_gain_to_buffer (data.get(), nread, gain);
 344                 }
 345
 346                 nfread = nread / channels;
 347
 348                 /* de-interleave */
 349
 350                 for (chn = 0; chn < channels; ++chn) {
 351
 352                         framecnt_t n;
 353                         for (x = chn, n = 0; n < nfread; x += channels, ++n) {
 354                                 channel_data[chn][n] = (Sample) data[x];
 355                         }
 356                 }
 357
 358                 /* flush to disk */
 359
 360                 for (chn = 0; chn < channels; ++chn) {
 361                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0) {
 362                                 afs->write (channel_data[chn].get(), nfread);
 363                         }
 364                 }
 365
 366                 read_count += nread;
 367                 status.progress = progress_base + progress_multiplier * read_count / (source->ratio () * source->length() * channels);
 368         }
 369 }
 370
 371 static void
 372 write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
 373                               vector<boost::shared_ptr<Source> >& newfiles)
 374 {
 375         uint32_t buf_size = 4;
 376         uint8_t* buf      = (uint8_t*) malloc (buf_size);
 377
 378         status.progress = 0.0f;
 379
 380         assert (newfiles.size() == source->num_tracks());
 381
 382         try {
 383                 vector<boost::shared_ptr<Source> >::iterator s = newfiles.begin();
 384
 385                 for (unsigned i = 1; i <= source->num_tracks(); ++i) {
 386
 387                         boost::shared_ptr<SMFSource> smfs = boost::dynamic_pointer_cast<SMFSource> (*s);
 388
 389                         smfs->drop_model ();
 390                         source->seek_to_track (i);
 391
 392                         uint64_t t       = 0;
 393                         uint32_t delta_t = 0;
 394                         uint32_t size    = 0;
 395                         bool first = true;
 396
 397                         while (!status.cancel) {
 398                                 gint note_id_ignored; // imported files either don't have NoteID's or we ignore them.
 399
 400                                 size = buf_size;
 401
 402                                 int ret = source->read_event (&delta_t, &size, &buf, &note_id_ignored);
 403
 404                                 if (size > buf_size) {
 405                                         buf_size = size;
 406                                 }
 407
 408                                 if (ret < 0) { // EOT
 409                                         break;
 410                                 }
 411
 412                                 t += delta_t;
 413
 414                                 if (ret == 0) { // Meta
 415                                         continue;
 416                                 }
 417
 418                                 if (first) {
 419                                         smfs->mark_streaming_write_started ();
 420                                         first = false;
 421                                 }
 422
 423                                 smfs->append_event_unlocked_beats(Evoral::Event<double>(0,
 424                                                                                         (double)t / (double)source->ppqn(),
 425                                                                                         size,
 426                                                                                         buf));
 427
 428                                 if (status.progress < 0.99) {
 429                                         status.progress += 0.01;
 430                                 }
 431                         }
 432
 433                         if (!first) {
 434
 435                                 /* we wrote something */
 436
 437                                 const framepos_t pos = 0;
 438                                 const double length_beats = ceil(t / (double)source->ppqn());
 439                                 BeatsFramesConverter converter(smfs->session().tempo_map(), pos);
 440                                 smfs->update_length(pos, converter.to(length_beats));
 441                                 smfs->mark_streaming_write_completed ();
 442
 443                                 if (status.cancel) {
 444                                         break;
 445                                 }
 446                         }
 447
 448                         ++s; // next source
 449                 }
 450
 451         } catch (...) {
 452                 error << "Corrupt MIDI file " << source->file_path() << endmsg;
 453         }
 454
 455         if (buf) {
 456                 free (buf);
 457         }
 458 }
 459
 460 static void
 461 remove_file_source (boost::shared_ptr<Source> source)
 462 {
 463         ::unlink (source->path().c_str());
 464 }
 465
 466 // This function is still unable to cleanly update an existing source, even though
 467 // it is possible to set the ImportStatus flag accordingly. The functinality
 468 // is disabled at the GUI until the Source implementations are able to provide
 469 // the necessary API.
 470 void
 471 Session::import_audiofiles (ImportStatus& status)
 472 {
 473         typedef vector<boost::shared_ptr<Source> > Sources;
 474         Sources all_new_sources;
 475         boost::shared_ptr<AudioFileSource> afs;
 476         boost::shared_ptr<SMFSource> smfs;
 477         uint channels = 0;
 478
 479         status.sources.clear ();
 480
 481         for (vector<string>::iterator p = status.paths.begin();
 482              p != status.paths.end() && !status.cancel;
 483              ++p)
 484         {
 485                 boost::shared_ptr<ImportableSource> source;
 486                 std::auto_ptr<Evoral::SMF>          smf_reader;
 487                 const DataType type = SMFSource::safe_midi_file_extension (*p) ? DataType::MIDI : DataType::AUDIO;
 488
 489                 if (type == DataType::AUDIO) {
 490                         try {
 491                                 source = open_importable_source (*p, frame_rate(), status.quality);
 492                                 channels = source->channels();
 493                         } catch (const failed_constructor& err) {
 494                                 error << string_compose(_("Import: cannot open input sound file \"%1\""), (*p)) << endmsg;
 495                                 status.done = status.cancel = true;
 496                                 return;
 497                         }
 498
 499                 } else {
 500                         try {
 501                                 smf_reader = std::auto_ptr<Evoral::SMF>(new Evoral::SMF());
 502                                 smf_reader->open(*p);
 503                                 channels = smf_reader->num_tracks();
 504                         } catch (...) {
 505                                 error << _("Import: error opening MIDI file") << endmsg;
 506                                 status.done = status.cancel = true;
 507                                 return;
 508                         }
 509                 }
 510
 511                 vector<string> new_paths = get_paths_for_new_sources (config.get_native_file_header_format(),
 512                                                                       status.replace_existing_source, *p,
 513                                                                       get_best_session_directory_for_new_source (),
 514                                                                       channels);
 515                 Sources newfiles;
 516                 framepos_t natural_position = source ? source->natural_position() : 0;
 517
 518
 519                 if (status.replace_existing_source) {
 520                         fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg;
 521                         status.cancel = !map_existing_mono_sources (new_paths, *this, frame_rate(), newfiles, this);
 522                 } else {
 523                         status.cancel = !create_mono_sources_for_writing (*p, new_paths, *this, frame_rate(), newfiles, natural_position);
 524                 }
 525
 526                 // copy on cancel/failure so that any files that were created will be removed below
 527                 std::copy (newfiles.begin(), newfiles.end(), std::back_inserter(all_new_sources));
 528
 529                 if (status.cancel) {
 530                         break;
 531                 }
 532
 533                 for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) {
 534                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*i)) != 0) {
 535                                 afs->prepare_for_peakfile_writes ();
 536                         }
 537                 }
 538
 539                 if (source) { // audio
 540                         status.doing_what = compose_status_message (*p, source->samplerate(),
 541                                                                     frame_rate(), status.current, status.total);
 542                         write_audio_data_to_new_files (source.get(), status, newfiles);
 543                 } else if (smf_reader.get()) { // midi
 544                         status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
 545                         write_midi_data_to_new_files (smf_reader.get(), status, newfiles);
 546                 }
 547
 548                 ++status.current;
 549                 status.progress = 0;
 550         }
 551
 552         if (!status.cancel) {
 553                 struct tm* now;
 554                 time_t xnow;
 555                 time (&xnow);
 556                 now = localtime (&xnow);
 557                 status.freeze = true;
 558
 559                 /* flush the final length(s) to the header(s) */
 560
 561                 for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
 562                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
 563                                 afs->update_header((*x)->natural_position(), *now, xnow);
 564                                 afs->done_with_peakfile_writes ();
 565
 566                                 /* now that there is data there, requeue the file for analysis */
 567
 568                                 if (Config->get_auto_analyse_audio()) {
 569                                         Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
 570                                 }
 571                         }
 572
 573                         /* don't create tracks for empty MIDI sources (channels) */
 574
 575                         if ((smfs = boost::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
 576                                 x = all_new_sources.erase(x);
 577                         } else {
 578                                 ++x;
 579                         }
 580                 }
 581
 582                 /* save state so that we don't lose these new Sources */
 583
 584                 save_state (_name);
 585
 586                 std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
 587         } else {
 588                 // this can throw...but it seems very unlikely
 589                 std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
 590         }
 591
 592         status.done = true;
 593 }
 594