OSCNode.h

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * OSCNode.h
 * A DMX orientated, C++ wrapper around liblo.
 * Copyright (C) 2012 Simon Newton
 */

#ifndef PLUGINS_OSC_OSCNODE_H_
#define PLUGINS_OSC_OSCNODE_H_

#include <lo/lo.h>
#include <ola/DmxBuffer.h>
#include <ola/ExportMap.h>
#include <ola/io/Descriptor.h>
#include <ola/io/SelectServerInterface.h>
#include <ola/network/SocketAddress.h>
#include <stdint.h>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "plugins/osc/OSCTarget.h"

namespace ola {
namespace plugin {
namespace osc {

using ola::ExportMap;
using ola::io::SelectServerInterface;
using ola::network::IPV4SocketAddress;
using std::auto_ptr;
using std::map;
using std::string;
using std::vector;

class OSCNode {
  public:
    // The different data formats we can send in.
    enum DataFormat {
      FORMAT_BLOB,
      FORMAT_INT_ARRAY,
      FORMAT_INT_INDIVIDUAL,
      FORMAT_FLOAT_ARRAY,
      FORMAT_FLOAT_INDIVIDUAL,
    };

    // The options for the OSCNode object.
    struct OSCNodeOptions {
      uint16_t listen_port;  // UDP port to listen on

      OSCNodeOptions() : listen_port(DEFAULT_OSC_PORT) {}
    };

    // The callback run when we receive new DMX data.
    typedef Callback1<void, const DmxBuffer&> DMXCallback;

    OSCNode(SelectServerInterface *ss,
            ExportMap *export_map,
            const OSCNodeOptions &options);
    ~OSCNode();

    bool Init();
    void Stop();

    // Sending methods
    void AddTarget(unsigned int group, const OSCTarget &target);
    bool RemoveTarget(unsigned int group, const OSCTarget &target);
    bool SendData(unsigned int group, DataFormat data_format,
                  const ola::DmxBuffer &data);

    // Receiving methods
    bool RegisterAddress(const string &osc_address, DMXCallback *callback);

    // Called by the liblo handlers.
    void SetUniverse(const string &osc_address, const uint8_t *data,
                     unsigned int size);
    void SetSlot(const string &osc_address, uint16_t slot, uint8_t value);

    // The port OSC is listening on.
    uint16_t ListeningPort() const;

  private:
    class NodeOSCTarget {
      public:
        explicit NodeOSCTarget(const OSCTarget &target);
        ~NodeOSCTarget();

        bool operator==(const NodeOSCTarget &other) const {
          return (socket_address == other.socket_address &&
                  osc_address == other.osc_address);
        }

        bool operator==(const OSCTarget &other) const {
          return (socket_address == other.socket_address &&
                  osc_address == other.osc_address);
        }

        IPV4SocketAddress socket_address;
        string osc_address;
        lo_address liblo_address;

      private:
        NodeOSCTarget(const NodeOSCTarget&);
        NodeOSCTarget& operator=(const NodeOSCTarget&);
    };

    typedef vector<NodeOSCTarget*> OSCTargetVector;

    struct OSCOutputGroup {
      OSCTargetVector targets;
      DmxBuffer dmx;  // holds the last values.
    };

    struct OSCInputGroup {
      explicit OSCInputGroup(DMXCallback *callback) : callback(callback) {}

      DmxBuffer dmx;
      auto_ptr<DMXCallback> callback;
    };

    typedef map<unsigned int, OSCOutputGroup*> OutputGroupMap;
    typedef map<string, OSCInputGroup*> InputUniverseMap;

    struct SlotMessage {
      unsigned int slot;
      lo_message message;
    };

    SelectServerInterface *m_ss;
    const uint16_t m_listen_port;
    auto_ptr<ola::io::UnmanagedFileDescriptor> m_descriptor;
    lo_server m_osc_server;
    OutputGroupMap m_output_map;
    InputUniverseMap m_input_map;

    void DescriptorReady();
    bool SendBlob(const DmxBuffer &data, const OSCTargetVector &targets);
    bool SendIndividualFloats(const DmxBuffer &data,
                              OSCOutputGroup *group);
    bool SendIndividualInts(const DmxBuffer &data,
                            OSCOutputGroup *group);
    bool SendIntArray(const DmxBuffer &data,
                      const OSCTargetVector &targets);
    bool SendFloatArray(const DmxBuffer &data,
                        const OSCTargetVector &targets);
    bool SendMessageToTargets(lo_message message,
                              const OSCTargetVector &targets);
    bool SendIndividualMessages(const DmxBuffer &data,
                                OSCOutputGroup *group,
                                const string &osc_type);

    static const uint16_t DEFAULT_OSC_PORT = 7770;
    static const char OSC_PORT_VARIABLE[];
};
}  // namespace osc
}  // namespace plugin
}  // namespace ola
#endif  // PLUGINS_OSC_OSCNODE_H_