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