Merge branch 'patch-1' of https://github.com/globin/ardour

[ardour.git] / libs / ardour / import.cc

diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc
index c36e44f2e23176d0537c596aea2b27d70fda4515..047b46f55305d5ff68d3beda87e0623ce60abe7d 100644 (file)
--- a/libs/ardour/import.cc
+++ b/libs/ardour/import.cc
@@ -52,6 +52,7 @@
 #include "ardour/import_status.h"
 #include "ardour/region_factory.h"
 #include "ardour/resampled_source.h"
+#include "ardour/runtime_functions.h"
 #include "ardour/session.h"
 #include "ardour/session_directory.h"
 #include "ardour/smf_source.h"
@@ -183,7 +184,7 @@ get_paths_for_new_sources (HeaderFormat hf, const bool allow_replacing, const st
                const DataType type = SMFSource::safe_midi_file_extension (import_file_path) ? DataType::MIDI : DataType::AUDIO;
 
                std::string filepath = (type == DataType::MIDI)
-                       ? sdir.midi_path().to_string() : sdir.sound_path().to_string();
+                       ? sdir.midi_path() : sdir.sound_path();
 
                filepath = Glib::build_filename (filepath,
                                                 get_non_existent_filename (hf, type, allow_replacing, filepath, basename, n, channels));
@@ -213,8 +214,7 @@ map_existing_mono_sources (const vector<string>& new_paths, Session& /*sess*/,
 }
 
 static bool
-create_mono_sources_for_writing (const string& origin,
-                                 const vector<string>& new_paths,
+create_mono_sources_for_writing (const vector<string>& new_paths,
                                  Session& sess, uint samplerate,
                                  vector<boost::shared_ptr<Source> >& newfiles,
                                  framepos_t timeline_position)
@@ -228,7 +228,6 @@ create_mono_sources_for_writing (const string& origin,
 
                        source = SourceFactory::createWritable (type, sess,
                                                                i->c_str(),
-                                                               origin,
                                                                false, // destructive
                                                                samplerate);
                }
@@ -419,10 +418,11 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                                        first = false;
                                }
 
-                               smfs->append_event_unlocked_beats(Evoral::Event<double>(0,
-                                                                                       (double)t / (double)source->ppqn(),
-                                                                                       size,
-                                                                                       buf));
+                               smfs->append_event_unlocked_beats(
+                                       Evoral::Event<double>(0,
+                                                             (double)t / (double)source->ppqn(),
+                                                             size,
+                                                             buf));
 
                                if (status.progress < 0.99) {
                                        status.progress += 0.01;
@@ -436,7 +436,7 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                                const framepos_t pos = 0;
                                const double length_beats = ceil(t / (double)source->ppqn());
                                BeatsFramesConverter converter(smfs->session().tempo_map(), pos);
-                               smfs->update_length(pos, converter.to(length_beats));
+                               smfs->update_length(pos + converter.to(length_beats));
                                smfs->mark_streaming_write_completed ();
 
                                if (status.cancel) {
@@ -450,7 +450,7 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                }
 
        } catch (...) {
-               error << string_compose (_("MIDI file %1 was not readable (no reason available"), source->file_path()) << endmsg;
+               error << string_compose (_("MIDI file %1 was not readable (no reason available)"), source->file_path()) << endmsg;
        }
 
        if (buf) {
@@ -461,7 +461,11 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
 static void
 remove_file_source (boost::shared_ptr<Source> source)
 {
-       ::unlink (source->path().c_str());
+       boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (source);
+
+       if (fs) {
+               ::unlink (fs->path().c_str());
+       }
 }
 
 // This function is still unable to cleanly update an existing source, even though
@@ -469,7 +473,7 @@ remove_file_source (boost::shared_ptr<Source> source)
 // is disabled at the GUI until the Source implementations are able to provide
 // the necessary API.
 void
-Session::import_audiofiles (ImportStatus& status)
+Session::import_files (ImportStatus& status)
 {
        typedef vector<boost::shared_ptr<Source> > Sources;
        Sources all_new_sources;
@@ -521,7 +525,7 @@ Session::import_audiofiles (ImportStatus& status)
                        fatal << "THIS IS NOT IMPLEMENTED YET, IT SHOULD NEVER GET CALLED!!! DYING!" << endmsg;
                        status.cancel = !map_existing_mono_sources (new_paths, *this, frame_rate(), newfiles, this);
                } else {
-                       status.cancel = !create_mono_sources_for_writing (*p, new_paths, *this, frame_rate(), newfiles, natural_position);
+                       status.cancel = !create_mono_sources_for_writing (new_paths, *this, frame_rate(), newfiles, natural_position);
                }
 
                // copy on cancel/failure so that any files that were created will be removed below
@@ -560,6 +564,7 @@ Session::import_audiofiles (ImportStatus& status)
                /* flush the final length(s) to the header(s) */
 
                for (Sources::iterator x = all_new_sources.begin(); x != all_new_sources.end(); ) {
+
                        if ((afs = boost::dynamic_pointer_cast<AudioFileSource>(*x)) != 0) {
                                afs->update_header((*x)->natural_position(), *now, xnow);
                                afs->done_with_peakfile_writes ();
@@ -570,6 +575,23 @@ Session::import_audiofiles (ImportStatus& status)
                                        Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
                                }
                        }
+                       
+                       /* imported, copied files cannot be written or removed
+                        */
+
+                       boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource>(*x);
+                       if (fs) {
+                               /* Only audio files should be marked as
+                                  immutable - we may need to rewrite MIDI
+                                  files at any time.
+                               */
+                               if (boost::dynamic_pointer_cast<AudioFileSource> (fs)) {
+                                       fs->mark_immutable ();
+                               } else {
+                                       fs->mark_immutable_except_write ();
+                               }
+                               fs->mark_nonremovable ();
+                       }
 
                        /* don't create tracks for empty MIDI sources (channels) */
 
@@ -586,8 +608,12 @@ Session::import_audiofiles (ImportStatus& status)
 
                std::copy (all_new_sources.begin(), all_new_sources.end(), std::back_inserter(status.sources));
        } else {
-               // this can throw...but it seems very unlikely
-               std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
+               try {
+                       std::for_each (all_new_sources.begin(), all_new_sources.end(), remove_file_source);
+               } catch (...) {
+                       error << _("Failed to remove some files after failed/cancelled import operation") << endmsg;
+               }
+                               
        }
 
        status.done = true;