#include "pbd/stl_delete.h"
#include "pbd/strsplit.h"
-#include <glib/gstdio.h>
+#include "pbd/gstdio_compat.h"
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
#include "evoral/Control.hpp"
#include "evoral/SMF.hpp"
+#include "ardour/debug.h"
+#include "ardour/midi_channel_filter.h"
#include "ardour/midi_model.h"
#include "ardour/midi_ring_buffer.h"
#include "ardour/midi_state_tracker.h"
#include "ardour/parameter_types.h"
#include "ardour/session.h"
#include "ardour/smf_source.h"
-#include "ardour/debug.h"
-#include "i18n.h"
+#include "pbd/i18n.h"
using namespace ARDOUR;
using namespace Glib;
if (init (_path, false)) {
throw failed_constructor ();
}
-
+
assert (!Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
existence_check ();
if (init (_path, true)) {
throw failed_constructor ();
}
-
+
assert (Glib::file_test (_path, Glib::FILE_TEST_EXISTS));
existence_check ();
return 0;
}
+void
+SMFSource::close ()
+{
+ /* nothing to do: file descriptor is never kept open */
+}
+
/** All stamps in audio frames */
framecnt_t
SMFSource::read_unlocked (const Lock& lock,
framepos_t const source_start,
framepos_t start,
framecnt_t duration,
- MidiStateTracker* tracker) const
+ Evoral::Range<framepos_t>* loop_range,
+ MidiStateTracker* tracker,
+ MidiChannelFilter* filter) const
{
int ret = 0;
uint64_t time = 0; // in SMF ticks, 1 tick per _ppqn
// Output parameters for read_event (which will allocate scratch in buffer as needed)
uint32_t ev_delta_t = 0;
- uint32_t ev_type = 0;
uint32_t ev_size = 0;
uint8_t* ev_buffer = 0;
continue;
}
- ev_type = midi_parameter_type(ev_buffer[0]);
-
- DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked delta %1, time %2, buf[0] %3, type %4\n",
- ev_delta_t, time, ev_buffer[0], ev_type));
+ DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF read_unlocked delta %1, time %2, buf[0] %3\n",
+ ev_delta_t, time, ev_buffer[0]));
assert(time >= start_ticks);
*/
const framepos_t ev_frame_time = converter.to(Evoral::Beats::ticks_at_rate(time, ppqn())) + source_start;
+ if (loop_range) {
+ loop_range->squish (ev_frame_time);
+ }
+
if (ev_frame_time < start + duration) {
- destination.write (ev_frame_time, ev_type, ev_size, ev_buffer);
- if (tracker) {
- tracker->track(ev_buffer);
+ if (!filter || !filter->filter(ev_buffer, ev_size)) {
+ destination.write (ev_frame_time, Evoral::MIDI_EVENT, ev_size, ev_buffer);
+ if (tracker) {
+ tracker->track(ev_buffer);
+ }
}
} else {
break;
_model->start_write();
}
- Evoral::MIDIEvent<framepos_t> ev;
+ Evoral::Event<framepos_t> ev;
while (true) {
/* Get the event time, in frames since session start but ignoring looping. */
bool ret;
break;
}
time -= position;
-
+
ev.set(buf, size, time);
- ev.set_event_type(midi_parameter_type(ev.buffer()[0]));
+ ev.set_event_type(Evoral::MIDI_EVENT);
ev.set_id(Evoral::next_event_id());
if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
return;
}
- /*printf("SMFSource: %s - append_event_beats ID = %d time = %lf, size = %u, data = ",
+#if 0
+ printf("SMFSource: %s - append_event_beats ID = %d time = %lf, size = %u, data = ",
name().c_str(), ev.id(), ev.time(), ev.size());
- for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
+ for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");
+#endif
Evoral::Beats time = ev.time();
if (time < _last_ev_time_beats) {
SMFSource::get_state ()
{
XMLNode& node = MidiSource::get_state();
- node.add_property (X_("origin"), _origin);
+ node.set_property (X_("origin"), _origin);
return node;
}
_model->set_edited(false);
}
- Evoral::SMF::end_write ();
+ Evoral::SMF::end_write (_path);
/* data in the file now, not removable */
static bool compile = true;
const int nmatches = 2;
regmatch_t matches[nmatches];
-
+
if (Glib::file_test (file, Glib::FILE_TEST_EXISTS)) {
if (!Glib::file_test (file, Glib::FILE_TEST_IS_REGULAR)) {
/* exists but is not a regular file */
} else {
compile = false;
}
-
+
if (regexec (&compiled_pattern, file.c_str(), nmatches, matches, 0)) {
return false;
}
}
static bool compare_eventlist (
- const std::pair< Evoral::Event<Evoral::Beats>*, gint >& a,
- const std::pair< Evoral::Event<Evoral::Beats>*, gint >& b) {
+ const std::pair< const Evoral::Event<Evoral::Beats>*, gint >& a,
+ const std::pair< const Evoral::Event<Evoral::Beats>*, gint >& b) {
return ( a.first->time() < b.first->time() );
}
if (!have_event_id) {
event_id = Evoral::next_event_id();
}
- const uint32_t event_type = midi_parameter_type(buf[0]);
const Evoral::Beats event_time = Evoral::Beats::ticks_at_rate(time, ppqn());
#ifndef NDEBUG
std::string ss;
ss += b;
}
- DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF %6 load model delta %1, time %2, size %3 buf %4, type %5\n",
- delta_t, time, size, ss , event_type, name()));
+ DEBUG_TRACE (DEBUG::MidiSourceIO, string_compose ("SMF %7 load model delta %1, time %2, size %3 buf %4, id %6\n",
+ delta_t, time, size, ss, event_id, name()));
#endif
eventlist.push_back(make_pair (
new Evoral::Event<Evoral::Beats> (
- event_type, event_time,
+ Evoral::MIDI_EVENT, event_time,
size, buf, true)
, event_id));
delete it->first;
}
+ // cerr << "----SMF-SRC-----\n";
+ // _playback_buf->dump (cerr);
+ // cerr << "----------------\n";
+
_model->end_write (Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, _length_beats);
_model->set_edited (false);
invalidate(lock);
ensure_disk_file (lock);
- Evoral::SMF::end_write ();
+ Evoral::SMF::end_write (_path);
/* data in the file means its no longer removable */
mark_nonremovable ();
SMFSource::set_path (const string& p)
{
FileSource::set_path (p);
- SMF::set_path (_path);
}
/** Ensure that this source has some file on disk, even if it's just a SMF header */
/* Unlike the audio case, the MIDI file remains mutable (because we can
edit MIDI data)
*/
-
+
_flags = Flag (_flags & ~(Removable|RemovableIfEmpty|RemoveAtDestroy));
}
-
-
projects / ardour.git / blobdiff