-/*\r
- oscpack -- Open Sound Control packet manipulation library\r
- http://www.audiomulch.com/~rossb/oscpack\r
-\r
- Copyright (c) 2004-2005 Ross Bencina <rossb@audiomulch.com>\r
-\r
- Permission is hereby granted, free of charge, to any person obtaining\r
- a copy of this software and associated documentation files\r
- (the "Software"), to deal in the Software without restriction,\r
- including without limitation the rights to use, copy, modify, merge,\r
- publish, distribute, sublicense, and/or sell copies of the Software,\r
- and to permit persons to whom the Software is furnished to do so,\r
- subject to the following conditions:\r
-\r
- The above copyright notice and this permission notice shall be\r
- included in all copies or substantial portions of the Software.\r
-\r
- Any person wishing to distribute modifications to the Software is\r
- requested to send the modifications to the original developer so that\r
- they can be incorporated into the canonical version.\r
-\r
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\r
- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR\r
- ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF\r
- CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
- WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
-*/\r
-#undef _CRT_SECURE_NO_WARNINGS\r
-#define _CRT_SECURE_NO_WARNINGS\r
-\r
-#include "OscOutboundPacketStream.h"\r
-\r
-#include <string.h>\r
-#include <stdlib.h>\r
-#include <assert.h>\r
-\r
-#if defined(__WIN32__) || defined(WIN32)\r
-#include <malloc.h> // for alloca\r
-#endif\r
-\r
-#include "OscHostEndianness.h"\r
-\r
-\r
-namespace osc{\r
-\r
-static void FromInt32( char *p, int32 x )\r
-{\r
-#ifdef OSC_HOST_LITTLE_ENDIAN\r
- union{\r
- osc::int32 i;\r
- char c[4];\r
- } u;\r
-\r
- u.i = x;\r
-\r
- p[3] = u.c[0];\r
- p[2] = u.c[1];\r
- p[1] = u.c[2];\r
- p[0] = u.c[3];\r
-#else\r
- *reinterpret_cast<int32*>(p) = x;\r
-#endif\r
-}\r
-\r
-\r
-static void FromUInt32( char *p, uint32 x )\r
-{\r
-#ifdef OSC_HOST_LITTLE_ENDIAN\r
- union{\r
- osc::uint32 i;\r
- char c[4];\r
- } u;\r
-\r
- u.i = x;\r
-\r
- p[3] = u.c[0];\r
- p[2] = u.c[1];\r
- p[1] = u.c[2];\r
- p[0] = u.c[3];\r
-#else\r
- *reinterpret_cast<uint32*>(p) = x;\r
-#endif\r
-}\r
-\r
-\r
-static void FromInt64( char *p, int64 x )\r
-{\r
-#ifdef OSC_HOST_LITTLE_ENDIAN\r
- union{\r
- osc::int64 i;\r
- char c[8];\r
- } u;\r
-\r
- u.i = x;\r
-\r
- p[7] = u.c[0];\r
- p[6] = u.c[1];\r
- p[5] = u.c[2];\r
- p[4] = u.c[3];\r
- p[3] = u.c[4];\r
- p[2] = u.c[5];\r
- p[1] = u.c[6];\r
- p[0] = u.c[7];\r
-#else\r
- *reinterpret_cast<int64*>(p) = x;\r
-#endif\r
-}\r
-\r
-\r
-static void FromUInt64( char *p, uint64 x )\r
-{\r
-#ifdef OSC_HOST_LITTLE_ENDIAN\r
- union{\r
- osc::uint64 i;\r
- char c[8];\r
- } u;\r
-\r
- u.i = x;\r
-\r
- p[7] = u.c[0];\r
- p[6] = u.c[1];\r
- p[5] = u.c[2];\r
- p[4] = u.c[3];\r
- p[3] = u.c[4];\r
- p[2] = u.c[5];\r
- p[1] = u.c[6];\r
- p[0] = u.c[7];\r
-#else\r
- *reinterpret_cast<uint64*>(p) = x;\r
-#endif\r
-}\r
-\r
-\r
-static inline long RoundUp4( long x )\r
-{\r
- return ((x-1) & (~0x03L)) + 4;\r
-}\r
-\r
-\r
-OutboundPacketStream::OutboundPacketStream( char *buffer, unsigned long capacity )\r
- : data_( buffer )\r
- , end_( data_ + capacity )\r
- , typeTagsCurrent_( end_ )\r
- , messageCursor_( data_ )\r
- , argumentCurrent_( data_ )\r
- , elementSizePtr_( 0 )\r
- , messageIsInProgress_( false )\r
-{\r
-\r
-}\r
-\r
-\r
-OutboundPacketStream::~OutboundPacketStream()\r
-{\r
-\r
-}\r
-\r
-\r
-char *OutboundPacketStream::BeginElement( char *beginPtr )\r
-{\r
- if( elementSizePtr_ == 0 ){\r
-\r
- elementSizePtr_ = reinterpret_cast<uint32*>(data_);\r
-\r
- return beginPtr;\r
-\r
- }else{\r
- // store an offset to the old element size ptr in the element size slot\r
- // we store an offset rather than the actual pointer to be 64 bit clean.\r
- *reinterpret_cast<uint32*>(beginPtr) =\r
- (uint32)(reinterpret_cast<char*>(elementSizePtr_) - data_);\r
-\r
- elementSizePtr_ = reinterpret_cast<uint32*>(beginPtr);\r
-\r
- return beginPtr + 4;\r
- }\r
-}\r
-\r
-\r
-void OutboundPacketStream::EndElement( char *endPtr )\r
-{\r
- assert( elementSizePtr_ != 0 );\r
-\r
- if( elementSizePtr_ == reinterpret_cast<uint32*>(data_) ){\r
-\r
- elementSizePtr_ = 0;\r
-\r
- }else{\r
- // while building an element, an offset to the containing element's\r
- // size slot is stored in the elements size slot (or a ptr to data_\r
- // if there is no containing element). We retrieve that here\r
- uint32 *previousElementSizePtr =\r
- (uint32*)(data_ + *reinterpret_cast<uint32*>(elementSizePtr_));\r
-\r
- // then we store the element size in the slot, note that the element\r
- // size does not include the size slot, hence the - 4 below.\r
- uint32 elementSize =\r
- static_cast<uint32>(endPtr - reinterpret_cast<char*>(elementSizePtr_)) - 4;\r
- FromUInt32( reinterpret_cast<char*>(elementSizePtr_), elementSize );\r
-\r
- // finally, we reset the element size ptr to the containing element\r
- elementSizePtr_ = previousElementSizePtr;\r
- }\r
-}\r
-\r
-\r
-bool OutboundPacketStream::ElementSizeSlotRequired() const\r
-{\r
- return (elementSizePtr_ != 0);\r
-}\r
-\r
-\r
-void OutboundPacketStream::CheckForAvailableBundleSpace()\r
-{\r
- unsigned long required = Size() + ((ElementSizeSlotRequired())?4:0) + 16;\r
-\r
- if( required > Capacity() )\r
- throw OutOfBufferMemoryException();\r
-}\r
-\r
-\r
-void OutboundPacketStream::CheckForAvailableMessageSpace( const char *addressPattern )\r
-{\r
- // plus 4 for at least four bytes of type tag\r
- unsigned long required = Size() + ((ElementSizeSlotRequired())?4:0)\r
- + RoundUp4(static_cast<unsigned long>(strlen(addressPattern)) + 1) + 4;\r
-\r
- if( required > Capacity() )\r
- throw OutOfBufferMemoryException();\r
-}\r
-\r
-\r
-void OutboundPacketStream::CheckForAvailableArgumentSpace( long argumentLength )\r
-{\r
- // plus three for extra type tag, comma and null terminator\r
- unsigned long required = static_cast<unsigned long>(argumentCurrent_ - data_) + argumentLength\r
- + RoundUp4( static_cast<unsigned long>(end_ - typeTagsCurrent_) + 3 );\r
-\r
- if( required > Capacity() )\r
- throw OutOfBufferMemoryException();\r
-}\r
-\r
-\r
-void OutboundPacketStream::Clear()\r
-{\r
- typeTagsCurrent_ = end_;\r
- messageCursor_ = data_;\r
- argumentCurrent_ = data_;\r
- elementSizePtr_ = 0;\r
- messageIsInProgress_ = false;\r
-}\r
-\r
-\r
-unsigned int OutboundPacketStream::Capacity() const\r
-{\r
- return static_cast<int>(end_ - data_);\r
-}\r
-\r
-\r
-unsigned int OutboundPacketStream::Size() const\r
-{\r
- unsigned int result = static_cast<unsigned long>(argumentCurrent_ - data_);\r
- if( IsMessageInProgress() ){\r
- // account for the length of the type tag string. the total type tag\r
- // includes an initial comma, plus at least one terminating \0\r
- result += RoundUp4( static_cast<unsigned long>(end_ - typeTagsCurrent_) + 2 );\r
- }\r
-\r
- return result;\r
-}\r
-\r
-\r
-const char *OutboundPacketStream::Data() const\r
-{\r
- return data_;\r
-}\r
-\r
-\r
-bool OutboundPacketStream::IsReady() const\r
-{\r
- return (!IsMessageInProgress() && !IsBundleInProgress());\r
-}\r
-\r
-\r
-bool OutboundPacketStream::IsMessageInProgress() const\r
-{\r
- return messageIsInProgress_;\r
-}\r
-\r
-\r
-bool OutboundPacketStream::IsBundleInProgress() const\r
-{\r
- return (elementSizePtr_ != 0);\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const BundleInitiator& rhs )\r
-{\r
- if( IsMessageInProgress() )\r
- throw MessageInProgressException();\r
-\r
- CheckForAvailableBundleSpace();\r
-\r
- messageCursor_ = BeginElement( messageCursor_ );\r
-\r
- memcpy( messageCursor_, "#bundle\0", 8 );\r
- FromUInt64( messageCursor_ + 8, rhs.timeTag );\r
-\r
- messageCursor_ += 16;\r
- argumentCurrent_ = messageCursor_;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const BundleTerminator& rhs )\r
-{\r
- (void) rhs;\r
-\r
- if( !IsBundleInProgress() )\r
- throw BundleNotInProgressException();\r
- if( IsMessageInProgress() )\r
- throw MessageInProgressException();\r
-\r
- EndElement( messageCursor_ );\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const BeginMessage& rhs )\r
-{\r
- if( IsMessageInProgress() )\r
- throw MessageInProgressException();\r
-\r
- CheckForAvailableMessageSpace( rhs.addressPattern );\r
-\r
- messageCursor_ = BeginElement( messageCursor_ );\r
-\r
- strcpy( messageCursor_, rhs.addressPattern );\r
- unsigned long rhsLength = static_cast<unsigned long>(strlen(rhs.addressPattern));\r
- messageCursor_ += rhsLength + 1;\r
-\r
- // zero pad to 4-byte boundary\r
- unsigned long i = rhsLength + 1;\r
- while( i & 0x3 ){\r
- *messageCursor_++ = '\0';\r
- ++i;\r
- }\r
-\r
- argumentCurrent_ = messageCursor_;\r
- typeTagsCurrent_ = end_;\r
-\r
- messageIsInProgress_ = true;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const MessageTerminator& rhs )\r
-{\r
- (void) rhs;\r
-\r
- if( !IsMessageInProgress() )\r
- throw MessageNotInProgressException();\r
-\r
- int typeTagsCount = static_cast<int>(end_ - typeTagsCurrent_);\r
-\r
- if( typeTagsCount ){\r
-\r
- char *tempTypeTags = (char*)alloca(typeTagsCount);\r
- memcpy( tempTypeTags, typeTagsCurrent_, typeTagsCount );\r
-\r
- // slot size includes comma and null terminator\r
- int typeTagSlotSize = RoundUp4( typeTagsCount + 2 );\r
-\r
- uint32 argumentsSize = static_cast<uint32>(argumentCurrent_ - messageCursor_);\r
-\r
- memmove( messageCursor_ + typeTagSlotSize, messageCursor_, argumentsSize );\r
-\r
- messageCursor_[0] = ',';\r
- // copy type tags in reverse (really forward) order\r
- for( int i=0; i < typeTagsCount; ++i )\r
- messageCursor_[i+1] = tempTypeTags[ (typeTagsCount-1) - i ];\r
-\r
- char *p = messageCursor_ + 1 + typeTagsCount;\r
- for( int i=0; i < (typeTagSlotSize - (typeTagsCount + 1)); ++i )\r
- *p++ = '\0';\r
-\r
- typeTagsCurrent_ = end_;\r
-\r
- // advance messageCursor_ for next message\r
- messageCursor_ += typeTagSlotSize + argumentsSize;\r
-\r
- }else{\r
- // send an empty type tags string\r
- memcpy( messageCursor_, ",\0\0\0", 4 );\r
-\r
- // advance messageCursor_ for next message\r
- messageCursor_ += 4;\r
- }\r
-\r
- argumentCurrent_ = messageCursor_;\r
-\r
- EndElement( messageCursor_ );\r
-\r
- messageIsInProgress_ = false;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( bool rhs )\r
-{\r
- CheckForAvailableArgumentSpace(0);\r
-\r
- *(--typeTagsCurrent_) = (char)((rhs) ? TRUE_TYPE_TAG : FALSE_TYPE_TAG);\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const NilType& rhs )\r
-{\r
- (void) rhs;\r
- CheckForAvailableArgumentSpace(0);\r
-\r
- *(--typeTagsCurrent_) = NIL_TYPE_TAG;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const InfinitumType& rhs )\r
-{\r
- (void) rhs;\r
- CheckForAvailableArgumentSpace(0);\r
-\r
- *(--typeTagsCurrent_) = INFINITUM_TYPE_TAG;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( int32 rhs )\r
-{\r
- CheckForAvailableArgumentSpace(4);\r
-\r
- *(--typeTagsCurrent_) = INT32_TYPE_TAG;\r
- FromInt32( argumentCurrent_, rhs );\r
- argumentCurrent_ += 4;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( float rhs )\r
-{\r
- CheckForAvailableArgumentSpace(4);\r
-\r
- *(--typeTagsCurrent_) = FLOAT_TYPE_TAG;\r
-\r
-#ifdef OSC_HOST_LITTLE_ENDIAN\r
- union{\r
- float f;\r
- char c[4];\r
- } u;\r
-\r
- u.f = rhs;\r
-\r
- argumentCurrent_[3] = u.c[0];\r
- argumentCurrent_[2] = u.c[1];\r
- argumentCurrent_[1] = u.c[2];\r
- argumentCurrent_[0] = u.c[3];\r
-#else\r
- *reinterpret_cast<float*>(argumentCurrent_) = rhs;\r
-#endif\r
-\r
- argumentCurrent_ += 4;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( char rhs )\r
-{\r
- CheckForAvailableArgumentSpace(4);\r
-\r
- *(--typeTagsCurrent_) = CHAR_TYPE_TAG;\r
- FromInt32( argumentCurrent_, rhs );\r
- argumentCurrent_ += 4;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const RgbaColor& rhs )\r
-{\r
- CheckForAvailableArgumentSpace(4);\r
-\r
- *(--typeTagsCurrent_) = RGBA_COLOR_TYPE_TAG;\r
- FromUInt32( argumentCurrent_, rhs );\r
- argumentCurrent_ += 4;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const MidiMessage& rhs )\r
-{\r
- CheckForAvailableArgumentSpace(4);\r
-\r
- *(--typeTagsCurrent_) = MIDI_MESSAGE_TYPE_TAG;\r
- FromUInt32( argumentCurrent_, rhs );\r
- argumentCurrent_ += 4;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( int64 rhs )\r
-{\r
- CheckForAvailableArgumentSpace(8);\r
-\r
- *(--typeTagsCurrent_) = INT64_TYPE_TAG;\r
- FromInt64( argumentCurrent_, rhs );\r
- argumentCurrent_ += 8;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const TimeTag& rhs )\r
-{\r
- CheckForAvailableArgumentSpace(8);\r
-\r
- *(--typeTagsCurrent_) = TIME_TAG_TYPE_TAG;\r
- FromUInt64( argumentCurrent_, rhs );\r
- argumentCurrent_ += 8;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( double rhs )\r
-{\r
- CheckForAvailableArgumentSpace(8);\r
-\r
- *(--typeTagsCurrent_) = DOUBLE_TYPE_TAG;\r
-\r
-#ifdef OSC_HOST_LITTLE_ENDIAN\r
- union{\r
- double f;\r
- char c[8];\r
- } u;\r
-\r
- u.f = rhs;\r
-\r
- argumentCurrent_[7] = u.c[0];\r
- argumentCurrent_[6] = u.c[1];\r
- argumentCurrent_[5] = u.c[2];\r
- argumentCurrent_[4] = u.c[3];\r
- argumentCurrent_[3] = u.c[4];\r
- argumentCurrent_[2] = u.c[5];\r
- argumentCurrent_[1] = u.c[6];\r
- argumentCurrent_[0] = u.c[7];\r
-#else\r
- *reinterpret_cast<double*>(argumentCurrent_) = rhs;\r
-#endif\r
-\r
- argumentCurrent_ += 8;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const char *rhs )\r
-{\r
- CheckForAvailableArgumentSpace( RoundUp4(static_cast<long>(strlen(rhs)) + 1) );\r
-\r
- *(--typeTagsCurrent_) = STRING_TYPE_TAG;\r
- strcpy( argumentCurrent_, rhs );\r
- unsigned long rhsLength = static_cast<unsigned long>(strlen(rhs));\r
- argumentCurrent_ += rhsLength + 1;\r
-\r
- // zero pad to 4-byte boundary\r
- unsigned long i = rhsLength + 1;\r
- while( i & 0x3 ){\r
- *argumentCurrent_++ = '\0';\r
- ++i;\r
- }\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const Symbol& rhs )\r
-{\r
- CheckForAvailableArgumentSpace( RoundUp4(static_cast<long>(strlen(rhs)) + 1) );\r
-\r
- *(--typeTagsCurrent_) = SYMBOL_TYPE_TAG;\r
- strcpy( argumentCurrent_, rhs );\r
- unsigned long rhsLength = static_cast<unsigned long>(strlen(rhs));\r
- argumentCurrent_ += rhsLength + 1;\r
-\r
- // zero pad to 4-byte boundary\r
- unsigned long i = rhsLength + 1;\r
- while( i & 0x3 ){\r
- *argumentCurrent_++ = '\0';\r
- ++i;\r
- }\r
-\r
- return *this;\r
-}\r
-\r
-\r
-OutboundPacketStream& OutboundPacketStream::operator<<( const Blob& rhs )\r
-{\r
- CheckForAvailableArgumentSpace( 4 + RoundUp4(rhs.size) );\r
-\r
- *(--typeTagsCurrent_) = BLOB_TYPE_TAG;\r
- FromUInt32( argumentCurrent_, rhs.size );\r
- argumentCurrent_ += 4;\r
- \r
- memcpy( argumentCurrent_, rhs.data, rhs.size );\r
- argumentCurrent_ += rhs.size;\r
-\r
- // zero pad to 4-byte boundary\r
- unsigned long i = rhs.size;\r
- while( i & 0x3 ){\r
- *argumentCurrent_++ = '\0';\r
- ++i;\r
- }\r
-\r
- return *this;\r
-}\r
-\r
-} // namespace osc\r
-\r
-\r
+/*
+ oscpack -- Open Sound Control packet manipulation library
+ http://www.audiomulch.com/~rossb/oscpack
+
+ Copyright (c) 2004-2005 Ross Bencina <rossb@audiomulch.com>
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files
+ (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software,
+ and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ Any person wishing to distribute modifications to the Software is
+ requested to send the modifications to the original developer so that
+ they can be incorporated into the canonical version.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+#undef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+
+#include "OscOutboundPacketStream.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#if defined(__WIN32__) || defined(WIN32)
+#include <malloc.h> // for alloca
+#endif
+
+#include "OscHostEndianness.h"
+
+
+namespace osc{
+
+static void FromInt32( char *p, int32 x )
+{
+#ifdef OSC_HOST_LITTLE_ENDIAN
+ union{
+ osc::int32 i;
+ char c[4];
+ } u;
+
+ u.i = x;
+
+ p[3] = u.c[0];
+ p[2] = u.c[1];
+ p[1] = u.c[2];
+ p[0] = u.c[3];
+#else
+ *reinterpret_cast<int32*>(p) = x;
+#endif
+}
+
+
+static void FromUInt32( char *p, uint32 x )
+{
+#ifdef OSC_HOST_LITTLE_ENDIAN
+ union{
+ osc::uint32 i;
+ char c[4];
+ } u;
+
+ u.i = x;
+
+ p[3] = u.c[0];
+ p[2] = u.c[1];
+ p[1] = u.c[2];
+ p[0] = u.c[3];
+#else
+ *reinterpret_cast<uint32*>(p) = x;
+#endif
+}
+
+
+static void FromInt64( char *p, int64 x )
+{
+#ifdef OSC_HOST_LITTLE_ENDIAN
+ union{
+ osc::int64 i;
+ char c[8];
+ } u;
+
+ u.i = x;
+
+ p[7] = u.c[0];
+ p[6] = u.c[1];
+ p[5] = u.c[2];
+ p[4] = u.c[3];
+ p[3] = u.c[4];
+ p[2] = u.c[5];
+ p[1] = u.c[6];
+ p[0] = u.c[7];
+#else
+ *reinterpret_cast<int64*>(p) = x;
+#endif
+}
+
+
+static void FromUInt64( char *p, uint64 x )
+{
+#ifdef OSC_HOST_LITTLE_ENDIAN
+ union{
+ osc::uint64 i;
+ char c[8];
+ } u;
+
+ u.i = x;
+
+ p[7] = u.c[0];
+ p[6] = u.c[1];
+ p[5] = u.c[2];
+ p[4] = u.c[3];
+ p[3] = u.c[4];
+ p[2] = u.c[5];
+ p[1] = u.c[6];
+ p[0] = u.c[7];
+#else
+ *reinterpret_cast<uint64*>(p) = x;
+#endif
+}
+
+
+static inline long RoundUp4( long x )
+{
+ return ((x-1) & (~0x03L)) + 4;
+}
+
+
+OutboundPacketStream::OutboundPacketStream( char *buffer, unsigned long capacity )
+ : data_( buffer )
+ , end_( data_ + capacity )
+ , typeTagsCurrent_( end_ )
+ , messageCursor_( data_ )
+ , argumentCurrent_( data_ )
+ , elementSizePtr_( 0 )
+ , messageIsInProgress_( false )
+{
+
+}
+
+
+OutboundPacketStream::~OutboundPacketStream()
+{
+
+}
+
+
+char *OutboundPacketStream::BeginElement( char *beginPtr )
+{
+ if( elementSizePtr_ == 0 ){
+
+ elementSizePtr_ = reinterpret_cast<uint32*>(data_);
+
+ return beginPtr;
+
+ }else{
+ // store an offset to the old element size ptr in the element size slot
+ // we store an offset rather than the actual pointer to be 64 bit clean.
+ *reinterpret_cast<uint32*>(beginPtr) =
+ (uint32)(reinterpret_cast<char*>(elementSizePtr_) - data_);
+
+ elementSizePtr_ = reinterpret_cast<uint32*>(beginPtr);
+
+ return beginPtr + 4;
+ }
+}
+
+
+void OutboundPacketStream::EndElement( char *endPtr )
+{
+ assert( elementSizePtr_ != 0 );
+
+ if( elementSizePtr_ == reinterpret_cast<uint32*>(data_) ){
+
+ elementSizePtr_ = 0;
+
+ }else{
+ // while building an element, an offset to the containing element's
+ // size slot is stored in the elements size slot (or a ptr to data_
+ // if there is no containing element). We retrieve that here
+ uint32 *previousElementSizePtr =
+ (uint32*)(data_ + *reinterpret_cast<uint32*>(elementSizePtr_));
+
+ // then we store the element size in the slot, note that the element
+ // size does not include the size slot, hence the - 4 below.
+ uint32 elementSize =
+ static_cast<uint32>(endPtr - reinterpret_cast<char*>(elementSizePtr_)) - 4;
+ FromUInt32( reinterpret_cast<char*>(elementSizePtr_), elementSize );
+
+ // finally, we reset the element size ptr to the containing element
+ elementSizePtr_ = previousElementSizePtr;
+ }
+}
+
+
+bool OutboundPacketStream::ElementSizeSlotRequired() const
+{
+ return (elementSizePtr_ != 0);
+}
+
+
+void OutboundPacketStream::CheckForAvailableBundleSpace()
+{
+ unsigned long required = Size() + ((ElementSizeSlotRequired())?4:0) + 16;
+
+ if( required > Capacity() )
+ throw OutOfBufferMemoryException();
+}
+
+
+void OutboundPacketStream::CheckForAvailableMessageSpace( const char *addressPattern )
+{
+ // plus 4 for at least four bytes of type tag
+ unsigned long required = Size() + ((ElementSizeSlotRequired())?4:0)
+ + RoundUp4(static_cast<unsigned long>(strlen(addressPattern)) + 1) + 4;
+
+ if( required > Capacity() )
+ throw OutOfBufferMemoryException();
+}
+
+
+void OutboundPacketStream::CheckForAvailableArgumentSpace( long argumentLength )
+{
+ // plus three for extra type tag, comma and null terminator
+ unsigned long required = static_cast<unsigned long>(argumentCurrent_ - data_) + argumentLength
+ + RoundUp4( static_cast<unsigned long>(end_ - typeTagsCurrent_) + 3 );
+
+ if( required > Capacity() )
+ throw OutOfBufferMemoryException();
+}
+
+
+void OutboundPacketStream::Clear()
+{
+ typeTagsCurrent_ = end_;
+ messageCursor_ = data_;
+ argumentCurrent_ = data_;
+ elementSizePtr_ = 0;
+ messageIsInProgress_ = false;
+}
+
+
+unsigned int OutboundPacketStream::Capacity() const
+{
+ return static_cast<int>(end_ - data_);
+}
+
+
+unsigned int OutboundPacketStream::Size() const
+{
+ unsigned int result = static_cast<unsigned long>(argumentCurrent_ - data_);
+ if( IsMessageInProgress() ){
+ // account for the length of the type tag string. the total type tag
+ // includes an initial comma, plus at least one terminating \0
+ result += RoundUp4( static_cast<unsigned long>(end_ - typeTagsCurrent_) + 2 );
+ }
+
+ return result;
+}
+
+
+const char *OutboundPacketStream::Data() const
+{
+ return data_;
+}
+
+
+bool OutboundPacketStream::IsReady() const
+{
+ return (!IsMessageInProgress() && !IsBundleInProgress());
+}
+
+
+bool OutboundPacketStream::IsMessageInProgress() const
+{
+ return messageIsInProgress_;
+}
+
+
+bool OutboundPacketStream::IsBundleInProgress() const
+{
+ return (elementSizePtr_ != 0);
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const BundleInitiator& rhs )
+{
+ if( IsMessageInProgress() )
+ throw MessageInProgressException();
+
+ CheckForAvailableBundleSpace();
+
+ messageCursor_ = BeginElement( messageCursor_ );
+
+ memcpy( messageCursor_, "#bundle\0", 8 );
+ FromUInt64( messageCursor_ + 8, rhs.timeTag );
+
+ messageCursor_ += 16;
+ argumentCurrent_ = messageCursor_;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const BundleTerminator& rhs )
+{
+ (void) rhs;
+
+ if( !IsBundleInProgress() )
+ throw BundleNotInProgressException();
+ if( IsMessageInProgress() )
+ throw MessageInProgressException();
+
+ EndElement( messageCursor_ );
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const BeginMessage& rhs )
+{
+ if( IsMessageInProgress() )
+ throw MessageInProgressException();
+
+ CheckForAvailableMessageSpace( rhs.addressPattern );
+
+ messageCursor_ = BeginElement( messageCursor_ );
+
+ strcpy( messageCursor_, rhs.addressPattern );
+ unsigned long rhsLength = static_cast<unsigned long>(strlen(rhs.addressPattern));
+ messageCursor_ += rhsLength + 1;
+
+ // zero pad to 4-byte boundary
+ unsigned long i = rhsLength + 1;
+ while( i & 0x3 ){
+ *messageCursor_++ = '\0';
+ ++i;
+ }
+
+ argumentCurrent_ = messageCursor_;
+ typeTagsCurrent_ = end_;
+
+ messageIsInProgress_ = true;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const MessageTerminator& rhs )
+{
+ (void) rhs;
+
+ if( !IsMessageInProgress() )
+ throw MessageNotInProgressException();
+
+ int typeTagsCount = static_cast<int>(end_ - typeTagsCurrent_);
+
+ if( typeTagsCount ){
+
+ char *tempTypeTags = (char*)alloca(typeTagsCount);
+ memcpy( tempTypeTags, typeTagsCurrent_, typeTagsCount );
+
+ // slot size includes comma and null terminator
+ int typeTagSlotSize = RoundUp4( typeTagsCount + 2 );
+
+ uint32 argumentsSize = static_cast<uint32>(argumentCurrent_ - messageCursor_);
+
+ memmove( messageCursor_ + typeTagSlotSize, messageCursor_, argumentsSize );
+
+ messageCursor_[0] = ',';
+ // copy type tags in reverse (really forward) order
+ for( int i=0; i < typeTagsCount; ++i )
+ messageCursor_[i+1] = tempTypeTags[ (typeTagsCount-1) - i ];
+
+ char *p = messageCursor_ + 1 + typeTagsCount;
+ for( int i=0; i < (typeTagSlotSize - (typeTagsCount + 1)); ++i )
+ *p++ = '\0';
+
+ typeTagsCurrent_ = end_;
+
+ // advance messageCursor_ for next message
+ messageCursor_ += typeTagSlotSize + argumentsSize;
+
+ }else{
+ // send an empty type tags string
+ memcpy( messageCursor_, ",\0\0\0", 4 );
+
+ // advance messageCursor_ for next message
+ messageCursor_ += 4;
+ }
+
+ argumentCurrent_ = messageCursor_;
+
+ EndElement( messageCursor_ );
+
+ messageIsInProgress_ = false;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( bool rhs )
+{
+ CheckForAvailableArgumentSpace(0);
+
+ *(--typeTagsCurrent_) = (char)((rhs) ? TRUE_TYPE_TAG : FALSE_TYPE_TAG);
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const NilType& rhs )
+{
+ (void) rhs;
+ CheckForAvailableArgumentSpace(0);
+
+ *(--typeTagsCurrent_) = NIL_TYPE_TAG;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const InfinitumType& rhs )
+{
+ (void) rhs;
+ CheckForAvailableArgumentSpace(0);
+
+ *(--typeTagsCurrent_) = INFINITUM_TYPE_TAG;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( int32 rhs )
+{
+ CheckForAvailableArgumentSpace(4);
+
+ *(--typeTagsCurrent_) = INT32_TYPE_TAG;
+ FromInt32( argumentCurrent_, rhs );
+ argumentCurrent_ += 4;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( float rhs )
+{
+ CheckForAvailableArgumentSpace(4);
+
+ *(--typeTagsCurrent_) = FLOAT_TYPE_TAG;
+
+#ifdef OSC_HOST_LITTLE_ENDIAN
+ union{
+ float f;
+ char c[4];
+ } u;
+
+ u.f = rhs;
+
+ argumentCurrent_[3] = u.c[0];
+ argumentCurrent_[2] = u.c[1];
+ argumentCurrent_[1] = u.c[2];
+ argumentCurrent_[0] = u.c[3];
+#else
+ *reinterpret_cast<float*>(argumentCurrent_) = rhs;
+#endif
+
+ argumentCurrent_ += 4;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( char rhs )
+{
+ CheckForAvailableArgumentSpace(4);
+
+ *(--typeTagsCurrent_) = CHAR_TYPE_TAG;
+ FromInt32( argumentCurrent_, rhs );
+ argumentCurrent_ += 4;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const RgbaColor& rhs )
+{
+ CheckForAvailableArgumentSpace(4);
+
+ *(--typeTagsCurrent_) = RGBA_COLOR_TYPE_TAG;
+ FromUInt32( argumentCurrent_, rhs );
+ argumentCurrent_ += 4;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const MidiMessage& rhs )
+{
+ CheckForAvailableArgumentSpace(4);
+
+ *(--typeTagsCurrent_) = MIDI_MESSAGE_TYPE_TAG;
+ FromUInt32( argumentCurrent_, rhs );
+ argumentCurrent_ += 4;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( int64 rhs )
+{
+ CheckForAvailableArgumentSpace(8);
+
+ *(--typeTagsCurrent_) = INT64_TYPE_TAG;
+ FromInt64( argumentCurrent_, rhs );
+ argumentCurrent_ += 8;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const TimeTag& rhs )
+{
+ CheckForAvailableArgumentSpace(8);
+
+ *(--typeTagsCurrent_) = TIME_TAG_TYPE_TAG;
+ FromUInt64( argumentCurrent_, rhs );
+ argumentCurrent_ += 8;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( double rhs )
+{
+ CheckForAvailableArgumentSpace(8);
+
+ *(--typeTagsCurrent_) = DOUBLE_TYPE_TAG;
+
+#ifdef OSC_HOST_LITTLE_ENDIAN
+ union{
+ double f;
+ char c[8];
+ } u;
+
+ u.f = rhs;
+
+ argumentCurrent_[7] = u.c[0];
+ argumentCurrent_[6] = u.c[1];
+ argumentCurrent_[5] = u.c[2];
+ argumentCurrent_[4] = u.c[3];
+ argumentCurrent_[3] = u.c[4];
+ argumentCurrent_[2] = u.c[5];
+ argumentCurrent_[1] = u.c[6];
+ argumentCurrent_[0] = u.c[7];
+#else
+ *reinterpret_cast<double*>(argumentCurrent_) = rhs;
+#endif
+
+ argumentCurrent_ += 8;
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const char *rhs )
+{
+ CheckForAvailableArgumentSpace( RoundUp4(static_cast<long>(strlen(rhs)) + 1) );
+
+ *(--typeTagsCurrent_) = STRING_TYPE_TAG;
+ strcpy( argumentCurrent_, rhs );
+ unsigned long rhsLength = static_cast<unsigned long>(strlen(rhs));
+ argumentCurrent_ += rhsLength + 1;
+
+ // zero pad to 4-byte boundary
+ unsigned long i = rhsLength + 1;
+ while( i & 0x3 ){
+ *argumentCurrent_++ = '\0';
+ ++i;
+ }
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const Symbol& rhs )
+{
+ CheckForAvailableArgumentSpace( RoundUp4(static_cast<long>(strlen(rhs)) + 1) );
+
+ *(--typeTagsCurrent_) = SYMBOL_TYPE_TAG;
+ strcpy( argumentCurrent_, rhs );
+ unsigned long rhsLength = static_cast<unsigned long>(strlen(rhs));
+ argumentCurrent_ += rhsLength + 1;
+
+ // zero pad to 4-byte boundary
+ unsigned long i = rhsLength + 1;
+ while( i & 0x3 ){
+ *argumentCurrent_++ = '\0';
+ ++i;
+ }
+
+ return *this;
+}
+
+
+OutboundPacketStream& OutboundPacketStream::operator<<( const Blob& rhs )
+{
+ CheckForAvailableArgumentSpace( 4 + RoundUp4(rhs.size) );
+
+ *(--typeTagsCurrent_) = BLOB_TYPE_TAG;
+ FromUInt32( argumentCurrent_, rhs.size );
+ argumentCurrent_ += 4;
+
+ memcpy( argumentCurrent_, rhs.data, rhs.size );
+ argumentCurrent_ += rhs.size;
+
+ // zero pad to 4-byte boundary
+ unsigned long i = rhs.size;
+ while( i & 0x3 ){
+ *argumentCurrent_++ = '\0';
+ ++i;
+ }
+
+ return *this;
+}
+
+} // namespace osc
+
+
projects / casparcg / blobdiff