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->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                         break;
 338                 }
 339
 340                 if (gain != 1) {
 341                         /* here is the gain fix for out-of-range sample values that we computed earlier */
 342                         apply_gain_to_buffer (data.get(), nread, gain);
 343                 }
 344
 345                 nfread = nread / channels;
 346
 347                 /* de-interleave */
 348
 349                 for (chn = 0; chn < channels; ++chn) {
 350
 351                         framecnt_t n;
 352                         for (x = chn, n = 0; n < nfread; x += channels, ++n) {
 353                                 channel_data[chn][n] = (Sample) data[x];
 354                         }
 355                 }
 356
 357                 /* flush to disk */
 358
 359                 for (chn = 0; chn < channels; ++chn) {
 360                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0) {
 361                                 afs->write (channel_data[chn].get(), nfread);
 362                         }
 363                 }
 364
 365                 read_count += nread;
 366                 status.progress = progress_base + progress_multiplier * read_count / (source->ratio () * source->length() * channels);
 367         }
 368 }
 369
 370 static void
 371 write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
 372                               vector<boost::shared_ptr<Source> >& newfiles)
 373 {
 374         uint32_t buf_size = 4;
 375         uint8_t* buf      = (uint8_t*) malloc (buf_size);
 376
 377         status.progress = 0.0f;
 378
 379         assert (newfiles.size() == source->num_tracks());
 380
 381         try {
 382                 vector<boost::shared_ptr<Source> >::iterator s = newfiles.begin();
 383
 384                 for (unsigned i = 1; i <= source->num_tracks(); ++i) {
 385
 386                         boost::shared_ptr<SMFSource> smfs = boost::dynamic_pointer_cast<SMFSource> (*s);
 387
 388                         smfs->drop_model ();
 389                         source->seek_to_track (i);
 390
 391                         uint64_t t       = 0;
 392                         uint32_t delta_t = 0;
 393                         uint32_t size    = 0;
 394                         bool first = true;
 395
 396                         while (!status.cancel) {
 397                                 gint note_id_ignored; // imported files either don't have NoteID's or we ignore them.
 398
 399                                 size = buf_size;
 400
 401                                 int ret = source->read_event (&delta_t, &size, &buf, &note_id_ignored);
 402
 403                                 if (size > buf_size) {
 404                                         buf_size = size;
 405                                 }
 406
 407                                 if (ret < 0) { // EOT
 408                                         break;
 409                                 }
 410
 411                                 t += delta_t;
 412
 413                                 if (ret == 0) { // Meta
 414                                         continue;
 415                                 }
 416
 417                                 if (first) {
 418                                         smfs->mark_streaming_write_started ();
 419                                         first = false;
 420                                 }
 421
 422                                 smfs->append_event_unlocked_beats(
 423                                         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                         } else {
 447                                 warning << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, source->file_path()) << endmsg;
 448                         }
 449
 450                         ++s; // next source
 451                 }
 452
 453         } catch (...) {
 454                 error << string_compose (_("MIDI file %1 was not readable (no reason available)"), source->file_path()) << endmsg;
 455         }
 456
 457         if (buf) {
 458                 free (buf);
 459         }
 460 }
 461
 462 static void
 463 remove_file_source (boost::shared_ptr<Source> source)
 464 {
 465         boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
 466
 467         if (fs) {
 468                 ::g_unlink (fs->path().c_str());
 469         }
 470 }
 471
 472 // This function is still unable to cleanly update an existing source, even though
 473 // it is possible to set the ImportStatus flag accordingly. The functinality
 474 // is disabled at the GUI until the Source implementations are able to provide
 475 // the necessary API.
 476 void
 477 Session::import_files (ImportStatus& status)
 478 {
 479         typedef vector<boost::shared_ptr<Source> > Sources;
 480         Sources all_new_sources;
 481         boost::shared_ptr<AudioFileSource> afs;
 482         boost::shared_ptr<SMFSource> smfs;
 483         uint32_t channels = 0;
 484
 485         status.sources.clear ();
 486
 487         for (vector<string>::iterator p = status.paths.begin();
 488              p != status.paths.end() && !status.cancel;
 489              ++p)
 490         {
 491                 boost::shared_ptr<ImportableSource> source;
 492                 std::auto_ptr<Evoral::SMF>          smf_reader;
 493                 const DataType type = SMFSource::safe_midi_file_extension (*p) ? DataType::MIDI : DataType::AUDIO;
 494
 495                 if (type == DataType::AUDIO) {
 496                         try {
 497                                 source = open_importable_source (*p, frame_rate(), status.quality);
 498                                 channels = source->channels();
 499                         } catch (const failed_constructor& err) {
 500                                 error << string_compose(_("Import: cannot open input sound file \"%1\""), (*p)) << endmsg;
 501                                 status.done = status.cancel = true;
 502                                 return;
 503                         }
 504
 505                 } else {
 506                         try {
 507                                 smf_reader = std::auto_ptr<Evoral::SMF>(new Evoral::SMF());
 508                                 smf_reader->open(*p);
 509                                 channels = smf_reader->num_tracks();
 510                         } catch (...) {
 511                                 error << _("Import: error opening MIDI file") << endmsg;
 512                                 status.done = status.cancel = true;
 513                                 return;
 514                         }
 515                 }
 516
 517                 vector<string> new_paths = get_paths_for_new_sources (config.get_native_file_header_format(),
 518                                                                       status.replace_existing_source, *p,
 519                                                                       get_best_session_directory_for_new_source (),
 520                                                                       channels);
 521                 Sources newfiles;
 522                 framepos_t natural_position = source ? source->natural_position() : 0;
 523
 524
 525                 if (status.replace_existing_source) {
 526                         fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg;
 527                         status.cancel = !map_existing_mono_sources (new_paths, *this, frame_rate(), newfiles, this);
 528                 } else {
 529                         status.cancel = !create_mono_sources_for_writing (new_paths, *this, frame_rate(), newfiles, natural_position);
 530                 }
 531
 532                 // copy on cancel/failure so that any files that were created will be removed below
 533                 std::copy (newfiles.begin(), newfiles.end(), std::back_inserter(all_new_sources));
 534
 535                 if (status.cancel) {
 536                         break;
 537                 }
 538
 539                 for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) {
 540                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*i)) != 0) {
 541                                 afs->prepare_for_peakfile_writes ();
 542                         }
 543                 }
 544
 545                 if (source) { // audio
 546                         status.doing_what = compose_status_message (*p, source->samplerate(),
 547                                                                     frame_rate(), status.current, status.total);
 548                         write_audio_data_to_new_files (source.get(), status, newfiles);
 549                 } else if (smf_reader.get()) { // midi
 550                         status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
 551                         write_midi_data_to_new_files (smf_reader.get(), status, newfiles);
 552                 }
 553
 554                 ++status.current;
 555                 status.progress = 0;
 556         }
 557
 558         if (!status.cancel) {
 559                 struct tm* now;
 560                 time_t xnow;
 561                 time (&xnow);
 562                 now = localtime (&xnow);
 563                 status.freeze = true;
 564
 565                 /* flush the final length(s) to the header(s) */
 566
 567                 for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
 568
 569                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
 570                                 afs->update_header((*x)->natural_position(), *now, xnow);
 571                                 afs->done_with_peakfile_writes ();
 572
 573                                 /* now that there is data there, requeue the file for analysis */
 574
 575                                 if (Config->get_auto_analyse_audio()) {
 576                                         Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
 577                                 }
 578                         }
 579
 580                         /* imported, copied files cannot be written or removed
 581                          */
 582
 583                         boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource>(*x);
 584                         if (fs) {
 585                                 /* Only audio files should be marked as
 586                                    immutable - we may need to rewrite MIDI
 587                                    files at any time.
 588                                 */
 589                                 if (boost::dynamic_pointer_cast<AudioFileSource> (fs)) {
 590                                         fs->mark_immutable ();
 591                                 } else {
 592                                         fs->mark_immutable_except_write ();
 593                                 }
 594                                 fs->mark_nonremovable ();
 595                         }
 596
 597                         /* don't create tracks for empty MIDI sources (channels) */
 598
 599                         if ((smfs = boost::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
 600                                 x = all_new_sources.erase(x);
 601                         } else {
 602                                 ++x;
 603                         }
 604                 }
 605
 606                 /* save state so that we don't lose these new Sources */
 607
 608                 save_state (_name);
 609
 610                 std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
 611         } else {
 612                 try {
 613                         std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
 614                 } catch (...) {
 615                         error << _("Failed to remove some files after failed/cancelled import operation") << endmsg;
 616                 }
 617
 618         }
 619
 620         status.done = true;
 621 }
 622