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 vector<string>
 121 Session::get_paths_for_new_sources (bool /*allow_replacing*/, const string& import_file_path, uint32_t channels)
 122 {
 123         vector<string> new_paths;
 124         const string basename = basename_nosuffix (import_file_path);
 125
 126         for (uint32_t n = 0; n < channels; ++n) {
 127
 128                 const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
 129                 string filepath;
 130
 131                 switch (type) {
 132                   case DataType::MIDI:
 133                                 if (channels > 1) {
 134                                         string mchn_name = string_compose ("%1-t%2", basename, n);
 135                                         filepath = new_midi_source_path (mchn_name);
 136                                 } else {
 137                                         filepath = new_midi_source_path (basename);
 138                                 }
 139                         break;
 140                 case DataType::AUDIO:
 141                         filepath = new_audio_source_path (basename, channels, n, false, false);
 142                         break;
 143                 }
 144
 145                 if (filepath.empty()) {
 146                         error << string_compose (_("Cannot find new filename for imported file %1"), import_file_path) << endmsg;
 147                         return vector<string>();
 148                 }
 149
 150                 new_paths.push_back (filepath);
 151         }
 152
 153         return new_paths;
 154 }
 155
 156 static bool
 157 map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
 158                            uint32_t /*samplerate*/, vector<boost::shared_ptr<Source> >& newfiles, Session *session)
 159 {
 160         for (vector<string>::const_iterator i = new_paths.begin();
 161              i != new_paths.end(); ++i)
 162         {
 163                 boost::shared_ptr<Source> source = session->audio_source_by_path_and_channel(*i, 0);
 164
 165                 if (source == 0) {
 166                         error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
 167                         return false;
 168                 }
 169
 170                 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
 171         }
 172         return true;
 173 }
 174
 175 static bool
 176 create_mono_sources_for_writing (const vector<string>& new_paths,
 177                                  Session& sess, uint32_t samplerate,
 178                                  vector<boost::shared_ptr<Source> >& newfiles,
 179                                  framepos_t timeline_position)
 180 {
 181         for (vector<string>::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i) {
 182
 183                 boost::shared_ptr<Source> source;
 184
 185                 try {
 186                         const DataType type = SMFSource::safe_midi_file_extension (*i) ? DataType::MIDI : DataType::AUDIO;
 187
 188                         source = SourceFactory::createWritable (type, sess,
 189                                                                 i->c_str(),
 190                                                                 false, // destructive
 191                                                                 samplerate);
 192                 }
 193
 194                 catch (const failed_constructor& err) {
 195                         error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg;
 196                         return false;
 197                 }
 198
 199                 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
 200
 201                 /* for audio files, reset the timeline position so that any BWF-ish
 202                    information in the original files we are importing from is maintained.
 203                 */
 204
 205                 boost::shared_ptr<AudioFileSource> afs;
 206                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(source)) != 0) {
 207                         afs->set_timeline_position(timeline_position);
 208                 }
 209         }
 210         return true;
 211 }
 212
 213 static string
 214 compose_status_message (const string& path,
 215                         uint32_t file_samplerate,
 216                         uint32_t session_samplerate,
 217                         uint32_t /* current_file */,
 218                         uint32_t /* total_files */)
 219 {
 220         if (file_samplerate != session_samplerate) {
 221                 return string_compose (_("Resampling %1 from %2kHz to %3kHz"),
 222                                        Glib::path_get_basename (path),
 223                                        file_samplerate/1000.0f,
 224                                        session_samplerate/1000.0f);
 225         }
 226
 227         return string_compose (_("Copying %1"), Glib::path_get_basename (path));
 228 }
 229
 230 static void
 231 write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
 232                                vector<boost::shared_ptr<Source> >& newfiles)
 233 {
 234         const framecnt_t nframes = ResampledImportableSource::blocksize;
 235         boost::shared_ptr<AudioFileSource> afs;
 236         uint32_t channels = source->channels();
 237
 238         boost::scoped_array<float> data(new float[nframes * channels]);
 239         vector<boost::shared_array<Sample> > channel_data;
 240
 241         for (uint32_t n = 0; n < channels; ++n) {
 242                 channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
 243         }
 244
 245         float gain = 1;
 246
 247         boost::shared_ptr<AudioSource> s = boost::dynamic_pointer_cast<AudioSource> (newfiles[0]);
 248         assert (s);
 249
 250         status.progress = 0.0f;
 251         float progress_multiplier = 1;
 252         float progress_base = 0;
 253
 254         if (!source->clamped_at_unity() && s->clamped_at_unity()) {
 255
 256                 /* The source we are importing from can return sample values with a magnitude greater than 1,
 257                    and the file we are writing the imported data to cannot handle such values.  Compute the gain
 258                    factor required to normalize the input sources to have a magnitude of less than 1.
 259                 */
 260
 261                 float peak = 0;
 262                 uint32_t read_count = 0;
 263
 264                 while (!status.cancel) {
 265                         framecnt_t const nread = source->read (data.get(), nframes);
 266                         if (nread == 0) {
 267                                 break;
 268                         }
 269
 270                         peak = compute_peak (data.get(), nread, peak);
 271
 272                         read_count += nread;
 273                         status.progress = 0.5 * read_count / (source->ratio() * source->length() * channels);
 274                 }
 275
 276                 if (peak >= 1) {
 277                         /* we are out of range: compute a gain to fix it */
 278                         gain = (1 - FLT_EPSILON) / peak;
 279                 }
 280
 281                 source->seek (0);
 282                 progress_multiplier = 0.5;
 283                 progress_base = 0.5;
 284         }
 285
 286         framecnt_t read_count = 0;
 287
 288         while (!status.cancel) {
 289
 290                 framecnt_t nread, nfread;
 291                 uint32_t x;
 292                 uint32_t chn;
 293
 294                 if ((nread = source->read (data.get(), nframes)) == 0) {
 295 #ifdef PLATFORM_WINDOWS
 296                         /* Flush the data once we've finished importing the file. Windows can  */
 297                         /* cache the data for very long periods of time (perhaps not writing   */
 298                         /* it to disk until Ardour closes). So let's force it to flush now.    */
 299                         for (chn = 0; chn < channels; ++chn)
 300                                 if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0)
 301                                         afs->flush ();
 302 #endif
 303                         break;
 304                 }
 305
 306                 if (gain != 1) {
 307                         /* here is the gain fix for out-of-range sample values that we computed earlier */
 308                         apply_gain_to_buffer (data.get(), nread, gain);
 309                 }
 310
 311                 nfread = nread / channels;
 312
 313                 /* de-interleave */
 314
 315                 for (chn = 0; chn < channels; ++chn) {
 316
 317                         framecnt_t n;
 318                         for (x = chn, n = 0; n < nfread; x += channels, ++n) {
 319                                 channel_data[chn][n] = (Sample) data[x];
 320                         }
 321                 }
 322
 323                 /* flush to disk */
 324
 325                 for (chn = 0; chn < channels; ++chn) {
 326                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0) {
 327                                 afs->write (channel_data[chn].get(), nfread);
 328                         }
 329                 }
 330
 331                 read_count += nread;
 332                 status.progress = progress_base + progress_multiplier * read_count / (source->ratio () * source->length() * channels);
 333         }
 334 }
 335
 336 static void
 337 write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
 338                               vector<boost::shared_ptr<Source> >& newfiles)
 339 {
 340         uint32_t buf_size = 4;
 341         uint8_t* buf      = (uint8_t*) malloc (buf_size);
 342
 343         status.progress = 0.0f;
 344
 345         assert (newfiles.size() == source->num_tracks());
 346
 347         try {
 348                 vector<boost::shared_ptr<Source> >::iterator s = newfiles.begin();
 349
 350                 for (unsigned i = 1; i <= source->num_tracks(); ++i) {
 351
 352                         boost::shared_ptr<SMFSource> smfs = boost::dynamic_pointer_cast<SMFSource> (*s);
 353
 354                         smfs->drop_model ();
 355                         source->seek_to_track (i);
 356
 357                         uint64_t t       = 0;
 358                         uint32_t delta_t = 0;
 359                         uint32_t size    = 0;
 360                         bool first = true;
 361
 362                         while (!status.cancel) {
 363                                 gint note_id_ignored; // imported files either don't have NoteID's or we ignore them.
 364
 365                                 size = buf_size;
 366
 367                                 int ret = source->read_event (&delta_t, &size, &buf, &note_id_ignored);
 368
 369                                 if (size > buf_size) {
 370                                         buf_size = size;
 371                                 }
 372
 373                                 if (ret < 0) { // EOT
 374                                         break;
 375                                 }
 376
 377                                 t += delta_t;
 378
 379                                 if (ret == 0) { // Meta
 380                                         continue;
 381                                 }
 382
 383                                 if (first) {
 384                                         smfs->mark_streaming_write_started ();
 385                                         first = false;
 386                                 }
 387
 388                                 smfs->append_event_unlocked_beats(
 389                                         Evoral::Event<double>(0,
 390                                                               (double)t / (double)source->ppqn(),
 391                                                               size,
 392                                                               buf));
 393
 394                                 if (status.progress < 0.99) {
 395                                         status.progress += 0.01;
 396                                 }
 397                         }
 398
 399                         if (!first) {
 400
 401                                 /* we wrote something */
 402
 403                                 const framepos_t pos = 0;
 404                                 const double length_beats = ceil(t / (double)source->ppqn());
 405                                 BeatsFramesConverter converter(smfs->session().tempo_map(), pos);
 406                                 smfs->update_length(pos + converter.to(length_beats));
 407                                 smfs->mark_streaming_write_completed ();
 408
 409                                 if (status.cancel) {
 410                                         break;
 411                                 }
 412                         } else {
 413                                 warning << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, source->file_path()) << endmsg;
 414                         }
 415
 416                         ++s; // next source
 417                 }
 418
 419         } catch (...) {
 420                 error << string_compose (_("MIDI file %1 was not readable (no reason available)"), source->file_path()) << endmsg;
 421         }
 422
 423         if (buf) {
 424                 free (buf);
 425         }
 426 }
 427
 428 static void
 429 remove_file_source (boost::shared_ptr<Source> source)
 430 {
 431         boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
 432
 433         fs->DropReferences ();
 434
 435         if (fs) {
 436                 ::g_unlink (fs->path().c_str());
 437         }
 438 }
 439
 440 // This function is still unable to cleanly update an existing source, even though
 441 // it is possible to set the ImportStatus flag accordingly. The functinality
 442 // is disabled at the GUI until the Source implementations are able to provide
 443 // the necessary API.
 444 void
 445 Session::import_files (ImportStatus& status)
 446 {
 447         typedef vector<boost::shared_ptr<Source> > Sources;
 448         Sources all_new_sources;
 449         boost::shared_ptr<AudioFileSource> afs;
 450         boost::shared_ptr<SMFSource> smfs;
 451         uint32_t channels = 0;
 452
 453         status.sources.clear ();
 454
 455         for (vector<string>::iterator p = status.paths.begin();
 456              p != status.paths.end() && !status.cancel;
 457              ++p)
 458         {
 459                 boost::shared_ptr<ImportableSource> source;
 460                 std::auto_ptr<Evoral::SMF>          smf_reader;
 461                 const DataType type = SMFSource::safe_midi_file_extension (*p) ? DataType::MIDI : DataType::AUDIO;
 462
 463                 if (type == DataType::AUDIO) {
 464                         try {
 465                                 source = open_importable_source (*p, frame_rate(), status.quality);
 466                                 channels = source->channels();
 467                         } catch (const failed_constructor& err) {
 468                                 error << string_compose(_("Import: cannot open input sound file \"%1\""), (*p)) << endmsg;
 469                                 status.done = status.cancel = true;
 470                                 return;
 471                         }
 472
 473                 } else {
 474                         try {
 475                                 smf_reader = std::auto_ptr<Evoral::SMF>(new Evoral::SMF());
 476                                 smf_reader->open(*p);
 477                                 channels = smf_reader->num_tracks();
 478                         } catch (...) {
 479                                 error << _("Import: error opening MIDI file") << endmsg;
 480                                 status.done = status.cancel = true;
 481                                 return;
 482                         }
 483                 }
 484
 485                 if (channels == 0) {
 486                         error << _("Import: file contains no channels.") << endmsg;
 487                         continue;
 488                 }
 489
 490                 vector<string> new_paths = get_paths_for_new_sources (status.replace_existing_source, *p, channels);
 491                 Sources newfiles;
 492                 framepos_t natural_position = source ? source->natural_position() : 0;
 493
 494
 495                 if (status.replace_existing_source) {
 496                         fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg;
 497                         status.cancel = !map_existing_mono_sources (new_paths, *this, frame_rate(), newfiles, this);
 498                 } else {
 499                         status.cancel = !create_mono_sources_for_writing (new_paths, *this, frame_rate(), newfiles, natural_position);
 500                 }
 501
 502                 // copy on cancel/failure so that any files that were created will be removed below
 503                 std::copy (newfiles.begin(), newfiles.end(), std::back_inserter(all_new_sources));
 504
 505                 if (status.cancel) {
 506                         break;
 507                 }
 508
 509                 for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) {
 510                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*i)) != 0) {
 511                                 afs->prepare_for_peakfile_writes ();
 512                         }
 513                 }
 514
 515                 if (source) { // audio
 516                         status.doing_what = compose_status_message (*p, source->samplerate(),
 517                                                                     frame_rate(), status.current, status.total);
 518                         write_audio_data_to_new_files (source.get(), status, newfiles);
 519                 } else if (smf_reader.get()) { // midi
 520                         status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
 521                         write_midi_data_to_new_files (smf_reader.get(), status, newfiles);
 522                 }
 523
 524                 ++status.current;
 525                 status.progress = 0;
 526         }
 527
 528         if (!status.cancel) {
 529                 struct tm* now;
 530                 time_t xnow;
 531                 time (&xnow);
 532                 now = localtime (&xnow);
 533                 status.freeze = true;
 534
 535                 /* flush the final length(s) to the header(s) */
 536
 537                 for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
 538
 539                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
 540                                 afs->update_header((*x)->natural_position(), *now, xnow);
 541                                 afs->done_with_peakfile_writes ();
 542
 543                                 /* now that there is data there, requeue the file for analysis */
 544
 545                                 if (Config->get_auto_analyse_audio()) {
 546                                         Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
 547                                 }
 548                         }
 549
 550                         /* imported, copied files cannot be written or removed
 551                          */
 552
 553                         boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource>(*x);
 554                         if (fs) {
 555                                 /* Only audio files should be marked as
 556                                    immutable - we may need to rewrite MIDI
 557                                    files at any time.
 558                                 */
 559                                 if (boost::dynamic_pointer_cast<AudioFileSource> (fs)) {
 560                                         fs->mark_immutable ();
 561                                 } else {
 562                                         fs->mark_immutable_except_write ();
 563                                 }
 564                                 fs->mark_nonremovable ();
 565                         }
 566
 567                         /* don't create tracks for empty MIDI sources (channels) */
 568
 569                         if ((smfs = boost::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
 570                                 x = all_new_sources.erase(x);
 571                         } else {
 572                                 ++x;
 573                         }
 574                 }
 575
 576                 /* save state so that we don't lose these new Sources */
 577
 578                 save_state (_name);
 579
 580                 std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
 581         } else {
 582                 try {
 583                         std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
 584                 } catch (...) {
 585                         error << _("Failed to remove some files after failed/cancelled import operation") << endmsg;
 586                 }
 587
 588         }
 589
 590         status.done = true;
 591 }
 592