From f9a7388d7aa62c6b8ab0bc8c62bf53ae1652e8e1 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Thu, 16 Aug 2007 01:25:58 +0000 Subject: Make SMFSource suck significantly less. Read from MidiRingbuffer directly into model, don't read MidiRingBuffer into a new midi buffer, then into the model. Pass rec data to UI via model instead of a separate buffer. Read MIDI CC data into MidiModel (though not actually used yet). Made quantization toggle edited flag so model is saved. git-svn-id: svn://localhost/ardour2/trunk@2308 d708f5d6-7413-0410-9779-e7cbd77b26cf --- gtk2_ardour/midi_region_view.cc | 23 ++-- gtk2_ardour/midi_streamview.cc | 29 +++-- gtk2_ardour/midi_streamview.h | 5 +- libs/ardour/ardour/automatable.h | 4 +- libs/ardour/ardour/midi_event.h | 5 +- libs/ardour/ardour/midi_model.h | 17 ++- libs/ardour/ardour/midi_ring_buffer.h | 27 ++++ libs/ardour/ardour/midi_source.h | 13 +- libs/ardour/ardour/session_object.h | 20 +-- libs/ardour/ardour/smf_source.h | 8 +- libs/ardour/midi_model.cc | 67 ++++++---- libs/ardour/midi_source.cc | 13 +- libs/ardour/quantize.cc | 2 + libs/ardour/route.cc | 2 +- libs/ardour/smf_source.cc | 226 ++++++++++++++++++++-------------- 15 files changed, 295 insertions(+), 166 deletions(-) diff --git a/gtk2_ardour/midi_region_view.cc b/gtk2_ardour/midi_region_view.cc index e96a65d893..c51cd314a2 100644 --- a/gtk2_ardour/midi_region_view.cc +++ b/gtk2_ardour/midi_region_view.cc @@ -394,11 +394,14 @@ MidiRegionView::display_model(boost::shared_ptr model) void MidiRegionView::redisplay_model() { - clear_events(); - - //cerr << "Redisplaying model " << _model << endl; + // Don't redisplay the model if we're currently recording and displaying that + if (_active_notes) + return; if (_model) { + + clear_events(); + begin_write(); for (size_t i=0; i < _model->n_notes(); ++i) @@ -406,7 +409,7 @@ MidiRegionView::redisplay_model() end_write(); } else { - warning << "MidiRegionView::redisplay_model called without a model" << endmsg; + cerr << "MidiRegionView::redisplay_model called without a model" << endmsg; } } @@ -414,7 +417,10 @@ MidiRegionView::redisplay_model() MidiRegionView::~MidiRegionView () { in_destructor = true; - end_write(); + if (_active_notes) + end_write(); + + clear_events(); RegionViewGoingAway (this); /* EMIT_SIGNAL */ } @@ -488,6 +494,7 @@ MidiRegionView::add_ghost (AutomationTimeAxisView& atv) void MidiRegionView::begin_write() { + assert(!_active_notes); _active_notes = new CanvasNote*[128]; for (unsigned i=0; i < 128; ++i) _active_notes[i] = NULL; @@ -512,9 +519,9 @@ MidiRegionView::end_write() void MidiRegionView::add_event (const MidiEvent& ev) { - /*printf("Event, time = %f, size = %zu, data = ", ev.time, ev.size); - for (size_t i=0; i < ev.size; ++i) { - printf("%X ", ev.buffer[i]); + /*printf("MRV add Event, time = %f, size = %u, data = ", ev.time(), ev.size()); + for (size_t i=0; i < ev.size(); ++i) { + printf("%X ", ev.buffer()[i]); } printf("\n\n");*/ diff --git a/gtk2_ardour/midi_streamview.cc b/gtk2_ardour/midi_streamview.cc index 484def2a3e..21eae23f90 100644 --- a/gtk2_ardour/midi_streamview.cc +++ b/gtk2_ardour/midi_streamview.cc @@ -410,7 +410,7 @@ MidiStreamView::setup_rec_box () } void -MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_t start, nframes_t dur) +MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_t start, nframes_t dur) { ENSURE_GUI_THREAD (bind (mem_fun (*this, &MidiStreamView::update_rec_regions), data, start, dur)); @@ -467,11 +467,24 @@ MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_ /* draw events */ MidiRegionView* mrv = (MidiRegionView*)iter->second; - for (MidiBuffer::iterator i = data->begin(); i != data->end(); ++i) { - const MidiEvent& ev = *i; - mrv->add_event(ev); - mrv->extend_active_notes(); + // FIXME: slow + for (size_t i=0; i < data->n_notes(); ++i) { + const MidiModel::Note& note = data->note_at(i); + if (note.time() > start + dur) + break; + + if (note.time() >= start) + if (data->note_mode() == Percussive || note.duration() > 0) + mrv->add_note(note); + else + mrv->add_event(note.on_event()); + + if (note.duration() > 0 && note.end_time() >= start) + mrv->add_event(note.off_event()); + } + + mrv->extend_active_notes(); } } @@ -508,18 +521,18 @@ MidiStreamView::update_rec_regions (boost::shared_ptr data, nframes_ } void -MidiStreamView::rec_data_range_ready (boost::shared_ptr data, jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr weak_src) +MidiStreamView::rec_data_range_ready (jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr weak_src) { // this is called from the butler thread for now - ENSURE_GUI_THREAD(bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), data, start, dur, weak_src)); + ENSURE_GUI_THREAD(bind (mem_fun (*this, &MidiStreamView::rec_data_range_ready), start, dur, weak_src)); boost::shared_ptr src (boost::dynamic_pointer_cast(weak_src.lock())); //cerr << src.get() << " MIDI READY: " << start << " * " << dur // << " -- " << data->size() << " events!" << endl; - this->update_rec_regions (data, start, dur); + this->update_rec_regions (src->model(), start, dur); } void diff --git a/gtk2_ardour/midi_streamview.h b/gtk2_ardour/midi_streamview.h index 567844e678..fa414cfe9c 100644 --- a/gtk2_ardour/midi_streamview.h +++ b/gtk2_ardour/midi_streamview.h @@ -40,6 +40,7 @@ namespace ARDOUR { class PeakData; class MidiRegion; class Source; + class MidiModel; } class PublicEditor; @@ -95,8 +96,8 @@ class MidiStreamView : public StreamView private: void setup_rec_box (); - void rec_data_range_ready (boost::shared_ptr data, jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr src); - void update_rec_regions (boost::shared_ptr data, jack_nframes_t start, jack_nframes_t dur); + void rec_data_range_ready (jack_nframes_t start, jack_nframes_t dur, boost::weak_ptr src); + void update_rec_regions (boost::shared_ptr data, jack_nframes_t start, jack_nframes_t dur); RegionView* add_region_view_internal (boost::shared_ptr, bool wait_for_waves); void display_region(MidiRegionView* region_view, bool load_model); diff --git a/libs/ardour/ardour/automatable.h b/libs/ardour/ardour/automatable.h index a48029734a..0af996f6c0 100644 --- a/libs/ardour/ardour/automatable.h +++ b/libs/ardour/ardour/automatable.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2000, 2007 Paul Davis + Copyright (C) 2000-2007 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -94,7 +94,7 @@ protected: mutable Glib::Mutex _automation_lock; - Controls _controls; + Controls _controls; std::set _visible_controls; std::set _can_automate_list; diff --git a/libs/ardour/ardour/midi_event.h b/libs/ardour/ardour/midi_event.h index 3a6b89f198..61e6b8af6e 100644 --- a/libs/ardour/ardour/midi_event.h +++ b/libs/ardour/ardour/midi_event.h @@ -112,11 +112,14 @@ struct MidiEvent { inline uint8_t channel() const { return (_buffer[0] & 0x0F); } inline bool is_note_on() const { return (type() == MIDI_CMD_NOTE_ON); } inline bool is_note_off() const { return (type() == MIDI_CMD_NOTE_OFF); } + inline bool is_cc() const { return (type() == MIDI_CMD_CONTROL); } inline bool is_note() const { return (is_note_on() || is_note_off()); } inline uint8_t note() const { return (_buffer[1]); } inline uint8_t velocity() const { return (_buffer[2]); } + inline uint8_t cc_number() const { return (_buffer[1]); } + inline uint8_t cc_value() const { return (_buffer[2]); } inline const Byte* buffer() const { return _buffer; } - inline Byte* buffer() { return _buffer; } + inline Byte*& buffer() { return _buffer; } private: double _time; /**< Sample index (or beat time) at which event is valid */ diff --git a/libs/ardour/ardour/midi_model.h b/libs/ardour/ardour/midi_model.h index 63b87c9683..f688c0fe09 100644 --- a/libs/ardour/ardour/midi_model.h +++ b/libs/ardour/ardour/midi_model.h @@ -28,6 +28,7 @@ #include #include #include +#include namespace ARDOUR { @@ -41,7 +42,7 @@ class MidiSource; * note on and off events (controller data is not here since it's represented * as an AutomationList) */ -class MidiModel : public boost::noncopyable { +class MidiModel : public boost::noncopyable, public Automatable { public: struct Note { Note(double time=0, double dur=0, uint8_t note=0, uint8_t vel=0x40); @@ -92,11 +93,13 @@ public: void append(const MidiBuffer& data); /** Resizes vector if necessary (NOT realtime safe) */ - void append(double time, size_t size, const Byte* in_buffer); + //void append(double time, size_t size, const Byte* in_buffer); + void append(const MidiEvent& ev); inline const Note& note_at(unsigned i) const { return _notes[i]; } inline size_t n_notes() const { return _notes.size(); } + inline bool empty() const { return _notes.size() == 0 && _controls.size() == 0; } typedef std::vector Notes; @@ -146,7 +149,12 @@ public: void apply_command(Command* cmd); bool edited() const { return _edited; } + void set_edited(bool yn) { _edited = yn; } bool write_to(boost::shared_ptr source); + + // MidiModel doesn't use the normal AutomationList serialisation code, as CC data is in the .mid + XMLNode& get_state(); + int set_state(const XMLNode&) { return 0; } sigc::signal ContentsChanged; @@ -155,12 +163,13 @@ private: void add_note_unlocked(const Note& note); void remove_note_unlocked(const Note& note); +#ifndef NDEBUG bool is_sorted() const; +#endif void append_note_on(double time, uint8_t note, uint8_t velocity); void append_note_off(double time, uint8_t note); - - Session& _session; + void append_cc(double time, uint8_t number, uint8_t value); Glib::RWLock _lock; diff --git a/libs/ardour/ardour/midi_ring_buffer.h b/libs/ardour/ardour/midi_ring_buffer.h index 21beebacd2..9389f962fc 100644 --- a/libs/ardour/ardour/midi_ring_buffer.h +++ b/libs/ardour/ardour/midi_ring_buffer.h @@ -233,6 +233,9 @@ public: size_t write(double time, size_t size, const Byte* buf); bool read(double* time, size_t* size, Byte* buf); + bool read_prefix(double* time, size_t* size); + bool read_contents(size_t size, Byte* buf); + size_t read(MidiBuffer& dst, nframes_t start, nframes_t end, nframes_t offset=0); }; @@ -250,6 +253,30 @@ MidiRingBuffer::read(double* time, size_t* size, Byte* buf) } +/** Read the time and size of an event. This call MUST be immediately proceeded + * by a call to read_contents (or the read pointer will be garabage). + */ +inline bool +MidiRingBuffer::read_prefix(double* time, size_t* size) +{ + bool success = MidiRingBufferBase::full_read(sizeof(double), (Byte*)time); + if (success) + success = MidiRingBufferBase::full_read(sizeof(size_t), (Byte*)size); + + return success; +} + + +/** Read the contenst of an event. This call MUST be immediately preceeded + * by a call to read_prefix (or the returned even will be garabage). + */ +inline bool +MidiRingBuffer::read_contents(size_t size, Byte* buf) +{ + return MidiRingBufferBase::full_read(size, buf); +} + + inline size_t MidiRingBuffer::write(double time, size_t size, const Byte* buf) { diff --git a/libs/ardour/ardour/midi_source.h b/libs/ardour/ardour/midi_source.h index 088175ab75..95d2a38c4e 100644 --- a/libs/ardour/ardour/midi_source.h +++ b/libs/ardour/ardour/midi_source.h @@ -53,8 +53,6 @@ class MidiSource : public Source virtual nframes_t write (MidiRingBuffer& src, nframes_t cnt); virtual void append_event_unlocked(const MidiEvent& ev) = 0; - virtual void flush() {} - virtual void mark_for_remove() = 0; virtual void mark_streaming_midi_write_started (NoteMode mode); virtual void mark_streaming_write_started (); @@ -72,8 +70,8 @@ class MidiSource : public Source static sigc::signal MidiSourceCreated; - // The MIDI equivalent to "peaks" (but complete data) - mutable sigc::signal,nframes_t,nframes_t> ViewDataRangeReady; + // Signal a range of recorded data is available for reading from model() + mutable sigc::signal ViewDataRangeReady; XMLNode& get_state (); int set_state (const XMLNode&); @@ -82,12 +80,14 @@ class MidiSource : public Source virtual void destroy_model() = 0; void set_note_mode(NoteMode mode) { if (_model) _model->set_note_mode(mode); } - virtual bool model_loaded() const { return _model_loaded; } boost::shared_ptr model() { return _model; } - void set_model(boost::shared_ptr m) { _model = m; _model_loaded = true; } + void set_model(boost::shared_ptr m) { _model = m; } protected: + virtual int flush_header() = 0; + virtual int flush_footer() = 0; + virtual nframes_t read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const = 0; virtual nframes_t write_unlocked (MidiRingBuffer& dst, nframes_t cnt) = 0; @@ -98,7 +98,6 @@ class MidiSource : public Source mutable uint32_t _write_data_count; ///< modified in write() boost::shared_ptr _model; - bool _model_loaded; bool _writing; private: diff --git a/libs/ardour/ardour/session_object.h b/libs/ardour/ardour/session_object.h index 9d82b4bba0..bb726cb0d0 100644 --- a/libs/ardour/ardour/session_object.h +++ b/libs/ardour/ardour/session_object.h @@ -20,6 +20,7 @@ #ifndef __ardour_session_object_h__ #define __ardour_session_object_h__ +#include #include namespace ARDOUR { @@ -36,22 +37,27 @@ class Session; class SessionObject : public PBD::StatefulDestructible { public: - SessionObject(Session& session, const string& name) + SessionObject(Session& session, const std::string& name) : _session(session) , _name(name) {} - Session& session() const { return _session; } - const string& name() const { return _name; } + Session& session() const { return _session; } + const std::string& name() const { return _name; } - virtual bool set_name (const string& str) - { if (_name != str) { _name = str; NameChanged(); } return true; } + virtual bool set_name (const std::string& str) { + if (_name != str) { + _name = str; + NameChanged(); + } + return true; + } sigc::signal NameChanged; protected: - Session& _session; - string _name; + Session& _session; + std::string _name; }; } // namespace ARDOUR diff --git a/libs/ardour/ardour/smf_source.h b/libs/ardour/ardour/smf_source.h index c852266e9c..bf5618d57a 100644 --- a/libs/ardour/ardour/smf_source.h +++ b/libs/ardour/ardour/smf_source.h @@ -74,8 +74,6 @@ class SMFSource : public MidiSource { int flush_header (); int flush_footer (); - void flush() { flush_header(); flush_footer(); } - int move_to_trash (const string trash_dir_name); bool is_empty () const; @@ -108,13 +106,15 @@ class SMFSource : public MidiSource { bool removable() const; bool writable() const { return _flags & Writable; } - int open(); + int open(); + void seek_to_end(); + void write_footer(); void write_chunk_header(char id[4], uint32_t length); void write_chunk(char id[4], uint32_t length, void* data); size_t write_var_len(uint32_t val); uint32_t read_var_len() const; - int read_event(jack_midi_event_t& ev) const; + int read_event(uint32_t* delta_t, uint32_t* size, Byte** buf) const; static const uint16_t _ppqn = 19200; diff --git a/libs/ardour/midi_model.cc b/libs/ardour/midi_model.cc index 45a49e73ba..7c67d40d75 100644 --- a/libs/ardour/midi_model.cc +++ b/libs/ardour/midi_model.cc @@ -99,7 +99,7 @@ MidiModel::Note::operator=(const Note& copy) // MidiModel MidiModel::MidiModel(Session& s, size_t size) - : _session(s) + : Automatable(s, "midi model") , _notes(size) , _note_mode(Sustained) , _writing(false) @@ -192,9 +192,10 @@ MidiModel::read (MidiRingBuffer& dst, nframes_t start, nframes_t nframes, nframe void MidiModel::start_write() { - //cerr << "MM START WRITE, MODE = " << enum_2_string(_note_mode) << endl; - _write_notes.clear(); + //cerr << "MM " << this << " START WRITE, MODE = " << enum_2_string(_note_mode) << endl; + _lock.writer_lock(); _writing = true; + _write_notes.clear(); } @@ -210,7 +211,7 @@ MidiModel::end_write(bool delete_stuck) { assert(_writing); - //cerr << "MM END WRITE: " << _notes.size() << " STUCK NOTES\n"; + //cerr << "MM " << this << " END WRITE: " << _notes.size() << " NOTES\n"; if (_note_mode == Sustained && delete_stuck) { for (Notes::iterator n = _notes.begin(); n != _notes.end() ; ) { @@ -225,6 +226,7 @@ MidiModel::end_write(bool delete_stuck) _write_notes.clear(); _writing = false; + _lock.writer_unlock(); } @@ -241,20 +243,10 @@ MidiModel::append(const MidiBuffer& buf) { assert(_writing); - _lock.writer_lock(); - for (MidiBuffer::const_iterator i = buf.begin(); i != buf.end(); ++i) { - const MidiEvent& ev = *i; - - assert(_notes.empty() || ev.time() >= _notes.back().time()); - - if (ev.type() == MIDI_CMD_NOTE_ON) - append_note_on(ev.time(), ev.note(), ev.velocity()); - else if (ev.type() == MIDI_CMD_NOTE_OFF) - append_note_off(ev.time(), ev.note()); + assert(_notes.empty() || (*i).time() >= _notes.back().time()); + append(*i); } - - _lock.writer_unlock(); } @@ -265,21 +257,27 @@ MidiModel::append(const MidiBuffer& buf) * and MUST be >= the latest event currently in the model. */ void -MidiModel::append(double time, size_t size, const Byte* buf) +MidiModel::append(const MidiEvent& ev) { - assert(_notes.empty() || time >= _notes.back().time()); + assert(_notes.empty() || ev.time() >= _notes.back().time()); assert(_writing); - if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_ON) - append_note_on(time, buf[1], buf[2]); - else if ((buf[0] & 0xF0) == MIDI_CMD_NOTE_OFF) - append_note_off(time, buf[1]); + if (ev.is_note_on()) + append_note_on(ev.time(), ev.note(), ev.velocity()); + else if (ev.is_note_off()) + append_note_off(ev.time(), ev.note()); + else if (ev.is_cc()) + append_cc(ev.time(), ev.cc_number(), ev.cc_value()); + else + printf("MM Unknown event type %X\n", ev.type()); } void MidiModel::append_note_on(double time, uint8_t note_num, uint8_t velocity) { + //cerr << "MidiModel " << this << " note " << (int)note_num << " on @ " << time << endl; + assert(_writing); _notes.push_back(Note(time, 0, note_num, velocity)); if (_note_mode == Sustained) { @@ -294,6 +292,8 @@ MidiModel::append_note_on(double time, uint8_t note_num, uint8_t velocity) void MidiModel::append_note_off(double time, uint8_t note_num) { + //cerr << "MidiModel " << this << " note " << (int)note_num << " off @ " << time << endl; + assert(_writing); if (_note_mode == Percussive) { //cerr << "MM Ignoring note off (percussive mode)" << endl; @@ -321,6 +321,19 @@ MidiModel::append_note_off(double time, uint8_t note_num) } +void +MidiModel::append_cc(double time, uint8_t number, uint8_t value) +{ + Parameter param(MidiCCAutomation, number); + + //cerr << "MidiModel " << this << " add CC " << (int)number << " = " << (int)value + // << " @ " << time << endl; + + boost::shared_ptr control = Automatable::control(param, true); + control->list()->fast_simple_add(time, (double)value); +} + + void MidiModel::add_note_unlocked(const Note& note) { @@ -340,6 +353,7 @@ MidiModel::remove_note_unlocked(const Note& note) } /** Slow! for debugging only. */ +#ifndef NDEBUG bool MidiModel::is_sorted() const { @@ -352,7 +366,7 @@ MidiModel::is_sorted() const return true; } - +#endif /** Start a new command. * @@ -509,3 +523,10 @@ MidiModel::write_to(boost::shared_ptr source) return true; } +XMLNode& +MidiModel::get_state() +{ + XMLNode *node = new XMLNode("MidiModel"); + return *node; +} + diff --git a/libs/ardour/midi_source.cc b/libs/ardour/midi_source.cc index c6e3bd0a08..4c97bb4e6d 100644 --- a/libs/ardour/midi_source.cc +++ b/libs/ardour/midi_source.cc @@ -50,7 +50,6 @@ MidiSource::MidiSource (Session& s, string name) : Source (s, name, DataType::MIDI) , _timeline_position(0) , _model(new MidiModel(s)) - , _model_loaded (false) , _writing (false) { _read_data_count = 0; @@ -61,7 +60,6 @@ MidiSource::MidiSource (Session& s, const XMLNode& node) : Source (s, node) , _timeline_position(0) , _model(new MidiModel(s)) - , _model_loaded (false) , _writing (false) { _read_data_count = 0; @@ -106,7 +104,7 @@ nframes_t MidiSource::read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const { Glib::Mutex::Lock lm (_lock); - if (_model_loaded && _model) { + if (_model) { /*const size_t n_events = */_model->read(dst, start, cnt, stamp_offset); //cout << "Read " << n_events << " events from model." << endl; return cnt; @@ -164,9 +162,10 @@ MidiSource::mark_streaming_write_completed () void MidiSource::session_saved() { - flush(); + flush_header(); + flush_footer(); - if (_model && _model_loaded && _model->edited()) { + if (_model && _model->edited()) { string newname; const string basename = PBD::basename_nosuffix(_name); string::size_type last_dash = basename.find_last_of("-"); @@ -193,9 +192,9 @@ MidiSource::session_saved() newsrc->set_model(_model); _model.reset(); - _model_loaded = false; - newsrc->flush(); + newsrc->flush_header(); + newsrc->flush_footer(); Switched.emit(newsrc); } diff --git a/libs/ardour/quantize.cc b/libs/ardour/quantize.cc index 5bee86d0c4..5da30e8466 100644 --- a/libs/ardour/quantize.cc +++ b/libs/ardour/quantize.cc @@ -79,6 +79,8 @@ Quantize::run (boost::shared_ptr r) i->set_duration(new_dur); } + model->set_edited(true); + return 0; #if 0 SourceList nsrcs; diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc index 914e936d6b..0453129f75 100644 --- a/libs/ardour/route.cc +++ b/libs/ardour/route.cc @@ -1445,7 +1445,7 @@ XMLNode& Route::state(bool full_state) { XMLNode *node = new XMLNode("Route"); - ProcessorList:: iterator i; + ProcessorList::iterator i; char buf[32]; if (_flags) { diff --git a/libs/ardour/smf_source.cc b/libs/ardour/smf_source.cc index dfba2d5c50..32f012e389 100644 --- a/libs/ardour/smf_source.cc +++ b/libs/ardour/smf_source.cc @@ -156,18 +156,24 @@ SMFSource::open() // We're making a new file } else { _fd = fopen(path().c_str(), "w+"); - _track_size = 0; + _track_size = 4; // Write a tentative header just to pad things out so writing happens in the right spot set_timeline_position(0); flush_header(); - - // Note file isn't a valid SMF at this point (no footer). Does it matter? + write_footer(); + seek_to_end(); } return (_fd == 0) ? -1 : 0; } +void +SMFSource::seek_to_end() +{ + fseek(_fd, -4, SEEK_END); +} + int SMFSource::flush_header () { @@ -202,14 +208,22 @@ SMFSource::flush_header () int SMFSource::flush_footer() { - //cerr << "SMF " << name() << " writing EOT\n"; + seek_to_end(); + write_footer(); + seek_to_end(); - fseek(_fd, 0, SEEK_END); + return 0; +} + +void +SMFSource::write_footer() +{ + //cerr << "SMF " << name() << " writing EOT at byte " << ftell(_fd) << endl; + write_var_len(0); char eot[3] = { 0xFF, 0x2F, 0x00 }; // end-of-track meta-event fwrite(eot, 1, 3, _fd); fflush(_fd); - return 0; } /** Returns the offset of the first event in the file with a time past @a start, @@ -243,57 +257,70 @@ SMFSource::find_first_event_after(nframes_t start) * will have it's time field set to it's delta time, in SMF tempo-based ticks, using the * rate given by ppqn() (it is the caller's responsibility to calculate a real time). * + * \a size should be the capacity of \a buf. If it is not large enough, \a buf will + * be freed and a new buffer allocated in its place, the size of which will be placed + * in size. + * * Returns event length (including status byte) on success, 0 if event was * skipped (eg a meta event), or -1 on EOF (or end of track). */ int -SMFSource::read_event(jack_midi_event_t& ev) const +SMFSource::read_event(uint32_t* delta_t, uint32_t* size, Byte** buf) 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) { if (feof(_fd)) { return -1; } - uint32_t delta_time = read_var_len(); + assert(delta_t); + assert(size); + assert(buf); + + *delta_t = read_var_len(); assert(!feof(_fd)); - int status = fgetc(_fd); + + const int status = fgetc(_fd); assert(status != EOF); // FIXME die gracefully + + //printf("Status @ %X = %X\n", (unsigned)ftell(_fd) - 1, status); + if (status == 0xFF) { assert(!feof(_fd)); - int type = fgetc(_fd); + const int type = fgetc(_fd); if ((unsigned char)type == 0x2F) { - //cerr << "SMF - hit EOT" << endl; - return -1; // we hit the logical EOF anyway... + //cerr << _name << " hit EOT" << endl; + return -1; } else { - ev.size = 0; - ev.time = delta_time; // this is needed regardless + *size = 0; return 0; } } - size_t event_size = midi_event_size((unsigned char)status) + 1; + const int event_size = midi_event_size((unsigned char)status) + 1; + if (event_size <= 0) { + *size = 0; + return 0; + } // Make sure we have enough scratch buffer - if (ev.size < event_size) - ev.buffer = (Byte*)realloc(ev.buffer, event_size); + if (*size < (unsigned)event_size) + *buf = (Byte*)realloc(*buf, event_size); - ev.time = delta_time; - ev.size = event_size; + *size = event_size; /*if (ev.buffer == NULL) ev.buffer = (Byte*)malloc(sizeof(Byte) * ev.size);*/ - ev.buffer[0] = (unsigned char)status; - fread(ev.buffer+1, 1, ev.size - 1, _fd); + (*buf)[0] = (unsigned char)status; + if (event_size > 1) + fread((*buf) + 1, 1, *size - 1, _fd); - /*printf("%s read event: delta = %u, size = %zu, data = ", _name.c_str(), delta_time, ev.size); - for (size_t i=0; i < ev.size; ++i) { - printf("%X ", ev.buffer[i]); + /*printf("%s read event: delta = %u, size = %u, data = ", _name.c_str(), *delta_t, *size); + for (size_t i=0; i < *size; ++i) { + printf("%X ", (*buf)[i]); } printf("\n");*/ - return ev.size; + return (int)*size; } /** All stamps in audio frames */ @@ -307,24 +334,24 @@ SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, n _read_data_count = 0; - jack_midi_event_t ev; // time in SMF ticks - ev.time = 0; - ev.size = 0; - ev.buffer = NULL; // read_event will allocate scratch as needed + // Output parameters for read_event (which will allocate scratch in buffer as needed) + uint32_t ev_delta_t = 0; + uint32_t ev_size = 0; + Byte* ev_buffer = 0; - size_t scratch_size = 0; // keep track of scratch and minimize reallocs + size_t scratch_size = 0; // keep track of scratch to minimize reallocs - // FIXME: don't seek to start every read + // FIXME: don't seek to start and search every read (brutal!) fseek(_fd, _header_size, 0); // 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()); - uint64_t start_ticks = (uint64_t)((start / frames_per_beat) * _ppqn); + const uint64_t start_ticks = (uint64_t)((start / frames_per_beat) * _ppqn); while (!feof(_fd)) { - int ret = read_event(ev); + int ret = read_event(&ev_delta_t, &ev_size, &ev_buffer); if (ret == -1) { // EOF //cerr << "SMF - EOF\n"; break; @@ -332,29 +359,28 @@ SMFSource::read_unlocked (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, n if (ret == 0) { // meta-event (skipped) //cerr << "SMF - META\n"; - time += ev.time; // just accumulate delta time and ignore event + time += ev_delta_t; // just accumulate delta time and ignore event continue; } - time += ev.time; // accumulate delta time - ev.time = time; // set ev.time to actual time (relative to source start) + time += ev_delta_t; // accumulate delta time + + if (time >= start_ticks) { + const nframes_t ev_frame_time = (nframes_t)( + ((time / (double)_ppqn) * frames_per_beat)) + stamp_offset; - if (ev.time >= start_ticks) { - if (ev.time < start_ticks + (cnt / frames_per_beat)) { + if (ev_frame_time <= start + cnt) + dst.write(ev_frame_time, ev_size, ev_buffer); + else break; - } else { - ev.time = (nframes_t)(((ev.time / (double)_ppqn) * frames_per_beat)) + stamp_offset; - // write event time in absolute frames - dst.write(ev.time, ev.size, ev.buffer); - } } - _read_data_count += ev.size; + _read_data_count += ev_size; - if (ev.size > scratch_size) - scratch_size = ev.size; + if (ev_size > scratch_size) + scratch_size = ev_size; else - ev.size = scratch_size; + ev_size = scratch_size; // minimize realloc in read_event } return cnt; @@ -365,35 +391,54 @@ nframes_t SMFSource::write_unlocked (MidiRingBuffer& src, nframes_t cnt) { _write_data_count = 0; + + double time; + size_t size; - boost::shared_ptr buf_ptr(new MidiBuffer(1024)); // FIXME: size? - MidiBuffer& buf = *buf_ptr.get(); - src.read(buf, /*_length*/0, _length + cnt); // FIXME? - - fseek(_fd, 0, SEEK_END); + size_t buf_capacity = 4; + Byte* buf = (Byte*)malloc(buf_capacity); - 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); + if (_model && ! _model->currently_writing()) + _model->start_write(); + + while (true) { + bool ret = src.full_peek(sizeof(double), (Byte*)&time); + if (!ret || time > _length + cnt) + break; - append_event_unlocked(ev); + ret = src.read_prefix(&time, &size); + if (!ret) + break; + + if (size > buf_capacity) { + buf_capacity = size; + buf = (Byte*)realloc(buf, size); + } + + ret = src.read_contents(size, buf); + if (!ret) { + cerr << "ERROR: Read time/size but not buffer, corrupt MIDI ring buffer" << endl; + break; + } + + assert(time >= _timeline_position); + time -= _timeline_position; + assert(time >= _last_ev_time); + + const MidiEvent ev(time, size, buf); + append_event_unlocked(MidiEvent(ev)); + + if (_model) + _model->append(ev); } fflush(_fd); + free(buf); const nframes_t oldlen = _length; update_length(oldlen, cnt); - if (_model) { - if ( ! _model->currently_writing()) { - _model->start_write(); - } - _model->append(buf); - } - - ViewDataRangeReady (buf_ptr, oldlen, cnt); /* EMIT SIGNAL */ + ViewDataRangeReady (oldlen, cnt); /* EMIT SIGNAL */ return cnt; } @@ -480,6 +525,7 @@ SMFSource::mark_streaming_write_completed () return; } + flush_header(); flush_footer(); #if 0 @@ -784,9 +830,6 @@ SMFSource::read_var_len() const { assert(!feof(_fd)); - //int offset = ftell(_fd); - //cerr << "SMF - reading var len at " << offset << endl; - uint32_t value; unsigned char c; @@ -810,16 +853,18 @@ SMFSource::load_model(bool lock, bool force_reload) if (lock) Glib::Mutex::Lock lm (_lock); - if (_model && _model_loaded && ! force_reload) { - assert(_model); + if (_model && !force_reload && !_model->empty()) { + //cerr << _name << " NOT reloading model " << _model.get() << " (" << _model->n_notes() + // << " notes)" << endl; return; } if (! _model) { - cerr << "SMFSource: Loading new model " << _model.get() << endl; _model = boost::shared_ptr(new MidiModel(_session)); + cerr << _name << " loaded new model " << _model.get() << endl; } else { - cerr << "SMFSource: Reloading model " << _model.get() << endl; + cerr << _name << " reloading model " << _model.get() + << " (" << _model->n_notes() << " notes)" <clear(); } @@ -828,10 +873,7 @@ SMFSource::load_model(bool lock, bool force_reload) fseek(_fd, _header_size, 0); uint64_t time = 0; /* in SMF ticks */ - jack_midi_event_t ev; - ev.time = 0; - ev.size = 0; - ev.buffer = NULL; + MidiEvent ev; size_t scratch_size = 0; // keep track of scratch and minimize reallocs @@ -839,35 +881,35 @@ SMFSource::load_model(bool lock, bool force_reload) const double frames_per_beat = _session.tempo_map().tempo_at(_timeline_position).frames_per_beat( _session.engine().frame_rate()); + uint32_t delta_t = 0; int ret; - while ((ret = read_event(ev)) >= 0) { + while ((ret = read_event(&delta_t, &ev.size(), &ev.buffer())) >= 0) { - time += ev.time; + time += delta_t; - const double ev_time = (double)(time * frames_per_beat / (double)_ppqn); // in frames - if (ret > 0) { // didn't skip (meta) event - _model->append(ev_time, ev.size, ev.buffer); + // make ev.time absolute time in frames + ev.time() = (double)time * frames_per_beat / (double)_ppqn; + + _model->append(ev); } - if (ev.size > scratch_size) - scratch_size = ev.size; + if (ev.size() > scratch_size) + scratch_size = ev.size(); else - ev.size = scratch_size; + ev.size() = scratch_size; } - _model->end_write(false); /* FIXME: delete stuck notes iff percussion? */ - - free(ev.buffer); + _model->end_write(false); - _model_loaded = true; + free(ev.buffer()); } void SMFSource::destroy_model() { - cerr << "SMFSource: Destroying model " << _model.get() << endl; + //cerr << _name << " destroying model " << _model.get() << endl; _model.reset(); } -- cgit v1.2.3