disallow placement of audio-locked tempi within a frame of any other.

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

diff --git a/libs/ardour/import.cc b/libs/ardour/import.cc
index 2524a3c0b0ce6720ac1d28d1104f9e8ff0bfcfbc..d441494ad7c5a5e7a969aeda3fe99b5767be5c88 100644 (file)
--- a/libs/ardour/import.cc
+++ b/libs/ardour/import.cc
@@ -34,7 +34,7 @@
 #include <sndfile.h>
 #include <samplerate.h>
 
-#include <pbd/gstdio_compat.h>
+#include "pbd/gstdio_compat.h"
 #include <glibmm.h>
 
 #include <boost/scoped_array.hpp>
@@ -67,7 +67,7 @@
 #include "ardour/caimportable.h"
 #endif
 
-#include "i18n.h"
+#include "pbd/i18n.h"
 
 using namespace std;
 using namespace ARDOUR;
@@ -265,14 +265,14 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
                uint32_t read_count = 0;
 
                while (!status.cancel) {
-                       framecnt_t const nread = source->read (data.get(), nframes);
+                       framecnt_t const nread = source->read (data.get(), nframes * channels);
                        if (nread == 0) {
                                break;
                        }
 
-                       peak = compute_peak (data.get(), nread, peak);
+                       peak = compute_peak (data.get(), nread * channels, peak);
 
-                       read_count += nread;
+                       read_count += nread / channels;
                        status.progress = 0.5 * read_count / (source->ratio() * source->length() * channels);
                }
 
@@ -294,7 +294,7 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
                uint32_t x;
                uint32_t chn;
 
-               if ((nread = source->read (data.get(), nframes)) == 0) {
+               if ((nread = source->read (data.get(), nframes * channels)) == 0) {
 #ifdef PLATFORM_WINDOWS
                        /* Flush the data once we've finished importing the file. Windows can  */
                        /* cache the data for very long periods of time (perhaps not writing   */
@@ -338,26 +338,40 @@ write_audio_data_to_new_files (ImportableSource* source, ImportStatus& status,
 
 static void
 write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
-                              vector<boost::shared_ptr<Source> >& newfiles)
+                              vector<boost::shared_ptr<Source> >& newfiles,
+                              bool split_type0)
 {
        uint32_t buf_size = 4;
        uint8_t* buf      = (uint8_t*) malloc (buf_size);
 
        status.progress = 0.0f;
+       uint16_t num_tracks;
+       bool type0 = source->is_type0 () && split_type0;
+       const std::set<uint8_t>& chn = source->channels ();
 
-       assert (newfiles.size() == source->num_tracks());
+       if (type0) {
+               num_tracks = source->channels().size();
+       } else {
+               num_tracks = source->num_tracks();
+       }
+       assert (newfiles.size() == num_tracks);
 
        try {
                vector<boost::shared_ptr<Source> >::iterator s = newfiles.begin();
+               std::set<uint8_t>::const_iterator cur_chan = chn.begin();
 
-               for (unsigned i = 1; i <= source->num_tracks(); ++i) {
+               for (unsigned i = 1; i <= num_tracks; ++i) {
 
                        boost::shared_ptr<SMFSource> smfs = boost::dynamic_pointer_cast<SMFSource> (*s);
 
                        Glib::Threads::Mutex::Lock source_lock(smfs->mutex());
 
                        smfs->drop_model (source_lock);
-                       source->seek_to_track (i);
+                       if (type0) {
+                               source->seek_to_start ();
+                       } else {
+                               source->seek_to_track (i);
+                       }
 
                        uint64_t t       = 0;
                        uint32_t delta_t = 0;
@@ -385,6 +399,17 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                                        continue;
                                }
 
+                               // type-0 files separate by channel
+                               if (type0) {
+                                       uint8_t type = buf[0] & 0xf0;
+                                       uint8_t chan = buf[0] & 0x0f;
+                                       if (type >= 0x80 && type <= 0xE0) {
+                                               if (chan != *cur_chan) {
+                                                       continue;
+                                               }
+                                       }
+                               }
+
                                if (first) {
                                        smfs->mark_streaming_write_started (source_lock);
                                        first = false;
@@ -393,7 +418,7 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                                smfs->append_event_beats(
                                        source_lock,
                                        Evoral::Event<Evoral::Beats>(
-                                               0,
+                                               Evoral::MIDI_EVENT,
                                                Evoral::Beats::ticks_at_rate(t, source->ppqn()),
                                                size,
                                                buf));
@@ -417,10 +442,13 @@ write_midi_data_to_new_files (Evoral::SMF* source, ImportStatus& status,
                                        break;
                                }
                        } else {
-                               info << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, source->num_tracks()) << endmsg;
+                               info << string_compose (_("Track %1 of %2 contained no usable MIDI data"), i, num_tracks) << endmsg;
                        }
 
                        ++s; // next source
+                       if (type0) {
+                               ++cur_chan;
+                       }
                }
 
        } catch (exception& e) {
@@ -459,7 +487,7 @@ Session::import_files (ImportStatus& status)
 
        status.sources.clear ();
 
-       for (vector<string>::iterator p = status.paths.begin();
+       for (vector<string>::const_iterator p = status.paths.begin();
             p != status.paths.end() && !status.cancel;
             ++p)
        {
@@ -481,14 +509,19 @@ Session::import_files (ImportStatus& status)
                        try {
                                smf_reader = std::auto_ptr<Evoral::SMF>(new Evoral::SMF());
                                smf_reader->open(*p);
-                               channels = smf_reader->num_tracks();
+
+                               if (smf_reader->is_type0 () && status.split_midi_channels) {
+                                       channels = smf_reader->channels().size();
+                               } else {
+                                       channels = smf_reader->num_tracks();
+                               }
                        } catch (...) {
                                error << _("Import: error opening MIDI file") << endmsg;
                                status.done = status.cancel = true;
                                return;
                        }
                }
-               
+
                if (channels == 0) {
                        error << _("Import: file contains no channels.") << endmsg;
                        continue;
@@ -525,7 +558,7 @@ Session::import_files (ImportStatus& status)
                        write_audio_data_to_new_files (source.get(), status, newfiles);
                } else if (smf_reader.get()) { // midi
                        status.doing_what = string_compose(_("Loading MIDI file %1"), *p);
-                       write_midi_data_to_new_files (smf_reader.get(), status, newfiles);
+                       write_midi_data_to_new_files (smf_reader.get(), status, newfiles, status.split_midi_channels);
                }
 
                ++status.current;
@@ -553,7 +586,7 @@ Session::import_files (ImportStatus& status)
                                        Analyser::queue_source_for_analysis (boost::static_pointer_cast<Source>(*x), false);
                                }
                        }
-                       
+
                        /* imported, copied files cannot be written or removed
                         */
 
@@ -591,7 +624,7 @@ Session::import_files (ImportStatus& status)
                } catch (...) {
                        error << _("Failed to remove some files after failed/cancelled import operation") << endmsg;
                }
-                               
+
        }
 
        status.done = true;