int
SMFSource::open()
{
- cerr << "Opening SMF file " << path() << " writeable: " << writable() << endl;
+ //cerr << "Opening SMF file " << path() << " writeable: " << writable() << endl;
assert(writable()); // FIXME;
uint32_t track_size_be = 0;
fread(&track_size_be, 4, 1, _fd);
_track_size = GUINT32_FROM_BE(track_size_be);
- cerr << "SMF - read track size " << _track_size << endl;
+ //cerr << "SMF - read track size " << _track_size << endl;
// We're making a new file
} else {
{
// FIXME: write timeline position somehow?
- cerr << "SMF Flushing header\n";
+ //cerr << "SMF Flushing header\n";
assert(_fd);
int
SMFSource::flush_footer()
{
- cerr << "SMF - Writing EOT\n";
+ //cerr << "SMF - Writing EOT\n";
fseek(_fd, 0, SEEK_END);
write_var_len(1); // whatever...
* skipped (eg a meta event), or -1 on EOF (or end of track).
*/
int
-SMFSource::read_event(MidiEvent& ev) const
+SMFSource::read_event(jack_midi_event_t& ev) const
{
// - 4 is for the EOT event, which we don't actually want to read
//if (feof(_fd) || ftell(_fd) >= _header_size + _track_size - 4) {
}
uint32_t delta_time = read_var_len();
+ assert(!feof(_fd));
int status = fgetc(_fd);
assert(status != EOF); // FIXME die gracefully
if (status == 0xFF) {
return 0;
}
}
+
+ size_t event_size = midi_event_size((unsigned char)status) + 1;
+
+ // Make sure we have enough scratch buffer
+ if (ev.size < event_size)
+ ev.buffer = (Byte*)realloc(ev.buffer, event_size);
+
+ ev.time = delta_time;
+ ev.size = event_size;
+
+ /*if (ev.buffer == NULL)
+ ev.buffer = (Byte*)malloc(sizeof(Byte) * ev.size);*/
ev.buffer[0] = (unsigned char)status;
- ev.size = midi_event_size(ev.buffer[0]) + 1;
fread(ev.buffer+1, 1, ev.size - 1, _fd);
- ev.time = delta_time;
/*printf("SMF - read event, delta = %u, size = %zu, data = ",
delta_time, ev.size);
_read_data_count = 0;
- // FIXME: ugh
- unsigned char ev_buf[MidiBuffer::max_event_size()];
- MidiEvent ev;
+ jack_midi_event_t ev; // time in SMF ticks
ev.time = 0;
- ev.size = MidiBuffer::max_event_size();
- ev.buffer = ev_buf;
+ ev.size = 0;
+ ev.buffer = NULL; // read_event will allocate scratch as needed
- // FIXME: it would be an impressive feat to actually make this any slower :)
-
+ size_t scratch_size = 0; // keep track of scratch and minimize reallocs
+
+ // FIXME: don't seek to start every read
fseek(_fd, _header_size, 0);
// FIXME: assumes tempo never changes after start
}
_read_data_count += ev.size;
+
+ if (ev.size > scratch_size)
+ scratch_size = ev.size;
+ else
+ ev.size = scratch_size;
}
return cnt;
const double frames_per_beat = _session.tempo_map().tempo_at(_timeline_position).frames_per_beat(
_session.engine().frame_rate());
- for (size_t i=0; i < buf.size(); ++i) {
- MidiEvent& ev = buf[i];
- assert(ev.time >= _timeline_position);
- ev.time -= _timeline_position;
- assert(ev.time >= _last_ev_time);
- const uint32_t delta_time = (uint32_t)(ev.time - _last_ev_time) / frames_per_beat * _ppqn;
+ for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
+ MidiEvent& ev = *i;
+ assert(ev.time() >= _timeline_position);
+ ev.time() -= _timeline_position;
+ assert(ev.time() >= _last_ev_time);
+ const uint32_t delta_time = (uint32_t)((ev.time() - _last_ev_time) / frames_per_beat * _ppqn);
/*printf("SMF - writing event, delta = %u, size = %zu, data = ",
delta_time, ev.size);
printf("\n");
*/
size_t stamp_size = write_var_len(delta_time);
- fwrite(ev.buffer, 1, ev.size, _fd);
+ fwrite(ev.buffer(), 1, ev.size(), _fd);
- _track_size += stamp_size + ev.size;
- _write_data_count += ev.size;
+ _track_size += stamp_size + ev.size();
+ _write_data_count += ev.size();
- _last_ev_time = ev.time;
+ _last_ev_time = ev.time();
}
fflush(_fd);
const nframes_t oldlen = _length;
update_length(oldlen, cnt);
- _model.append(buf);
+ if (_model) {
+ if ( ! _model->currently_writing()) {
+ _model->start_write();
+ }
+ _model->append(buf);
+ }
ViewDataRangeReady (buf_ptr, oldlen, cnt); /* EMIT SIGNAL */
void
SMFSource::mark_streaming_write_completed ()
{
+ MidiSource::mark_streaming_write_completed();
+
if (!writable()) {
return;
}
}
int
-SMFSource::set_name (string newname, bool destructive)
+SMFSource::set_source_name (string newname, bool destructive)
{
//Glib::Mutex::Lock lm (_lock); FIXME
string oldpath = _path;
}
void
-SMFSource::load_model(bool lock)
+SMFSource::load_model(bool lock, bool force_reload)
{
+ if (_writing)
+ return;
+
if (lock)
Glib::Mutex::Lock lm (_lock);
- _model.clear();
-
+ if (_model && _model_loaded && ! force_reload) {
+ assert(_model);
+ return;
+ }
+
+ if (! _model) {
+ _model = boost::shared_ptr<MidiModel>(new MidiModel(_session));
+ } else {
+ cerr << "SMFSource: Reloading model." << endl;
+ _model->clear();
+ }
+
+ _model->start_write();
+
fseek(_fd, _header_size, 0);
- double time = 0;
- MidiEvent ev;
+ uint64_t time = 0; /* in SMF ticks */
+ jack_midi_event_t ev;
+ ev.time = 0;
+ ev.size = 0;
+ ev.buffer = NULL;
+
+ size_t scratch_size = 0; // keep track of scratch and minimize reallocs
+
+ // FIXME: assumes tempo never changes after start
+ const double frames_per_beat = _session.tempo_map().tempo_at(_timeline_position).frames_per_beat(
+ _session.engine().frame_rate());
int ret;
while ((ret = read_event(ev)) >= 0) {
+
time += ev.time;
- ev.time = time;
+
+ const double ev_time = (double)(time * frames_per_beat / (double)_ppqn); // in frames
+
if (ret > 0) { // didn't skip (meta) event
- _model.append(ev);
+ _model->append(ev_time, ev.size, ev.buffer);
}
+
+ if (ev.size > scratch_size)
+ scratch_size = ev.size;
+ else
+ ev.size = scratch_size;
}
+
+ _model->end_write(false); /* FIXME: delete stuck notes iff percussion? */
+
+ free(ev.buffer);
+
+ _model_loaded = true;
}
+
void
SMFSource::destroy_model()
{
- _model.clear();
+ _model.reset();
}
projects / ardour.git / blobdiff