visus
/
teensy-core-4.1
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Teensy 4.1 core updated for C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1135 Commits
2 Branches
Tree: add1b5ab6c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'add1b5ab6c'
${ noResults }
teensy-core-4.1/teensy4/usb_midi.c

499 lines
16KB
Raw Blame History 

  1. /* Teensyduino Core Library

  2.  * http://www.pjrc.com/teensy/

  3.  * Copyright (c) 2017 PJRC.COM, LLC.

  4.  *

  5.  * Permission is hereby granted, free of charge, to any person obtaining

  6.  * a copy of this software and associated documentation files (the

  7.  * "Software"), to deal in the Software without restriction, including

  8.  * without limitation the rights to use, copy, modify, merge, publish,

  9.  * distribute, sublicense, and/or sell copies of the Software, and to

  10.  * permit persons to whom the Software is furnished to do so, subject to

  11.  * the following conditions:

  12.  *

  13.  * 1. The above copyright notice and this permission notice shall be

  14.  * included in all copies or substantial portions of the Software.

  15.  *

  16.  * 2. If the Software is incorporated into a build system that allows

  17.  * selection among a list of target devices, then similar target

  18.  * devices manufactured by PJRC.COM must be included in the list of

  19.  * target devices and selectable in the same manner.

  20.  *

  21.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  22.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

  23.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  24.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

  25.  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

  26.  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  27.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  28.  * SOFTWARE.

  29.  */

  30. 

  31. #include "usb_dev.h"

  32. #include "usb_midi.h"

  33. #include "core_pins.h" // for yield()

  34. #include <string.h> // for memcpy()

  35. #include "avr/pgmspace.h" // for PROGMEM, DMAMEM, FASTRUN

  36. #include "debug/printf.h"

  37. #include "core_pins.h"

  38. 

  39. #ifdef MIDI_INTERFACE // defined by usb_dev.h -> usb_desc.h

  40. 

  41. uint8_t usb_midi_msg_cable;

  42. uint8_t usb_midi_msg_channel;

  43. uint8_t usb_midi_msg_type;

  44. uint8_t usb_midi_msg_data1;

  45. uint8_t usb_midi_msg_data2;

  46. // TODO: separate sysex buffers for each cable...

  47. uint8_t usb_midi_msg_sysex[USB_MIDI_SYSEX_MAX];

  48. uint16_t usb_midi_msg_sysex_len;

  49. void (*usb_midi_handleNoteOff)(uint8_t ch, uint8_t note, uint8_t vel) = NULL;

  50. void (*usb_midi_handleNoteOn)(uint8_t ch, uint8_t note, uint8_t vel) = NULL;

  51. void (*usb_midi_handleVelocityChange)(uint8_t ch, uint8_t note, uint8_t vel) = NULL;

  52. void (*usb_midi_handleControlChange)(uint8_t ch, uint8_t control, uint8_t value) = NULL;

  53. void (*usb_midi_handleProgramChange)(uint8_t ch, uint8_t program) = NULL;

  54. void (*usb_midi_handleAfterTouch)(uint8_t ch, uint8_t pressure) = NULL;

  55. void (*usb_midi_handlePitchChange)(uint8_t ch, int pitch) = NULL;

  56. void (*usb_midi_handleSysExPartial)(const uint8_t *data, uint16_t length, uint8_t complete) = NULL;

  57. void (*usb_midi_handleSysExComplete)(uint8_t *data, unsigned int size) = NULL;

  58. void (*usb_midi_handleTimeCodeQuarterFrame)(uint8_t data) = NULL;

  59. void (*usb_midi_handleSongPosition)(uint16_t beats) = NULL;

  60. void (*usb_midi_handleSongSelect)(uint8_t songnumber) = NULL;

  61. void (*usb_midi_handleTuneRequest)(void) = NULL;

  62. void (*usb_midi_handleClock)(void) = NULL;

  63. void (*usb_midi_handleStart)(void) = NULL;

  64. void (*usb_midi_handleContinue)(void) = NULL;

  65. void (*usb_midi_handleStop)(void) = NULL;

  66. void (*usb_midi_handleActiveSensing)(void) = NULL;

  67. void (*usb_midi_handleSystemReset)(void) = NULL;

  68. void (*usb_midi_handleRealTimeSystem)(uint8_t rtb) = NULL;

  69. 

  70. 

  71. //static usb_packet_t *rx_packet=NULL;

  72. //static usb_packet_t *tx_packet=NULL;

  73. static uint8_t transmit_previous_timeout=0;

  74. static uint8_t tx_noautoflush=0;

  75. extern volatile uint8_t usb_high_speed;

  76. 

  77. 

  78. #define TX_NUM   4

  79. #define TX_SIZE  512 /* should be a multiple of MIDI_TX_SIZE_480 */

  80. static transfer_t tx_transfer[TX_NUM] __attribute__ ((used, aligned(32)));

  81. DMAMEM static uint8_t txbuffer[TX_SIZE * TX_NUM] __attribute__ ((aligned(32)));

  82. static uint8_t tx_head=0;

  83. static uint16_t tx_available=0;

  84. static uint16_t tx_packet_size=0;

  85. 

  86. #define RX_NUM  6

  87. static transfer_t rx_transfer[RX_NUM] __attribute__ ((used, aligned(32)));

  88. DMAMEM static uint8_t rx_buffer[RX_NUM * MIDI_RX_SIZE_480] __attribute__ ((aligned(32)));

  89. static uint16_t rx_count[RX_NUM];

  90. static uint16_t rx_index[RX_NUM];

  91. static uint16_t rx_packet_size=0;

  92. static volatile uint8_t rx_head;

  93. static volatile uint8_t rx_tail;

  94. static uint8_t rx_list[RX_NUM + 1];

  95. static volatile uint32_t rx_available;

  96. static void rx_queue_transfer(int i);

  97. static void rx_event(transfer_t *t);

  98. 

  99. 

  100. void usb_midi_configure(void)

  101. {

  102. 	printf("usb_midi_configure\n");

  103. 	if (usb_high_speed) {

  104. 		tx_packet_size = MIDI_TX_SIZE_480;

  105. 		rx_packet_size = MIDI_RX_SIZE_480;

  106. 	} else {

  107. 		tx_packet_size = MIDI_TX_SIZE_12;

  108. 		rx_packet_size = MIDI_RX_SIZE_12;

  109. 	}

  110. 	memset(tx_transfer, 0, sizeof(tx_transfer));

  111. 	tx_head = 0;

  112. 	tx_available = 0;

  113. 	memset(rx_transfer, 0, sizeof(rx_transfer));

  114. 	memset(rx_count, 0, sizeof(rx_count));

  115. 	memset(rx_index, 0, sizeof(rx_index));

  116. 	rx_head = 0;

  117. 	rx_tail = 0;

  118. 	rx_available = 0;

  119. 	usb_config_rx(MIDI_RX_ENDPOINT, rx_packet_size, 0, rx_event);

  120. 	usb_config_tx(MIDI_TX_ENDPOINT, tx_packet_size, 0, NULL); // TODO: is ZLP needed?

  121. 	int i;

  122. 	for (i=0; i < RX_NUM; i++) rx_queue_transfer(i);

  123. 	transmit_previous_timeout = 0;

  124. 	tx_noautoflush = 0;

  125. }

  126. 

  127. 

  128. 

  129. // When the PC isn't listening, how long do we wait before discarding data?

  130. #define TX_TIMEOUT_MSEC 40

  131. 

  132. 

  133. void usb_midi_write_packed(uint32_t n)

  134. {

  135. 	printf("usb_midi_write_packed\n");

  136. 	if (!usb_configuration) return;

  137. 	tx_noautoflush = 1;

  138. 	uint32_t head = tx_head;

  139. 	transfer_t *xfer = tx_transfer + head;

  140. 	uint32_t wait_begin_at = systick_millis_count;

  141. 	while (!tx_available) {

  142. 		uint32_t status = usb_transfer_status(xfer);

  143. 		if (!(status & 0x80)) {

  144. 			if (status & 0x68) {

  145. 				// TODO: what if status has errors???

  146. 			}

  147. 			tx_available = tx_packet_size;

  148. 			transmit_previous_timeout = 0;

  149. 			break;

  150. 		}

  151. 		if (systick_millis_count - wait_begin_at > TX_TIMEOUT_MSEC) {

  152. 			transmit_previous_timeout = 1;

  153. 		}

  154. 		if (transmit_previous_timeout) return;

  155. 		if (!usb_configuration) return;

  156. 		yield();

  157. 	}

  158. 	uint32_t *txdata = (uint32_t *)(txbuffer + (tx_head * TX_SIZE) + (TX_SIZE - tx_available));

  159. 	*txdata = n;

  160. 	tx_available -= 4;

  161. 	if (tx_available == 0) {

  162. 		uint8_t *txbuf = txbuffer + (tx_head * TX_SIZE);

  163. 		usb_prepare_transfer(xfer, txbuf, tx_packet_size, 0);

  164. 		arm_dcache_flush_delete(txbuf, TX_SIZE);

  165. 		usb_transmit(MIDI_TX_ENDPOINT, xfer);

  166. 		if (++head >= TX_NUM) head = 0;

  167. 		tx_head = head;

  168. 		usb_stop_sof_interrupts(MIDI_INTERFACE);

  169. 	} else {

  170. 		usb_start_sof_interrupts(MIDI_INTERFACE);

  171. 	}

  172. 	tx_noautoflush = 0;

  173. }

  174. 

  175. void usb_midi_flush_output(void)

  176. {

  177. 	//printf("usb_midi_flush_output\n");

  178. 	if (tx_noautoflush == 0 && tx_available > 0) {

  179. 		printf(" tx, %d %d\n", tx_packet_size, tx_available);

  180. 		uint32_t head = tx_head;

  181. 		transfer_t *xfer = tx_transfer + head;

  182. 		uint8_t *txbuf = txbuffer + (head * TX_SIZE);

  183. 		uint32_t len = tx_packet_size - tx_available;

  184. 		usb_prepare_transfer(xfer, txbuf, len, 0);

  185. 		arm_dcache_flush_delete(txbuf, TX_SIZE);

  186. 		usb_transmit(MIDI_TX_ENDPOINT, xfer);

  187. 		if (++head >= TX_NUM) head = 0;

  188. 		tx_head = head;

  189. 		tx_available = 0;

  190. 		usb_stop_sof_interrupts(MIDI_INTERFACE);

  191. 	}

  192. }

  193. 

  194. void usb_midi_send_sysex_buffer_has_term(const uint8_t *data, uint32_t length, uint8_t cable)

  195. {

  196. 	cable = (cable & 0x0F) << 4;

  197.         while (length > 3) {

  198.                 usb_midi_write_packed(0x04 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));

  199.                 data += 3;

  200.                 length -= 3;

  201.         }

  202.         if (length == 3) {

  203.                 usb_midi_write_packed(0x07 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));

  204.         } else if (length == 2) {

  205.                 usb_midi_write_packed(0x06 | cable | (data[0] << 8) | (data[1] << 16));

  206.         } else if (length == 1) {

  207.                 usb_midi_write_packed(0x05 | cable | (data[0] << 8));

  208.         }

  209. }

  210. 

  211. void usb_midi_send_sysex_add_term_bytes(const uint8_t *data, uint32_t length, uint8_t cable)

  212. {

  213. 	cable = (cable & 0x0F) << 4;

  214. 

  215. 	if (length == 0) {

  216. 		usb_midi_write_packed(0x06 | cable | (0xF0 << 8) | (0xF7 << 16));

  217. 		return;

  218. 	} else if (length == 1) {

  219. 		usb_midi_write_packed(0x07 | cable | (0xF0 << 8) | (data[0] << 16) | (0xF7 << 24));

  220. 		return;

  221. 	} else {

  222. 		usb_midi_write_packed(0x04 | cable | (0xF0 << 8) | (data[0] << 16) | (data[1] << 24));

  223. 		data += 2;

  224. 		length -= 2;

  225. 	}

  226. 	while (length >= 3) {

  227. 		usb_midi_write_packed(0x04 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));

  228. 		data += 3;

  229. 		length -= 3;

  230. 	}

  231. 	if (length == 2) {

  232. 		usb_midi_write_packed(0x07 | cable | (data[0] << 8) | (data[1] << 16) | (0xF7 << 24));

  233. 	} else if (length == 1) {

  234.                 usb_midi_write_packed(0x06 | cable | (data[0] << 8) | (0xF7 << 16));

  235. 	} else {

  236.                 usb_midi_write_packed(0x05 | cable | (0xF7 << 8));

  237. 	}

  238. }

  239. 

  240. void static sysex_byte(uint8_t b)

  241. {

  242. 	if (usb_midi_handleSysExPartial && usb_midi_msg_sysex_len >= USB_MIDI_SYSEX_MAX) {

  243. 		// when buffer is full, send another chunk to partial handler.

  244. 		(*usb_midi_handleSysExPartial)(usb_midi_msg_sysex, usb_midi_msg_sysex_len, 0);

  245. 		usb_midi_msg_sysex_len = 0;

  246. 	}

  247. 	if (usb_midi_msg_sysex_len < USB_MIDI_SYSEX_MAX) {

  248. 		usb_midi_msg_sysex[usb_midi_msg_sysex_len++] = b;

  249. 	}

  250. }

  251. 

  252. 

  253. 

  254. 

  255. 

  256. 

  257. static void rx_queue_transfer(int i)

  258. {

  259. 	NVIC_DISABLE_IRQ(IRQ_USB1);

  260. 	void *buffer = rx_buffer + i * MIDI_RX_SIZE_480;

  261. 	usb_prepare_transfer(rx_transfer + i, buffer, rx_packet_size, i);

  262. 	arm_dcache_delete(buffer, rx_packet_size);

  263. 	usb_receive(MIDI_RX_ENDPOINT, rx_transfer + i);

  264. 	NVIC_ENABLE_IRQ(IRQ_USB1);

  265. }

  266. 

  267. 

  268. 

  269. // called by USB interrupt when any packet is received

  270. static void rx_event(transfer_t *t)

  271. {

  272. 	int len = rx_packet_size - ((t->status >> 16) & 0x7FFF);

  273. 	len &= 0xFFFC; // MIDI packets must be multiple of 4 bytes

  274. 	int i = t->callback_param;

  275. 	printf("rx event, len=%d, i=%d\n", len, i);

  276. 	if (len > 0) {

  277. 		uint32_t head = rx_head;

  278. 		rx_count[i] = len;

  279. 		rx_index[i] = 0;

  280. 		if (++head > RX_NUM) head = 0;

  281. 		rx_list[head] = i;

  282. 		rx_head = head;

  283. 		rx_available += len;

  284. 	} else {

  285. 		// received a zero length packet

  286. 		rx_queue_transfer(i);

  287. 	}

  288. }

  289. 

  290. 

  291. uint32_t usb_midi_available(void)

  292. {

  293. 	return rx_available / 4;

  294. }

  295. 

  296. uint32_t usb_midi_read_message(void)

  297. {

  298. 	uint32_t n = 0;

  299. 	NVIC_DISABLE_IRQ(IRQ_USB1);

  300. 	uint32_t tail = rx_tail;

  301. 	if (tail != rx_head) {

  302. 		if (++tail > RX_NUM) tail = 0;

  303. 		uint32_t i = rx_list[tail];

  304. 		//uint32_t avail = (rx_count[i] - rx_index[i]) / 4;

  305. 		void *p = rx_buffer + i * MIDI_RX_SIZE_480 + rx_index[i];

  306. 		n = *(uint32_t *)p;

  307. 		rx_available -= 4;

  308. 		rx_index[i] += 4;

  309. 		if (rx_index[i] >= rx_count[i]) {

  310. 			rx_tail = tail;

  311. 			rx_queue_transfer(i);

  312. 		}

  313. 	}

  314. 	NVIC_ENABLE_IRQ(IRQ_USB1);

  315. 	return n;

  316. }

  317. 

  318. int usb_midi_read(uint32_t channel)

  319. {

  320. 	uint32_t n, ch, type1, type2, b1;

  321. 	

  322. 	n = usb_midi_read_message();

  323. 	if (n == 0) return 0;

  324. 	type1 = n & 15;

  325. 	type2 = (n >> 12) & 15;

  326. 	b1 = (n >> 8) & 0xFF;

  327. 	ch = (b1 & 15) + 1;

  328. 	usb_midi_msg_cable = (n >> 4) & 15;

  329. 	if (type1 >= 0x08 && type1 <= 0x0E) {

  330. 		if (channel && channel != ch) {

  331. 			// ignore other channels when user wants single channel read

  332. 			return 0;

  333. 		}

  334. 		if (type1 == 0x08 && type2 == 0x08) {

  335. 			usb_midi_msg_type = 0x80;		// 0x80 = usbMIDI.NoteOff

  336. 			if (usb_midi_handleNoteOff)

  337. 				(*usb_midi_handleNoteOff)(ch, (n >> 16), (n >> 24));

  338. 		} else

  339. 		if (type1 == 0x09 && type2 == 0x09) {

  340. 			if ((n >> 24) > 0) {

  341. 				usb_midi_msg_type = 0x90;	// 0x90 = usbMIDI.NoteOn

  342. 				if (usb_midi_handleNoteOn)

  343. 					(*usb_midi_handleNoteOn)(ch, (n >> 16), (n >> 24));

  344. 			} else {

  345. 				usb_midi_msg_type = 0x80;	// 0x80 = usbMIDI.NoteOff

  346. 				if (usb_midi_handleNoteOff)

  347. 					(*usb_midi_handleNoteOff)(ch, (n >> 16), (n >> 24));

  348. 			}

  349. 		} else

  350. 		if (type1 == 0x0A && type2 == 0x0A) {

  351. 			usb_midi_msg_type = 0xA0;		// 0xA0 = usbMIDI.AfterTouchPoly

  352. 			if (usb_midi_handleVelocityChange)

  353. 				(*usb_midi_handleVelocityChange)(ch, (n >> 16), (n >> 24));

  354. 		} else

  355. 		if (type1 == 0x0B && type2 == 0x0B) {

  356. 			usb_midi_msg_type = 0xB0;		// 0xB0 = usbMIDI.ControlChange

  357. 			if (usb_midi_handleControlChange)

  358. 				(*usb_midi_handleControlChange)(ch, (n >> 16), (n >> 24));

  359. 		} else

  360. 		if (type1 == 0x0C && type2 == 0x0C) {

  361. 			usb_midi_msg_type = 0xC0;		// 0xC0 = usbMIDI.ProgramChange

  362. 			if (usb_midi_handleProgramChange)

  363. 				(*usb_midi_handleProgramChange)(ch, (n >> 16));

  364. 		} else

  365. 		if (type1 == 0x0D && type2 == 0x0D) {

  366. 			usb_midi_msg_type = 0xD0;		// 0xD0 = usbMIDI.AfterTouchChannel

  367. 			if (usb_midi_handleAfterTouch)

  368. 				(*usb_midi_handleAfterTouch)(ch, (n >> 16));

  369. 		} else

  370. 		if (type1 == 0x0E && type2 == 0x0E) {

  371. 			usb_midi_msg_type = 0xE0;		// 0xE0 = usbMIDI.PitchBend

  372. 			if (usb_midi_handlePitchChange) {

  373. 				int value = ((n >> 16) & 0x7F) | ((n >> 17) & 0x3F80);

  374. 				value -= 8192; // 0 to 16383 --> -8192 to +8191

  375. 				(*usb_midi_handlePitchChange)(ch, value);

  376. 			}

  377. 		} else {

  378. 			return 0;

  379. 		}

  380. 		return_message:

  381. 		usb_midi_msg_channel = ch;

  382. 		usb_midi_msg_data1 = (n >> 16);

  383. 		usb_midi_msg_data2 = (n >> 24);

  384. 		return 1;

  385. 	}

  386. 	if (type1 == 0x02 || type1 == 0x03 || (type1 == 0x05 && b1 >= 0xF1 && b1 != 0xF7)) {

  387. 		// system common or system realtime message

  388. 		system_common_or_realtime:

  389. 		switch (b1) {

  390. 		  case 0xF1: // usbMIDI.TimeCodeQuarterFrame

  391. 			if (usb_midi_handleTimeCodeQuarterFrame) {

  392. 				(*usb_midi_handleTimeCodeQuarterFrame)(n >> 16);

  393. 			}

  394. 			break;

  395. 		  case 0xF2: // usbMIDI.SongPosition

  396. 			if (usb_midi_handleSongPosition) {

  397. 				(*usb_midi_handleSongPosition)(

  398. 				  ((n >> 16) & 0x7F) | ((n >> 17) & 0x3F80));

  399. 			}

  400. 			break;

  401. 		  case 0xF3: // usbMIDI.SongSelect

  402. 			if (usb_midi_handleSongSelect) {

  403. 				(*usb_midi_handleSongSelect)(n >> 16);

  404. 			}

  405. 			break;

  406. 		  case 0xF6: // usbMIDI.TuneRequest

  407. 			if (usb_midi_handleTuneRequest) {

  408. 				(*usb_midi_handleTuneRequest)();

  409. 			}

  410. 			break;

  411. 		  case 0xF8: // usbMIDI.Clock

  412. 			if (usb_midi_handleClock) {

  413. 				(*usb_midi_handleClock)();

  414. 			} else if (usb_midi_handleRealTimeSystem) {

  415. 				(*usb_midi_handleRealTimeSystem)(0xF8);

  416. 			}

  417. 			break;

  418. 		  case 0xFA: // usbMIDI.Start

  419. 			if (usb_midi_handleStart) {

  420. 				(*usb_midi_handleStart)();

  421. 			} else if (usb_midi_handleRealTimeSystem) {

  422. 				(*usb_midi_handleRealTimeSystem)(0xFA);

  423. 			}

  424. 			break;

  425. 		  case 0xFB: // usbMIDI.Continue

  426. 			if (usb_midi_handleContinue) {

  427. 				(*usb_midi_handleContinue)();

  428. 			} else if (usb_midi_handleRealTimeSystem) {

  429. 				(*usb_midi_handleRealTimeSystem)(0xFB);

  430. 			}

  431. 			break;

  432. 		  case 0xFC: // usbMIDI.Stop

  433. 			if (usb_midi_handleStop) {

  434. 				(*usb_midi_handleStop)();

  435. 			} else if (usb_midi_handleRealTimeSystem) {

  436. 				(*usb_midi_handleRealTimeSystem)(0xFC);

  437. 			}

  438. 			break;

  439. 		  case 0xFE: // usbMIDI.ActiveSensing

  440. 			if (usb_midi_handleActiveSensing) {

  441. 				(*usb_midi_handleActiveSensing)();

  442. 			} else if (usb_midi_handleRealTimeSystem) {

  443. 				(*usb_midi_handleRealTimeSystem)(0xFE);

  444. 			}

  445. 			break;

  446. 		  case 0xFF: // usbMIDI.SystemReset

  447. 			if (usb_midi_handleSystemReset) {

  448. 				(*usb_midi_handleSystemReset)();

  449. 			} else if (usb_midi_handleRealTimeSystem) {

  450. 				(*usb_midi_handleRealTimeSystem)(0xFF);

  451. 			}

  452. 			break;

  453. 		  default:

  454. 			return 0; // unknown message, ignore it

  455. 		}

  456. 		usb_midi_msg_type = b1;

  457. 		goto return_message;

  458. 	}

  459. 	if (type1 == 0x04) {

  460. 		sysex_byte(n >> 8);

  461. 		sysex_byte(n >> 16);

  462. 		sysex_byte(n >> 24);

  463. 		return 0;

  464. 	}

  465. 	if (type1 >= 0x05 && type1 <= 0x07) {

  466. 		sysex_byte(b1);

  467. 		if (type1 >= 0x06) sysex_byte(n >> 16);

  468. 		if (type1 == 0x07) sysex_byte(n >> 24);

  469. 		uint16_t len = usb_midi_msg_sysex_len;

  470. 		usb_midi_msg_data1 = len;

  471. 		usb_midi_msg_data2 = len >> 8;

  472. 		usb_midi_msg_sysex_len = 0;

  473. 		usb_midi_msg_type = 0xF0;			// 0xF0 = usbMIDI.SystemExclusive

  474. 		if (usb_midi_handleSysExPartial) {

  475. 			(*usb_midi_handleSysExPartial)(usb_midi_msg_sysex, len, 1);

  476. 		} else if (usb_midi_handleSysExComplete) {

  477. 			(*usb_midi_handleSysExComplete)(usb_midi_msg_sysex, len);

  478. 		}

  479. 		return 1;

  480. 	}

  481. 	if (type1 == 0x0F) {

  482. 		if (b1 >= 0xF8) {

  483. 			// From Sebastian Tomczak, seb.tomczak at gmail.com

  484. 			// http://little-scale.blogspot.com/2011/08/usb-midi-game-boy-sync-for-16.html

  485. 			goto system_common_or_realtime;

  486. 		}

  487. 		if (b1 == 0xF0 || usb_midi_msg_sysex_len > 0) {

  488. 			// From David Sorlien, dsorlien at gmail.com, http://axe4live.wordpress.com

  489. 			// OSX sometimes uses Single Byte Unparsed to

  490. 			// send bytes in the middle of a SYSEX message.

  491. 			sysex_byte(b1);

  492. 		}

  493. 	}

  494. 	return 0;

  495. }

  496. 

  497. 

  498. #endif // MIDI_INTERFACE