, Evoral::SMF()
, _last_ev_time_beats(0.0)
, _last_ev_time_frames(0)
+ , _smf_last_read_end (0)
{
if (init(_name, false)) {
throw failed_constructor ();
, FileSource(s, node, must_exist)
, _last_ev_time_beats(0.0)
, _last_ev_time_frames(0)
+ , _smf_last_read_end (0)
{
if (set_state(node)) {
throw failed_constructor ();
/** All stamps in audio frames */
nframes_t
-SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& destination, sframes_t position,
+SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& destination, sframes_t source_start,
sframes_t start, nframes_t duration,
sframes_t stamp_offset, sframes_t negative_stamp_offset) const
{
size_t scratch_size = 0; // keep track of scratch to minimize reallocs
- BeatsFramesConverter converter(_session, position);
+ BeatsFramesConverter converter(_session, source_start);
const uint64_t start_ticks = (uint64_t)(converter.from(start) * ppqn());
- if (_last_read_end == 0 || start != _last_read_end) {
- cerr << "SMFSource::read_unlocked seeking to " << start << endl;
+ if (_smf_last_read_end == 0 || start != _smf_last_read_end) {
+ //cerr << "SMFSource::read_unlocked seeking to " << start << endl;
Evoral::SMF::seek_to_start();
while (time < start_ticks) {
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
if (ret == -1) { // EOF
- _last_read_end = start + duration;
+ _smf_last_read_end = start + duration;
return duration;
}
time += ev_delta_t; // accumulate delta time
}
}
- _last_read_end = start + duration;
+ _smf_last_read_end = start + duration;
while (true) {
ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
ev_type = EventTypeMap::instance().midi_event_type(ev_buffer[0]);
+#if 0
+ cerr << "+++ SMF source read "
+ << " delta = " << ev_delta_t
+ << " time = " << time
+ << " buf[0] " << hex << (int) ev_buffer[0] << dec
+ << " type = " << ev_type;
+#endif
+
assert(time >= start_ticks);
const sframes_t ev_frame_time = converter.to(time / (double)ppqn()) + stamp_offset;
+#if 0
+ cerr << " frames = " << ev_frame_time
+ << " w/offset = " << ev_frame_time - negative_stamp_offset
+ << endl;
+#endif
+
if (ev_frame_time < start + duration) {
destination.write(ev_frame_time - negative_stamp_offset, ev_type, ev_size, ev_buffer);
} else {
break;
}
+
_read_data_count += ev_size;
if (ev_size > scratch_size) {
{
_write_data_count = 0;
- nframes_t event_time;
- Evoral::EventType event_type;
- uint32_t event_size;
+ nframes_t time;
+ Evoral::EventType type;
+ uint32_t size;
size_t buf_capacity = 4;
uint8_t* buf = (uint8_t*)malloc(buf_capacity);
Evoral::MIDIEvent<nframes_t> ev;
while (true) {
- bool ret = source.peek_time(&event_time);
- g_debug ("event_time: %u, last_write_end: %lu, duration: %u", event_time, _last_write_end, duration);
- if (!ret || event_time > _last_write_end + duration) {
- if (!ret) g_debug ("peek failed");
- if (event_time > _last_write_end + duration) g_debug ("event_time: %u > last_write_end: %lu + duration: %u", event_time, _last_write_end, duration);
-
+ bool ret = source.peek_time(&time);
+ if (!ret || time > _last_write_end + duration) {
break;
}
- ret = source.read_prefix(&event_time, &event_type, &event_size);
+ ret = source.read_prefix(&time, &type, &size);
if (!ret) {
cerr << "ERROR: Unable to read event prefix, corrupt MIDI ring buffer" << endl;
break;
}
- if (event_size > buf_capacity) {
- buf_capacity = event_size;
- buf = (uint8_t*)realloc(buf, event_size);
+ if (size > buf_capacity) {
+ buf_capacity = size;
+ buf = (uint8_t*)realloc(buf, size);
}
- ret = source.read_contents(event_size, buf);
+ ret = source.read_contents(size, buf);
if (!ret) {
- cerr << "ERROR: Read event time/size but not buffer, corrupt MIDI ring buffer" << endl;
+ cerr << "ERROR: Read time/size but not buffer, corrupt MIDI ring buffer" << endl;
break;
}
- assert(event_time >= position);
- event_time -= position;
+ assert(time >= position);
+ time -= position;
- ev.set(buf, event_size, event_time);
+ ev.set(buf, size, time);
ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
cerr << "SMFSource: WARNING: caller tried to write non SMF-Event of type "
const double delta_time_beats = ev.time() - _last_ev_time_beats;
const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
-
+
Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
_last_ev_time_beats = ev.time();
if (! _model) {
_model = boost::shared_ptr<MidiModel>(new MidiModel(this));
- cerr << _name << " loaded new model " << _model.get() << endl;
+ //cerr << _name << " loaded new model " << _model.get() << endl;
} else {
- cerr << _name << " reloading model " << _model.get()
- << " (" << _model->n_notes() << " notes)" <<endl;
+ /*cerr << _name << " reloading model " << _model.get()
+ << " (" << _model->n_notes() << " notes)" << endl;*/
_model->clear();
}
while ((ret = read_event(&delta_t, &size, &buf)) >= 0) {
time += delta_t;
ev.set(buf, size, time / (double)ppqn());
-
+
if (ret > 0) { // didn't skip (meta) event
ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0]));
_model->append(ev);