The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
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.

1150 lines
43KB

  1. /*
  2. ==============================================================================
  3. This file is part of the JUCE library.
  4. Copyright (c) 2013 - Raw Material Software Ltd.
  5. Permission is granted to use this software under the terms of either:
  6. a) the GPL v2 (or any later version)
  7. b) the Affero GPL v3
  8. Details of these licenses can be found at: www.gnu.org/licenses
  9. JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  10. WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  11. A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  12. ------------------------------------------------------------------------------
  13. To release a closed-source product which uses JUCE, commercial licenses are
  14. available: visit www.juce.com for more information.
  15. ==============================================================================
  16. */
  17. namespace
  18. {
  19. //==========================================================================
  20. /** Allows a block of data to be accessed as a stream of OSC data.
  21. The memory is shared and will be neither copied nor owned by the OSCInputStream.
  22. This class is implementing the Open Sound Control 1.0 Specification for
  23. interpreting the data.
  24. Note: some older implementations of OSC may omit the OSC Type Tag string
  25. in OSC messages. This class will treat such OSC messages as format errors.
  26. */
  27. class OSCInputStream
  28. {
  29. public:
  30. /** Creates an OSCInputStream.
  31. @param sourceData the block of data to use as the stream's source
  32. @param sourceDataSize the number of bytes in the source data block
  33. */
  34. OSCInputStream (const void* sourceData, size_t sourceDataSize)
  35. : input (sourceData, sourceDataSize, false)
  36. {}
  37. //======================================================================
  38. /** Returns a pointer to the source data block from which this stream is reading. */
  39. const void* getData() const noexcept { return input.getData(); }
  40. /** Returns the number of bytes of source data in the block from which this stream is reading. */
  41. size_t getDataSize() const noexcept { return input.getDataSize(); }
  42. /** Returns the current position of the stream. */
  43. int64 getPosition() { return input.getPosition(); }
  44. /** Attempts to set the current position of the stream. Returns true if this was successful. */
  45. bool setPosition (int64 pos) { return input.setPosition (pos); }
  46. /** Returns the total amount of data in bytes accessible by this stream. */
  47. int64 getTotalLength() { return input.getTotalLength(); }
  48. /** Returns true if the stream has no more data to read. */
  49. bool isExhausted() { return input.isExhausted(); }
  50. //======================================================================
  51. int32 readInt32()
  52. {
  53. if (input.getNumBytesRemaining() < 4)
  54. throw OSCFormatError ("OSC input stream exhausted while reading int32");
  55. return input.readIntBigEndian();
  56. }
  57. uint64 readUint64()
  58. {
  59. if (input.getNumBytesRemaining() < 8)
  60. throw OSCFormatError ("OSC input stream exhausted while reading uint64");
  61. return input.readInt64BigEndian();
  62. }
  63. float readFloat32()
  64. {
  65. if (input.getNumBytesRemaining() < 4)
  66. throw OSCFormatError ("OSC input stream exhausted while reading float");
  67. return input.readFloatBigEndian();
  68. }
  69. String readString()
  70. {
  71. if (input.getNumBytesRemaining() < 4)
  72. throw OSCFormatError ("OSC input stream exhausted while reading string");
  73. const size_t posBegin = (size_t) getPosition();
  74. String s (input.readString());
  75. const size_t posEnd = (size_t) getPosition();
  76. if (static_cast<const char*> (getData()) [posEnd - 1] != '\0')
  77. throw OSCFormatError ("OSC input stream exhausted before finding null terminator of string");
  78. size_t bytesRead = posEnd - posBegin;
  79. readPaddingZeros (bytesRead);
  80. return s;
  81. }
  82. MemoryBlock readBlob()
  83. {
  84. if (input.getNumBytesRemaining() < 4)
  85. throw OSCFormatError ("OSC input stream exhausted while reading blob");
  86. const size_t blobDataSize = static_cast<size_t> (input.readIntBigEndian());
  87. if (input.getNumBytesRemaining() < (blobDataSize + 3) % 4)
  88. throw OSCFormatError ("OSC input stream exhausted before reaching end of blob");
  89. MemoryBlock blob;
  90. const size_t bytesRead = input.readIntoMemoryBlock (blob, blobDataSize);
  91. readPaddingZeros (bytesRead);
  92. return blob;
  93. }
  94. OSCTimeTag readTimeTag()
  95. {
  96. if (input.getNumBytesRemaining() < 8)
  97. throw OSCFormatError ("OSC input stream exhausted while reading time tag");
  98. return OSCTimeTag (input.readInt64BigEndian());
  99. }
  100. OSCAddress readAddress()
  101. {
  102. return OSCAddress (readString());
  103. }
  104. OSCAddressPattern readAddressPattern()
  105. {
  106. return OSCAddressPattern (readString());
  107. }
  108. //======================================================================
  109. OSCTypeList readTypeTagString()
  110. {
  111. OSCTypeList typeList;
  112. if (input.getNumBytesRemaining() < 4)
  113. throw OSCFormatError ("OSC input stream exhausted while reading type tag string");
  114. if (input.readByte() != ',')
  115. throw OSCFormatError ("OSC input stream format error: expected type tag string");
  116. for (;;)
  117. {
  118. if (isExhausted())
  119. throw OSCFormatError ("OSC input stream exhausted while reading type tag string");
  120. const OSCType type = input.readByte();
  121. if (type == 0)
  122. break; // encountered null terminator. list is complete.
  123. if (! OSCTypes::isSupportedType (type))
  124. throw OSCFormatError ("OSC input stream format error: encountered unsupported type tag");
  125. typeList.add (type);
  126. }
  127. size_t bytesRead = typeList.size() + 2;
  128. readPaddingZeros (bytesRead);
  129. return typeList;
  130. }
  131. //==========================================================================
  132. OSCArgument readArgument (OSCType type)
  133. {
  134. switch (type)
  135. {
  136. case OSCTypes::int32: return OSCArgument (readInt32());
  137. case OSCTypes::float32: return OSCArgument (readFloat32());
  138. case OSCTypes::string: return OSCArgument (readString());
  139. case OSCTypes::blob: return OSCArgument (readBlob());
  140. default:
  141. // You supplied an invalid OSCType when calling readArgument! This should never happen.
  142. jassertfalse;
  143. throw OSCInternalError ("OSC input stream: internal error while reading message argument");
  144. }
  145. }
  146. //======================================================================
  147. OSCMessage readMessage()
  148. {
  149. OSCAddressPattern ap = readAddressPattern();
  150. OSCTypeList types = readTypeTagString();
  151. OSCMessage msg (ap);
  152. for (OSCType* type = types.begin(); type != types.end(); ++type)
  153. msg.addArgument (readArgument (*type));
  154. return msg;
  155. }
  156. //======================================================================
  157. OSCBundle readBundle()
  158. {
  159. if (input.getNumBytesRemaining() < 16)
  160. throw OSCFormatError ("OSC input stream exhausted while reading bundle");
  161. if (readString() != "#bundle")
  162. throw OSCFormatError ("OSC input stream format error: bundle does not start with string '#bundle'");
  163. OSCBundle bundle (readTimeTag());
  164. while (! isExhausted())
  165. bundle.addElement (readElement());
  166. return bundle;
  167. }
  168. //======================================================================
  169. OSCBundle::Element readElement()
  170. {
  171. if (input.getNumBytesRemaining() < 4)
  172. throw OSCFormatError("OSC input stream exhausted while reading bundle element size");
  173. const int elementSize = readInt32();
  174. if (elementSize < 4)
  175. throw OSCFormatError("OSC input stream format error: invalid bundle element size");
  176. return readElementWithKnownSize (elementSize);
  177. }
  178. //======================================================================
  179. OSCBundle::Element readElementWithKnownSize (size_t elementSize)
  180. {
  181. if (input.getNumBytesRemaining() < elementSize)
  182. throw OSCFormatError ("OSC input stream exhausted while reading bundle element content");
  183. const char firstContentChar = static_cast<const char*> (getData()) [getPosition()];
  184. if (firstContentChar == '/') return OSCBundle::Element (readMessageWithCheckedSize (elementSize));
  185. if (firstContentChar == '#') return OSCBundle::Element (readBundleWithCheckedSize (elementSize));
  186. throw OSCFormatError ("OSC input stream: invalid bundle element content");
  187. }
  188. private:
  189. MemoryInputStream input;
  190. //======================================================================
  191. void readPaddingZeros (size_t bytesRead)
  192. {
  193. size_t numZeros = ~(bytesRead - 1) & 0x03;
  194. while (numZeros > 0)
  195. {
  196. if (isExhausted() || input.readByte() != 0)
  197. throw OSCFormatError ("OSC input stream format error: missing padding zeros");
  198. --numZeros;
  199. }
  200. }
  201. OSCBundle readBundleWithCheckedSize (size_t size)
  202. {
  203. const size_t begin = (size_t) getPosition();
  204. OSCBundle bundle (readBundle());
  205. if (getPosition() - begin != size)
  206. throw OSCFormatError ("OSC input stream format error: wrong element content size encountered while reading");
  207. return bundle;
  208. }
  209. OSCMessage readMessageWithCheckedSize (size_t size)
  210. {
  211. const size_t begin = (size_t) getPosition();
  212. OSCMessage message (readMessage());
  213. if (getPosition() - begin != size)
  214. throw OSCFormatError ("OSC input stream format error: wrong element content size encountered while reading");
  215. return message;
  216. }
  217. };
  218. } // namespace
  219. //==============================================================================
  220. struct OSCReceiver::Pimpl : private Thread,
  221. private MessageListener
  222. {
  223. Pimpl()
  224. : Thread ("Juce OSC server"),
  225. formatErrorHandler (nullptr)
  226. {
  227. }
  228. ~Pimpl()
  229. {
  230. disconnect();
  231. }
  232. //==========================================================================
  233. bool connectToPort (int portNum)
  234. {
  235. if (! disconnect())
  236. return false;
  237. portNumber = portNum;
  238. socket = new DatagramSocket (false);
  239. if (! socket->bindToPort (portNumber))
  240. return false;
  241. startThread();
  242. return true;
  243. }
  244. bool disconnect()
  245. {
  246. if (socket != nullptr)
  247. {
  248. signalThreadShouldExit();
  249. socket->shutdown();
  250. waitForThreadToExit (10000);
  251. socket = nullptr;
  252. }
  253. return true;
  254. }
  255. //==========================================================================
  256. void addListener (Listener<MessageLoopCallback>* listenerToAdd)
  257. {
  258. listeners.add (listenerToAdd);
  259. }
  260. void addListener (Listener<RealtimeCallback>* listenerToAdd)
  261. {
  262. realtimeListeners.add (listenerToAdd);
  263. }
  264. void addListener (ListenerWithOSCAddress<MessageLoopCallback>* listenerToAdd,
  265. OSCAddress addressToMatch)
  266. {
  267. addListenerWithAddress (listenerToAdd, addressToMatch, listenersWithAddress);
  268. }
  269. void addListener (ListenerWithOSCAddress<RealtimeCallback>* listenerToAdd,
  270. OSCAddress addressToMatch)
  271. {
  272. addListenerWithAddress (listenerToAdd, addressToMatch, realtimeListenersWithAddress);
  273. }
  274. void removeListener (Listener<MessageLoopCallback>* listenerToRemove)
  275. {
  276. listeners.remove (listenerToRemove);
  277. }
  278. void removeListener (Listener<RealtimeCallback>* listenerToRemove)
  279. {
  280. realtimeListeners.remove (listenerToRemove);
  281. }
  282. void removeListener (ListenerWithOSCAddress<MessageLoopCallback>* listenerToRemove)
  283. {
  284. removeListenerWithAddress (listenerToRemove, listenersWithAddress);
  285. }
  286. void removeListener (ListenerWithOSCAddress<RealtimeCallback>* listenerToRemove)
  287. {
  288. removeListenerWithAddress (listenerToRemove, realtimeListenersWithAddress);
  289. }
  290. //==========================================================================
  291. struct CallbackMessage : public Message
  292. {
  293. CallbackMessage (OSCBundle::Element oscElement) : content (oscElement) {}
  294. // the payload of the message. Can be either an OSCMessage or an OSCBundle.
  295. OSCBundle::Element content;
  296. };
  297. //==========================================================================
  298. void handleBuffer (const char* data, int dataSize)
  299. {
  300. OSCInputStream inStream (data, dataSize);
  301. try
  302. {
  303. OSCBundle::Element content = inStream.readElementWithKnownSize (dataSize);
  304. // realtime listeners should receive the OSC content first - and immediately
  305. // on this thread:
  306. callRealtimeListeners (content);
  307. if (content.isMessage())
  308. callRealtimeListenersWithAddress (content.getMessage());
  309. // now post the message that will trigger the handleMessage callback
  310. // dealing with the non-realtime listeners.
  311. if (listeners.size() > 0 || listenersWithAddress.size() > 0)
  312. postMessage (new CallbackMessage (content));
  313. }
  314. catch (OSCFormatError)
  315. {
  316. if (formatErrorHandler != nullptr)
  317. formatErrorHandler (data, dataSize);
  318. }
  319. }
  320. //==========================================================================
  321. void registerFormatErrorHandler (OSCReceiver::FormatErrorHandler handler)
  322. {
  323. formatErrorHandler = handler;
  324. }
  325. private:
  326. //==========================================================================
  327. void run() override
  328. {
  329. while (! threadShouldExit())
  330. {
  331. jassert (socket != nullptr);
  332. char buffer[oscBufferSize];
  333. const int bytesRead = socket->read (buffer, (int) sizeof (buffer), false);
  334. if (bytesRead >= 4)
  335. handleBuffer (buffer, bytesRead);
  336. }
  337. }
  338. //==========================================================================
  339. template <typename ListenerType>
  340. void addListenerWithAddress (ListenerType* listenerToAdd,
  341. OSCAddress address,
  342. Array<std::pair<OSCAddress, ListenerType*> >& array)
  343. {
  344. for (int i = 0; i < array.size(); ++i)
  345. if (address == array.getReference (i).first && listenerToAdd == array.getReference (i).second)
  346. return;
  347. array.add (std::make_pair (address, listenerToAdd));
  348. }
  349. //==========================================================================
  350. template <typename ListenerType>
  351. void removeListenerWithAddress (ListenerType* listenerToRemove,
  352. Array<std::pair<OSCAddress, ListenerType*> >& array)
  353. {
  354. for (int i = 0; i < array.size(); ++i)
  355. {
  356. if (listenerToRemove == array.getReference (i).second)
  357. {
  358. // aarrgh... can't simply call array.remove (i) because this
  359. // requires a default c'tor to be present for OSCAddress...
  360. // luckily, we don't care about methods preserving element order:
  361. array.swap (i, array.size() - 1);
  362. array.removeLast();
  363. break;
  364. }
  365. }
  366. }
  367. //==========================================================================
  368. void handleMessage (const Message& msg) override
  369. {
  370. if (const CallbackMessage* callbackMessage = dynamic_cast<const CallbackMessage*> (&msg))
  371. {
  372. const OSCBundle::Element& content = callbackMessage->content;
  373. callListeners (content);
  374. if (content.isMessage())
  375. callListenersWithAddress (content.getMessage());
  376. }
  377. }
  378. //==========================================================================
  379. void callListeners (const OSCBundle::Element& content)
  380. {
  381. typedef OSCReceiver::Listener<OSCReceiver::MessageLoopCallback> Listener;
  382. if (content.isMessage())
  383. listeners.call (&Listener::oscMessageReceived, content.getMessage());
  384. else if (content.isBundle())
  385. listeners.call (&Listener::oscBundleReceived, content.getBundle());
  386. }
  387. void callRealtimeListeners (const OSCBundle::Element& content)
  388. {
  389. typedef OSCReceiver::Listener<OSCReceiver::RealtimeCallback> Listener;
  390. if (content.isMessage())
  391. realtimeListeners.call (&Listener::oscMessageReceived, content.getMessage());
  392. else if (content.isBundle())
  393. realtimeListeners.call (&Listener::oscBundleReceived, content.getBundle());
  394. }
  395. //==========================================================================
  396. void callListenersWithAddress (const OSCMessage& message)
  397. {
  398. typedef OSCReceiver::ListenerWithOSCAddress<OSCReceiver::MessageLoopCallback> Listener;
  399. for (std::pair<OSCAddress, Listener*>* entry = listenersWithAddress.begin();
  400. entry != listenersWithAddress.end();
  401. ++entry)
  402. {
  403. if (Listener* listener = entry->second)
  404. if (message.getAddressPattern().matches (entry->first))
  405. listener->oscMessageReceived (message);
  406. }
  407. }
  408. void callRealtimeListenersWithAddress (const OSCMessage& message)
  409. {
  410. typedef OSCReceiver::ListenerWithOSCAddress<OSCReceiver::RealtimeCallback> Listener;
  411. for (std::pair<OSCAddress, Listener*>* entry = realtimeListenersWithAddress.begin();
  412. entry != realtimeListenersWithAddress.end();
  413. ++entry)
  414. {
  415. if (Listener* listener = entry->second)
  416. if (message.getAddressPattern().matches (entry->first))
  417. listener->oscMessageReceived (message);
  418. }
  419. }
  420. //==========================================================================
  421. ListenerList<OSCReceiver::Listener<OSCReceiver::MessageLoopCallback> > listeners;
  422. ListenerList<OSCReceiver::Listener<OSCReceiver::RealtimeCallback> > realtimeListeners;
  423. Array<std::pair<OSCAddress, OSCReceiver::ListenerWithOSCAddress<OSCReceiver::MessageLoopCallback>* > > listenersWithAddress;
  424. Array<std::pair<OSCAddress, OSCReceiver::ListenerWithOSCAddress<OSCReceiver::RealtimeCallback>* > > realtimeListenersWithAddress;
  425. ScopedPointer<DatagramSocket> socket;
  426. int portNumber;
  427. OSCReceiver::FormatErrorHandler formatErrorHandler;
  428. enum { oscBufferSize = 4098 };
  429. JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)
  430. };
  431. //==============================================================================
  432. OSCReceiver::OSCReceiver() : pimpl (new Pimpl())
  433. {
  434. }
  435. OSCReceiver::~OSCReceiver()
  436. {
  437. pimpl = nullptr;
  438. }
  439. bool OSCReceiver::connect (int portNumber)
  440. {
  441. return pimpl->connectToPort (portNumber);
  442. }
  443. bool OSCReceiver::disconnect()
  444. {
  445. return pimpl->disconnect();
  446. }
  447. void OSCReceiver::addListener (Listener<MessageLoopCallback>* listenerToAdd)
  448. {
  449. pimpl->addListener (listenerToAdd);
  450. }
  451. void OSCReceiver::addListener (Listener<RealtimeCallback>* listenerToAdd)
  452. {
  453. pimpl->addListener (listenerToAdd);
  454. }
  455. void OSCReceiver::addListener (ListenerWithOSCAddress<MessageLoopCallback>* listenerToAdd, OSCAddress addressToMatch)
  456. {
  457. pimpl->addListener (listenerToAdd, addressToMatch);
  458. }
  459. void OSCReceiver::addListener (ListenerWithOSCAddress<RealtimeCallback>* listenerToAdd, OSCAddress addressToMatch)
  460. {
  461. pimpl->addListener (listenerToAdd, addressToMatch);
  462. }
  463. void OSCReceiver::removeListener (Listener<MessageLoopCallback>* listenerToRemove)
  464. {
  465. pimpl->removeListener (listenerToRemove);
  466. }
  467. void OSCReceiver::removeListener (Listener<RealtimeCallback>* listenerToRemove)
  468. {
  469. pimpl->removeListener (listenerToRemove);
  470. }
  471. void OSCReceiver::removeListener (ListenerWithOSCAddress<MessageLoopCallback>* listenerToRemove)
  472. {
  473. pimpl->removeListener (listenerToRemove);
  474. }
  475. void OSCReceiver::removeListener (ListenerWithOSCAddress<RealtimeCallback>* listenerToRemove)
  476. {
  477. pimpl->removeListener (listenerToRemove);
  478. }
  479. void OSCReceiver::registerFormatErrorHandler (FormatErrorHandler handler)
  480. {
  481. pimpl->registerFormatErrorHandler (handler);
  482. }
  483. //==============================================================================
  484. //==============================================================================
  485. #if JUCE_UNIT_TESTS
  486. class OSCInputStreamTests : public UnitTest
  487. {
  488. public:
  489. OSCInputStreamTests() : UnitTest ("OSCInputStream class") {}
  490. void runTest()
  491. {
  492. beginTest ("reading OSC addresses");
  493. {
  494. const char buffer[16] = {
  495. '/', 't', 'e', 's', 't', '/', 'f', 'a',
  496. 'd', 'e', 'r', '7', '\0', '\0', '\0', '\0' };
  497. // reading a valid osc address:
  498. {
  499. OSCInputStream inStream (buffer, sizeof (buffer));
  500. OSCAddress address = inStream.readAddress();
  501. expect (inStream.getPosition() == sizeof (buffer));
  502. expectEquals (address.toString(), String ("/test/fader7"));
  503. }
  504. // check various possible failures:
  505. {
  506. // zero padding is present, but size is not modulo 4:
  507. OSCInputStream inStream (buffer, 15);
  508. expectThrowsType (inStream.readAddress(), OSCFormatError)
  509. }
  510. {
  511. // zero padding is missing:
  512. OSCInputStream inStream (buffer, 12);
  513. expectThrowsType (inStream.readAddress(), OSCFormatError)
  514. }
  515. {
  516. // pattern does not start with a forward slash:
  517. OSCInputStream inStream (buffer + 4, 12);
  518. expectThrowsType (inStream.readAddress(), OSCFormatError)
  519. }
  520. }
  521. beginTest ("reading OSC address patterns");
  522. {
  523. const char buffer[20] = {
  524. '/', '*', '/', '*', 'p', 'u', 't', '/',
  525. 'f', 'a', 'd', 'e', 'r', '[', '0', '-',
  526. '9', ']', '\0', '\0' };
  527. // reading a valid osc address pattern:
  528. {
  529. OSCInputStream inStream (buffer, sizeof (buffer));
  530. expectDoesNotThrow (inStream.readAddressPattern());
  531. }
  532. {
  533. OSCInputStream inStream (buffer, sizeof (buffer));
  534. OSCAddressPattern ap = inStream.readAddressPattern();
  535. expect (inStream.getPosition() == sizeof (buffer));
  536. expectEquals (ap.toString(), String ("/*/*put/fader[0-9]"));
  537. expect (ap.containsWildcards());
  538. }
  539. // check various possible failures:
  540. {
  541. // zero padding is present, but size is not modulo 4:
  542. OSCInputStream inStream (buffer, 19);
  543. expectThrowsType (inStream.readAddressPattern(), OSCFormatError)
  544. }
  545. {
  546. // zero padding is missing:
  547. OSCInputStream inStream (buffer, 16);
  548. expectThrowsType (inStream.readAddressPattern(), OSCFormatError)
  549. }
  550. {
  551. // pattern does not start with a forward slash:
  552. OSCInputStream inStream (buffer + 4, 16);
  553. expectThrowsType (inStream.readAddressPattern(), OSCFormatError)
  554. }
  555. }
  556. beginTest ("reading OSC time tags");
  557. {
  558. char buffer[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 };
  559. OSCInputStream inStream (buffer, sizeof (buffer));
  560. OSCTimeTag tag = inStream.readTimeTag();
  561. expect (tag.isImmediately());
  562. }
  563. {
  564. char buffer[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
  565. OSCInputStream inStream (buffer, sizeof (buffer));
  566. OSCTimeTag tag = inStream.readTimeTag();
  567. expect (! tag.isImmediately());
  568. }
  569. beginTest ("reading OSC arguments");
  570. {
  571. // test data:
  572. int testInt = -2015;
  573. const uint8 testIntRepresentation[] = { 0xFF, 0xFF, 0xF8, 0x21 }; // big endian two's complement
  574. float testFloat = 345.6125f;
  575. const uint8 testFloatRepresentation[] = { 0x43, 0xAC, 0xCE, 0x66 }; // big endian IEEE 754
  576. String testString = "Hello, World!";
  577. const char testStringRepresentation[] = {
  578. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W',
  579. 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0' }; // padded to size % 4 == 0
  580. const uint8 testBlobData[] = { 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
  581. const MemoryBlock testBlob (testBlobData, sizeof (testBlobData));
  582. const uint8 testBlobRepresentation[] = {
  583. 0x00, 0x00, 0x00, 0x05,
  584. 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x00, 0x00 }; // size prefixed + padded to size % 4 == 0
  585. // read:
  586. {
  587. {
  588. // int32:
  589. OSCInputStream inStream (testIntRepresentation, sizeof (testIntRepresentation));
  590. OSCArgument arg = inStream.readArgument (OSCTypes::int32);
  591. expect (inStream.getPosition() == 4);
  592. expect (arg.isInt32());
  593. expectEquals (arg.getInt32(), testInt);
  594. }
  595. {
  596. // float32:
  597. OSCInputStream inStream (testFloatRepresentation, sizeof (testFloatRepresentation));
  598. OSCArgument arg = inStream.readArgument (OSCTypes::float32);
  599. expect (inStream.getPosition() == 4);
  600. expect (arg.isFloat32());
  601. expectEquals (arg.getFloat32(), testFloat);
  602. }
  603. {
  604. // string:
  605. OSCInputStream inStream (testStringRepresentation, sizeof (testStringRepresentation));
  606. OSCArgument arg = inStream.readArgument (OSCTypes::string);
  607. expect (inStream.getPosition() == sizeof (testStringRepresentation));
  608. expect (arg.isString());
  609. expectEquals (arg.getString(), testString);
  610. }
  611. {
  612. // blob:
  613. OSCInputStream inStream (testBlobRepresentation, sizeof (testBlobRepresentation));
  614. OSCArgument arg = inStream.readArgument (OSCTypes::blob);
  615. expect (inStream.getPosition() == sizeof (testBlobRepresentation));
  616. expect (arg.isBlob());
  617. expect (arg.getBlob() == testBlob);
  618. }
  619. }
  620. // read invalid representations:
  621. {
  622. // not enough bytes
  623. {
  624. const uint8 rawData[] = { 0xF8, 0x21 };
  625. OSCInputStream inStream (rawData, sizeof (rawData));
  626. expectThrowsType (inStream.readArgument (OSCTypes::int32), OSCFormatError);
  627. expectThrowsType (inStream.readArgument (OSCTypes::float32), OSCFormatError);
  628. }
  629. // test string not being padded to multiple of 4 bytes:
  630. {
  631. const char rawData[] = {
  632. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W',
  633. 'o', 'r', 'l', 'd', '!', '\0' }; // padding missing
  634. OSCInputStream inStream (rawData, sizeof (rawData));
  635. expectThrowsType (inStream.readArgument (OSCTypes::string), OSCFormatError);
  636. }
  637. {
  638. const char rawData[] = {
  639. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W',
  640. 'o', 'r', 'l', 'd', '!', '\0', 'x', 'x' }; // padding with non-zero chars
  641. OSCInputStream inStream (rawData, sizeof (rawData));
  642. expectThrowsType (inStream.readArgument (OSCTypes::string), OSCFormatError);
  643. }
  644. // test blob not being padded to multiple of 4 bytes:
  645. {
  646. const uint8 rawData[] = { 0x00, 0x00, 0x00, 0x05, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; // padding missing
  647. OSCInputStream inStream (rawData, sizeof (rawData));
  648. expectThrowsType (inStream.readArgument (OSCTypes::blob), OSCFormatError);
  649. }
  650. // test blob having wrong size
  651. {
  652. const uint8 rawData[] = { 0x00, 0x00, 0x00, 0x12, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
  653. OSCInputStream inStream (rawData, sizeof (rawData));
  654. expectThrowsType (inStream.readArgument (OSCTypes::blob), OSCFormatError);
  655. }
  656. }
  657. }
  658. beginTest ("reading OSC messages (type tag string)");
  659. {
  660. {
  661. // valid empty message
  662. const char data[] = {
  663. '/', 't', 'e', 's', 't', '\0', '\0', '\0',
  664. ',', '\0', '\0', '\0' };
  665. OSCInputStream inStream (data, sizeof (data));
  666. OSCMessage msg = inStream.readMessage();
  667. expect (msg.getAddressPattern().toString() == "/test");
  668. expect (msg.size() == 0);
  669. }
  670. {
  671. // invalid message: no type tag string
  672. const char data[] = {
  673. '/', 't', 'e', 's', 't', '\0', '\0', '\0',
  674. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W',
  675. 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0' };
  676. OSCInputStream inStream (data, sizeof (data));
  677. expectThrowsType (inStream.readMessage(), OSCFormatError);
  678. }
  679. {
  680. // invalid message: no type tag string and also empty
  681. const char data[] = { '/', 't', 'e', 's', 't', '\0', '\0', '\0' };
  682. OSCInputStream inStream (data, sizeof (data));
  683. expectThrowsType (inStream.readMessage(), OSCFormatError);
  684. }
  685. // invalid message: wrong padding
  686. {
  687. const char data[] = { '/', 't', 'e', 's', 't', '\0', '\0', '\0', ',', '\0', '\0', '\0' };
  688. OSCInputStream inStream (data, sizeof (data) - 1);
  689. expectThrowsType (inStream.readMessage(), OSCFormatError);
  690. }
  691. // invalid message: says it contains an arg, but doesn't
  692. {
  693. const char data[] = { '/', 't', 'e', 's', 't', '\0', '\0', '\0', ',', 'i', '\0', '\0' };
  694. OSCInputStream inStream (data, sizeof (data));
  695. expectThrowsType (inStream.readMessage(), OSCFormatError);
  696. }
  697. // invalid message: binary size does not match size deducted from type tag string
  698. {
  699. const char data[] = { '/', 't', 'e', 's', 't', '\0', '\0', '\0', ',', 'i', 'f', '\0' };
  700. OSCInputStream inStream (data, sizeof (data));
  701. expectThrowsType (inStream.readMessage(), OSCFormatError);
  702. }
  703. }
  704. beginTest ("reading OSC messages (contents)");
  705. {
  706. // valid non-empty message.
  707. {
  708. int32 testInt = -2015;
  709. float testFloat = 345.6125f;
  710. String testString = "Hello, World!";
  711. const uint8 testBlobData[] = { 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
  712. const MemoryBlock testBlob (testBlobData, sizeof (testBlobData));
  713. uint8 data[] = {
  714. '/', 't', 'e', 's', 't', '\0', '\0', '\0',
  715. ',', 'i', 'f', 's', 'b', '\0', '\0', '\0',
  716. 0xFF, 0xFF, 0xF8, 0x21,
  717. 0x43, 0xAC, 0xCE, 0x66,
  718. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0',
  719. 0x00, 0x00, 0x00, 0x05, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x00, 0x00
  720. };
  721. OSCInputStream inStream (data, sizeof (data));
  722. OSCMessage msg = inStream.readMessage();
  723. expectEquals (msg.getAddressPattern().toString(), String ("/test"));
  724. expectEquals (msg.size(), 4);
  725. expectEquals (msg[0].getType(), OSCTypes::int32);
  726. expectEquals (msg[1].getType(), OSCTypes::float32);
  727. expectEquals (msg[2].getType(), OSCTypes::string);
  728. expectEquals (msg[3].getType(), OSCTypes::blob);
  729. expectEquals (msg[0].getInt32(), testInt);
  730. expectEquals (msg[1].getFloat32(), testFloat);
  731. expectEquals (msg[2].getString(), testString);
  732. expect (msg[3].getBlob() == testBlob);
  733. }
  734. }
  735. beginTest ("reading OSC messages (handling of corrupted messages)");
  736. {
  737. // invalid messages
  738. {
  739. OSCInputStream inStream (nullptr, 0);
  740. expectThrowsType (inStream.readMessage(), OSCFormatError);
  741. }
  742. {
  743. const uint8 data[] = { 0x00 };
  744. OSCInputStream inStream (data, 0);
  745. expectThrowsType (inStream.readMessage(), OSCFormatError);
  746. }
  747. {
  748. uint8 data[] = {
  749. '/', 't', 'e', 's', 't', '\0', '\0', '\0',
  750. ',', 'i', 'f', 's', 'b', // type tag string not padded
  751. 0xFF, 0xFF, 0xF8, 0x21,
  752. 0x43, 0xAC, 0xCE, 0x66,
  753. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0',
  754. 0x00, 0x00, 0x00, 0x05, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x00, 0x00
  755. };
  756. OSCInputStream inStream (data, sizeof (data));
  757. expectThrowsType (inStream.readMessage(), OSCFormatError);
  758. }
  759. {
  760. uint8 data[] = {
  761. '/', 't', 'e', 's', 't', '\0', '\0', '\0',
  762. ',', 'i', 'f', 's', 'b', '\0', '\0', '\0',
  763. 0xFF, 0xFF, 0xF8, 0x21,
  764. 0x43, 0xAC, 0xCE, 0x66,
  765. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0' // rest of message cut off
  766. };
  767. OSCInputStream inStream (data, sizeof (data));
  768. expectThrowsType (inStream.readMessage(), OSCFormatError);
  769. }
  770. }
  771. beginTest ("reading OSC messages (handling messages without type tag strings)");
  772. {
  773. {
  774. uint8 data[] = { '/', 't', 'e', 's', 't', '\0', '\0', '\0' };
  775. OSCInputStream inStream (data, sizeof (data));
  776. expectThrowsType (inStream.readMessage(), OSCFormatError);
  777. }
  778. {
  779. uint8 data[] = {
  780. '/', 't', 'e', 's', 't', '\0', '\0', '\0',
  781. 0xFF, 0xFF, 0xF8, 0x21,
  782. 0x43, 0xAC, 0xCE, 0x66,
  783. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0',
  784. 0x00, 0x00, 0x00, 0x05, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x00, 0x00
  785. };
  786. OSCInputStream inStream (data, sizeof (data));
  787. expectThrowsType (inStream.readMessage(), OSCFormatError);
  788. }
  789. }
  790. beginTest ("reading OSC bundles");
  791. {
  792. // valid bundle (empty)
  793. {
  794. uint8 data[] = {
  795. '#', 'b', 'u', 'n', 'd', 'l', 'e', '\0',
  796. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01
  797. };
  798. OSCInputStream inStream (data, sizeof (data));
  799. OSCBundle bundle = inStream.readBundle();
  800. expect (bundle.getTimeTag().isImmediately());
  801. expect (bundle.size() == 0);
  802. }
  803. // valid bundle (containing both messages and other bundles)
  804. {
  805. int32 testInt = -2015;
  806. float testFloat = 345.6125f;
  807. String testString = "Hello, World!";
  808. const uint8 testBlobData[] = { 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
  809. const MemoryBlock testBlob (testBlobData, sizeof (testBlobData));
  810. uint8 data[] = {
  811. '#', 'b', 'u', 'n', 'd', 'l', 'e', '\0',
  812. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
  813. 0x00, 0x00, 0x00, 0x34,
  814. '/', 't', 'e', 's', 't', '/', '1', '\0',
  815. ',', 'i', 'f', 's', 'b', '\0', '\0', '\0',
  816. 0xFF, 0xFF, 0xF8, 0x21,
  817. 0x43, 0xAC, 0xCE, 0x66,
  818. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0',
  819. 0x00, 0x00, 0x00, 0x05, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x00, 0x00,
  820. 0x00, 0x00, 0x00, 0x0C,
  821. '/', 't', 'e', 's', 't', '/', '2', '\0',
  822. ',', '\0', '\0', '\0',
  823. 0x00, 0x00, 0x00, 0x10,
  824. '#', 'b', 'u', 'n', 'd', 'l', 'e', '\0',
  825. 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
  826. };
  827. OSCInputStream inStream (data, sizeof (data));
  828. OSCBundle bundle = inStream.readBundle();
  829. expect (bundle.getTimeTag().isImmediately());
  830. expect (bundle.size() == 3);
  831. OSCBundle::Element* elements = bundle.begin();
  832. expect (elements[0].isMessage());
  833. expect (elements[0].getMessage().getAddressPattern().toString() == "/test/1");
  834. expect (elements[0].getMessage().size() == 4);
  835. expect (elements[0].getMessage()[0].isInt32());
  836. expect (elements[0].getMessage()[1].isFloat32());
  837. expect (elements[0].getMessage()[2].isString());
  838. expect (elements[0].getMessage()[3].isBlob());
  839. expectEquals (elements[0].getMessage()[0].getInt32(), testInt);
  840. expectEquals (elements[0].getMessage()[1].getFloat32(), testFloat);
  841. expectEquals (elements[0].getMessage()[2].getString(), testString);
  842. expect (elements[0].getMessage()[3].getBlob() == testBlob);
  843. expect (elements[1].isMessage());
  844. expect (elements[1].getMessage().getAddressPattern().toString() == "/test/2");
  845. expect (elements[1].getMessage().size() == 0);
  846. expect (elements[2].isBundle());
  847. expect (! elements[2].getBundle().getTimeTag().isImmediately());
  848. }
  849. // invalid bundles.
  850. {
  851. uint8 data[] = {
  852. '#', 'b', 'u', 'n', 'd', 'l', 'e', '\0',
  853. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
  854. 0x00, 0x00, 0x00, 0x34, // wrong bundle element size (too large)
  855. '/', 't', 'e', 's', 't', '/', '1', '\0',
  856. ',', 's', '\0', '\0',
  857. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0'
  858. };
  859. OSCInputStream inStream (data, sizeof (data));
  860. expectThrowsType (inStream.readBundle(), OSCFormatError);
  861. }
  862. {
  863. uint8 data[] = {
  864. '#', 'b', 'u', 'n', 'd', 'l', 'e', '\0',
  865. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
  866. 0x00, 0x00, 0x00, 0x08, // wrong bundle element size (too small)
  867. '/', 't', 'e', 's', 't', '/', '1', '\0',
  868. ',', 's', '\0', '\0',
  869. 'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\0', '\0', '\0'
  870. };
  871. OSCInputStream inStream (data, sizeof (data));
  872. expectThrowsType (inStream.readBundle(), OSCFormatError);
  873. }
  874. {
  875. uint8 data[] = {
  876. '#', 'b', 'u', 'n', 'd', 'l', 'e', '\0',
  877. 0x00, 0x00, 0x00, 0x00 // incomplete time tag
  878. };
  879. OSCInputStream inStream (data, sizeof (data));
  880. expectThrowsType (inStream.readBundle(), OSCFormatError);
  881. }
  882. {
  883. uint8 data[] = {
  884. '#', 'b', 'u', 'n', 'x', 'l', 'e', '\0', // wrong initial string
  885. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  886. };
  887. OSCInputStream inStream (data, sizeof (data));
  888. expectThrowsType (inStream.readBundle(), OSCFormatError);
  889. }
  890. {
  891. uint8 data[] = {
  892. '#', 'b', 'u', 'n', 'd', 'l', 'e', // padding missing from string
  893. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  894. };
  895. OSCInputStream inStream (data, sizeof (data));
  896. expectThrowsType (inStream.readBundle(), OSCFormatError);
  897. }
  898. }
  899. }
  900. };
  901. static OSCInputStreamTests OSCInputStreamUnitTests;
  902. #endif // JUCE_UNIT_TESTS