Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595
  1. /* USB EHCI Host for Teensy 3.6
  2. * Copyright 2017 Paul Stoffregen (paul@pjrc.com)
  3. *
  4. * Permission is hereby granted, free of charge, to any person obtaining a
  5. * copy of this software and associated documentation files (the
  6. * "Software"), to deal in the Software without restriction, including
  7. * without limitation the rights to use, copy, modify, merge, publish,
  8. * distribute, sublicense, and/or sell copies of the Software, and to
  9. * permit persons to whom the Software is furnished to do so, subject to
  10. * the following conditions:
  11. *
  12. * The above copyright notice and this permission notice shall be included
  13. * in all copies or substantial portions of the Software.
  14. *
  15. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16. * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  19. * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  20. * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  21. * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22. */
  23. #include <Arduino.h>
  24. #include "USBHost_t36.h" // Read this header first for key info
  25. #define print USBHost::print_
  26. #define println USBHost::println_
  27. void MIDIDeviceBase::init()
  28. {
  29. contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));
  30. contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));
  31. contribute_String_Buffers(mystring_bufs, sizeof(mystring_bufs)/sizeof(strbuf_t));
  32. handleNoteOff = NULL;
  33. handleNoteOn = NULL;
  34. handleVelocityChange = NULL;
  35. handleControlChange = NULL;
  36. handleProgramChange = NULL;
  37. handleAfterTouch = NULL;
  38. handlePitchChange = NULL;
  39. handleSysExPartial = NULL;
  40. handleSysExComplete = NULL;
  41. handleTimeCodeQuarterFrame = NULL;
  42. handleSongPosition = NULL;
  43. handleSongSelect = NULL;
  44. handleTuneRequest = NULL;
  45. handleClock = NULL;
  46. handleStart = NULL;
  47. handleContinue = NULL;
  48. handleStop = NULL;
  49. handleActiveSensing = NULL;
  50. handleSystemReset = NULL;
  51. handleRealTimeSystem = NULL;
  52. rx_head = 0;
  53. rx_tail = 0;
  54. rxpipe = NULL;
  55. txpipe = NULL;
  56. driver_ready_for_device(this);
  57. }
  58. // Audio Class-Specific Descriptor Types (audio 1.0, page 99)
  59. // CS_UNDEFINED 0x20
  60. // CS_DEVICE 0x21
  61. // CS_CONFIGURATION 0x22
  62. // CS_STRING 0x23
  63. // CS_INTERFACE 0x24
  64. // CS_ENDPOINT 0x25
  65. // MS Class-Specific Interface Descriptor Subtypes (midi 1.0, page 36)
  66. // MS_DESCRIPTOR_UNDEFINED 0x00
  67. // MS_HEADER 0x01
  68. // MIDI_IN_JACK 0x02
  69. // MIDI_OUT_JACK 0x03
  70. // ELEMENT 0x04
  71. // MS Class-Specific Endpoint Descriptor Subtypes (midi 1.0, page 36)
  72. // DESCRIPTOR_UNDEFINED 0x00
  73. // MS_GENERAL 0x01
  74. // MS MIDI IN and OUT Jack types (midi 1.0, page 36)
  75. // JACK_TYPE_UNDEFINED 0x00
  76. // EMBEDDED 0x01
  77. // EXTERNAL 0x02
  78. // Endpoint Control Selectors (midi 1.0, page 36)
  79. // EP_CONTROL_UNDEFINED 0x00
  80. // ASSOCIATION_CONTROL 0x01
  81. bool MIDIDeviceBase::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)
  82. {
  83. // only claim at interface level
  84. if (type != 1) return false;
  85. println("MIDIDevice claim this=", (uint32_t)this, HEX);
  86. println("len = ", len);
  87. const uint8_t *p = descriptors;
  88. const uint8_t *end = p + len;
  89. if (p[0] != 9 || p[1] != 4) return false; // interface descriptor
  90. //println(" bInterfaceClass=", p[5]);
  91. //println(" bInterfaceSubClass=", p[6]);
  92. bool ismidi = false;
  93. if (p[5] == 1 && p[6] == 3) {
  94. println(" Interface is MIDI"); // p[5] is bInterfaceClass: 1 = Audio class
  95. ismidi = true; // p[6] is bInterfaceSubClass: 3 = MIDI
  96. } else {
  97. if (p[5] >= 2 && p[5] <= 18) return false; // definitely not MIDI
  98. // Yamaha uses vendor specific class, but can be
  99. // identified as MIDI from CS_INTERFACE descriptors.
  100. // https://forum.pjrc.com/threads/55142?p=199162&viewfull=1#post199162
  101. println(" Interface is unknown (might be Yahama)");
  102. }
  103. p += 9;
  104. rx_ep = 0;
  105. tx_ep = 0;
  106. while (p < end) {
  107. len = *p;
  108. if (len < 4) return false; // all audio desc are at least 4 bytes
  109. if (p + len > end) return false; // reject if beyond end of data
  110. uint32_t type = p[1];
  111. print("type: ", type);
  112. println(", len: ", len);
  113. if (type == 4 || type == 11) break; // interface or IAD, not for us
  114. if (type == 0x24) { // 0x24 = Audio CS_INTERFACE, audio 1.0, page 99
  115. uint32_t subtype = p[2];
  116. //println("subtype: ", subtype);
  117. if (subtype == 1) {
  118. // Interface Header, midi 1.0, page 21
  119. println(" MIDI Header (ignored)");
  120. ismidi = true;
  121. } else if (subtype == 2) {
  122. // MIDI IN Jack, midi 1.0, page 22
  123. println(" MIDI IN Jack (ignored)");
  124. ismidi = true;
  125. } else if (subtype == 3) {
  126. // MIDI OUT Jack, midi 1.0, page 22
  127. println(" MIDI OUT Jack (ignored)");
  128. ismidi = true;
  129. } else if (subtype == 4) {
  130. // Element Descriptor, midi 1.0, page 23-24
  131. println(" MIDI Element (ignored)");
  132. ismidi = true;
  133. } else if (subtype == 0xF1 && p[3] == 2) {
  134. // see Linux sound/usb/quirks.c create_roland_midi_quirk()
  135. println(" Roland vendor-specific (ignored)");
  136. ismidi = true;
  137. } else {
  138. println(" Unknown MIDI CS_INTERFACE descriptor!");
  139. return false; // unknown
  140. }
  141. } else if (type == 5) {
  142. // endpoint descriptor
  143. if (p[0] < 7) return false; // at least 7 bytes
  144. if (p[3] != 2 && p[3] != 3) return false; // must be bulk or interrupt type
  145. println(" MIDI Endpoint: ", p[2], HEX);
  146. switch (p[2] & 0xF0) {
  147. case 0x80:
  148. // IN endpoint
  149. if (rx_ep == 0) {
  150. rx_ep = p[2] & 0x0F;
  151. rx_ep_type = p[3];
  152. rx_size = p[4] | (p[5] << 8);
  153. println(" rx_size = ", rx_size);
  154. }
  155. break;
  156. case 0x00:
  157. // OUT endpoint
  158. if (tx_ep == 0) {
  159. tx_ep = p[2];
  160. tx_ep_type = p[3];
  161. tx_size = p[4] | (p[5] << 8);
  162. println(" tx_size = ", tx_size);
  163. }
  164. break;
  165. default:
  166. return false;
  167. }
  168. } else if (type == 37) {
  169. // MIDI endpoint info, midi 1.0: 6.2.2, page 26
  170. println(" MIDI Endpoint Jack Association (ignored)");
  171. } else {
  172. println(" Unknown descriptor, type=", type);
  173. return false; // unknown
  174. }
  175. p += len;
  176. }
  177. if (!ismidi) {
  178. println("This interface is not MIDI");
  179. return false;
  180. }
  181. // if an IN endpoint was found, create its pipe
  182. if (rx_ep && rx_size <= max_packet_size) {
  183. rxpipe = new_Pipe(dev, rx_ep_type, rx_ep, 1, rx_size);
  184. if (rxpipe) {
  185. rxpipe->callback_function = rx_callback;
  186. queue_Data_Transfer(rxpipe, rx_buffer, rx_size, this);
  187. rx_packet_queued = true;
  188. }
  189. } else {
  190. rxpipe = NULL;
  191. }
  192. // if an OUT endpoint was found, create its pipe
  193. if (tx_ep && tx_size <= max_packet_size) {
  194. txpipe = new_Pipe(dev, tx_ep_type, tx_ep, 0, tx_size);
  195. if (txpipe) {
  196. txpipe->callback_function = tx_callback;
  197. tx1_count = 0;
  198. tx2_count = 0;
  199. }
  200. } else {
  201. txpipe = NULL;
  202. }
  203. rx_head = 0;
  204. rx_tail = 0;
  205. msg_channel = 0;
  206. msg_type = 0;
  207. msg_data1 = 0;
  208. msg_data2 = 0;
  209. msg_sysex_len = 0;
  210. // claim if either pipe created
  211. return (rxpipe || txpipe);
  212. }
  213. void MIDIDeviceBase::rx_callback(const Transfer_t *transfer)
  214. {
  215. if (transfer->driver) {
  216. ((MIDIDevice *)(transfer->driver))->rx_data(transfer);
  217. }
  218. }
  219. void MIDIDeviceBase::tx_callback(const Transfer_t *transfer)
  220. {
  221. if (transfer->driver) {
  222. ((MIDIDevice *)(transfer->driver))->tx_data(transfer);
  223. }
  224. }
  225. void MIDIDeviceBase::rx_data(const Transfer_t *transfer)
  226. {
  227. println("MIDIDevice Receive");
  228. print(" MIDI Data: ");
  229. uint32_t len = (transfer->length - ((transfer->qtd.token >> 16) & 0x7FFF)) >> 2;
  230. print_hexbytes(transfer->buffer, len * 4);
  231. uint32_t head = rx_head;
  232. uint32_t tail = rx_tail;
  233. for (uint32_t i=0; i < len; i++) {
  234. uint32_t msg = rx_buffer[i];
  235. if (msg) {
  236. if (++head >= rx_queue_size) head = 0;
  237. rx_queue[head] = msg;
  238. }
  239. }
  240. rx_head = head;
  241. rx_tail = tail;
  242. uint32_t avail = (head < tail) ? tail - head - 1 : rx_queue_size - 1 - head + tail;
  243. //println("rx_size = ", rx_size);
  244. println("avail = ", avail);
  245. if (avail >= (uint32_t)(rx_size>>2)) {
  246. // enough space to accept another full packet
  247. println("queue another receive packet");
  248. queue_Data_Transfer(rxpipe, rx_buffer, rx_size, this);
  249. rx_packet_queued = true;
  250. } else {
  251. // queue can't accept another packet's data, so leave
  252. // the data waiting on the device until we can accept it
  253. println("wait to receive more packets");
  254. rx_packet_queued = false;
  255. }
  256. }
  257. void MIDIDeviceBase::tx_data(const Transfer_t *transfer)
  258. {
  259. println("MIDIDevice transmit complete");
  260. print(" MIDI Data: ");
  261. print_hexbytes(transfer->buffer, tx_size);
  262. if (transfer->buffer == tx_buffer1) {
  263. tx1_count = 0;
  264. } else if (transfer->buffer == tx_buffer2) {
  265. tx2_count = 0;
  266. }
  267. }
  268. void MIDIDeviceBase::disconnect()
  269. {
  270. // should rx_queue be cleared?
  271. // as-is, the user can still read MIDI messages
  272. // which arrived before the device disconnected.
  273. rxpipe = NULL;
  274. txpipe = NULL;
  275. }
  276. void MIDIDeviceBase::write_packed(uint32_t data)
  277. {
  278. if (!txpipe) return;
  279. uint32_t tx_max = tx_size / 4;
  280. while (1) {
  281. uint32_t tx1 = tx1_count;
  282. uint32_t tx2 = tx2_count;
  283. if (tx1 < tx_max && (tx2 == 0 || tx2 >= tx_max)) {
  284. // use tx_buffer1
  285. tx_buffer1[tx1++] = data;
  286. tx1_count = tx1;
  287. __disable_irq();
  288. if (tx1 >= tx_max) {
  289. queue_Data_Transfer(txpipe, tx_buffer1, tx_max*4, this);
  290. } else {
  291. // TODO: start a timer, rather than sending the buffer
  292. // before it's full, to make best use of bandwidth
  293. tx1_count = tx_max;
  294. queue_Data_Transfer(txpipe, tx_buffer1, tx_max*4, this);
  295. }
  296. __enable_irq();
  297. return;
  298. }
  299. if (tx2 < tx_max) {
  300. // use tx_buffer2
  301. tx_buffer2[tx2++] = data;
  302. tx2_count = tx2;
  303. __disable_irq();
  304. if (tx2 >= tx_max) {
  305. queue_Data_Transfer(txpipe, tx_buffer2, tx_max*4, this);
  306. } else {
  307. // TODO: start a timer, rather than sending the buffer
  308. // before it's full, to make best use of bandwidth
  309. tx2_count = tx_max;
  310. queue_Data_Transfer(txpipe, tx_buffer2, tx_max*4, this);
  311. }
  312. __enable_irq();
  313. return;
  314. }
  315. }
  316. }
  317. void MIDIDeviceBase::send_sysex_buffer_has_term(const uint8_t *data, uint32_t length, uint8_t cable)
  318. {
  319. cable = (cable & 0x0F) << 4;
  320. while (length > 3) {
  321. write_packed(0x04 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));
  322. data += 3;
  323. length -= 3;
  324. }
  325. if (length == 3) {
  326. write_packed(0x07 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));
  327. } else if (length == 2) {
  328. write_packed(0x06 | cable | (data[0] << 8) | (data[1] << 16));
  329. } else if (length == 1) {
  330. write_packed(0x05 | cable | (data[0] << 8));
  331. }
  332. }
  333. void MIDIDeviceBase::send_sysex_add_term_bytes(const uint8_t *data, uint32_t length, uint8_t cable)
  334. {
  335. cable = (cable & 0x0F) << 4;
  336. if (length == 0) {
  337. write_packed(0x06 | cable | (0xF0 << 8) | (0xF7 << 16));
  338. return;
  339. } else if (length == 1) {
  340. write_packed(0x07 | cable | (0xF0 << 8) | (data[0] << 16) | (0xF7 << 24));
  341. return;
  342. } else {
  343. write_packed(0x04 | cable | (0xF0 << 8) | (data[0] << 16) | (data[1] << 24));
  344. data += 2;
  345. length -= 2;
  346. }
  347. while (length >= 3) {
  348. write_packed(0x04 | cable | (data[0] << 8) | (data[1] << 16) | (data[2] << 24));
  349. data += 3;
  350. length -= 3;
  351. }
  352. if (length == 2) {
  353. write_packed(0x07 | cable | (data[0] << 8) | (data[1] << 16) | (0xF7 << 24));
  354. } else if (length == 1) {
  355. write_packed(0x06 | cable | (data[0] << 8) | (0xF7 << 16));
  356. } else {
  357. write_packed(0x05 | cable | (0xF7 << 8));
  358. }
  359. }
  360. bool MIDIDeviceBase::read(uint8_t channel)
  361. {
  362. uint32_t n, head, tail, avail, ch, type1, type2, b1;
  363. head = rx_head;
  364. tail = rx_tail;
  365. if (head == tail) return false;
  366. if (++tail >= rx_queue_size) tail = 0;
  367. n = rx_queue[tail];
  368. rx_tail = tail;
  369. if (!rx_packet_queued && rxpipe) {
  370. avail = (head < tail) ? tail - head - 1 : rx_queue_size - 1 - head + tail;
  371. if (avail >= (uint32_t)(rx_size>>2)) {
  372. __disable_irq();
  373. queue_Data_Transfer(rxpipe, rx_buffer, rx_size, this);
  374. __enable_irq();
  375. }
  376. }
  377. println("read: ", n, HEX);
  378. type1 = n & 15;
  379. type2 = (n >> 12) & 15;
  380. b1 = (n >> 8) & 0xFF;
  381. ch = (b1 & 15) + 1;
  382. msg_cable = (n >> 4) & 15;
  383. if (type1 >= 0x08 && type1 <= 0x0E) {
  384. if (channel && channel != ch) {
  385. // ignore other channels when user wants single channel read
  386. return false;
  387. }
  388. if (type1 == 0x08 && type2 == 0x08) {
  389. msg_type = 0x80; // 0x80 = Note off
  390. if (handleNoteOff) {
  391. (*handleNoteOff)(ch, (n >> 16), (n >> 24));
  392. }
  393. } else
  394. if (type1 == 0x09 && type2 == 0x09) {
  395. if ((n >> 24) > 0) {
  396. msg_type = 0x90; // 0x90 = Note on
  397. if (handleNoteOn) {
  398. (*handleNoteOn)(ch, (n >> 16), (n >> 24));
  399. }
  400. } else {
  401. msg_type = 0x80; // 0x80 = Note off
  402. if (handleNoteOff) {
  403. (*handleNoteOff)(ch, (n >> 16), (n >> 24));
  404. }
  405. }
  406. } else
  407. if (type1 == 0x0A && type2 == 0x0A) {
  408. msg_type = 0xA0; // 0xA0 = AfterTouchPoly
  409. if (handleVelocityChange) {
  410. (*handleVelocityChange)(ch, (n >> 16), (n >> 24));
  411. }
  412. } else
  413. if (type1 == 0x0B && type2 == 0x0B) {
  414. msg_type = 0xB0; // 0xB0 = Control Change
  415. if (handleControlChange) {
  416. (*handleControlChange)(ch, (n >> 16), (n >> 24));
  417. }
  418. } else
  419. if (type1 == 0x0C && type2 == 0x0C) {
  420. msg_type = 0xC0; // 0xC0 = Program Change
  421. if (handleProgramChange) {
  422. (*handleProgramChange)(ch, (n >> 16));
  423. }
  424. } else
  425. if (type1 == 0x0D && type2 == 0x0D) {
  426. msg_type = 0xD0; // 0xD0 = After Touch
  427. if (handleAfterTouch) {
  428. (*handleAfterTouch)(ch, (n >> 16));
  429. }
  430. } else
  431. if (type1 == 0x0E && type2 == 0x0E) {
  432. msg_type = 0xE0; // 0xE0 = Pitch Bend
  433. if (handlePitchChange) {
  434. int value = ((n >> 16) & 0x7F) | ((n >> 17) & 0x3F80);
  435. value -= 8192; // 0 to 16383 --> -8192 to +8191
  436. (*handlePitchChange)(ch, value);
  437. }
  438. } else {
  439. return false;
  440. }
  441. return_message:
  442. msg_channel = ch;
  443. msg_data1 = (n >> 16);
  444. msg_data2 = (n >> 24);
  445. return true;
  446. }
  447. if (type1 == 0x02 || type1 == 0x03 || (type1 == 0x05 && b1 >= 0xF1 && b1 != 0xF7)) {
  448. // system common or system realtime message
  449. system_common_or_realtime:
  450. switch (b1) {
  451. case 0xF1: // usbMIDI.TimeCodeQuarterFrame
  452. if (handleTimeCodeQuarterFrame) {
  453. (*handleTimeCodeQuarterFrame)(n >> 16);
  454. }
  455. break;
  456. case 0xF2: // usbMIDI.SongPosition
  457. if (handleSongPosition) {
  458. (*handleSongPosition)(((n >> 16) & 0x7F) | ((n >> 17) & 0x3F80));
  459. }
  460. break;
  461. case 0xF3: // usbMIDI.SongSelect
  462. if (handleSongSelect) {
  463. (*handleSongSelect)(n >> 16);
  464. }
  465. break;
  466. case 0xF6: // usbMIDI.TuneRequest
  467. if (handleTuneRequest) {
  468. (*handleTuneRequest)();
  469. }
  470. break;
  471. case 0xF8: // usbMIDI.Clock
  472. if (handleClock) {
  473. (*handleClock)();
  474. } else if (handleRealTimeSystem) {
  475. (*handleRealTimeSystem)(0xF8);
  476. }
  477. break;
  478. case 0xFA: // usbMIDI.Start
  479. if (handleStart) {
  480. (*handleStart)();
  481. } else if (handleRealTimeSystem) {
  482. (*handleRealTimeSystem)(0xFA);
  483. }
  484. break;
  485. case 0xFB: // usbMIDI.Continue
  486. if (handleContinue) {
  487. (*handleContinue)();
  488. } else if (handleRealTimeSystem) {
  489. (*handleRealTimeSystem)(0xFB);
  490. }
  491. break;
  492. case 0xFC: // usbMIDI.Stop
  493. if (handleStop) {
  494. (*handleStop)();
  495. } else if (handleRealTimeSystem) {
  496. (*handleRealTimeSystem)(0xFC);
  497. }
  498. break;
  499. case 0xFE: // usbMIDI.ActiveSensing
  500. if (handleActiveSensing) {
  501. (*handleActiveSensing)();
  502. } else if (handleRealTimeSystem) {
  503. (*handleRealTimeSystem)(0xFE);
  504. }
  505. break;
  506. case 0xFF: // usbMIDI.SystemReset
  507. if (handleSystemReset) {
  508. (*handleSystemReset)();
  509. } else if (handleRealTimeSystem) {
  510. (*handleRealTimeSystem)(0xFF);
  511. }
  512. break;
  513. default:
  514. return false; // unknown message, ignore it
  515. }
  516. msg_type = b1;
  517. goto return_message;
  518. }
  519. if (type1 == 0x04) {
  520. sysex_byte(n >> 8);
  521. sysex_byte(n >> 16);
  522. sysex_byte(n >> 24);
  523. return false;
  524. }
  525. if (type1 >= 0x05 && type1 <= 0x07) {
  526. sysex_byte(b1);
  527. // allow for buggy devices which use code 5 to transmit 1 byte at a time
  528. // https://forum.pjrc.com/threads/43450?p=164596&viewfull=1#post164596
  529. if (type1 == 0x05 && b1 != 0xF7) return false;
  530. if (type1 >= 0x06) sysex_byte(n >> 16);
  531. if (type1 == 0x07) sysex_byte(n >> 24);
  532. uint16_t len = msg_sysex_len;
  533. msg_data1 = len;
  534. msg_data2 = len >> 8;
  535. msg_sysex_len = 0;
  536. msg_type = 0xF0; // 0xF0 = SystemExclusive
  537. if (handleSysExPartial) {
  538. (*handleSysExPartial)(msg_sysex, len, 1);
  539. } else if (handleSysExComplete) {
  540. (*handleSysExComplete)(msg_sysex, len);
  541. }
  542. return true;
  543. }
  544. if (type1 == 0x0F) {
  545. if (b1 >= 0xF8) {
  546. goto system_common_or_realtime;
  547. }
  548. if (b1 == 0xF0 || msg_sysex_len > 0) {
  549. // Is this really needed? Mac OS-X does this, but do any devices?
  550. sysex_byte(b1);
  551. }
  552. }
  553. return false;
  554. }
  555. void MIDIDeviceBase::sysex_byte(uint8_t b)
  556. {
  557. if (handleSysExPartial && msg_sysex_len >= SYSEX_MAX_LEN) {
  558. // when buffer is full, send another chunk to partial handler.
  559. (*handleSysExPartial)(msg_sysex, msg_sysex_len, 0);
  560. msg_sysex_len = 0;
  561. }
  562. if (msg_sysex_len < SYSEX_MAX_LEN) {
  563. msg_sysex[msg_sysex_len++] = b;
  564. }
  565. }