clang-format changes
This commit is contained in:
parent
61af76a10d
commit
b624f32f94
502 changed files with 32259 additions and 39062 deletions
28
tmk_core/protocol/midi/Config/LUFAConfig.h
Executable file → Normal file
28
tmk_core/protocol/midi/Config/LUFAConfig.h
Executable file → Normal file
|
@ -42,12 +42,12 @@
|
|||
#ifndef _LUFA_CONFIG_H_
|
||||
#define _LUFA_CONFIG_H_
|
||||
|
||||
#if (ARCH == ARCH_AVR8)
|
||||
#if (ARCH == ARCH_AVR8)
|
||||
|
||||
/* Non-USB Related Configuration Tokens: */
|
||||
/* Non-USB Related Configuration Tokens: */
|
||||
// #define DISABLE_TERMINAL_CODES
|
||||
|
||||
/* USB Class Driver Related Tokens: */
|
||||
/* USB Class Driver Related Tokens: */
|
||||
// #define HID_HOST_BOOT_PROTOCOL_ONLY
|
||||
// #define HID_STATETABLE_STACK_DEPTH {Insert Value Here}
|
||||
// #define HID_USAGE_STACK_DEPTH {Insert Value Here}
|
||||
|
@ -56,38 +56,38 @@
|
|||
// #define HID_MAX_REPORT_IDS {Insert Value Here}
|
||||
// #define NO_CLASS_DRIVER_AUTOFLUSH
|
||||
|
||||
/* General USB Driver Related Tokens: */
|
||||
/* General USB Driver Related Tokens: */
|
||||
// #define ORDERED_EP_CONFIG
|
||||
#define USE_STATIC_OPTIONS (USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)
|
||||
#define USB_DEVICE_ONLY
|
||||
# define USE_STATIC_OPTIONS (USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)
|
||||
# define USB_DEVICE_ONLY
|
||||
// #define USB_HOST_ONLY
|
||||
// #define USB_STREAM_TIMEOUT_MS {Insert Value Here}
|
||||
// #define NO_LIMITED_CONTROLLER_CONNECT
|
||||
// #define NO_SOF_EVENTS
|
||||
|
||||
/* USB Device Mode Driver Related Tokens: */
|
||||
/* USB Device Mode Driver Related Tokens: */
|
||||
// #define USE_RAM_DESCRIPTORS
|
||||
#define USE_FLASH_DESCRIPTORS
|
||||
# define USE_FLASH_DESCRIPTORS
|
||||
// #define USE_EEPROM_DESCRIPTORS
|
||||
// #define NO_INTERNAL_SERIAL
|
||||
#define FIXED_CONTROL_ENDPOINT_SIZE 8
|
||||
# define FIXED_CONTROL_ENDPOINT_SIZE 8
|
||||
// #define DEVICE_STATE_AS_GPIOR {Insert Value Here}
|
||||
#define FIXED_NUM_CONFIGURATIONS 1
|
||||
# define FIXED_NUM_CONFIGURATIONS 1
|
||||
// #define CONTROL_ONLY_DEVICE
|
||||
// #define INTERRUPT_CONTROL_ENDPOINT
|
||||
// #define NO_DEVICE_REMOTE_WAKEUP
|
||||
// #define NO_DEVICE_SELF_POWER
|
||||
|
||||
/* USB Host Mode Driver Related Tokens: */
|
||||
/* USB Host Mode Driver Related Tokens: */
|
||||
// #define HOST_STATE_AS_GPIOR {Insert Value Here}
|
||||
// #define USB_HOST_TIMEOUT_MS {Insert Value Here}
|
||||
// #define HOST_DEVICE_SETTLE_DELAY_MS {Insert Value Here}
|
||||
// #define NO_AUTO_VBUS_MANAGEMENT
|
||||
// #define INVERTED_VBUS_ENABLE_LINE
|
||||
|
||||
#else
|
||||
#else
|
||||
|
||||
#error Unsupported architecture for this LUFA configuration file.
|
||||
# error Unsupported architecture for this LUFA configuration file.
|
||||
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
|
93
tmk_core/protocol/midi/bytequeue/bytequeue.c
Executable file → Normal file
93
tmk_core/protocol/midi/bytequeue/bytequeue.c
Executable file → Normal file
|
@ -1,65 +1,62 @@
|
|||
//this is a single reader [maybe multiple writer?] byte queue
|
||||
//Copyright 2008 Alex Norman
|
||||
//writen by Alex Norman
|
||||
// this is a single reader [maybe multiple writer?] byte queue
|
||||
// Copyright 2008 Alex Norman
|
||||
// writen by Alex Norman
|
||||
//
|
||||
//This file is part of avr-bytequeue.
|
||||
// This file is part of avr-bytequeue.
|
||||
//
|
||||
//avr-bytequeue 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 3 of the License, or
|
||||
// avr-bytequeue 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-bytequeue 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 more details.
|
||||
// avr-bytequeue 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include "bytequeue.h"
|
||||
#include "interrupt_setting.h"
|
||||
|
||||
void bytequeue_init(byteQueue_t * queue, uint8_t * dataArray, byteQueueIndex_t arrayLen){
|
||||
queue->length = arrayLen;
|
||||
queue->data = dataArray;
|
||||
queue->start = queue->end = 0;
|
||||
void bytequeue_init(byteQueue_t* queue, uint8_t* dataArray, byteQueueIndex_t arrayLen) {
|
||||
queue->length = arrayLen;
|
||||
queue->data = dataArray;
|
||||
queue->start = queue->end = 0;
|
||||
}
|
||||
|
||||
bool bytequeue_enqueue(byteQueue_t * queue, uint8_t item){
|
||||
interrupt_setting_t setting = store_and_clear_interrupt();
|
||||
//full
|
||||
if(((queue->end + 1) % queue->length) == queue->start){
|
||||
restore_interrupt_setting(setting);
|
||||
return false;
|
||||
} else {
|
||||
queue->data[queue->end] = item;
|
||||
queue->end = (queue->end + 1) % queue->length;
|
||||
restore_interrupt_setting(setting);
|
||||
return true;
|
||||
}
|
||||
bool bytequeue_enqueue(byteQueue_t* queue, uint8_t item) {
|
||||
interrupt_setting_t setting = store_and_clear_interrupt();
|
||||
// full
|
||||
if (((queue->end + 1) % queue->length) == queue->start) {
|
||||
restore_interrupt_setting(setting);
|
||||
return false;
|
||||
} else {
|
||||
queue->data[queue->end] = item;
|
||||
queue->end = (queue->end + 1) % queue->length;
|
||||
restore_interrupt_setting(setting);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
byteQueueIndex_t bytequeue_length(byteQueue_t * queue){
|
||||
byteQueueIndex_t len;
|
||||
interrupt_setting_t setting = store_and_clear_interrupt();
|
||||
if(queue->end >= queue->start)
|
||||
len = queue->end - queue->start;
|
||||
else
|
||||
len = (queue->length - queue->start) + queue->end;
|
||||
restore_interrupt_setting(setting);
|
||||
return len;
|
||||
byteQueueIndex_t bytequeue_length(byteQueue_t* queue) {
|
||||
byteQueueIndex_t len;
|
||||
interrupt_setting_t setting = store_and_clear_interrupt();
|
||||
if (queue->end >= queue->start)
|
||||
len = queue->end - queue->start;
|
||||
else
|
||||
len = (queue->length - queue->start) + queue->end;
|
||||
restore_interrupt_setting(setting);
|
||||
return len;
|
||||
}
|
||||
|
||||
//we don't need to avoid interrupts if there is only one reader
|
||||
uint8_t bytequeue_get(byteQueue_t * queue, byteQueueIndex_t index){
|
||||
return queue->data[(queue->start + index) % queue->length];
|
||||
}
|
||||
// we don't need to avoid interrupts if there is only one reader
|
||||
uint8_t bytequeue_get(byteQueue_t* queue, byteQueueIndex_t index) { return queue->data[(queue->start + index) % queue->length]; }
|
||||
|
||||
//we just update the start index to remove elements
|
||||
void bytequeue_remove(byteQueue_t * queue, byteQueueIndex_t numToRemove){
|
||||
interrupt_setting_t setting = store_and_clear_interrupt();
|
||||
queue->start = (queue->start + numToRemove) % queue->length;
|
||||
restore_interrupt_setting(setting);
|
||||
// we just update the start index to remove elements
|
||||
void bytequeue_remove(byteQueue_t* queue, byteQueueIndex_t numToRemove) {
|
||||
interrupt_setting_t setting = store_and_clear_interrupt();
|
||||
queue->start = (queue->start + numToRemove) % queue->length;
|
||||
restore_interrupt_setting(setting);
|
||||
}
|
||||
|
||||
|
|
59
tmk_core/protocol/midi/bytequeue/bytequeue.h
Executable file → Normal file
59
tmk_core/protocol/midi/bytequeue/bytequeue.h
Executable file → Normal file
|
@ -1,28 +1,28 @@
|
|||
//this is a single reader [maybe multiple writer?] byte queue
|
||||
//Copyright 2008 Alex Norman
|
||||
//writen by Alex Norman
|
||||
// this is a single reader [maybe multiple writer?] byte queue
|
||||
// Copyright 2008 Alex Norman
|
||||
// writen by Alex Norman
|
||||
//
|
||||
//This file is part of avr-bytequeue.
|
||||
// This file is part of avr-bytequeue.
|
||||
//
|
||||
//avr-bytequeue 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 3 of the License, or
|
||||
// avr-bytequeue 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-bytequeue 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 more details.
|
||||
// avr-bytequeue 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef BYTEQUEUE_H
|
||||
#define BYTEQUEUE_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdbool.h>
|
||||
|
@ -30,30 +30,29 @@ extern "C" {
|
|||
typedef uint8_t byteQueueIndex_t;
|
||||
|
||||
typedef struct {
|
||||
byteQueueIndex_t start;
|
||||
byteQueueIndex_t end;
|
||||
byteQueueIndex_t length;
|
||||
uint8_t * data;
|
||||
byteQueueIndex_t start;
|
||||
byteQueueIndex_t end;
|
||||
byteQueueIndex_t length;
|
||||
uint8_t* data;
|
||||
} byteQueue_t;
|
||||
|
||||
//you must have a queue, an array of data which the queue will use, and the length of that array
|
||||
void bytequeue_init(byteQueue_t * queue, uint8_t * dataArray, byteQueueIndex_t arrayLen);
|
||||
// you must have a queue, an array of data which the queue will use, and the length of that array
|
||||
void bytequeue_init(byteQueue_t* queue, uint8_t* dataArray, byteQueueIndex_t arrayLen);
|
||||
|
||||
//add an item to the queue, returns false if the queue is full
|
||||
bool bytequeue_enqueue(byteQueue_t * queue, uint8_t item);
|
||||
// add an item to the queue, returns false if the queue is full
|
||||
bool bytequeue_enqueue(byteQueue_t* queue, uint8_t item);
|
||||
|
||||
//get the length of the queue
|
||||
byteQueueIndex_t bytequeue_length(byteQueue_t * queue);
|
||||
// get the length of the queue
|
||||
byteQueueIndex_t bytequeue_length(byteQueue_t* queue);
|
||||
|
||||
//this grabs data at the index given [starting at queue->start]
|
||||
uint8_t bytequeue_get(byteQueue_t * queue, byteQueueIndex_t index);
|
||||
// this grabs data at the index given [starting at queue->start]
|
||||
uint8_t bytequeue_get(byteQueue_t* queue, byteQueueIndex_t index);
|
||||
|
||||
//update the index in the queue to reflect data that has been dealt with
|
||||
void bytequeue_remove(byteQueue_t * queue, byteQueueIndex_t numToRemove);
|
||||
// update the index in the queue to reflect data that has been dealt with
|
||||
void bytequeue_remove(byteQueue_t* queue, byteQueueIndex_t numToRemove);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
54
tmk_core/protocol/midi/bytequeue/interrupt_setting.c
Executable file → Normal file
54
tmk_core/protocol/midi/bytequeue/interrupt_setting.c
Executable file → Normal file
|
@ -1,49 +1,43 @@
|
|||
//Copyright 20010 Alex Norman
|
||||
//writen by Alex Norman
|
||||
// Copyright 20010 Alex Norman
|
||||
// writen by Alex Norman
|
||||
//
|
||||
//This file is part of avr-bytequeue.
|
||||
// This file is part of avr-bytequeue.
|
||||
//
|
||||
//avr-bytequeue 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 3 of the License, or
|
||||
// avr-bytequeue 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-bytequeue 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 more details.
|
||||
// avr-bytequeue 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
|
||||
//AVR specific code
|
||||
//should be able to port to other systems by simply providing chip specific
|
||||
//implementations of the typedef and these functions
|
||||
// AVR specific code
|
||||
// should be able to port to other systems by simply providing chip specific
|
||||
// implementations of the typedef and these functions
|
||||
|
||||
#include "interrupt_setting.h"
|
||||
#if defined(__AVR__)
|
||||
#include <avr/interrupt.h>
|
||||
# include <avr/interrupt.h>
|
||||
|
||||
interrupt_setting_t store_and_clear_interrupt(void) {
|
||||
uint8_t sreg = SREG;
|
||||
cli();
|
||||
return sreg;
|
||||
uint8_t sreg = SREG;
|
||||
cli();
|
||||
return sreg;
|
||||
}
|
||||
|
||||
void restore_interrupt_setting(interrupt_setting_t setting) {
|
||||
SREG = setting;
|
||||
}
|
||||
void restore_interrupt_setting(interrupt_setting_t setting) { SREG = setting; }
|
||||
#elif defined(__arm__)
|
||||
#include "ch.h"
|
||||
# include "ch.h"
|
||||
|
||||
interrupt_setting_t store_and_clear_interrupt(void) {
|
||||
chSysLock();
|
||||
return 0;
|
||||
chSysLock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void restore_interrupt_setting(interrupt_setting_t setting) {
|
||||
chSysUnlock();
|
||||
}
|
||||
void restore_interrupt_setting(interrupt_setting_t setting) { chSysUnlock(); }
|
||||
#endif
|
||||
|
||||
|
|
33
tmk_core/protocol/midi/bytequeue/interrupt_setting.h
Executable file → Normal file
33
tmk_core/protocol/midi/bytequeue/interrupt_setting.h
Executable file → Normal file
|
@ -1,39 +1,38 @@
|
|||
//Copyright 20010 Alex Norman
|
||||
//writen by Alex Norman
|
||||
// Copyright 20010 Alex Norman
|
||||
// writen by Alex Norman
|
||||
//
|
||||
//This file is part of avr-bytequeue.
|
||||
// This file is part of avr-bytequeue.
|
||||
//
|
||||
//avr-bytequeue 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 3 of the License, or
|
||||
// avr-bytequeue 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-bytequeue 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 more details.
|
||||
// avr-bytequeue 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-bytequeue. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef INTERRUPT_SETTING_H
|
||||
#define INTERRUPT_SETTING_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
//AVR specific typedef
|
||||
// AVR specific typedef
|
||||
typedef uint8_t interrupt_setting_t;
|
||||
|
||||
interrupt_setting_t store_and_clear_interrupt(void);
|
||||
void restore_interrupt_setting(interrupt_setting_t setting);
|
||||
void restore_interrupt_setting(interrupt_setting_t setting);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
378
tmk_core/protocol/midi/midi.c
Executable file → Normal file
378
tmk_core/protocol/midi/midi.c
Executable file → Normal file
|
@ -1,277 +1,181 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include "midi.h"
|
||||
#include <string.h> //for memcpy
|
||||
#include <string.h> //for memcpy
|
||||
|
||||
#define MIN(x,y) (((x) < (y)) ? (x) : (y))
|
||||
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL 0
|
||||
# define NULL 0
|
||||
#endif
|
||||
|
||||
bool midi_is_statusbyte(uint8_t theByte){
|
||||
return (bool)(theByte & MIDI_STATUSMASK);
|
||||
bool midi_is_statusbyte(uint8_t theByte) { return (bool)(theByte & MIDI_STATUSMASK); }
|
||||
|
||||
bool midi_is_realtime(uint8_t theByte) { return (theByte >= MIDI_CLOCK); }
|
||||
|
||||
midi_packet_length_t midi_packet_length(uint8_t status) {
|
||||
switch (status & 0xF0) {
|
||||
case MIDI_CC:
|
||||
case MIDI_NOTEON:
|
||||
case MIDI_NOTEOFF:
|
||||
case MIDI_AFTERTOUCH:
|
||||
case MIDI_PITCHBEND:
|
||||
return THREE;
|
||||
case MIDI_PROGCHANGE:
|
||||
case MIDI_CHANPRESSURE:
|
||||
case MIDI_SONGSELECT:
|
||||
return TWO;
|
||||
case 0xF0:
|
||||
switch (status) {
|
||||
case MIDI_CLOCK:
|
||||
case MIDI_TICK:
|
||||
case MIDI_START:
|
||||
case MIDI_CONTINUE:
|
||||
case MIDI_STOP:
|
||||
case MIDI_ACTIVESENSE:
|
||||
case MIDI_RESET:
|
||||
case MIDI_TUNEREQUEST:
|
||||
return ONE;
|
||||
case MIDI_SONGPOSITION:
|
||||
return THREE;
|
||||
case MIDI_TC_QUARTERFRAME:
|
||||
case MIDI_SONGSELECT:
|
||||
return TWO;
|
||||
case SYSEX_END:
|
||||
case SYSEX_BEGIN:
|
||||
default:
|
||||
return UNDEFINED;
|
||||
}
|
||||
default:
|
||||
return UNDEFINED;
|
||||
}
|
||||
}
|
||||
|
||||
bool midi_is_realtime(uint8_t theByte){
|
||||
return (theByte >= MIDI_CLOCK);
|
||||
void midi_send_cc(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t val) {
|
||||
// CC Status: 0xB0 to 0xBF where the low nibble is the MIDI channel.
|
||||
// CC Data: Controller Num, Controller Val
|
||||
device->send_func(device, 3, MIDI_CC | (chan & MIDI_CHANMASK), num & 0x7F, val & 0x7F);
|
||||
}
|
||||
|
||||
midi_packet_length_t midi_packet_length(uint8_t status){
|
||||
switch(status & 0xF0){
|
||||
case MIDI_CC:
|
||||
case MIDI_NOTEON:
|
||||
case MIDI_NOTEOFF:
|
||||
case MIDI_AFTERTOUCH:
|
||||
case MIDI_PITCHBEND:
|
||||
return THREE;
|
||||
case MIDI_PROGCHANGE:
|
||||
case MIDI_CHANPRESSURE:
|
||||
case MIDI_SONGSELECT:
|
||||
return TWO;
|
||||
case 0xF0:
|
||||
switch(status) {
|
||||
case MIDI_CLOCK:
|
||||
case MIDI_TICK:
|
||||
case MIDI_START:
|
||||
case MIDI_CONTINUE:
|
||||
case MIDI_STOP:
|
||||
case MIDI_ACTIVESENSE:
|
||||
case MIDI_RESET:
|
||||
case MIDI_TUNEREQUEST:
|
||||
return ONE;
|
||||
case MIDI_SONGPOSITION:
|
||||
return THREE;
|
||||
case MIDI_TC_QUARTERFRAME:
|
||||
case MIDI_SONGSELECT:
|
||||
return TWO;
|
||||
case SYSEX_END:
|
||||
case SYSEX_BEGIN:
|
||||
default:
|
||||
return UNDEFINED;
|
||||
}
|
||||
default:
|
||||
return UNDEFINED;
|
||||
}
|
||||
void midi_send_noteon(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t vel) {
|
||||
// Note Data: Note Num, Note Velocity
|
||||
device->send_func(device, 3, MIDI_NOTEON | (chan & MIDI_CHANMASK), num & 0x7F, vel & 0x7F);
|
||||
}
|
||||
|
||||
void midi_send_cc(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t val){
|
||||
//CC Status: 0xB0 to 0xBF where the low nibble is the MIDI channel.
|
||||
//CC Data: Controller Num, Controller Val
|
||||
device->send_func(device, 3,
|
||||
MIDI_CC | (chan & MIDI_CHANMASK),
|
||||
num & 0x7F,
|
||||
val & 0x7F);
|
||||
void midi_send_noteoff(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t vel) {
|
||||
// Note Data: Note Num, Note Velocity
|
||||
device->send_func(device, 3, MIDI_NOTEOFF | (chan & MIDI_CHANMASK), num & 0x7F, vel & 0x7F);
|
||||
}
|
||||
|
||||
void midi_send_noteon(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel){
|
||||
//Note Data: Note Num, Note Velocity
|
||||
device->send_func(device, 3,
|
||||
MIDI_NOTEON | (chan & MIDI_CHANMASK),
|
||||
num & 0x7F,
|
||||
vel & 0x7F);
|
||||
void midi_send_aftertouch(MidiDevice* device, uint8_t chan, uint8_t note_num, uint8_t amt) { device->send_func(device, 3, MIDI_AFTERTOUCH | (chan & MIDI_CHANMASK), note_num & 0x7F, amt & 0x7F); }
|
||||
|
||||
// XXX does this work right?
|
||||
// amt in range -0x2000, 0x1fff
|
||||
// uAmt should be in range..
|
||||
// 0x0000 to 0x3FFF
|
||||
void midi_send_pitchbend(MidiDevice* device, uint8_t chan, int16_t amt) {
|
||||
uint16_t uAmt;
|
||||
// check range
|
||||
if (amt > 0x1fff) {
|
||||
uAmt = 0x3FFF;
|
||||
} else if (amt < -0x2000) {
|
||||
uAmt = 0;
|
||||
} else {
|
||||
uAmt = amt + 0x2000;
|
||||
}
|
||||
device->send_func(device, 3, MIDI_PITCHBEND | (chan & MIDI_CHANMASK), uAmt & 0x7F, (uAmt >> 7) & 0x7F);
|
||||
}
|
||||
|
||||
void midi_send_noteoff(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel){
|
||||
//Note Data: Note Num, Note Velocity
|
||||
device->send_func(device, 3,
|
||||
MIDI_NOTEOFF | (chan & MIDI_CHANMASK),
|
||||
num & 0x7F,
|
||||
vel & 0x7F);
|
||||
void midi_send_programchange(MidiDevice* device, uint8_t chan, uint8_t num) { device->send_func(device, 2, MIDI_PROGCHANGE | (chan & MIDI_CHANMASK), num & 0x7F, 0); }
|
||||
|
||||
void midi_send_channelpressure(MidiDevice* device, uint8_t chan, uint8_t amt) { device->send_func(device, 2, MIDI_CHANPRESSURE | (chan & MIDI_CHANMASK), amt & 0x7F, 0); }
|
||||
|
||||
void midi_send_clock(MidiDevice* device) { device->send_func(device, 1, MIDI_CLOCK, 0, 0); }
|
||||
|
||||
void midi_send_tick(MidiDevice* device) { device->send_func(device, 1, MIDI_TICK, 0, 0); }
|
||||
|
||||
void midi_send_start(MidiDevice* device) { device->send_func(device, 1, MIDI_START, 0, 0); }
|
||||
|
||||
void midi_send_continue(MidiDevice* device) { device->send_func(device, 1, MIDI_CONTINUE, 0, 0); }
|
||||
|
||||
void midi_send_stop(MidiDevice* device) { device->send_func(device, 1, MIDI_STOP, 0, 0); }
|
||||
|
||||
void midi_send_activesense(MidiDevice* device) { device->send_func(device, 1, MIDI_ACTIVESENSE, 0, 0); }
|
||||
|
||||
void midi_send_reset(MidiDevice* device) { device->send_func(device, 1, MIDI_RESET, 0, 0); }
|
||||
|
||||
void midi_send_tcquarterframe(MidiDevice* device, uint8_t time) { device->send_func(device, 2, MIDI_TC_QUARTERFRAME, time & 0x7F, 0); }
|
||||
|
||||
// XXX is this right?
|
||||
void midi_send_songposition(MidiDevice* device, uint16_t pos) { device->send_func(device, 3, MIDI_SONGPOSITION, pos & 0x7F, (pos >> 7) & 0x7F); }
|
||||
|
||||
void midi_send_songselect(MidiDevice* device, uint8_t song) { device->send_func(device, 2, MIDI_SONGSELECT, song & 0x7F, 0); }
|
||||
|
||||
void midi_send_tunerequest(MidiDevice* device) { device->send_func(device, 1, MIDI_TUNEREQUEST, 0, 0); }
|
||||
|
||||
void midi_send_byte(MidiDevice* device, uint8_t b) { device->send_func(device, 1, b, 0, 0); }
|
||||
|
||||
void midi_send_data(MidiDevice* device, uint16_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
|
||||
// ensure that the count passed along is always 3 or lower
|
||||
if (count > 3) {
|
||||
// TODO how to do this correctly?
|
||||
}
|
||||
device->send_func(device, count, byte0, byte1, byte2);
|
||||
}
|
||||
|
||||
void midi_send_aftertouch(MidiDevice * device, uint8_t chan, uint8_t note_num, uint8_t amt){
|
||||
device->send_func(device, 3,
|
||||
MIDI_AFTERTOUCH | (chan & MIDI_CHANMASK),
|
||||
note_num & 0x7F,
|
||||
amt & 0x7F);
|
||||
void midi_send_array(MidiDevice* device, uint16_t count, uint8_t* array) {
|
||||
uint16_t i;
|
||||
for (i = 0; i < count; i += 3) {
|
||||
uint8_t b[3] = {0, 0, 0};
|
||||
uint16_t to_send = count - i;
|
||||
to_send = (to_send > 3) ? 3 : to_send;
|
||||
memcpy(b, array + i, to_send);
|
||||
midi_send_data(device, to_send, b[0], b[1], b[2]);
|
||||
}
|
||||
}
|
||||
|
||||
//XXX does this work right?
|
||||
//amt in range -0x2000, 0x1fff
|
||||
//uAmt should be in range..
|
||||
//0x0000 to 0x3FFF
|
||||
void midi_send_pitchbend(MidiDevice * device, uint8_t chan, int16_t amt){
|
||||
uint16_t uAmt;
|
||||
//check range
|
||||
if(amt > 0x1fff){
|
||||
uAmt = 0x3FFF;
|
||||
} else if(amt < -0x2000){
|
||||
uAmt = 0;
|
||||
} else {
|
||||
uAmt = amt + 0x2000;
|
||||
}
|
||||
device->send_func(device, 3,
|
||||
MIDI_PITCHBEND | (chan & MIDI_CHANMASK),
|
||||
uAmt & 0x7F,
|
||||
(uAmt >> 7) & 0x7F);
|
||||
}
|
||||
void midi_register_cc_callback(MidiDevice* device, midi_three_byte_func_t func) { device->input_cc_callback = func; }
|
||||
|
||||
void midi_send_programchange(MidiDevice * device, uint8_t chan, uint8_t num){
|
||||
device->send_func(device, 2,
|
||||
MIDI_PROGCHANGE | (chan & MIDI_CHANMASK),
|
||||
num & 0x7F,
|
||||
0);
|
||||
}
|
||||
void midi_register_noteon_callback(MidiDevice* device, midi_three_byte_func_t func) { device->input_noteon_callback = func; }
|
||||
|
||||
void midi_send_channelpressure(MidiDevice * device, uint8_t chan, uint8_t amt){
|
||||
device->send_func(device, 2,
|
||||
MIDI_CHANPRESSURE | (chan & MIDI_CHANMASK),
|
||||
amt & 0x7F,
|
||||
0);
|
||||
}
|
||||
void midi_register_noteoff_callback(MidiDevice* device, midi_three_byte_func_t func) { device->input_noteoff_callback = func; }
|
||||
|
||||
void midi_send_clock(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_CLOCK, 0, 0);
|
||||
}
|
||||
void midi_register_aftertouch_callback(MidiDevice* device, midi_three_byte_func_t func) { device->input_aftertouch_callback = func; }
|
||||
|
||||
void midi_send_tick(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_TICK, 0, 0);
|
||||
}
|
||||
void midi_register_pitchbend_callback(MidiDevice* device, midi_three_byte_func_t func) { device->input_pitchbend_callback = func; }
|
||||
|
||||
void midi_send_start(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_START, 0, 0);
|
||||
}
|
||||
void midi_register_songposition_callback(MidiDevice* device, midi_three_byte_func_t func) { device->input_songposition_callback = func; }
|
||||
|
||||
void midi_send_continue(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_CONTINUE, 0, 0);
|
||||
}
|
||||
void midi_register_progchange_callback(MidiDevice* device, midi_two_byte_func_t func) { device->input_progchange_callback = func; }
|
||||
|
||||
void midi_send_stop(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_STOP, 0, 0);
|
||||
}
|
||||
void midi_register_chanpressure_callback(MidiDevice* device, midi_two_byte_func_t func) { device->input_chanpressure_callback = func; }
|
||||
|
||||
void midi_send_activesense(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_ACTIVESENSE, 0, 0);
|
||||
}
|
||||
void midi_register_songselect_callback(MidiDevice* device, midi_two_byte_func_t func) { device->input_songselect_callback = func; }
|
||||
|
||||
void midi_send_reset(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_RESET, 0, 0);
|
||||
}
|
||||
void midi_register_tc_quarterframe_callback(MidiDevice* device, midi_two_byte_func_t func) { device->input_tc_quarterframe_callback = func; }
|
||||
|
||||
void midi_send_tcquarterframe(MidiDevice * device, uint8_t time){
|
||||
device->send_func(device, 2,
|
||||
MIDI_TC_QUARTERFRAME,
|
||||
time & 0x7F,
|
||||
0);
|
||||
}
|
||||
void midi_register_realtime_callback(MidiDevice* device, midi_one_byte_func_t func) { device->input_realtime_callback = func; }
|
||||
|
||||
//XXX is this right?
|
||||
void midi_send_songposition(MidiDevice * device, uint16_t pos){
|
||||
device->send_func(device, 3,
|
||||
MIDI_SONGPOSITION,
|
||||
pos & 0x7F,
|
||||
(pos >> 7) & 0x7F);
|
||||
}
|
||||
void midi_register_tunerequest_callback(MidiDevice* device, midi_one_byte_func_t func) { device->input_tunerequest_callback = func; }
|
||||
|
||||
void midi_send_songselect(MidiDevice * device, uint8_t song){
|
||||
device->send_func(device, 2,
|
||||
MIDI_SONGSELECT,
|
||||
song & 0x7F,
|
||||
0);
|
||||
}
|
||||
void midi_register_sysex_callback(MidiDevice* device, midi_sysex_func_t func) { device->input_sysex_callback = func; }
|
||||
|
||||
void midi_send_tunerequest(MidiDevice * device){
|
||||
device->send_func(device, 1, MIDI_TUNEREQUEST, 0, 0);
|
||||
}
|
||||
|
||||
void midi_send_byte(MidiDevice * device, uint8_t b){
|
||||
device->send_func(device, 1, b, 0, 0);
|
||||
}
|
||||
|
||||
void midi_send_data(MidiDevice * device, uint16_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2){
|
||||
//ensure that the count passed along is always 3 or lower
|
||||
if (count > 3) {
|
||||
//TODO how to do this correctly?
|
||||
}
|
||||
device->send_func(device, count, byte0, byte1, byte2);
|
||||
}
|
||||
|
||||
void midi_send_array(MidiDevice * device, uint16_t count, uint8_t * array) {
|
||||
uint16_t i;
|
||||
for (i = 0; i < count; i += 3) {
|
||||
uint8_t b[3] = { 0, 0, 0 };
|
||||
uint16_t to_send = count - i;
|
||||
to_send = (to_send > 3) ? 3 : to_send;
|
||||
memcpy(b, array + i, to_send);
|
||||
midi_send_data(device, to_send, b[0], b[1], b[2]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void midi_register_cc_callback(MidiDevice * device, midi_three_byte_func_t func){
|
||||
device->input_cc_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_noteon_callback(MidiDevice * device, midi_three_byte_func_t func){
|
||||
device->input_noteon_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_noteoff_callback(MidiDevice * device, midi_three_byte_func_t func){
|
||||
device->input_noteoff_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_aftertouch_callback(MidiDevice * device, midi_three_byte_func_t func){
|
||||
device->input_aftertouch_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_pitchbend_callback(MidiDevice * device, midi_three_byte_func_t func){
|
||||
device->input_pitchbend_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_songposition_callback(MidiDevice * device, midi_three_byte_func_t func){
|
||||
device->input_songposition_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_progchange_callback(MidiDevice * device, midi_two_byte_func_t func) {
|
||||
device->input_progchange_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_chanpressure_callback(MidiDevice * device, midi_two_byte_func_t func) {
|
||||
device->input_chanpressure_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_songselect_callback(MidiDevice * device, midi_two_byte_func_t func) {
|
||||
device->input_songselect_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_tc_quarterframe_callback(MidiDevice * device, midi_two_byte_func_t func) {
|
||||
device->input_tc_quarterframe_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_realtime_callback(MidiDevice * device, midi_one_byte_func_t func){
|
||||
device->input_realtime_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_tunerequest_callback(MidiDevice * device, midi_one_byte_func_t func){
|
||||
device->input_tunerequest_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_sysex_callback(MidiDevice * device, midi_sysex_func_t func) {
|
||||
device->input_sysex_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_fallthrough_callback(MidiDevice * device, midi_var_byte_func_t func){
|
||||
device->input_fallthrough_callback = func;
|
||||
}
|
||||
|
||||
void midi_register_catchall_callback(MidiDevice * device, midi_var_byte_func_t func){
|
||||
device->input_catchall_callback = func;
|
||||
}
|
||||
void midi_register_fallthrough_callback(MidiDevice* device, midi_var_byte_func_t func) { device->input_fallthrough_callback = func; }
|
||||
|
||||
void midi_register_catchall_callback(MidiDevice* device, midi_var_byte_func_t func) { device->input_catchall_callback = func; }
|
||||
|
|
152
tmk_core/protocol/midi/midi.h
Executable file → Normal file
152
tmk_core/protocol/midi/midi.h
Executable file → Normal file
|
@ -1,20 +1,20 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
/**
|
||||
* @file
|
||||
|
@ -30,7 +30,7 @@
|
|||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "midi_device.h"
|
||||
#include "midi_function_types.h"
|
||||
|
@ -48,8 +48,8 @@ extern "C" {
|
|||
* You must call this before using the device in question.
|
||||
*
|
||||
* @param device the device to initialize
|
||||
*/
|
||||
void midi_device_init(MidiDevice * device); // [implementation in midi_device.c]
|
||||
*/
|
||||
void midi_device_init(MidiDevice* device); // [implementation in midi_device.c]
|
||||
|
||||
/**
|
||||
* @brief Process input data
|
||||
|
@ -58,8 +58,8 @@ void midi_device_init(MidiDevice * device); // [implementation in midi_device.c]
|
|||
* if you expect to have your input callbacks called.
|
||||
*
|
||||
* @param device the device to process
|
||||
*/
|
||||
void midi_device_process(MidiDevice * device); // [implementation in midi_device.c]
|
||||
*/
|
||||
void midi_device_process(MidiDevice* device); // [implementation in midi_device.c]
|
||||
|
||||
/**@}*/
|
||||
|
||||
|
@ -76,8 +76,8 @@ void midi_device_process(MidiDevice * device); // [implementation in midi_device
|
|||
* @param chan the channel to send on, 0-15
|
||||
* @param num the cc num
|
||||
* @param val the value of that cc num
|
||||
*/
|
||||
void midi_send_cc(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t val);
|
||||
*/
|
||||
void midi_send_cc(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t val);
|
||||
|
||||
/**
|
||||
* @brief Send a note on message via the given device.
|
||||
|
@ -86,8 +86,8 @@ void midi_send_cc(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t val);
|
|||
* @param chan the channel to send on, 0-15
|
||||
* @param num the note number
|
||||
* @param vel the note velocity
|
||||
*/
|
||||
void midi_send_noteon(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel);
|
||||
*/
|
||||
void midi_send_noteon(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t vel);
|
||||
|
||||
/**
|
||||
* @brief Send a note off message via the given device.
|
||||
|
@ -96,8 +96,8 @@ void midi_send_noteon(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t ve
|
|||
* @param chan the channel to send on, 0-15
|
||||
* @param num the note number
|
||||
* @param vel the note velocity
|
||||
*/
|
||||
void midi_send_noteoff(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t vel);
|
||||
*/
|
||||
void midi_send_noteoff(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t vel);
|
||||
|
||||
/**
|
||||
* @brief Send an after touch message via the given device.
|
||||
|
@ -106,8 +106,8 @@ void midi_send_noteoff(MidiDevice * device, uint8_t chan, uint8_t num, uint8_t v
|
|||
* @param chan the channel to send on, 0-15
|
||||
* @param note_num the note number
|
||||
* @param amt the after touch amount
|
||||
*/
|
||||
void midi_send_aftertouch(MidiDevice * device, uint8_t chan, uint8_t note_num, uint8_t amt);
|
||||
*/
|
||||
void midi_send_aftertouch(MidiDevice* device, uint8_t chan, uint8_t note_num, uint8_t amt);
|
||||
|
||||
/**
|
||||
* @brief Send a pitch bend message via the given device.
|
||||
|
@ -115,8 +115,8 @@ void midi_send_aftertouch(MidiDevice * device, uint8_t chan, uint8_t note_num, u
|
|||
* @param device the device to use for sending
|
||||
* @param chan the channel to send on, 0-15
|
||||
* @param amt the bend amount range: -8192..8191, 0 means no bend
|
||||
*/
|
||||
void midi_send_pitchbend(MidiDevice * device, uint8_t chan, int16_t amt); //range -8192, 8191
|
||||
*/
|
||||
void midi_send_pitchbend(MidiDevice* device, uint8_t chan, int16_t amt); // range -8192, 8191
|
||||
|
||||
/**
|
||||
* @brief Send a program change message via the given device.
|
||||
|
@ -124,8 +124,8 @@ void midi_send_pitchbend(MidiDevice * device, uint8_t chan, int16_t amt); //rang
|
|||
* @param device the device to use for sending
|
||||
* @param chan the channel to send on, 0-15
|
||||
* @param num the program to change to
|
||||
*/
|
||||
void midi_send_programchange(MidiDevice * device, uint8_t chan, uint8_t num);
|
||||
*/
|
||||
void midi_send_programchange(MidiDevice* device, uint8_t chan, uint8_t num);
|
||||
|
||||
/**
|
||||
* @brief Send a channel pressure message via the given device.
|
||||
|
@ -133,58 +133,57 @@ void midi_send_programchange(MidiDevice * device, uint8_t chan, uint8_t num);
|
|||
* @param device the device to use for sending
|
||||
* @param chan the channel to send on, 0-15
|
||||
* @param amt the amount of channel pressure
|
||||
*/
|
||||
void midi_send_channelpressure(MidiDevice * device, uint8_t chan, uint8_t amt);
|
||||
*/
|
||||
void midi_send_channelpressure(MidiDevice* device, uint8_t chan, uint8_t amt);
|
||||
|
||||
/**
|
||||
* @brief Send a clock message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_clock(MidiDevice * device);
|
||||
void midi_send_clock(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a tick message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_tick(MidiDevice * device);
|
||||
void midi_send_tick(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a start message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_start(MidiDevice * device);
|
||||
void midi_send_start(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a continue message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_continue(MidiDevice * device);
|
||||
void midi_send_continue(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a stop message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_stop(MidiDevice * device);
|
||||
void midi_send_stop(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send an active sense message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_activesense(MidiDevice * device);
|
||||
void midi_send_activesense(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a reset message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_reset(MidiDevice * device);
|
||||
|
||||
void midi_send_reset(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a tc quarter frame message via the given device.
|
||||
|
@ -192,7 +191,7 @@ void midi_send_reset(MidiDevice * device);
|
|||
* @param device the device to use for sending
|
||||
* @param time the time of this quarter frame, range 0..16383
|
||||
*/
|
||||
void midi_send_tcquarterframe(MidiDevice * device, uint8_t time);
|
||||
void midi_send_tcquarterframe(MidiDevice* device, uint8_t time);
|
||||
|
||||
/**
|
||||
* @brief Send a song position message via the given device.
|
||||
|
@ -200,7 +199,7 @@ void midi_send_tcquarterframe(MidiDevice * device, uint8_t time);
|
|||
* @param device the device to use for sending
|
||||
* @param pos the song position
|
||||
*/
|
||||
void midi_send_songposition(MidiDevice * device, uint16_t pos);
|
||||
void midi_send_songposition(MidiDevice* device, uint16_t pos);
|
||||
|
||||
/**
|
||||
* @brief Send a song select message via the given device.
|
||||
|
@ -208,14 +207,14 @@ void midi_send_songposition(MidiDevice * device, uint16_t pos);
|
|||
* @param device the device to use for sending
|
||||
* @param song the song to select
|
||||
*/
|
||||
void midi_send_songselect(MidiDevice * device, uint8_t song);
|
||||
void midi_send_songselect(MidiDevice* device, uint8_t song);
|
||||
|
||||
/**
|
||||
* @brief Send a tune request message via the given device.
|
||||
*
|
||||
* @param device the device to use for sending
|
||||
*/
|
||||
void midi_send_tunerequest(MidiDevice * device);
|
||||
void midi_send_tunerequest(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* @brief Send a byte via the given device.
|
||||
|
@ -228,7 +227,7 @@ void midi_send_tunerequest(MidiDevice * device);
|
|||
* @param device the device to use for sending
|
||||
* @param b the byte to send
|
||||
*/
|
||||
void midi_send_byte(MidiDevice * device, uint8_t b);
|
||||
void midi_send_byte(MidiDevice* device, uint8_t b);
|
||||
|
||||
/**
|
||||
* @brief Send up to 3 bytes of data
|
||||
|
@ -241,7 +240,7 @@ void midi_send_byte(MidiDevice * device, uint8_t b);
|
|||
* @param byte1 the second byte, ignored if cnt % 4 != 2
|
||||
* @param byte2 the third byte, ignored if cnt % 4 != 3
|
||||
*/
|
||||
void midi_send_data(MidiDevice * device, uint16_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
void midi_send_data(MidiDevice* device, uint16_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
|
||||
/**
|
||||
* @brief Send an array of formatted midi data.
|
||||
|
@ -252,14 +251,13 @@ void midi_send_data(MidiDevice * device, uint16_t count, uint8_t byte0, uint8_t
|
|||
* @param count the count of bytes to send
|
||||
* @param array the array of bytes
|
||||
*/
|
||||
void midi_send_array(MidiDevice * device, uint16_t count, uint8_t * array);
|
||||
void midi_send_array(MidiDevice* device, uint16_t count, uint8_t* array);
|
||||
|
||||
/**@}*/
|
||||
|
||||
|
||||
/**
|
||||
* @defgroup input_callback_reg Input callback registration functions
|
||||
*
|
||||
*
|
||||
* @brief These are the functions you use to register your input callbacks.
|
||||
*
|
||||
* The functions are called when the appropriate midi message is matched on the
|
||||
|
@ -268,7 +266,7 @@ void midi_send_array(MidiDevice * device, uint16_t count, uint8_t * array);
|
|||
* @{
|
||||
*/
|
||||
|
||||
//three byte funcs
|
||||
// three byte funcs
|
||||
|
||||
/**
|
||||
* @brief Register a control change message (cc) callback.
|
||||
|
@ -276,7 +274,7 @@ void midi_send_array(MidiDevice * device, uint16_t count, uint8_t * array);
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_cc_callback(MidiDevice * device, midi_three_byte_func_t func);
|
||||
void midi_register_cc_callback(MidiDevice* device, midi_three_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a note on callback.
|
||||
|
@ -284,7 +282,7 @@ void midi_register_cc_callback(MidiDevice * device, midi_three_byte_func_t func)
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_noteon_callback(MidiDevice * device, midi_three_byte_func_t func);
|
||||
void midi_register_noteon_callback(MidiDevice* device, midi_three_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a note off callback.
|
||||
|
@ -292,7 +290,7 @@ void midi_register_noteon_callback(MidiDevice * device, midi_three_byte_func_t f
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_noteoff_callback(MidiDevice * device, midi_three_byte_func_t func);
|
||||
void midi_register_noteoff_callback(MidiDevice* device, midi_three_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register an after touch callback.
|
||||
|
@ -301,7 +299,7 @@ void midi_register_noteoff_callback(MidiDevice * device, midi_three_byte_func_t
|
|||
* @param func the callback function to register
|
||||
*/
|
||||
|
||||
void midi_register_aftertouch_callback(MidiDevice * device, midi_three_byte_func_t func);
|
||||
void midi_register_aftertouch_callback(MidiDevice* device, midi_three_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a pitch bend callback.
|
||||
|
@ -309,7 +307,7 @@ void midi_register_aftertouch_callback(MidiDevice * device, midi_three_byte_func
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_pitchbend_callback(MidiDevice * device, midi_three_byte_func_t func);
|
||||
void midi_register_pitchbend_callback(MidiDevice* device, midi_three_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a song position callback.
|
||||
|
@ -317,9 +315,9 @@ void midi_register_pitchbend_callback(MidiDevice * device, midi_three_byte_func_
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_songposition_callback(MidiDevice * device, midi_three_byte_func_t func);
|
||||
void midi_register_songposition_callback(MidiDevice* device, midi_three_byte_func_t func);
|
||||
|
||||
//two byte funcs
|
||||
// two byte funcs
|
||||
|
||||
/**
|
||||
* @brief Register a program change callback.
|
||||
|
@ -327,7 +325,7 @@ void midi_register_songposition_callback(MidiDevice * device, midi_three_byte_fu
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_progchange_callback(MidiDevice * device, midi_two_byte_func_t func);
|
||||
void midi_register_progchange_callback(MidiDevice* device, midi_two_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a channel pressure callback.
|
||||
|
@ -335,7 +333,7 @@ void midi_register_progchange_callback(MidiDevice * device, midi_two_byte_func_t
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_chanpressure_callback(MidiDevice * device, midi_two_byte_func_t func);
|
||||
void midi_register_chanpressure_callback(MidiDevice* device, midi_two_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a song select callback.
|
||||
|
@ -343,7 +341,7 @@ void midi_register_chanpressure_callback(MidiDevice * device, midi_two_byte_func
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_songselect_callback(MidiDevice * device, midi_two_byte_func_t func);
|
||||
void midi_register_songselect_callback(MidiDevice* device, midi_two_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a tc quarter frame callback.
|
||||
|
@ -351,9 +349,9 @@ void midi_register_songselect_callback(MidiDevice * device, midi_two_byte_func_t
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_tc_quarterframe_callback(MidiDevice * device, midi_two_byte_func_t func);
|
||||
void midi_register_tc_quarterframe_callback(MidiDevice* device, midi_two_byte_func_t func);
|
||||
|
||||
//one byte funcs
|
||||
// one byte funcs
|
||||
|
||||
/**
|
||||
* @brief Register a realtime callback.
|
||||
|
@ -363,7 +361,7 @@ void midi_register_tc_quarterframe_callback(MidiDevice * device, midi_two_byte_f
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_realtime_callback(MidiDevice * device, midi_one_byte_func_t func);
|
||||
void midi_register_realtime_callback(MidiDevice* device, midi_one_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a tune request callback.
|
||||
|
@ -371,7 +369,7 @@ void midi_register_realtime_callback(MidiDevice * device, midi_one_byte_func_t f
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_tunerequest_callback(MidiDevice * device, midi_one_byte_func_t func);
|
||||
void midi_register_tunerequest_callback(MidiDevice* device, midi_one_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a sysex callback.
|
||||
|
@ -379,7 +377,7 @@ void midi_register_tunerequest_callback(MidiDevice * device, midi_one_byte_func_
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_sysex_callback(MidiDevice * device, midi_sysex_func_t func);
|
||||
void midi_register_sysex_callback(MidiDevice* device, midi_sysex_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register fall through callback.
|
||||
|
@ -391,8 +389,7 @@ void midi_register_sysex_callback(MidiDevice * device, midi_sysex_func_t func);
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_fallthrough_callback(MidiDevice * device, midi_var_byte_func_t func);
|
||||
|
||||
void midi_register_fallthrough_callback(MidiDevice* device, midi_var_byte_func_t func);
|
||||
|
||||
/**
|
||||
* @brief Register a catch all callback.
|
||||
|
@ -403,7 +400,7 @@ void midi_register_fallthrough_callback(MidiDevice * device, midi_var_byte_func_
|
|||
* @param device the device associate with
|
||||
* @param func the callback function to register
|
||||
*/
|
||||
void midi_register_catchall_callback(MidiDevice * device, midi_var_byte_func_t func);
|
||||
void midi_register_catchall_callback(MidiDevice* device, midi_var_byte_func_t func);
|
||||
|
||||
/**@}*/
|
||||
|
||||
|
@ -417,11 +414,7 @@ void midi_register_catchall_callback(MidiDevice * device, midi_var_byte_func_t f
|
|||
*
|
||||
* An enumeration of the possible packet length values.
|
||||
*/
|
||||
typedef enum {
|
||||
UNDEFINED = 0,
|
||||
ONE = 1,
|
||||
TWO = 2,
|
||||
THREE = 3} midi_packet_length_t;
|
||||
typedef enum { UNDEFINED = 0, ONE = 1, TWO = 2, THREE = 3 } midi_packet_length_t;
|
||||
|
||||
/**
|
||||
* @brief Test to see if the byte given is a status byte
|
||||
|
@ -456,11 +449,11 @@ midi_packet_length_t midi_packet_length(uint8_t status);
|
|||
#define SYSEX_BEGIN 0xF0
|
||||
#define SYSEX_END 0xF7
|
||||
|
||||
//if you and this with a byte and you get anything non-zero
|
||||
//it is a status message
|
||||
// if you and this with a byte and you get anything non-zero
|
||||
// it is a status message
|
||||
#define MIDI_STATUSMASK 0x80
|
||||
//if you and this with a status message that contains channel info,
|
||||
//you'll get the channel
|
||||
// if you and this with a status message that contains channel info,
|
||||
// you'll get the channel
|
||||
#define MIDI_CHANMASK 0x0F
|
||||
|
||||
#define MIDI_CC 0xB0
|
||||
|
@ -471,7 +464,7 @@ midi_packet_length_t midi_packet_length(uint8_t status);
|
|||
#define MIDI_PROGCHANGE 0xC0
|
||||
#define MIDI_CHANPRESSURE 0xD0
|
||||
|
||||
//midi realtime
|
||||
// midi realtime
|
||||
#define MIDI_CLOCK 0xF8
|
||||
#define MIDI_TICK 0xF9
|
||||
#define MIDI_START 0xFA
|
||||
|
@ -485,14 +478,13 @@ midi_packet_length_t midi_packet_length(uint8_t status);
|
|||
#define MIDI_SONGSELECT 0xF3
|
||||
#define MIDI_TUNEREQUEST 0xF6
|
||||
|
||||
//This ID is for educational or development use only
|
||||
// This ID is for educational or development use only
|
||||
#define SYSEX_EDUMANUFID 0x7D
|
||||
|
||||
/**@}*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
483
tmk_core/protocol/midi/midi_device.c
Executable file → Normal file
483
tmk_core/protocol/midi/midi_device.c
Executable file → Normal file
|
@ -1,291 +1,272 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include "midi_device.h"
|
||||
#include "midi.h"
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL 0
|
||||
# define NULL 0
|
||||
#endif
|
||||
|
||||
//forward declarations, internally used to call the callbacks
|
||||
void midi_input_callbacks(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
void midi_process_byte(MidiDevice * device, uint8_t input);
|
||||
// forward declarations, internally used to call the callbacks
|
||||
void midi_input_callbacks(MidiDevice* device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
void midi_process_byte(MidiDevice* device, uint8_t input);
|
||||
|
||||
void midi_device_init(MidiDevice * device){
|
||||
device->input_state = IDLE;
|
||||
device->input_count = 0;
|
||||
bytequeue_init(&device->input_queue, device->input_queue_data, MIDI_INPUT_QUEUE_LENGTH);
|
||||
void midi_device_init(MidiDevice* device) {
|
||||
device->input_state = IDLE;
|
||||
device->input_count = 0;
|
||||
bytequeue_init(&device->input_queue, device->input_queue_data, MIDI_INPUT_QUEUE_LENGTH);
|
||||
|
||||
//three byte funcs
|
||||
device->input_cc_callback = NULL;
|
||||
device->input_noteon_callback = NULL;
|
||||
device->input_noteoff_callback = NULL;
|
||||
device->input_aftertouch_callback = NULL;
|
||||
device->input_pitchbend_callback = NULL;
|
||||
device->input_songposition_callback = NULL;
|
||||
// three byte funcs
|
||||
device->input_cc_callback = NULL;
|
||||
device->input_noteon_callback = NULL;
|
||||
device->input_noteoff_callback = NULL;
|
||||
device->input_aftertouch_callback = NULL;
|
||||
device->input_pitchbend_callback = NULL;
|
||||
device->input_songposition_callback = NULL;
|
||||
|
||||
//two byte funcs
|
||||
device->input_progchange_callback = NULL;
|
||||
device->input_chanpressure_callback = NULL;
|
||||
device->input_songselect_callback = NULL;
|
||||
device->input_tc_quarterframe_callback = NULL;
|
||||
// two byte funcs
|
||||
device->input_progchange_callback = NULL;
|
||||
device->input_chanpressure_callback = NULL;
|
||||
device->input_songselect_callback = NULL;
|
||||
device->input_tc_quarterframe_callback = NULL;
|
||||
|
||||
//one byte funcs
|
||||
device->input_realtime_callback = NULL;
|
||||
device->input_tunerequest_callback = NULL;
|
||||
// one byte funcs
|
||||
device->input_realtime_callback = NULL;
|
||||
device->input_tunerequest_callback = NULL;
|
||||
|
||||
//var byte functions
|
||||
device->input_sysex_callback = NULL;
|
||||
device->input_fallthrough_callback = NULL;
|
||||
device->input_catchall_callback = NULL;
|
||||
// var byte functions
|
||||
device->input_sysex_callback = NULL;
|
||||
device->input_fallthrough_callback = NULL;
|
||||
device->input_catchall_callback = NULL;
|
||||
|
||||
device->pre_input_process_callback = NULL;
|
||||
device->pre_input_process_callback = NULL;
|
||||
}
|
||||
|
||||
void midi_device_input(MidiDevice * device, uint8_t cnt, uint8_t * input) {
|
||||
uint8_t i;
|
||||
for (i = 0; i < cnt; i++)
|
||||
bytequeue_enqueue(&device->input_queue, input[i]);
|
||||
void midi_device_input(MidiDevice* device, uint8_t cnt, uint8_t* input) {
|
||||
uint8_t i;
|
||||
for (i = 0; i < cnt; i++) bytequeue_enqueue(&device->input_queue, input[i]);
|
||||
}
|
||||
|
||||
void midi_device_set_send_func(MidiDevice * device, midi_var_byte_func_t send_func){
|
||||
device->send_func = send_func;
|
||||
}
|
||||
void midi_device_set_send_func(MidiDevice* device, midi_var_byte_func_t send_func) { device->send_func = send_func; }
|
||||
|
||||
void midi_device_set_pre_input_process_func(MidiDevice * device, midi_no_byte_func_t pre_process_func){
|
||||
device->pre_input_process_callback = pre_process_func;
|
||||
}
|
||||
void midi_device_set_pre_input_process_func(MidiDevice* device, midi_no_byte_func_t pre_process_func) { device->pre_input_process_callback = pre_process_func; }
|
||||
|
||||
void midi_device_process(MidiDevice * device) {
|
||||
//call the pre_input_process_callback if there is one
|
||||
if(device->pre_input_process_callback)
|
||||
device->pre_input_process_callback(device);
|
||||
void midi_device_process(MidiDevice* device) {
|
||||
// call the pre_input_process_callback if there is one
|
||||
if (device->pre_input_process_callback) device->pre_input_process_callback(device);
|
||||
|
||||
//pull stuff off the queue and process
|
||||
byteQueueIndex_t len = bytequeue_length(&device->input_queue);
|
||||
uint16_t i;
|
||||
//TODO limit number of bytes processed?
|
||||
for(i = 0; i < len; i++) {
|
||||
uint8_t val = bytequeue_get(&device->input_queue, 0);
|
||||
midi_process_byte(device, val);
|
||||
bytequeue_remove(&device->input_queue, 1);
|
||||
}
|
||||
}
|
||||
|
||||
void midi_process_byte(MidiDevice * device, uint8_t input) {
|
||||
if (midi_is_realtime(input)) {
|
||||
//call callback, store and restore state
|
||||
input_state_t state = device->input_state;
|
||||
device->input_state = ONE_BYTE_MESSAGE;
|
||||
midi_input_callbacks(device, 1, input, 0, 0);
|
||||
device->input_state = state;
|
||||
} else if (midi_is_statusbyte(input)) {
|
||||
//store the byte
|
||||
if (device->input_state != SYSEX_MESSAGE) {
|
||||
device->input_buffer[0] = input;
|
||||
device->input_count = 1;
|
||||
// pull stuff off the queue and process
|
||||
byteQueueIndex_t len = bytequeue_length(&device->input_queue);
|
||||
uint16_t i;
|
||||
// TODO limit number of bytes processed?
|
||||
for (i = 0; i < len; i++) {
|
||||
uint8_t val = bytequeue_get(&device->input_queue, 0);
|
||||
midi_process_byte(device, val);
|
||||
bytequeue_remove(&device->input_queue, 1);
|
||||
}
|
||||
switch (midi_packet_length(input)) {
|
||||
case ONE:
|
||||
device->input_state = ONE_BYTE_MESSAGE;;
|
||||
}
|
||||
|
||||
void midi_process_byte(MidiDevice* device, uint8_t input) {
|
||||
if (midi_is_realtime(input)) {
|
||||
// call callback, store and restore state
|
||||
input_state_t state = device->input_state;
|
||||
device->input_state = ONE_BYTE_MESSAGE;
|
||||
midi_input_callbacks(device, 1, input, 0, 0);
|
||||
device->input_state = IDLE;
|
||||
break;
|
||||
case TWO:
|
||||
device->input_state = TWO_BYTE_MESSAGE;
|
||||
break;
|
||||
case THREE:
|
||||
device->input_state = THREE_BYTE_MESSAGE;
|
||||
break;
|
||||
case UNDEFINED:
|
||||
switch(input) {
|
||||
case SYSEX_BEGIN:
|
||||
device->input_state = SYSEX_MESSAGE;
|
||||
device->input_state = state;
|
||||
} else if (midi_is_statusbyte(input)) {
|
||||
// store the byte
|
||||
if (device->input_state != SYSEX_MESSAGE) {
|
||||
device->input_buffer[0] = input;
|
||||
device->input_count = 1;
|
||||
break;
|
||||
case SYSEX_END:
|
||||
//send what is left in the input buffer, set idle
|
||||
device->input_count = 1;
|
||||
}
|
||||
switch (midi_packet_length(input)) {
|
||||
case ONE:
|
||||
device->input_state = ONE_BYTE_MESSAGE;
|
||||
;
|
||||
midi_input_callbacks(device, 1, input, 0, 0);
|
||||
device->input_state = IDLE;
|
||||
break;
|
||||
case TWO:
|
||||
device->input_state = TWO_BYTE_MESSAGE;
|
||||
break;
|
||||
case THREE:
|
||||
device->input_state = THREE_BYTE_MESSAGE;
|
||||
break;
|
||||
case UNDEFINED:
|
||||
switch (input) {
|
||||
case SYSEX_BEGIN:
|
||||
device->input_state = SYSEX_MESSAGE;
|
||||
device->input_buffer[0] = input;
|
||||
device->input_count = 1;
|
||||
break;
|
||||
case SYSEX_END:
|
||||
// send what is left in the input buffer, set idle
|
||||
device->input_buffer[device->input_count % 3] = input;
|
||||
device->input_count += 1;
|
||||
// call the callback
|
||||
midi_input_callbacks(device, device->input_count, device->input_buffer[0], device->input_buffer[1], device->input_buffer[2]);
|
||||
device->input_state = IDLE;
|
||||
break;
|
||||
default:
|
||||
device->input_state = IDLE;
|
||||
device->input_count = 0;
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
device->input_state = IDLE;
|
||||
device->input_count = 0;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (device->input_state != IDLE) {
|
||||
// store the byte
|
||||
device->input_buffer[device->input_count % 3] = input;
|
||||
// increment count
|
||||
uint16_t prev = device->input_count;
|
||||
device->input_count += 1;
|
||||
//call the callback
|
||||
midi_input_callbacks(device, device->input_count,
|
||||
device->input_buffer[0], device->input_buffer[1], device->input_buffer[2]);
|
||||
device->input_state = IDLE;
|
||||
break;
|
||||
default:
|
||||
device->input_state = IDLE;
|
||||
device->input_count = 0;
|
||||
}
|
||||
|
||||
break;
|
||||
default:
|
||||
device->input_state = IDLE;
|
||||
device->input_count = 0;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (device->input_state != IDLE) {
|
||||
//store the byte
|
||||
device->input_buffer[device->input_count % 3] = input;
|
||||
//increment count
|
||||
uint16_t prev = device->input_count;
|
||||
device->input_count += 1;
|
||||
|
||||
switch(prev % 3) {
|
||||
case 2:
|
||||
//call callback
|
||||
midi_input_callbacks(device, device->input_count,
|
||||
device->input_buffer[0], device->input_buffer[1], device->input_buffer[2]);
|
||||
if (device->input_state != SYSEX_MESSAGE) {
|
||||
//set to 1, keeping status byte, allowing for running status
|
||||
device->input_count = 1;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
if (device->input_state == TWO_BYTE_MESSAGE) {
|
||||
//call callback
|
||||
midi_input_callbacks(device, device->input_count,
|
||||
device->input_buffer[0], device->input_buffer[1], 0);
|
||||
if (device->input_state != SYSEX_MESSAGE) {
|
||||
//set to 1, keeping status byte, allowing for running status
|
||||
device->input_count = 1;
|
||||
switch (prev % 3) {
|
||||
case 2:
|
||||
// call callback
|
||||
midi_input_callbacks(device, device->input_count, device->input_buffer[0], device->input_buffer[1], device->input_buffer[2]);
|
||||
if (device->input_state != SYSEX_MESSAGE) {
|
||||
// set to 1, keeping status byte, allowing for running status
|
||||
device->input_count = 1;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
if (device->input_state == TWO_BYTE_MESSAGE) {
|
||||
// call callback
|
||||
midi_input_callbacks(device, device->input_count, device->input_buffer[0], device->input_buffer[1], 0);
|
||||
if (device->input_state != SYSEX_MESSAGE) {
|
||||
// set to 1, keeping status byte, allowing for running status
|
||||
device->input_count = 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 0:
|
||||
default:
|
||||
// one byte messages are dealt with directly
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 0:
|
||||
default:
|
||||
//one byte messages are dealt with directly
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void midi_input_callbacks(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
|
||||
//did we end up calling a callback?
|
||||
bool called = false;
|
||||
if (device->input_state == SYSEX_MESSAGE) {
|
||||
if (device->input_sysex_callback) {
|
||||
const uint16_t start = ((cnt - 1) / 3) * 3;
|
||||
const uint8_t length = (cnt - start);
|
||||
uint8_t data[3];
|
||||
data[0] = byte0;
|
||||
data[1] = byte1;
|
||||
data[2] = byte2;
|
||||
device->input_sysex_callback(device, start, length, data);
|
||||
called = true;
|
||||
}
|
||||
} else {
|
||||
switch (cnt) {
|
||||
case 3:
|
||||
{
|
||||
midi_three_byte_func_t func = NULL;
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_CC:
|
||||
func = device->input_cc_callback;
|
||||
break;
|
||||
case MIDI_NOTEON:
|
||||
func = device->input_noteon_callback;
|
||||
break;
|
||||
case MIDI_NOTEOFF:
|
||||
func = device->input_noteoff_callback;
|
||||
break;
|
||||
case MIDI_AFTERTOUCH:
|
||||
func = device->input_aftertouch_callback;
|
||||
break;
|
||||
case MIDI_PITCHBEND:
|
||||
func = device->input_pitchbend_callback;
|
||||
break;
|
||||
case 0xF0:
|
||||
if (byte0 == MIDI_SONGPOSITION)
|
||||
func = device->input_songposition_callback;
|
||||
break;
|
||||
void midi_input_callbacks(MidiDevice* device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
|
||||
// did we end up calling a callback?
|
||||
bool called = false;
|
||||
if (device->input_state == SYSEX_MESSAGE) {
|
||||
if (device->input_sysex_callback) {
|
||||
const uint16_t start = ((cnt - 1) / 3) * 3;
|
||||
const uint8_t length = (cnt - start);
|
||||
uint8_t data[3];
|
||||
data[0] = byte0;
|
||||
data[1] = byte1;
|
||||
data[2] = byte2;
|
||||
device->input_sysex_callback(device, start, length, data);
|
||||
called = true;
|
||||
}
|
||||
} else {
|
||||
switch (cnt) {
|
||||
case 3: {
|
||||
midi_three_byte_func_t func = NULL;
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_CC:
|
||||
func = device->input_cc_callback;
|
||||
break;
|
||||
case MIDI_NOTEON:
|
||||
func = device->input_noteon_callback;
|
||||
break;
|
||||
case MIDI_NOTEOFF:
|
||||
func = device->input_noteoff_callback;
|
||||
break;
|
||||
case MIDI_AFTERTOUCH:
|
||||
func = device->input_aftertouch_callback;
|
||||
break;
|
||||
case MIDI_PITCHBEND:
|
||||
func = device->input_pitchbend_callback;
|
||||
break;
|
||||
case 0xF0:
|
||||
if (byte0 == MIDI_SONGPOSITION) func = device->input_songposition_callback;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (func) {
|
||||
// mask off the channel for non song position functions
|
||||
if (byte0 == MIDI_SONGPOSITION)
|
||||
func(device, byte0, byte1, byte2);
|
||||
else
|
||||
func(device, byte0 & 0x0F, byte1, byte2);
|
||||
called = true;
|
||||
}
|
||||
} break;
|
||||
case 2: {
|
||||
midi_two_byte_func_t func = NULL;
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_PROGCHANGE:
|
||||
func = device->input_progchange_callback;
|
||||
break;
|
||||
case MIDI_CHANPRESSURE:
|
||||
func = device->input_chanpressure_callback;
|
||||
break;
|
||||
case 0xF0:
|
||||
if (byte0 == MIDI_SONGSELECT)
|
||||
func = device->input_songselect_callback;
|
||||
else if (byte0 == MIDI_TC_QUARTERFRAME)
|
||||
func = device->input_tc_quarterframe_callback;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (func) {
|
||||
// mask off the channel
|
||||
if (byte0 == MIDI_SONGSELECT || byte0 == MIDI_TC_QUARTERFRAME)
|
||||
func(device, byte0, byte1);
|
||||
else
|
||||
func(device, byte0 & 0x0F, byte1);
|
||||
called = true;
|
||||
}
|
||||
} break;
|
||||
case 1: {
|
||||
midi_one_byte_func_t func = NULL;
|
||||
if (midi_is_realtime(byte0))
|
||||
func = device->input_realtime_callback;
|
||||
else if (byte0 == MIDI_TUNEREQUEST)
|
||||
func = device->input_tunerequest_callback;
|
||||
if (func) {
|
||||
func(device, byte0);
|
||||
called = true;
|
||||
}
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(func) {
|
||||
//mask off the channel for non song position functions
|
||||
if (byte0 == MIDI_SONGPOSITION)
|
||||
func(device, byte0, byte1, byte2);
|
||||
else
|
||||
func(device, byte0 & 0x0F, byte1, byte2);
|
||||
called = true;
|
||||
}
|
||||
// just in case
|
||||
if (cnt > 3) cnt = 0;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
{
|
||||
midi_two_byte_func_t func = NULL;
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_PROGCHANGE:
|
||||
func = device->input_progchange_callback;
|
||||
break;
|
||||
case MIDI_CHANPRESSURE:
|
||||
func = device->input_chanpressure_callback;
|
||||
break;
|
||||
case 0xF0:
|
||||
if (byte0 == MIDI_SONGSELECT)
|
||||
func = device->input_songselect_callback;
|
||||
else if (byte0 == MIDI_TC_QUARTERFRAME)
|
||||
func = device->input_tc_quarterframe_callback;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(func) {
|
||||
//mask off the channel
|
||||
if (byte0 == MIDI_SONGSELECT || byte0 == MIDI_TC_QUARTERFRAME)
|
||||
func(device, byte0, byte1);
|
||||
else
|
||||
func(device, byte0 & 0x0F, byte1);
|
||||
called = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
{
|
||||
midi_one_byte_func_t func = NULL;
|
||||
if (midi_is_realtime(byte0))
|
||||
func = device->input_realtime_callback;
|
||||
else if (byte0 == MIDI_TUNEREQUEST)
|
||||
func = device->input_tunerequest_callback;
|
||||
if (func) {
|
||||
func(device, byte0);
|
||||
called = true;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
//just in case
|
||||
if (cnt > 3)
|
||||
cnt = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//if there is fallthrough default callback and we haven't called a more specific one,
|
||||
//call the fallthrough
|
||||
if (!called && device->input_fallthrough_callback)
|
||||
device->input_fallthrough_callback(device, cnt, byte0, byte1, byte2);
|
||||
//always call the catch all if it exists
|
||||
if (device->input_catchall_callback)
|
||||
device->input_catchall_callback(device, cnt, byte0, byte1, byte2);
|
||||
// if there is fallthrough default callback and we haven't called a more specific one,
|
||||
// call the fallthrough
|
||||
if (!called && device->input_fallthrough_callback) device->input_fallthrough_callback(device, cnt, byte0, byte1, byte2);
|
||||
// always call the catch all if it exists
|
||||
if (device->input_catchall_callback) device->input_catchall_callback(device, cnt, byte0, byte1, byte2);
|
||||
}
|
||||
|
||||
|
|
109
tmk_core/protocol/midi/midi_device.h
Executable file → Normal file
109
tmk_core/protocol/midi/midi_device.h
Executable file → Normal file
|
@ -1,20 +1,20 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
/**
|
||||
* @file
|
||||
|
@ -26,7 +26,7 @@
|
|||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @defgroup midi_device Functions used when implementing your own midi device.
|
||||
|
@ -51,14 +51,9 @@ extern "C" {
|
|||
#include "bytequeue/bytequeue.h"
|
||||
#define MIDI_INPUT_QUEUE_LENGTH 192
|
||||
|
||||
typedef enum {
|
||||
IDLE,
|
||||
ONE_BYTE_MESSAGE = 1,
|
||||
TWO_BYTE_MESSAGE = 2,
|
||||
THREE_BYTE_MESSAGE = 3,
|
||||
SYSEX_MESSAGE} input_state_t;
|
||||
typedef enum { IDLE, ONE_BYTE_MESSAGE = 1, TWO_BYTE_MESSAGE = 2, THREE_BYTE_MESSAGE = 3, SYSEX_MESSAGE } input_state_t;
|
||||
|
||||
typedef void (* midi_no_byte_func_t)(MidiDevice * device);
|
||||
typedef void (*midi_no_byte_func_t)(MidiDevice* device);
|
||||
|
||||
/**
|
||||
* \struct _midi_device
|
||||
|
@ -71,45 +66,45 @@ typedef void (* midi_no_byte_func_t)(MidiDevice * device);
|
|||
* You should not need to modify this structure directly.
|
||||
*/
|
||||
struct _midi_device {
|
||||
//output send function
|
||||
midi_var_byte_func_t send_func;
|
||||
// output send function
|
||||
midi_var_byte_func_t send_func;
|
||||
|
||||
//********input callbacks
|
||||
//three byte funcs
|
||||
midi_three_byte_func_t input_cc_callback;
|
||||
midi_three_byte_func_t input_noteon_callback;
|
||||
midi_three_byte_func_t input_noteoff_callback;
|
||||
midi_three_byte_func_t input_aftertouch_callback;
|
||||
midi_three_byte_func_t input_pitchbend_callback;
|
||||
midi_three_byte_func_t input_songposition_callback;
|
||||
//two byte funcs
|
||||
midi_two_byte_func_t input_progchange_callback;
|
||||
midi_two_byte_func_t input_chanpressure_callback;
|
||||
midi_two_byte_func_t input_songselect_callback;
|
||||
midi_two_byte_func_t input_tc_quarterframe_callback;
|
||||
//one byte funcs
|
||||
midi_one_byte_func_t input_realtime_callback;
|
||||
midi_one_byte_func_t input_tunerequest_callback;
|
||||
//********input callbacks
|
||||
// three byte funcs
|
||||
midi_three_byte_func_t input_cc_callback;
|
||||
midi_three_byte_func_t input_noteon_callback;
|
||||
midi_three_byte_func_t input_noteoff_callback;
|
||||
midi_three_byte_func_t input_aftertouch_callback;
|
||||
midi_three_byte_func_t input_pitchbend_callback;
|
||||
midi_three_byte_func_t input_songposition_callback;
|
||||
// two byte funcs
|
||||
midi_two_byte_func_t input_progchange_callback;
|
||||
midi_two_byte_func_t input_chanpressure_callback;
|
||||
midi_two_byte_func_t input_songselect_callback;
|
||||
midi_two_byte_func_t input_tc_quarterframe_callback;
|
||||
// one byte funcs
|
||||
midi_one_byte_func_t input_realtime_callback;
|
||||
midi_one_byte_func_t input_tunerequest_callback;
|
||||
|
||||
//sysex
|
||||
midi_sysex_func_t input_sysex_callback;
|
||||
// sysex
|
||||
midi_sysex_func_t input_sysex_callback;
|
||||
|
||||
//only called if more specific callback is not matched
|
||||
midi_var_byte_func_t input_fallthrough_callback;
|
||||
//called if registered, independent of other callbacks
|
||||
midi_var_byte_func_t input_catchall_callback;
|
||||
// only called if more specific callback is not matched
|
||||
midi_var_byte_func_t input_fallthrough_callback;
|
||||
// called if registered, independent of other callbacks
|
||||
midi_var_byte_func_t input_catchall_callback;
|
||||
|
||||
//pre input processing function
|
||||
midi_no_byte_func_t pre_input_process_callback;
|
||||
// pre input processing function
|
||||
midi_no_byte_func_t pre_input_process_callback;
|
||||
|
||||
//for internal input processing
|
||||
uint8_t input_buffer[3];
|
||||
input_state_t input_state;
|
||||
uint16_t input_count;
|
||||
// for internal input processing
|
||||
uint8_t input_buffer[3];
|
||||
input_state_t input_state;
|
||||
uint16_t input_count;
|
||||
|
||||
//for queueing data between the input and the processing functions
|
||||
uint8_t input_queue_data[MIDI_INPUT_QUEUE_LENGTH];
|
||||
byteQueue_t input_queue;
|
||||
// for queueing data between the input and the processing functions
|
||||
uint8_t input_queue_data[MIDI_INPUT_QUEUE_LENGTH];
|
||||
byteQueue_t input_queue;
|
||||
};
|
||||
|
||||
/**
|
||||
|
@ -122,7 +117,7 @@ struct _midi_device {
|
|||
* @param cnt the number of bytes you are processing
|
||||
* @param input the bytes to process
|
||||
*/
|
||||
void midi_device_input(MidiDevice * device, uint8_t cnt, uint8_t * input);
|
||||
void midi_device_input(MidiDevice* device, uint8_t cnt, uint8_t* input);
|
||||
|
||||
/**
|
||||
* @brief Set the callback function that will be used for sending output
|
||||
|
@ -134,7 +129,7 @@ void midi_device_input(MidiDevice * device, uint8_t cnt, uint8_t * input);
|
|||
* \param device the midi device to associate this callback with
|
||||
* \param send_func the callback function that will do the sending
|
||||
*/
|
||||
void midi_device_set_send_func(MidiDevice * device, midi_var_byte_func_t send_func);
|
||||
void midi_device_set_send_func(MidiDevice* device, midi_var_byte_func_t send_func);
|
||||
|
||||
/**
|
||||
* @brief Set a callback which is called at the beginning of the
|
||||
|
@ -145,12 +140,12 @@ void midi_device_set_send_func(MidiDevice * device, midi_var_byte_func_t send_fu
|
|||
* \param device the midi device to associate this callback with
|
||||
* \param midi_no_byte_func_t the actual callback function
|
||||
*/
|
||||
void midi_device_set_pre_input_process_func(MidiDevice * device, midi_no_byte_func_t pre_process_func);
|
||||
void midi_device_set_pre_input_process_func(MidiDevice* device, midi_no_byte_func_t pre_process_func);
|
||||
|
||||
/**@}*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
44
tmk_core/protocol/midi/midi_function_types.h
Executable file → Normal file
44
tmk_core/protocol/midi/midi_function_types.h
Executable file → Normal file
|
@ -1,20 +1,20 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
/**
|
||||
* @file
|
||||
|
@ -26,25 +26,25 @@
|
|||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
//forward declaration
|
||||
// forward declaration
|
||||
typedef struct _midi_device MidiDevice;
|
||||
|
||||
typedef void (* midi_one_byte_func_t)(MidiDevice * device, uint8_t byte);
|
||||
typedef void (* midi_two_byte_func_t)(MidiDevice * device, uint8_t byte0, uint8_t byte1);
|
||||
typedef void (* midi_three_byte_func_t)(MidiDevice * device, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
//all bytes after count bytes should be ignored
|
||||
typedef void (* midi_var_byte_func_t)(MidiDevice * device, uint16_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
typedef void (*midi_one_byte_func_t)(MidiDevice *device, uint8_t byte);
|
||||
typedef void (*midi_two_byte_func_t)(MidiDevice *device, uint8_t byte0, uint8_t byte1);
|
||||
typedef void (*midi_three_byte_func_t)(MidiDevice *device, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
// all bytes after count bytes should be ignored
|
||||
typedef void (*midi_var_byte_func_t)(MidiDevice *device, uint16_t count, uint8_t byte0, uint8_t byte1, uint8_t byte2);
|
||||
|
||||
//the start byte tells you how far into the sysex message you are, the data_length tells you how many bytes data is
|
||||
typedef void (* midi_sysex_func_t)(MidiDevice * device, uint16_t start_byte, uint8_t data_length, uint8_t *data);
|
||||
// the start byte tells you how far into the sysex message you are, the data_length tells you how many bytes data is
|
||||
typedef void (*midi_sysex_func_t)(MidiDevice *device, uint16_t start_byte, uint8_t data_length, uint8_t *data);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
#include "usb_descriptor.h"
|
||||
#include "process_midi.h"
|
||||
#if API_SYSEX_ENABLE
|
||||
#include "api.h"
|
||||
# include "api.h"
|
||||
#endif
|
||||
|
||||
/*******************************************************************************
|
||||
|
@ -23,162 +23,154 @@ MidiDevice midi_device;
|
|||
#define SYS_COMMON_2 0x20
|
||||
#define SYS_COMMON_3 0x30
|
||||
|
||||
static void usb_send_func(MidiDevice * device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
|
||||
MIDI_EventPacket_t event;
|
||||
event.Data1 = byte0;
|
||||
event.Data2 = byte1;
|
||||
event.Data3 = byte2;
|
||||
static void usb_send_func(MidiDevice* device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
|
||||
MIDI_EventPacket_t event;
|
||||
event.Data1 = byte0;
|
||||
event.Data2 = byte1;
|
||||
event.Data3 = byte2;
|
||||
|
||||
uint8_t cable = 0;
|
||||
uint8_t cable = 0;
|
||||
|
||||
//if the length is undefined we assume it is a SYSEX message
|
||||
if (midi_packet_length(byte0) == UNDEFINED) {
|
||||
switch(cnt) {
|
||||
case 3:
|
||||
if (byte2 == SYSEX_END)
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_3);
|
||||
else
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
|
||||
break;
|
||||
case 2:
|
||||
if (byte1 == SYSEX_END)
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_2);
|
||||
else
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
|
||||
break;
|
||||
case 1:
|
||||
if (byte0 == SYSEX_END)
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_1);
|
||||
else
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
|
||||
break;
|
||||
default:
|
||||
return; //invalid cnt
|
||||
// if the length is undefined we assume it is a SYSEX message
|
||||
if (midi_packet_length(byte0) == UNDEFINED) {
|
||||
switch (cnt) {
|
||||
case 3:
|
||||
if (byte2 == SYSEX_END)
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_3);
|
||||
else
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
|
||||
break;
|
||||
case 2:
|
||||
if (byte1 == SYSEX_END)
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_2);
|
||||
else
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
|
||||
break;
|
||||
case 1:
|
||||
if (byte0 == SYSEX_END)
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_ENDS_IN_1);
|
||||
else
|
||||
event.Event = MIDI_EVENT(cable, SYSEX_START_OR_CONT);
|
||||
break;
|
||||
default:
|
||||
return; // invalid cnt
|
||||
}
|
||||
} else {
|
||||
// deal with 'system common' messages
|
||||
// TODO are there any more?
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_SONGPOSITION:
|
||||
event.Event = MIDI_EVENT(cable, SYS_COMMON_3);
|
||||
break;
|
||||
case MIDI_SONGSELECT:
|
||||
case MIDI_TC_QUARTERFRAME:
|
||||
event.Event = MIDI_EVENT(cable, SYS_COMMON_2);
|
||||
break;
|
||||
default:
|
||||
event.Event = MIDI_EVENT(cable, byte0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
//deal with 'system common' messages
|
||||
//TODO are there any more?
|
||||
switch(byte0 & 0xF0){
|
||||
case MIDI_SONGPOSITION:
|
||||
event.Event = MIDI_EVENT(cable, SYS_COMMON_3);
|
||||
break;
|
||||
case MIDI_SONGSELECT:
|
||||
case MIDI_TC_QUARTERFRAME:
|
||||
event.Event = MIDI_EVENT(cable, SYS_COMMON_2);
|
||||
break;
|
||||
default:
|
||||
event.Event = MIDI_EVENT(cable, byte0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
send_midi_packet(&event);
|
||||
send_midi_packet(&event);
|
||||
}
|
||||
|
||||
static void usb_get_midi(MidiDevice * device) {
|
||||
MIDI_EventPacket_t event;
|
||||
while (recv_midi_packet(&event)) {
|
||||
static void usb_get_midi(MidiDevice* device) {
|
||||
MIDI_EventPacket_t event;
|
||||
while (recv_midi_packet(&event)) {
|
||||
midi_packet_length_t length = midi_packet_length(event.Data1);
|
||||
uint8_t input[3];
|
||||
input[0] = event.Data1;
|
||||
input[1] = event.Data2;
|
||||
input[2] = event.Data3;
|
||||
if (length == UNDEFINED) {
|
||||
// sysex
|
||||
if (event.Event == MIDI_EVENT(0, SYSEX_START_OR_CONT) || event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_3)) {
|
||||
length = 3;
|
||||
} else if (event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_2)) {
|
||||
length = 2;
|
||||
} else if (event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_1)) {
|
||||
length = 1;
|
||||
} else {
|
||||
// XXX what to do?
|
||||
}
|
||||
}
|
||||
|
||||
midi_packet_length_t length = midi_packet_length(event.Data1);
|
||||
uint8_t input[3];
|
||||
input[0] = event.Data1;
|
||||
input[1] = event.Data2;
|
||||
input[2] = event.Data3;
|
||||
if (length == UNDEFINED) {
|
||||
//sysex
|
||||
if (event.Event == MIDI_EVENT(0, SYSEX_START_OR_CONT) || event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_3)) {
|
||||
length = 3;
|
||||
} else if (event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_2)) {
|
||||
length = 2;
|
||||
} else if(event.Event == MIDI_EVENT(0, SYSEX_ENDS_IN_1)) {
|
||||
length = 1;
|
||||
} else {
|
||||
//XXX what to do?
|
||||
}
|
||||
// pass the data to the device input function
|
||||
if (length != UNDEFINED) midi_device_input(device, length, input);
|
||||
}
|
||||
|
||||
//pass the data to the device input function
|
||||
if (length != UNDEFINED)
|
||||
midi_device_input(device, length, input);
|
||||
}
|
||||
}
|
||||
|
||||
static void fallthrough_callback(MidiDevice * device,
|
||||
uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2){
|
||||
|
||||
static void fallthrough_callback(MidiDevice* device, uint16_t cnt, uint8_t byte0, uint8_t byte1, uint8_t byte2) {
|
||||
#ifdef AUDIO_ENABLE
|
||||
if (cnt == 3) {
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_NOTEON:
|
||||
play_note(((double)261.6)*pow(2.0, -4.0)*pow(2.0,(byte1 & 0x7F)/12.0), (byte2 & 0x7F) / 8);
|
||||
break;
|
||||
case MIDI_NOTEOFF:
|
||||
stop_note(((double)261.6)*pow(2.0, -4.0)*pow(2.0,(byte1 & 0x7F)/12.0));
|
||||
break;
|
||||
if (cnt == 3) {
|
||||
switch (byte0 & 0xF0) {
|
||||
case MIDI_NOTEON:
|
||||
play_note(((double)261.6) * pow(2.0, -4.0) * pow(2.0, (byte1 & 0x7F) / 12.0), (byte2 & 0x7F) / 8);
|
||||
break;
|
||||
case MIDI_NOTEOFF:
|
||||
stop_note(((double)261.6) * pow(2.0, -4.0) * pow(2.0, (byte1 & 0x7F) / 12.0));
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (byte0 == MIDI_STOP) {
|
||||
stop_all_notes();
|
||||
}
|
||||
}
|
||||
if (byte0 == MIDI_STOP) {
|
||||
stop_all_notes();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
static void cc_callback(MidiDevice * device,
|
||||
uint8_t chan, uint8_t num, uint8_t val) {
|
||||
//sending it back on the next channel
|
||||
// midi_send_cc(device, (chan + 1) % 16, num, val);
|
||||
static void cc_callback(MidiDevice* device, uint8_t chan, uint8_t num, uint8_t val) {
|
||||
// sending it back on the next channel
|
||||
// midi_send_cc(device, (chan + 1) % 16, num, val);
|
||||
}
|
||||
|
||||
#ifdef API_SYSEX_ENABLE
|
||||
uint8_t midi_buffer[MIDI_SYSEX_BUFFER] = {0};
|
||||
|
||||
static void sysex_callback(MidiDevice * device, uint16_t start, uint8_t length, uint8_t * data) {
|
||||
// SEND_STRING("\n");
|
||||
// send_word(start);
|
||||
// SEND_STRING(": ");
|
||||
// Don't store the header
|
||||
int16_t pos = start - 4;
|
||||
for (uint8_t place = 0; place < length; place++) {
|
||||
// send_byte(*data);
|
||||
if (pos >= 0) {
|
||||
if (*data == 0xF7) {
|
||||
// SEND_STRING("\nRD: ");
|
||||
// for (uint8_t i = 0; i < start + place + 1; i++){
|
||||
// send_byte(midi_buffer[i]);
|
||||
// SEND_STRING(" ");
|
||||
// }
|
||||
const unsigned decoded_length = sysex_decoded_length(pos);
|
||||
uint8_t decoded[API_SYSEX_MAX_SIZE];
|
||||
sysex_decode(decoded, midi_buffer, pos);
|
||||
process_api(decoded_length, decoded);
|
||||
return;
|
||||
}
|
||||
else if (pos >= MIDI_SYSEX_BUFFER) {
|
||||
return;
|
||||
}
|
||||
midi_buffer[pos] = *data;
|
||||
}
|
||||
// SEND_STRING(" ");
|
||||
data++;
|
||||
pos++;
|
||||
}
|
||||
static void sysex_callback(MidiDevice* device, uint16_t start, uint8_t length, uint8_t* data) {
|
||||
// SEND_STRING("\n");
|
||||
// send_word(start);
|
||||
// SEND_STRING(": ");
|
||||
// Don't store the header
|
||||
int16_t pos = start - 4;
|
||||
for (uint8_t place = 0; place < length; place++) {
|
||||
// send_byte(*data);
|
||||
if (pos >= 0) {
|
||||
if (*data == 0xF7) {
|
||||
// SEND_STRING("\nRD: ");
|
||||
// for (uint8_t i = 0; i < start + place + 1; i++){
|
||||
// send_byte(midi_buffer[i]);
|
||||
// SEND_STRING(" ");
|
||||
// }
|
||||
const unsigned decoded_length = sysex_decoded_length(pos);
|
||||
uint8_t decoded[API_SYSEX_MAX_SIZE];
|
||||
sysex_decode(decoded, midi_buffer, pos);
|
||||
process_api(decoded_length, decoded);
|
||||
return;
|
||||
} else if (pos >= MIDI_SYSEX_BUFFER) {
|
||||
return;
|
||||
}
|
||||
midi_buffer[pos] = *data;
|
||||
}
|
||||
// SEND_STRING(" ");
|
||||
data++;
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void midi_init(void);
|
||||
|
||||
void setup_midi(void)
|
||||
{
|
||||
void setup_midi(void) {
|
||||
#ifdef MIDI_ADVANCED
|
||||
midi_init();
|
||||
midi_init();
|
||||
#endif
|
||||
midi_device_init(&midi_device);
|
||||
midi_device_set_send_func(&midi_device, usb_send_func);
|
||||
midi_device_set_pre_input_process_func(&midi_device, usb_get_midi);
|
||||
midi_register_fallthrough_callback(&midi_device, fallthrough_callback);
|
||||
midi_register_cc_callback(&midi_device, cc_callback);
|
||||
midi_device_init(&midi_device);
|
||||
midi_device_set_send_func(&midi_device, usb_send_func);
|
||||
midi_device_set_pre_input_process_func(&midi_device, usb_get_midi);
|
||||
midi_register_fallthrough_callback(&midi_device, fallthrough_callback);
|
||||
midi_register_cc_callback(&midi_device, cc_callback);
|
||||
#ifdef API_SYSEX_ENABLE
|
||||
midi_register_sysex_callback(&midi_device, sysex_callback);
|
||||
midi_register_sysex_callback(&midi_device, sysex_callback);
|
||||
#endif
|
||||
}
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
#pragma once
|
||||
|
||||
#ifdef MIDI_ENABLE
|
||||
#include "midi.h"
|
||||
extern MidiDevice midi_device;
|
||||
void setup_midi(void);
|
||||
void send_midi_packet(MIDI_EventPacket_t* event);
|
||||
bool recv_midi_packet(MIDI_EventPacket_t* const event);
|
||||
# include "midi.h"
|
||||
extern MidiDevice midi_device;
|
||||
void setup_midi(void);
|
||||
void send_midi_packet(MIDI_EventPacket_t* event);
|
||||
bool recv_midi_packet(MIDI_EventPacket_t* const event);
|
||||
#endif
|
||||
|
|
158
tmk_core/protocol/midi/sysex_tools.c
Executable file → Normal file
158
tmk_core/protocol/midi/sysex_tools.c
Executable file → Normal file
|
@ -1,99 +1,97 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#include "sysex_tools.h"
|
||||
|
||||
uint16_t sysex_encoded_length(uint16_t decoded_length){
|
||||
uint8_t remainder = decoded_length % 7;
|
||||
if (remainder)
|
||||
return (decoded_length / 7) * 8 + remainder + 1;
|
||||
else
|
||||
return (decoded_length / 7) * 8;
|
||||
uint16_t sysex_encoded_length(uint16_t decoded_length) {
|
||||
uint8_t remainder = decoded_length % 7;
|
||||
if (remainder)
|
||||
return (decoded_length / 7) * 8 + remainder + 1;
|
||||
else
|
||||
return (decoded_length / 7) * 8;
|
||||
}
|
||||
|
||||
uint16_t sysex_decoded_length(uint16_t encoded_length){
|
||||
uint8_t remainder = encoded_length % 8;
|
||||
if (remainder)
|
||||
return (encoded_length / 8) * 7 + remainder - 1;
|
||||
else
|
||||
return (encoded_length / 8) * 7;
|
||||
uint16_t sysex_decoded_length(uint16_t encoded_length) {
|
||||
uint8_t remainder = encoded_length % 8;
|
||||
if (remainder)
|
||||
return (encoded_length / 8) * 7 + remainder - 1;
|
||||
else
|
||||
return (encoded_length / 8) * 7;
|
||||
}
|
||||
|
||||
uint16_t sysex_encode(uint8_t *encoded, const uint8_t *source, const uint16_t length){
|
||||
uint16_t encoded_full = length / 7; //number of full 8 byte sections from 7 bytes of input
|
||||
uint16_t i,j;
|
||||
uint16_t sysex_encode(uint8_t *encoded, const uint8_t *source, const uint16_t length) {
|
||||
uint16_t encoded_full = length / 7; // number of full 8 byte sections from 7 bytes of input
|
||||
uint16_t i, j;
|
||||
|
||||
//fill out the fully encoded sections
|
||||
for(i = 0; i < encoded_full; i++) {
|
||||
uint16_t encoded_msb_idx = i * 8;
|
||||
uint16_t input_start_idx = i * 7;
|
||||
encoded[encoded_msb_idx] = 0;
|
||||
for(j = 0; j < 7; j++){
|
||||
uint8_t current = source[input_start_idx + j];
|
||||
encoded[encoded_msb_idx] |= (0x80 & current) >> (1 + j);
|
||||
encoded[encoded_msb_idx + 1 + j] = 0x7F & current;
|
||||
}
|
||||
}
|
||||
// fill out the fully encoded sections
|
||||
for (i = 0; i < encoded_full; i++) {
|
||||
uint16_t encoded_msb_idx = i * 8;
|
||||
uint16_t input_start_idx = i * 7;
|
||||
encoded[encoded_msb_idx] = 0;
|
||||
for (j = 0; j < 7; j++) {
|
||||
uint8_t current = source[input_start_idx + j];
|
||||
encoded[encoded_msb_idx] |= (0x80 & current) >> (1 + j);
|
||||
encoded[encoded_msb_idx + 1 + j] = 0x7F & current;
|
||||
}
|
||||
}
|
||||
|
||||
//fill out the rest if there is any more
|
||||
uint8_t remainder = length % 7;
|
||||
if (remainder) {
|
||||
uint16_t encoded_msb_idx = encoded_full * 8;
|
||||
uint16_t input_start_idx = encoded_full * 7;
|
||||
encoded[encoded_msb_idx] = 0;
|
||||
for(j = 0; j < remainder; j++){
|
||||
uint8_t current = source[input_start_idx + j];
|
||||
encoded[encoded_msb_idx] |= (0x80 & current) >> (1 + j);
|
||||
encoded[encoded_msb_idx + 1 + j] = 0x7F & current;
|
||||
}
|
||||
return encoded_msb_idx + remainder + 1;
|
||||
} else {
|
||||
return encoded_full * 8;
|
||||
}
|
||||
// fill out the rest if there is any more
|
||||
uint8_t remainder = length % 7;
|
||||
if (remainder) {
|
||||
uint16_t encoded_msb_idx = encoded_full * 8;
|
||||
uint16_t input_start_idx = encoded_full * 7;
|
||||
encoded[encoded_msb_idx] = 0;
|
||||
for (j = 0; j < remainder; j++) {
|
||||
uint8_t current = source[input_start_idx + j];
|
||||
encoded[encoded_msb_idx] |= (0x80 & current) >> (1 + j);
|
||||
encoded[encoded_msb_idx + 1 + j] = 0x7F & current;
|
||||
}
|
||||
return encoded_msb_idx + remainder + 1;
|
||||
} else {
|
||||
return encoded_full * 8;
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t sysex_decode(uint8_t *decoded, const uint8_t *source, const uint16_t length){
|
||||
uint16_t decoded_full = length / 8;
|
||||
uint16_t i,j;
|
||||
uint16_t sysex_decode(uint8_t *decoded, const uint8_t *source, const uint16_t length) {
|
||||
uint16_t decoded_full = length / 8;
|
||||
uint16_t i, j;
|
||||
|
||||
if (length < 2)
|
||||
return 0;
|
||||
if (length < 2) return 0;
|
||||
|
||||
//fill out the fully encoded sections
|
||||
for(i = 0; i < decoded_full; i++) {
|
||||
uint16_t encoded_msb_idx = i * 8;
|
||||
uint16_t output_start_index = i * 7;
|
||||
for(j = 0; j < 7; j++){
|
||||
decoded[output_start_index + j] = 0x7F & source[encoded_msb_idx + j + 1];
|
||||
decoded[output_start_index + j] |= (0x80 & (source[encoded_msb_idx] << (1 + j)));
|
||||
}
|
||||
}
|
||||
uint8_t remainder = length % 8;
|
||||
if (remainder) {
|
||||
uint16_t encoded_msb_idx = decoded_full * 8;
|
||||
uint16_t output_start_index = decoded_full * 7;
|
||||
for(j = 0; j < (remainder - 1); j++) {
|
||||
decoded[output_start_index + j] = 0x7F & source[encoded_msb_idx + j + 1];
|
||||
decoded[output_start_index + j] |= (0x80 & (source[encoded_msb_idx] << (1 + j)));
|
||||
}
|
||||
return decoded_full * 7 + remainder - 1;
|
||||
} else {
|
||||
return decoded_full * 7;
|
||||
}
|
||||
// fill out the fully encoded sections
|
||||
for (i = 0; i < decoded_full; i++) {
|
||||
uint16_t encoded_msb_idx = i * 8;
|
||||
uint16_t output_start_index = i * 7;
|
||||
for (j = 0; j < 7; j++) {
|
||||
decoded[output_start_index + j] = 0x7F & source[encoded_msb_idx + j + 1];
|
||||
decoded[output_start_index + j] |= (0x80 & (source[encoded_msb_idx] << (1 + j)));
|
||||
}
|
||||
}
|
||||
uint8_t remainder = length % 8;
|
||||
if (remainder) {
|
||||
uint16_t encoded_msb_idx = decoded_full * 8;
|
||||
uint16_t output_start_index = decoded_full * 7;
|
||||
for (j = 0; j < (remainder - 1); j++) {
|
||||
decoded[output_start_index + j] = 0x7F & source[encoded_msb_idx + j + 1];
|
||||
decoded[output_start_index + j] |= (0x80 & (source[encoded_msb_idx] << (1 + j)));
|
||||
}
|
||||
return decoded_full * 7 + remainder - 1;
|
||||
} else {
|
||||
return decoded_full * 7;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
34
tmk_core/protocol/midi/sysex_tools.h
Executable file → Normal file
34
tmk_core/protocol/midi/sysex_tools.h
Executable file → Normal file
|
@ -1,27 +1,27 @@
|
|||
//midi for embedded chips,
|
||||
//Copyright 2010 Alex Norman
|
||||
// midi for embedded chips,
|
||||
// Copyright 2010 Alex Norman
|
||||
//
|
||||
//This file is part of avr-midi.
|
||||
// This file is part of avr-midi.
|
||||
//
|
||||
//avr-midi 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 3 of the License, or
|
||||
// avr-midi 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 3 of the License, or
|
||||
//(at your option) any later version.
|
||||
//
|
||||
//avr-midi 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 more details.
|
||||
// avr-midi 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 more details.
|
||||
//
|
||||
//You should have received a copy of the GNU General Public License
|
||||
//along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with avr-midi. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
#ifndef SYSEX_TOOLS_H
|
||||
#define SYSEX_TOOLS_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <inttypes.h>
|
||||
|
||||
|
@ -31,7 +31,7 @@ extern "C" {
|
|||
*
|
||||
* These functions are for converting data to and from a "midi-safe" format,
|
||||
* which can be use to send data with sysex messages. Sysex messages may only
|
||||
* contain data where the to bit is not set.
|
||||
* contain data where the to bit is not set.
|
||||
*
|
||||
* An "encoded" midi message is one that contains all of the data from its
|
||||
* original state, but does not have any of the top bits set.
|
||||
|
@ -70,7 +70,7 @@ uint16_t sysex_decoded_length(uint16_t encoded_length);
|
|||
* @param encoded The output data buffer, must be at least sysex_encoded_length(length) bytes long.
|
||||
* @param source The input buffer of data to be encoded.
|
||||
* @param length The number of bytes from the input buffer to encode.
|
||||
*
|
||||
*
|
||||
* @return number of bytes encoded.
|
||||
*/
|
||||
uint16_t sysex_encode(uint8_t *encoded, const uint8_t *source, uint16_t length);
|
||||
|
@ -81,7 +81,7 @@ uint16_t sysex_encode(uint8_t *encoded, const uint8_t *source, uint16_t length);
|
|||
* @param decoded The output data buffer, must be at least sysex_decoded_length(length) bytes long.
|
||||
* @param source The input buffer of data to be decoded.
|
||||
* @param length The number of bytes from the input buffer to decode.
|
||||
*
|
||||
*
|
||||
* @return number of bytes decoded.
|
||||
*/
|
||||
uint16_t sysex_decode(uint8_t *decoded, const uint8_t *source, uint16_t length);
|
||||
|
@ -90,6 +90,6 @@ uint16_t sysex_decode(uint8_t *decoded, const uint8_t *source, uint16_t length);
|
|||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue