Trim session.h include dependency tree.
[ardour.git] / 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 #ifdef USE_COREAUDIO_FOR_FILE_IO
67 #include "ardour/caimportable.h"
68 #endif
69 #endif
70
71 #include "i18n.h"
72
73 using namespace std;
74 using namespace ARDOUR;
75 using namespace PBD;
76
77 static boost::shared_ptr<ImportableSource>
78 open_importable_source (const string& path, nframes_t samplerate, ARDOUR::SrcQuality quality)
79 {
80 #ifdef HAVE_COREAUDIO
81 #ifdef USE_COREAUDIO_FOR_FILE_IO
82
83         /* see if we can use CoreAudio to handle the IO */
84
85         try {
86                 CAImportableSource* src = new CAImportableSource(path);
87                 boost::shared_ptr<CAImportableSource> source (src);
88
89                 if (source->samplerate() == samplerate) {
90                         return source;
91                 }
92
93                 /* rewrap as a resampled source */
94
95                 return boost::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
96         }
97
98         catch (...) {
99
100                 /* fall back to SndFile */
101 #endif
102 #endif
103
104                 try {
105                         boost::shared_ptr<SndFileImportableSource> source(new SndFileImportableSource(path));
106
107                         if (source->samplerate() == samplerate) {
108                                 return source;
109                         }
110
111                         /* rewrap as a resampled source */
112
113                         return boost::shared_ptr<ImportableSource>(new ResampledImportableSource(source, samplerate, quality));
114                 }
115
116                 catch (...) {
117                         throw; // rethrow
118                 }
119
120 #ifdef HAVE_COREAUDIO
121 #ifdef USE_COREAUDIO_FOR_FILE_IO
122         }
123 #endif
124 #endif
125 }
126
127 static std::string
128 get_non_existent_filename (DataType type, const bool allow_replacing, const std::string destdir, const std::string& basename, uint channel, uint channels)
129 {
130         char buf[PATH_MAX+1];
131         bool goodfile = false;
132         string base(basename);
133         const char* ext = (type == DataType::AUDIO) ? "wav" : "mid";
134
135         do {
136
137                 if (type == DataType::AUDIO && channels == 2) {
138                         if (channel == 0) {
139                                 snprintf (buf, sizeof(buf), "%s-L.wav", base.c_str());
140                         } else {
141                                 snprintf (buf, sizeof(buf), "%s-R.wav", base.c_str());
142                         }
143                 } else if (channels > 1) {
144                         snprintf (buf, sizeof(buf), "%s-c%d.%s", base.c_str(), channel, ext);
145                 } else {
146                         snprintf (buf, sizeof(buf), "%s.%s", base.c_str(), ext);
147                 }
148
149
150                 string tempname = destdir + "/" + buf;
151                 if (!allow_replacing && Glib::file_test (tempname, Glib::FILE_TEST_EXISTS)) {
152
153                         /* if the file already exists, we must come up with
154                          *  a new name for it.  for now we just keep appending
155                          *  _ to basename
156                          */
157
158                         base += "_";
159
160                 } else {
161
162                         goodfile = true;
163                 }
164
165         } while ( !goodfile);
166
167         return buf;
168 }
169
170 static vector<string>
171 get_paths_for_new_sources (const bool allow_replacing, const string& import_file_path, const string& session_dir, uint channels)
172 {
173         vector<string> new_paths;
174         const string basename = basename_nosuffix (import_file_path);
175
176         SessionDirectory sdir(session_dir);
177
178         for (uint n = 0; n < channels; ++n) {
179
180                 const DataType type = (import_file_path.rfind(".mid") != string::npos)
181                                 ? DataType::MIDI : DataType::AUDIO;
182
183                 std::string filepath = (type == DataType::MIDI)
184                                 ? sdir.midi_path().to_string() : sdir.sound_path().to_string();
185
186                 filepath += '/';
187                 filepath += get_non_existent_filename (type, allow_replacing, filepath, basename, n, channels);
188                 new_paths.push_back (filepath);
189         }
190
191         return new_paths;
192 }
193
194 static bool
195 map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
196                            uint /*samplerate*/, vector<boost::shared_ptr<Source> >& newfiles, Session *session)
197 {
198         for (vector<string>::const_iterator i = new_paths.begin();
199                         i != new_paths.end(); ++i)
200         {
201                 boost::shared_ptr<Source> source = session->source_by_path_and_channel(*i, 0);
202
203                 if (source == 0) {
204                         error << string_compose(_("Could not find a source for %1 even though we are updating this file!"), (*i)) << endl;
205                         return false;
206                 }
207
208                 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
209         }
210         return true;
211 }
212
213 static bool
214 create_mono_sources_for_writing (const vector<string>& new_paths, Session& sess,
215                                  uint samplerate, vector<boost::shared_ptr<Source> >& newfiles,
216                                  nframes64_t /*timeline_position*/)
217 {
218         for (vector<string>::const_iterator i = new_paths.begin(); i != new_paths.end(); ++i)
219         {
220                 boost::shared_ptr<Source> source;
221
222                 try
223                 {
224                         const DataType type = ((*i).rfind(".mid") != string::npos)
225                                 ? DataType::MIDI : DataType::AUDIO;
226
227                         source = SourceFactory::createWritable (type, sess,
228                                         i->c_str(), true,
229                                         false, // destructive
230                                         samplerate);
231                 }
232                 catch (const failed_constructor& err)
233                 {
234                         error << string_compose (_("Unable to create file %1 during import"), *i) << endmsg;
235                         return false;
236                 }
237
238                 newfiles.push_back(boost::dynamic_pointer_cast<Source>(source));
239         }
240         return true;
241 }
242
243 static Glib::ustring
244 compose_status_message (const string& path,
245                         uint file_samplerate,
246                         uint session_samplerate,
247                         uint current_file,
248                         uint total_files)
249 {
250         if (file_samplerate != session_samplerate) {
251                 return string_compose (_("resampling %1 from %2kHz to %3kHz\n(%4 of %5)"),
252                                        Glib::path_get_basename (path),
253                                        file_samplerate/1000.0f,
254                                        session_samplerate/1000.0f,
255                                        current_file, total_files);
256         }
257
258         return string_compose (_("copying %1\n(%2 of %3)"),
259                                Glib::path_get_basename (path),
260                                current_file, total_files);
261 }
262
263 static void
264 write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
265                                vector<boost::shared_ptr<Source> >& newfiles)
266 {
267         const nframes_t nframes = ResampledImportableSource::blocksize;
268         boost::shared_ptr<AudioFileSource> afs;
269         uint channels = source->channels();
270
271         boost::scoped_array<float> data(new float[nframes * channels]);
272         vector<boost::shared_array<Sample> > channel_data;
273
274         for (uint n = 0; n < channels; ++n) {
275                 channel_data.push_back(boost::shared_array<Sample>(new Sample[nframes]));
276         }
277
278         uint read_count = 0;
279         status.progress = 0.0f;
280
281         while (!status.cancel) {
282
283                 nframes_t nread, nfread;
284                 uint x;
285                 uint chn;
286
287                 if ((nread = source->read (data.get(), nframes)) == 0) {
288                         break;
289                 }
290                 nfread = nread / channels;
291
292                 /* de-interleave */
293
294                 for (chn = 0; chn < channels; ++chn) {
295
296                         nframes_t n;
297                         for (x = chn, n = 0; n < nfread; x += channels, ++n) {
298                                 channel_data[chn][n] = (Sample) data[x];
299                         }
300                 }
301
302                 /* flush to disk */
303
304                 for (chn = 0; chn < channels; ++chn) {
305                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(newfiles[chn])) != 0) {
306                                 afs->write (channel_data[chn].get(), nfread);
307                         }
308                 }
309
310                 read_count += nread;
311                 status.progress = read_count / (source->ratio () * source->length() * channels);
312         }
313 }
314
315 static void
316 write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
317                 vector<boost::shared_ptr<Source> >& newfiles)
318 {
319         uint32_t buf_size = 4;
320         uint8_t* buf      = (uint8_t*)malloc(buf_size);
321
322         status.progress = 0.0f;
323
324         try {
325
326         for (unsigned i = 1; i <= source->num_tracks(); ++i) {
327                 boost::shared_ptr<SMFSource> smfs = boost::dynamic_pointer_cast<SMFSource>(newfiles[i-1]);
328                 smfs->drop_model();
329
330                 source->seek_to_track(i);
331
332                 uint64_t t       = 0;
333                 uint32_t delta_t = 0;
334                 uint32_t size    = 0;
335
336                 while (!status.cancel) {
337                         size = buf_size;
338
339                         int ret = source->read_event(&delta_t, &size, &buf);
340                         if (size > buf_size)
341                                 buf_size = size;
342
343                         if (ret < 0) { // EOT
344                                 break;
345                         }
346
347                         t += delta_t;
348
349                         if (ret == 0) { // Meta
350                                 continue;
351                         }
352
353                         smfs->append_event_unlocked_beats(Evoral::Event<double>(0,
354                                         (double)t / (double)source->ppqn(),
355                                         size,
356                                         buf));
357
358                         if (status.progress < 0.99)
359                                 status.progress += 0.01;
360                 }
361
362                 const nframes64_t pos = 0;
363                 const double length_beats = ceil(t / (double)source->ppqn());
364                 BeatsFramesConverter converter(smfs->session().tempo_map(), pos);
365                 smfs->update_length(pos, converter.to(length_beats));
366                 smfs->end_write();
367
368                 if (status.cancel) {
369                         break;
370                 }
371         }
372
373         } catch (...) {
374                 error << "Corrupt MIDI file " << source->file_path() << endl;
375         }
376 }
377
378 static void
379 remove_file_source (boost::shared_ptr<Source> source)
380 {
381         ::unlink (source->path().c_str());
382 }
383
384 // This function is still unable to cleanly update an existing source, even though
385 // it is possible to set the ImportStatus flag accordingly. The functinality
386 // is disabled at the GUI until the Source implementations are able to provide
387 // the necessary API.
388 void
389 Session::import_audiofiles (ImportStatus& status)
390 {
391         uint32_t cnt = 1;
392         typedef vector<boost::shared_ptr<Source> > Sources;
393         Sources all_new_sources;
394         boost::shared_ptr<AudioFileSource> afs;
395         boost::shared_ptr<SMFSource> smfs;
396         uint channels = 0;
397
398         status.sources.clear ();
399
400         for (vector<Glib::ustring>::iterator p = status.paths.begin();
401                         p != status.paths.end() && !status.cancel;
402                         ++p, ++cnt)
403         {
404                 boost::shared_ptr<ImportableSource> source;
405                 std::auto_ptr<Evoral::SMF>          smf_reader;
406                 const DataType type = ((*p).rfind(".mid") != string::npos) ?
407                         DataType::MIDI : DataType::AUDIO;
408
409                 if (type == DataType::AUDIO) {
410                         try {
411                                 source = open_importable_source (*p, frame_rate(), status.quality);
412                                 channels = source->channels();
413                         } catch (const failed_constructor& err) {
414                                 error << string_compose(_("Import: cannot open input sound file \"%1\""), (*p)) << endmsg;
415                                 status.done = status.cancel = true;
416                                 return;
417                         }
418
419                 } else {
420                         try {
421                                 smf_reader = std::auto_ptr<Evoral::SMF>(new Evoral::SMF());
422                                 smf_reader->open(*p);
423                                 channels = smf_reader->num_tracks();
424                         } catch (...) {
425                                 error << _("Import: error opening MIDI file") << endmsg;
426                                 status.done = status.cancel = true;
427                                 return;
428                         }
429                 }
430
431                 vector<string> new_paths = get_paths_for_new_sources (status.replace_existing_source, *p,
432                                                                       get_best_session_directory_for_new_source (),
433                                                                       channels);
434                 Sources newfiles;
435                 nframes64_t natural_position = source ? source->natural_position() : 0;
436
437                 if (status.replace_existing_source) {
438                         fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endl;
439                         status.cancel = !map_existing_mono_sources (new_paths, *this, frame_rate(), newfiles, this);
440                 } else {
441                         status.cancel = !create_mono_sources_for_writing (new_paths, *this, frame_rate(), newfiles, natural_position);
442                 }
443
444                 // copy on cancel/failure so that any files that were created will be removed below
445                 std::copy (newfiles.begin(), newfiles.end(), std::back_inserter(all_new_sources));
446
447                 if (status.cancel) {
448                         break;
449                 }
450
451                 for (Sources::iterator i = newfiles.begin(); i != newfiles.end(); ++i) {
452                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*i)) != 0) {
453                                 afs->prepare_for_peakfile_writes ();
454                         }
455                 }
456
457                 if (source) { // audio
458                         status.doing_what = compose_status_message (*p, source->samplerate(),
459                                                                     frame_rate(), cnt, status.total);
460                         write_audio_data_to_new_files (source.get(), status, newfiles);
461                 } else if (smf_reader.get()) { // midi
462                         status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
463                         write_midi_data_to_new_files (smf_reader.get(), status, newfiles);
464                 }
465         }
466
467         if (!status.cancel) {
468                 struct tm* now;
469                 time_t xnow;
470                 time (&xnow);
471                 now = localtime (&xnow);
472                 status.freeze = true;
473
474                 /* flush the final length(s) to the header(s) */
475
476                 for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
477                         if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
478                                 afs->update_header(0, *now, xnow);
479                                 afs->done_with_peakfile_writes ();
480
481                                 /* now that there is data there, requeue the file for analysis */
482
483                                 if (Config->get_auto_analyse_audio()) {
484                                         Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
485                                 }
486                         }
487
488                         /* don't create tracks for empty MIDI sources (channels) */
489
490                         if ((smfs = boost::dynamic_pointer_cast<SMFSource>(*x)) != 0 && smfs->is_empty()) {
491                                 x = all_new_sources.erase(x);
492                         } else {
493                                 ++x;
494                         }
495                 }
496
497                 /* save state so that we don't lose these new Sources */
498
499                 save_state (_name);
500
501                 std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
502         } else {
503                 // this can throw...but it seems very unlikely
504                 std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
505         }
506
507         status.done = true;
508 }
509