src/calf/osctl.h

   1 /* Calf DSP Library
   2  * Open Sound Control primitives
   3  *
   4  * Copyright (C) 2007 Krzysztof Foltman
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General
  17  * Public License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #ifndef __CALF_OSCTL_H
  23 #define __CALF_OSCTL_H
  24
  25 #include <string>
  26 #include <vector>
  27 #include <string.h>
  28 #include <errno.h>
  29 #include <netinet/in.h>
  30 #include <netdb.h>
  31 #include <iostream>
  32
  33 namespace osctl
  34 {
  35
  36 enum osc_type
  37 {
  38     osc_i32 = 'i',
  39     osc_f32 = 'f',
  40     osc_string = 's',
  41     osc_blob = 'b',
  42
  43     // unsupported
  44     osc_i64 = 'h',
  45     osc_ts = 't',
  46     osc_f64 = 'd',
  47     osc_string_alt = 'S',
  48     osc_char = 'c',
  49     osc_rgba = 'r',
  50     osc_midi = 'm',
  51     osc_true = 'T',
  52     osc_false = 'F',
  53     osc_nil = 'N',
  54     osc_inf = 'I',
  55     osc_start_array = '[',
  56     osc_end_array = ']'
  57 };
  58
  59 extern const char *osc_type_name(osc_type type);
  60
  61 struct osc_exception: public std::exception
  62 {
  63     virtual const char *what() const throw() { return "OSC parsing error"; }
  64 };
  65
  66 struct osc_read_exception: public std::exception
  67 {
  68     virtual const char *what() const throw() { return "OSC buffer underflow"; }
  69 };
  70
  71 struct osc_write_exception: public std::exception
  72 {
  73     virtual const char *what() const throw() { return "OSC buffer overflow"; }
  74 };
  75
  76 struct null_buffer
  77 {
  78     static bool read(uint8_t *dest, uint32_t bytes)
  79     {
  80         return false;
  81     }
  82     static bool write(uint8_t *dest, uint32_t bytes)
  83     {
  84         return true;
  85     }
  86     static void clear()
  87     {
  88     }
  89 };
  90
  91 struct raw_buffer
  92 {
  93     uint8_t *ptr;
  94     uint32_t pos, count, size;
  95
  96     raw_buffer()
  97     {
  98         ptr = NULL;
  99         pos = count = size = 0;
 100     }
 101     raw_buffer(uint8_t *_ptr, uint32_t _count, uint32_t _size)
 102     {
 103         set(_ptr, _count, _size);
 104     }
 105     inline void set(uint8_t *_ptr, uint32_t _count, uint32_t _size)
 106     {
 107         ptr = _ptr;
 108         pos = 0;
 109         count = _count;
 110         size = _size;
 111     }
 112     bool read(uint8_t *dest, uint32_t bytes)
 113     {
 114         if (pos + bytes > count)
 115             return false;
 116         memcpy(dest, ptr + pos, bytes);
 117         pos += bytes;
 118         return true;
 119     }
 120     bool write(const uint8_t *src, uint32_t bytes)
 121     {
 122         if (count + bytes > size)
 123             return false;
 124         memcpy(ptr + count, src, bytes);
 125         count += bytes;
 126         return true;
 127     }
 128     int read_left()
 129     {
 130         return count - pos;
 131     }
 132     int write_left()
 133     {
 134         return size - count;
 135     }
 136     inline int write_misalignment()
 137     {
 138         return 4 - (count & 3);
 139     }
 140     void clear()
 141     {
 142         pos = 0;
 143         count = 0;
 144     }
 145     int tell()
 146     {
 147         return pos;
 148     }
 149     void seek(int _pos)
 150     {
 151         pos = _pos;
 152     }
 153 };
 154
 155 struct string_buffer
 156 {
 157     std::string data;
 158     uint32_t pos, size;
 159
 160     string_buffer()
 161     {
 162         pos = 0;
 163         size = 1048576;
 164     }
 165     string_buffer(std::string _data, int _size = 1048576)
 166     {
 167         data = _data;
 168         pos = 0;
 169         size = _size;
 170     }
 171     bool read(uint8_t *dest, uint32_t bytes)
 172     {
 173         if (pos + bytes > data.length())
 174             return false;
 175         memcpy(dest, &data[pos], bytes);
 176         pos += bytes;
 177         return true;
 178     }
 179     bool write(const uint8_t *src, uint32_t bytes)
 180     {
 181         if (data.length() + bytes > size)
 182             return false;
 183         uint32_t wpos = data.length();
 184         data.resize(wpos + bytes);
 185         memcpy(&data[wpos], src, bytes);
 186         return true;
 187     }
 188     inline int read_left()
 189     {
 190         return data.length() - pos;
 191     }
 192     inline int write_left()
 193     {
 194         return size - data.length();
 195     }
 196     inline int write_misalignment()
 197     {
 198         return 4 - (data.length() & 3);
 199     }
 200     void clear()
 201     {
 202         data.clear();
 203         pos = 0;
 204     }
 205     int tell()
 206     {
 207         return pos;
 208     }
 209     void seek(int _pos)
 210     {
 211         pos = _pos;
 212     }
 213 };
 214
 215 template<class Buffer, class TypeBuffer = null_buffer, bool Throw = true>
 216 struct osc_stream
 217 {
 218     Buffer &buffer;
 219     TypeBuffer *type_buffer;
 220     bool error;
 221
 222     osc_stream(Buffer &_buffer) : buffer(_buffer), type_buffer(NULL), error(false) {}
 223     osc_stream(Buffer &_buffer, TypeBuffer &_type_buffer) : buffer(_buffer), type_buffer(&_type_buffer), error(false) {}
 224     inline void pad()
 225     {
 226         uint32_t zero = 0;
 227         write(&zero, buffer.write_misalignment());
 228     }
 229     inline void read(void *dest, uint32_t bytes)
 230     {
 231         if (!buffer.read((uint8_t *)dest, bytes))
 232         {
 233             if (Throw)
 234                 throw osc_read_exception();
 235             else
 236             {
 237                 error = true;
 238                 memset(dest, 0, bytes);
 239             }
 240         }
 241     }
 242     inline void write(const void *src, uint32_t bytes)
 243     {
 244         if (!buffer.write((const uint8_t *)src, bytes))
 245         {
 246             if (Throw)
 247                 throw osc_write_exception();
 248             else
 249                 error = true;
 250         }
 251     }
 252     inline void clear()
 253     {
 254         buffer.clear();
 255         if (type_buffer)
 256             type_buffer->clear();
 257     }
 258     inline void write_type(char ch)
 259     {
 260         if (type_buffer)
 261             type_buffer->write((uint8_t *)&ch, 1);
 262     }
 263 };
 264
 265 typedef osc_stream<string_buffer> osc_strstream;
 266 typedef osc_stream<string_buffer, string_buffer> osc_typed_strstream;
 267
 268 struct osc_inline_strstream: public string_buffer, public osc_strstream
 269 {
 270     osc_inline_strstream()
 271     : string_buffer(), osc_strstream(static_cast<string_buffer &>(*this))
 272     {
 273     }
 274 };
 275
 276 struct osc_str_typed_buffer_pair
 277 {
 278     string_buffer buf_data, buf_types;
 279 };
 280
 281 struct osc_inline_typed_strstream: public osc_str_typed_buffer_pair, public osc_typed_strstream
 282 {
 283     osc_inline_typed_strstream()
 284     : osc_str_typed_buffer_pair(), osc_typed_strstream(buf_data, buf_types)
 285     {
 286     }
 287 };
 288
 289 template<class Buffer, class TypeBuffer>
 290 inline osc_stream<Buffer, TypeBuffer> &
 291 operator <<(osc_stream<Buffer, TypeBuffer> &s, uint32_t val)
 292 {
 293     val = htonl(val);
 294     s.write(&val, 4);
 295     s.write_type(osc_i32);
 296     return s;
 297 }
 298
 299 template<class Buffer, class TypeBuffer>
 300 inline osc_stream<Buffer, TypeBuffer> &
 301 operator >>(osc_stream<Buffer, TypeBuffer> &s, uint32_t &val)
 302 {
 303     s.read(&val, 4);
 304     val = htonl(val);
 305     return s;
 306 }
 307
 308 template<class Buffer, class TypeBuffer>
 309 inline osc_stream<Buffer, TypeBuffer> &
 310 operator >>(osc_stream<Buffer, TypeBuffer> &s, int32_t &val)
 311 {
 312     s.read(&val, 4);
 313     val = htonl(val);
 314     return s;
 315 }
 316
 317 template<class Buffer, class TypeBuffer>
 318 inline osc_stream<Buffer, TypeBuffer> &
 319 operator <<(osc_stream<Buffer, TypeBuffer> &s, float val)
 320 {
 321     union { float v; uint32_t i; } val2;
 322     val2.v = val;
 323     val2.i = htonl(val2.i);
 324     s.write(&val2.i, 4);
 325     s.write_type(osc_f32);
 326     return s;
 327 }
 328
 329 template<class Buffer, class TypeBuffer>
 330 inline osc_stream<Buffer, TypeBuffer> &
 331 operator >>(osc_stream<Buffer, TypeBuffer> &s, float &val)
 332 {
 333     union { float v; uint32_t i; } val2;
 334     s.read(&val2.i, 4);
 335     val2.i = htonl(val2.i);
 336     val = val2.v;
 337     return s;
 338 }
 339
 340 template<class Buffer, class TypeBuffer>
 341 inline osc_stream<Buffer, TypeBuffer> &
 342 operator <<(osc_stream<Buffer, TypeBuffer> &s, const std::string &str)
 343 {
 344     s.write(&str[0], str.length());
 345     s.pad();
 346     s.write_type(osc_string);
 347     return s;
 348 }
 349
 350 template<class Buffer, class TypeBuffer>
 351 inline osc_stream<Buffer, TypeBuffer> &
 352 operator >>(osc_stream<Buffer, TypeBuffer> &s, std::string &str)
 353 {
 354     // inefficient...
 355     char five[5];
 356     five[4] = '\0';
 357     str.resize(0);
 358     while(1)
 359     {
 360         s.read(five, 4);
 361         if (five[0] == '\0')
 362             break;
 363         str += five;
 364         if (!five[1] || !five[2] || !five[3])
 365             break;
 366     }
 367     return s;
 368 }
 369
 370 template<class Buffer, class TypeBuffer, class DestBuffer>
 371 inline osc_stream<Buffer, TypeBuffer> &
 372 read_buffer_from_osc_stream(osc_stream<Buffer, TypeBuffer> &s, DestBuffer &buf)
 373 {
 374     uint32_t nlen = 0;
 375     s.read(&nlen, 4);
 376     uint32_t len = htonl(nlen);
 377     // write length in network order
 378     for (uint32_t i = 0; i < len; i += 1024)
 379     {
 380         uint8_t tmp[1024];
 381         uint32_t part = std::min((uint32_t)1024, len - i);
 382         s.read(tmp, part);
 383         buf.write(tmp, part);
 384     }
 385     // pad
 386     s.read(&nlen, 4 - (len & 3));
 387     return s;
 388 }
 389
 390 template<class Buffer, class TypeBuffer, class SrcBuffer>
 391 inline osc_stream<Buffer, TypeBuffer> &
 392 write_buffer_to_osc_stream(osc_stream<Buffer, TypeBuffer> &s, SrcBuffer &buf)
 393 {
 394     uint32_t len = buf.read_left();
 395     uint32_t nlen = ntohl(len);
 396     s.write(&nlen, 4);
 397     // write length in network order
 398     for (uint32_t i = 0; i < len; i += 1024)
 399     {
 400         uint8_t tmp[1024];
 401         uint32_t part = std::min((uint32_t)1024, len - i);
 402         buf.read(tmp, part);
 403         s.write(tmp, part);
 404     }
 405     s.pad();
 406     s.write_type(osc_blob);
 407     return s;
 408 }
 409
 410 template<class Buffer, class TypeBuffer>
 411 inline osc_stream<Buffer, TypeBuffer> &
 412 operator >>(osc_stream<Buffer, TypeBuffer> &s, raw_buffer &str)
 413 {
 414     return read_buffer_from_osc_stream(s, str);
 415 }
 416
 417 template<class Buffer, class TypeBuffer>
 418 inline osc_stream<Buffer, TypeBuffer> &
 419 operator >>(osc_stream<Buffer, TypeBuffer> &s, string_buffer &str)
 420 {
 421     return read_buffer_from_osc_stream(s, str);
 422 }
 423
 424 template<class Buffer, class TypeBuffer>
 425 inline osc_stream<Buffer, TypeBuffer> &
 426 operator <<(osc_stream<Buffer, TypeBuffer> &s, raw_buffer &str)
 427 {
 428     return write_buffer_to_osc_stream(s, str);
 429 }
 430
 431 template<class Buffer, class TypeBuffer>
 432 inline osc_stream<Buffer, TypeBuffer> &
 433 operator <<(osc_stream<Buffer, TypeBuffer> &s, string_buffer &str)
 434 {
 435     return write_buffer_to_osc_stream(s, str);
 436 }
 437
 438 // XXXKF: I don't support reading binary blobs yet
 439
 440 struct osc_net_bad_address: public std::exception
 441 {
 442     std::string addr, error_msg;
 443     osc_net_bad_address(const char *_addr)
 444     {
 445         addr = _addr;
 446         error_msg = "Incorrect OSC URI: " + addr;
 447     }
 448     virtual const char *what() const throw() { return error_msg.c_str(); }
 449     virtual ~osc_net_bad_address() throw () {}
 450 };
 451
 452 struct osc_net_exception: public std::exception
 453 {
 454     int net_errno;
 455     std::string command, error_msg;
 456     osc_net_exception(const char *cmd, int _errno = errno)
 457     {
 458         command = cmd;
 459         net_errno = _errno;
 460         error_msg = "OSC error in "+command+": "+strerror(_errno);
 461     }
 462     virtual const char *what() const throw() { return error_msg.c_str(); }
 463     virtual ~osc_net_exception() throw () {}
 464 };
 465
 466 struct osc_net_dns_exception: public std::exception
 467 {
 468     int net_errno;
 469     std::string command, error_msg;
 470     osc_net_dns_exception(const char *cmd, int _errno = h_errno)
 471     {
 472         command = cmd;
 473         net_errno = _errno;
 474         error_msg = "OSC error in "+command+": "+hstrerror(_errno);
 475     }
 476     virtual const char *what() const throw() { return error_msg.c_str(); }
 477     virtual ~osc_net_dns_exception() throw () {}
 478 };
 479
 480 template<class OscStream>
 481 struct osc_message_sink
 482 {
 483     virtual void receive_osc_message(std::string address, std::string type_tag, OscStream &buffer)=0;
 484     virtual ~osc_message_sink() {}
 485 };
 486
 487 template<class OscStream, class DumpStream>
 488 struct osc_message_dump: public osc_message_sink<OscStream>
 489 {
 490     DumpStream &stream;
 491     osc_message_dump(DumpStream &_stream) : stream(_stream) {}
 492
 493     virtual void receive_osc_message(std::string address, std::string type_tag, OscStream &buffer)
 494     {
 495         int pos = buffer.buffer.tell();
 496         stream << "address: " << address << ", type tag: " << type_tag << std::endl;
 497         for (unsigned int i = 0; i < type_tag.size(); i++)
 498         {
 499             stream << "Argument " << i << " is ";
 500             switch(type_tag[i])
 501             {
 502                 case 'i':
 503                 {
 504                     uint32_t val;
 505                     buffer >> val;
 506                     stream << val;
 507                     break;
 508                 }
 509                 case 'f':
 510                 {
 511                     float val;
 512                     buffer >> val;
 513                     stream << val;
 514                     break;
 515                 }
 516                 case 's':
 517                 {
 518                     std::string val;
 519                     buffer >> val;
 520                     stream << val;
 521                     break;
 522                 }
 523                 case 'b':
 524                 {
 525                     osctl::string_buffer val;
 526                     buffer >> val;
 527                     stream << "blob (" << val.data.length() << " bytes)";
 528                     break;
 529                 }
 530                 default:
 531                 {
 532                     stream << "unknown - cannot parse more arguments" << std::endl;
 533                     i = type_tag.size();
 534                     break;
 535                 }
 536             }
 537             stream << std::endl;
 538         }
 539         stream << std::flush;
 540         buffer.buffer.seek(pos);
 541     }
 542 };
 543
 544 };
 545
 546 #endif