X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fevoral%2Fsrc%2FSMF.cpp;h=b84507818c306a752089976e42695ff08c873707;hb=202788ea18ddff1754da0b77d1d77ca6ef6fbca1;hp=4165a331cbf0d74d89ca5bfc6f0a7cacb2301610;hpb=9a30bb2aecabcdd16568e6548dd1aeade8effa48;p=ardour.git diff --git a/libs/evoral/src/SMF.cpp b/libs/evoral/src/SMF.cpp index 4165a331cb..b84507818c 100644 --- a/libs/evoral/src/SMF.cpp +++ b/libs/evoral/src/SMF.cpp @@ -1,209 +1,187 @@ /* This file is part of Evoral. - * Copyright (C) 2008 Dave Robillard + * Copyright (C) 2008 David Robillard * Copyright (C) 2000-2008 Paul Davis - * + * Author: Hans Baier + * * Evoral is free software; you can redistribute it and/or modify it under the * terms of the GNU General Public License as published by the Free Software * Foundation; either version 2 of the License, or (at your option) any later * version. - * + * * Evoral is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details. - * + * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include -#include -#include -#include #include +#include #include -#include -#include -#include -#include -#include +#include +#include "libsmf/smf.h" +#include "evoral/Event.hpp" +#include "evoral/SMF.hpp" +#include "evoral/midi_util.h" +#include "pbd/file_manager.h" using namespace std; namespace Evoral { -SMF::SMF() - : _fd(0) - , _last_ev_time(0) - , _track_size(4) // 4 bytes for the ever-present EOT event - , _header_size(22) - , _empty(true) +SMF::~SMF() { + if (_smf) { + smf_delete(_smf); + _smf = 0; + _smf_track = 0; + } } -SMF::~SMF() +uint16_t +SMF::num_tracks() const { + return _smf->number_of_tracks; } -/** Attempt to open the SMF file for reading and writing. - * - * Currently SMF is always read/write. - * - * \return 0 on success - * -1 if the file can not be opened for reading, - * -2 if the file can not be opened for writing +uint16_t +SMF::ppqn() const +{ + return _smf->ppqn; +} + +/** Seek to the specified track (1-based indexing) + * \return 0 on success */ int -SMF::open(const std::string& path) +SMF::seek_to_track(int track) { - //cerr << "Opening SMF file " << path() << " writeable: " << writable() << endl; - _fd = fopen(path.c_str(), "r+"); - - // File already exists - if (_fd) { - fseek(_fd, _header_size - 4, 0); - uint32_t track_size_be = 0; - fread(&track_size_be, 4, 1, _fd); - _track_size = GUINT32_FROM_BE(track_size_be); - _empty = _track_size > 4; - //cerr << "SMF - read track size " << _track_size << endl; - - // We're making a new file + _smf_track = smf_get_track_by_number(_smf, track); + if (_smf_track != NULL) { + _smf_track->next_event_number = (_smf_track->number_of_events == 0) ? 0 : 1; + return 0; } else { - _fd = fopen(path.c_str(), "w+"); - if (_fd == NULL) { - cerr << "ERROR: Can not open SMF file " << path << " for writing: " << - strerror(errno) << endl; - return -2; - } - _track_size = 4; - _empty = true; - - // Write a tentative header just to pad things out so writing happens in the right spot - flush_header(); - flush_footer(); + return -1; } - - return (_fd == 0) ? -1 : 0; } -void -SMF::close() +/** Attempt to open the SMF file for reading and/or writing. + * + * \return 0 on success + * -1 if the file can not be opened or created + * -2 if the file exists but specified track does not exist + */ +int +SMF::open(const std::string& path, int track) THROW_FILE_ERROR { - if (_fd) { - flush_header(); - flush_footer(); - fclose(_fd); - _fd = NULL; + assert(track >= 1); + if (_smf) { + smf_delete(_smf); } -} -void -SMF::seek_to_start() const -{ - fseek(_fd, _header_size, SEEK_SET); -} + _file_path = path; -void -SMF::seek_to_footer_position() -{ - uint8_t buffer[4]; - - // Check if there is a track end marker at the end of the data - fseek(_fd, -4, SEEK_END); - size_t read_bytes = fread(buffer, sizeof(uint8_t), 4, _fd); - - if ((read_bytes == 4) - && buffer[0] == 0x00 - && buffer[1] == 0xFF - && buffer[2] == 0x2F - && buffer[3] == 0x00) { - // there is one, so overwrite it - fseek(_fd, -4, SEEK_END); + PBD::StdioFileDescriptor d (_file_path, "r"); + FILE* f = d.allocate (); + if (f == 0) { + return -1; + } + + if ((_smf = smf_load (f)) == 0) { + return -1; + } + + if ((_smf_track = smf_get_track_by_number(_smf, track)) == 0) { + return -2; + } + + //cerr << "Track " << track << " # events: " << _smf_track->number_of_events << endl; + if (_smf_track->number_of_events == 0) { + _smf_track->next_event_number = 0; + _empty = true; } else { - // there is none, so append - fseek(_fd, 0, SEEK_END); + _smf_track->next_event_number = 1; + _empty = false; } -} -void -SMF::flush() -{ - fflush(_fd); + return 0; } + +/** Attempt to create a new SMF file for reading and/or writing. + * + * \return 0 on success + * -1 if the file can not be created + * -2 if the track can not be created + */ int -SMF::flush_header() +SMF::create(const std::string& path, int track, uint16_t ppqn) THROW_FILE_ERROR { - // FIXME: write timeline position somehow? - - //cerr << path() << " SMF Flushing header\n"; + assert(track >= 1); + if (_smf) { + smf_delete(_smf); + } - assert(_fd); + _file_path = path; - const uint16_t type = GUINT16_TO_BE(0); // SMF Type 0 (single track) - const uint16_t ntracks = GUINT16_TO_BE(1); // Number of tracks (always 1 for Type 0) - const uint16_t division = GUINT16_TO_BE(_ppqn); // Pulses per quarter note (beat) + _smf = smf_new(); - char data[6]; - memcpy(data, &type, 2); - memcpy(data+2, &ntracks, 2); - memcpy(data+4, &division, 2); + if (_smf == NULL) { + return -1; + } - //_fd = freopen(path().c_str(), "r+", _fd); - //assert(_fd); - fseek(_fd, 0, SEEK_SET); - write_chunk("MThd", 6, data); - write_chunk_header("MTrk", _track_size); + if (smf_set_ppqn(_smf, ppqn) != 0) { + return -1; + } - fflush(_fd); + for (int i = 0; i < track; ++i) { + _smf_track = smf_track_new(); + assert(_smf_track); + smf_add_track(_smf, _smf_track); + } - return 0; -} + _smf_track = smf_get_track_by_number(_smf, track); + if (!_smf_track) + return -2; -int -SMF::flush_footer() -{ - //cerr << path() << " SMF Flushing footer\n"; - seek_to_footer_position(); - write_footer(); - seek_to_footer_position(); + _smf_track->next_event_number = 0; + + { + /* put a stub file on disk */ + + PBD::StdioFileDescriptor d (_file_path, "w+"); + FILE* f = d.allocate (); + if (f == 0) { + return -1; + } + + if (smf_save (_smf, f)) { + return -1; + } + } + + _empty = true; return 0; } void -SMF::write_footer() +SMF::close() THROW_FILE_ERROR { - write_var_len(0); - char eot[3] = { 0xFF, 0x2F, 0x00 }; // end-of-track meta-event - fwrite(eot, 1, 3, _fd); - fflush(_fd); + if (_smf) { + smf_delete(_smf); + _smf = 0; + _smf_track = 0; + } } -/** Returns the offset of the first event in the file with a time past @a start, - * relative to the start of the source. - * - * Returns -1 if not found. - */ -/* -long -SMF::find_first_event_after(nframes_t start) +void +SMF::seek_to_start() const { - // FIXME: obviously this is slooow - - fseek(_fd, _header_size, 0); - - while ( ! feof(_fd) ) { - const uint32_t delta_time = read_var_len(); - - if (delta_time > start) - return delta_time; - } - - return -1; + _smf_track->next_event_number = 1; } -*/ /** Read an event from the current position in file. * @@ -212,151 +190,190 @@ SMF::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. + * \a buf must be a pointer to a buffer allocated with malloc, or a pointer to NULL. + * \a size must be the capacity of \a buf. If it is not large enough, \a buf will + * be reallocated and *size will be set to the new size of buf. * - * 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). + * if the event is a meta-event and is an Evoral Note ID, then \a note_id will be set + * to the value of the NoteID; otherwise, meta-events will set \a note_id to -1. + * + * \return event length (including status byte) on success, 0 if event was + * a meta event, or -1 on EOF (or end of track). */ int -SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf) const +SMF::read_event(uint32_t* delta_t, uint32_t* size, uint8_t** buf, event_id_t* note_id) const { - if (feof(_fd)) { - return -1; - } + smf_event_t* event; assert(delta_t); assert(size); assert(buf); + assert(note_id); - try { - *delta_t = SMFReader::read_var_len(_fd); - } catch (...) { - return -1; // Premature EOF - } - - if (feof(_fd)) { - return -1; // Premature EOF - } + if ((event = smf_track_get_next_event(_smf_track)) != NULL) { - const int status = fgetc(_fd); + *delta_t = event->delta_time_pulses; - if (status == EOF) { - return -1; // Premature EOF - } + if (smf_event_is_metadata(event)) { + *note_id = -1; // "no note id in this meta-event */ - //printf("Status @ %X = %X\n", (unsigned)ftell(_fd) - 1, status); + if (event->midi_buffer[1] == 0x7f) { // Sequencer-specific - if (status == 0xFF) { - if (feof(_fd)) { - return -1; // Premature EOF + uint32_t evsize; + uint32_t lenlen; + + if (smf_extract_vlq (&event->midi_buffer[2], event->midi_buffer_length-2, &evsize, &lenlen) == 0) { + + if (event->midi_buffer[2+lenlen] == 0x99 && // Evoral + event->midi_buffer[3+lenlen] == 0x1) { // Evoral Note ID + + uint32_t id; + uint32_t idlen; + + if (smf_extract_vlq (&event->midi_buffer[4+lenlen], event->midi_buffer_length-(4+lenlen), &id, &idlen) == 0) { + *note_id = id; + } + } + } + } + return 0; /* this is a meta-event */ } - const int type = fgetc(_fd); - if ((unsigned char)type == 0x2F) { - return -1; // hit end of track - } else { - *size = 0; - return 0; + + int event_size = event->midi_buffer_length; + assert(event_size > 0); + + // Make sure we have enough scratch buffer + if (*size < (unsigned)event_size) { + *buf = (uint8_t*)realloc(*buf, event_size); } + memcpy(*buf, event->midi_buffer, size_t(event_size)); + *size = event_size; + + assert(midi_event_is_valid(*buf, *size)); + + /* printf("SMF::read_event @ %u: ", *delta_t); + for (size_t i = 0; i < *size; ++i) { + printf("%X ", (*buf)[i]); + } printf("\n") */ + + return event_size; + } else { + return -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 (*size < (unsigned)event_size) - *buf = (uint8_t*)realloc(*buf, event_size); - - *size = event_size; - - (*buf)[0] = (unsigned char)status; - if (event_size > 1) - fread((*buf) + 1, 1, *size - 1, _fd); - - /*printf("SMF %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 (int)*size; } void -SMF::append_event_unlocked(uint32_t delta_t, const Evoral::Event& ev) +SMF::append_event_delta(uint32_t delta_t, uint32_t size, const uint8_t* buf, event_id_t note_id) { - if (ev.size() == 0) + if (size == 0) { + return; + } + + /* printf("SMF::append_event_delta @ %u:", delta_t); + for (size_t i = 0; i < size; ++i) { + printf("%X ", buf[i]); + } printf("\n"); */ + + if (!midi_event_is_valid(buf, size)) { + cerr << "WARNING: SMF ignoring illegal MIDI event" << endl; return; + } - const size_t stamp_size = write_var_len(delta_t); - fwrite(ev.buffer(), 1, ev.size(), _fd); + smf_event_t* event; - _track_size += stamp_size + ev.size(); - _last_ev_time = ev.time(); + /* XXX july 2010: currently only store event ID's for notes, program changes and bank changes + */ - if (ev.size() > 0) - _empty = false; -} + uint8_t const c = buf[0] & 0xf0; + bool const store_id = ( + c == MIDI_CMD_NOTE_ON || + c == MIDI_CMD_NOTE_OFF || + c == MIDI_CMD_PGM_CHANGE || + (c == MIDI_CMD_CONTROL && (buf[1] == MIDI_CTL_MSB_BANK || buf[1] == MIDI_CTL_LSB_BANK)) + ); -void -SMF::begin_write(nframes_t start_frame) -{ - _last_ev_time = 0; - fseek(_fd, _header_size, SEEK_SET); -} + if (store_id && note_id >= 0) { + int idlen; + int lenlen; + uint8_t idbuf[16]; + uint8_t lenbuf[16]; -void -SMF::end_write() -{ - flush_header(); - flush_footer(); + event = smf_event_new (); + assert(event != NULL); + + /* generate VLQ representation of note ID */ + idlen = smf_format_vlq (idbuf, sizeof(idbuf), note_id); + + /* generate VLQ representation of meta event length, + which is the idlen + 2 bytes (Evoral type ID plus Note ID type) + */ + + lenlen = smf_format_vlq (lenbuf, sizeof(lenbuf), idlen+2); + + event->midi_buffer_length = 2 + lenlen + 2 + idlen; + /* this should be allocated by malloc(3) because libsmf will + call free(3) on it + */ + event->midi_buffer = (uint8_t*) malloc (sizeof (uint8_t*) * event->midi_buffer_length); + + event->midi_buffer[0] = 0xff; // Meta-event + event->midi_buffer[1] = 0x7f; // Sequencer-specific + memcpy (&event->midi_buffer[2], lenbuf, lenlen); + event->midi_buffer[2+lenlen] = 0x99; // Evoral type ID + event->midi_buffer[3+lenlen] = 0x1; // Evoral type Note ID + memcpy (&event->midi_buffer[4+lenlen], idbuf, idlen); + + assert(_smf_track); + smf_track_add_event_delta_pulses(_smf_track, event, 0); + } + + event = smf_event_new_from_pointer(buf, size); + assert(event != NULL); + + assert(_smf_track); + smf_track_add_event_delta_pulses(_smf_track, event, delta_t); + _empty = false; } void -SMF::write_chunk_header(const char id[4], uint32_t length) +SMF::begin_write() { - const uint32_t length_be = GUINT32_TO_BE(length); + assert(_smf_track); + smf_track_delete(_smf_track); - fwrite(id, 1, 4, _fd); - fwrite(&length_be, 4, 1, _fd); + _smf_track = smf_track_new(); + assert(_smf_track); + + smf_add_track(_smf, _smf_track); + assert(_smf->number_of_tracks == 1); } void -SMF::write_chunk(const char id[4], uint32_t length, void* data) +SMF::end_write() THROW_FILE_ERROR { - write_chunk_header(id, length); - - fwrite(data, 1, length, _fd); + PBD::StdioFileDescriptor d (_file_path, "w+"); + FILE* f = d.allocate (); + if (f == 0) { + throw FileError (_file_path); + } + + if (smf_save(_smf, f) != 0) { + throw FileError (_file_path); + } } -/** Returns the size (in bytes) of the value written. */ -size_t -SMF::write_var_len(uint32_t value) +double +SMF::round_to_file_precision (double val) const { - size_t ret = 0; + double div = ppqn(); - uint32_t buffer = value & 0x7F; - - while ( (value >>= 7) ) { - buffer <<= 8; - buffer |= ((value & 0x7F) | 0x80); - } - - while (true) { - //printf("Writing var len byte %X\n", (unsigned char)buffer); - ++ret; - fputc(buffer, _fd); - if (buffer & 0x80) - buffer >>= 8; - else - break; - } + return round (val * div) / div; +} - return ret; +void +SMF::set_path (const std::string& p) +{ + _file_path = p; } } // namespace Evoral