ArtNetNode.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.
 *
 * ArtNetNodeImpl.h
 * Header file for the ArtNetNodeImpl class
 * Copyright (C) 2005-2010 Simon Newton
 */

#ifndef PLUGINS_ARTNET_ARTNETNODE_H_
#define PLUGINS_ARTNET_ARTNETNODE_H_

#include <map>
#include <memory>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include "ola/Callback.h"
#include "ola/Clock.h"
#include "ola/DmxBuffer.h"
#include "ola/network/IPV4Address.h"
#include "ola/network/Interface.h"
#include "ola/io/SelectServerInterface.h"
#include "ola/network/Socket.h"
#include "ola/rdm/QueueingRDMController.h"
#include "ola/rdm/RDMCommand.h"
#include "ola/rdm/RDMControllerInterface.h"
#include "ola/rdm/UIDSet.h"
#include "ola/timecode/TimeCode.h"
#include "plugins/artnet/ArtNetPackets.h"

namespace ola {
namespace plugin {
namespace artnet {

using ola::network::IPV4Address;
using ola::rdm::RDMCallback;
using ola::rdm::RDMCommand;
using ola::rdm::RDMDiscoveryCallback;
using ola::rdm::RDMRequest;
using ola::rdm::RDMResponse;
using ola::rdm::UID;
using ola::rdm::UIDSet;
using std::map;
using std::queue;
using std::set;
using std::string;


// The directions are the opposite from what OLA uses
typedef enum {
  ARTNET_INPUT_PORT,  // sends ArtNet data
  ARTNET_OUTPUT_PORT,  // receives ArtNet data
} artnet_port_type;

typedef enum {
  ARTNET_MERGE_HTP,  // default
  ARTNET_MERGE_LTP,
} artnet_merge_mode;


// This can be passed to SetPortUniverse to disable ports
static const uint8_t ARTNET_DISABLE_PORT = 0xf0;

class ArtNetNodeOptions {
 public:
  ArtNetNodeOptions()
      : always_broadcast(false),
        use_limited_broadcast_address(false),
        rdm_queue_size(20),
        broadcast_threshold(30),
        input_port_count(4) {
  }

  bool always_broadcast;
  bool use_limited_broadcast_address;
  unsigned int rdm_queue_size;
  unsigned int broadcast_threshold;
  uint8_t input_port_count;
};


class ArtNetNodeImpl {
 public:
  ArtNetNodeImpl(const ola::network::Interface &interface,
                 ola::io::SelectServerInterface *ss,
                 const ArtNetNodeOptions &options,
                 ola::network::UDPSocketInterface *socket = NULL);
  virtual ~ArtNetNodeImpl();

  bool Start();
  bool Stop();

  /*
   * Configuration mode.
   * This allows the caller to make changes without triggering an ArtPoll or
   * ArtPollReply per change. e.g.
   * node.EnterConfigurationMode()
   * node.SetShortName()
   * node.SetInputPortUniverse()
   * node.SetOutputPortUniverse()
   * // The poll / poll reply is sent here
   * node.ExitConfigurationMode()
   */
  bool EnterConfigurationMode();
  bool ExitConfigurationMode();


  // Various parameters to control the behaviour
  bool SetShortName(const string &name);
  string ShortName() const { return m_short_name; }
  bool SetLongName(const string &name);
  string LongName() const { return m_long_name; }

  uint8_t NetAddress() const { return m_net_address; }
  bool SetNetAddress(uint8_t net_address);

  bool SetSubnetAddress(uint8_t subnet_address);
  uint8_t SubnetAddress() const {
    return m_output_ports[0].universe_address >> 4;
  }

  uint8_t InputPortCount() const;
  bool SetInputPortUniverse(uint8_t port_id, uint8_t universe_id);
  uint8_t GetInputPortUniverse(uint8_t port_id) const;
  void DisableInputPort(uint8_t port_id);
  bool InputPortState(uint8_t port_id) const;

  bool SetOutputPortUniverse(uint8_t port_id, uint8_t universe_id);
  uint8_t GetOutputPortUniverse(uint8_t port_id);
  void DisableOutputPort(uint8_t port_id);
  bool OutputPortState(uint8_t port_id) const;

  void SetBroadcastThreshold(unsigned int threshold) {
    m_broadcast_threshold = threshold;
  }

  bool SetMergeMode(uint8_t port_id, artnet_merge_mode merge_mode);

  // Poll, this should be called periodically if we're sending data.
  bool SendPoll();

  // The following apply to Input Ports (those which send data)
  bool SendDMX(uint8_t port_id, const ola::DmxBuffer &buffer);
  void RunFullDiscovery(uint8_t port_id,
                        ola::rdm::RDMDiscoveryCallback *callback);
  void RunIncrementalDiscovery(uint8_t port_id,
                               ola::rdm::RDMDiscoveryCallback *callback);
  void SendRDMRequest(uint8_t port_id,
                      const RDMRequest *request,
                      RDMCallback *on_complete);
  bool SetUnsolicitedUIDSetHandler(
      uint8_t port_id,
      ola::Callback1<void, const ola::rdm::UIDSet&> *on_tod);
  void GetSubscribedNodes(uint8_t port_id,
                          std::vector<IPV4Address> *node_addresses);

  // The following apply to Output Ports (those which receive data);
  bool SetDMXHandler(uint8_t port_id,
                     DmxBuffer *buffer,
                     ola::Callback0<void> *handler);
  bool SendTod(uint8_t port_id, const UIDSet &uid_set);
  bool SetOutputPortRDMHandlers(
      uint8_t port_id,
      ola::Callback0<void> *on_discover,
      ola::Callback0<void> *on_flush,
      ola::Callback2<void, const RDMRequest*, RDMCallback*> *on_rdm_request);

  // send time code
  bool SendTimeCode(const ola::timecode::TimeCode &timecode);

 private:
  class InputPort;
  typedef vector<InputPort*> InputPorts;

  // map a uid to a IP address and the number of times we've missed a
  // response.
  typedef map<UID, std::pair<IPV4Address, uint8_t> > uid_map;

  enum { MAX_MERGE_SOURCES = 2 };

  struct DMXSource {
    DmxBuffer buffer;
    TimeStamp timestamp;
    IPV4Address address;
  };

  // Output Ports receive ArtNet data
  struct OutputPort {
    uint8_t universe_address;
    uint8_t sequence_number;
    bool enabled;
    artnet_merge_mode merge_mode;
    bool is_merging;
    DMXSource sources[MAX_MERGE_SOURCES];
    DmxBuffer *buffer;
    map<UID, IPV4Address> uid_map;
    Callback0<void> *on_data;
    Callback0<void> *on_discover;
    Callback0<void> *on_flush;
    ola::Callback2<void, const RDMRequest*, RDMCallback*> *on_rdm_request;
  };

  bool m_running;
  uint8_t m_net_address;  // this is the 'net' portion of the Artnet address
  bool m_send_reply_on_change;
  string m_short_name;
  string m_long_name;
  unsigned int m_broadcast_threshold;
  unsigned int m_unsolicited_replies;
  ola::io::SelectServerInterface *m_ss;
  bool m_always_broadcast;
  bool m_use_limited_broadcast_address;

  // The following keep track of "Configuration mode"
  bool m_in_configuration_mode;
  bool m_artpoll_required;
  bool m_artpollreply_required;

  InputPorts m_input_ports;
  OutputPort m_output_ports[ARTNET_MAX_PORTS];
  ola::network::Interface m_interface;
  std::auto_ptr<ola::network::UDPSocketInterface> m_socket;

  ArtNetNodeImpl(const ArtNetNodeImpl&);
  ArtNetNodeImpl& operator=(const ArtNetNodeImpl&);

  void SocketReady();
  bool SendPollIfAllowed();
  bool SendPollReplyIfRequired();
  bool SendPollReply(const IPV4Address &destination);
  bool SendIPReply(const IPV4Address &destination);
  void HandlePacket(const IPV4Address &source_address,
                    const artnet_packet &packet,
                    unsigned int packet_size);
  void HandlePollPacket(const IPV4Address &source_address,
                        const artnet_poll_t &packet,
                        unsigned int packet_size);
  void HandleReplyPacket(const IPV4Address &source_address,
                         const artnet_reply_t &packet,
                         unsigned int packet_size);
  void HandleDataPacket(const IPV4Address &source_address,
                        const artnet_dmx_t &packet,
                        unsigned int packet_size);
  void HandleTodRequest(const IPV4Address &source_address,
                        const artnet_todrequest_t &packet,
                        unsigned int packet_size);
  void HandleTodData(const IPV4Address &source_address,
                     const artnet_toddata_t &packet,
                     unsigned int packet_size);
  void HandleTodControl(const IPV4Address &source_address,
                        const artnet_todcontrol_t &packet,
                        unsigned int packet_size);
  void HandleRdm(const IPV4Address &source_address,
                 const artnet_rdm_t &packet,
                 unsigned int packet_size);
  void RDMRequestCompletion(IPV4Address destination,
                            uint8_t port_id,
                            uint8_t universe_address,
                            ola::rdm::rdm_response_code code,
                            const RDMResponse *response,
                            const std::vector<std::string> &packets);
  void HandleRDMResponse(InputPort *port,
                         const string &rdm_data,
                         const IPV4Address &source_address);
  void HandleIPProgram(const IPV4Address &source_address,
                       const artnet_ip_prog_t &packet,
                       unsigned int packet_size);
  void PopulatePacketHeader(artnet_packet *packet, uint16_t op_code);
  bool SendPacket(const artnet_packet &packet,
                  unsigned int size,
                  const IPV4Address &destination);
  void TimeoutRDMRequest(InputPort *port);
  bool SendRDMCommand(const RDMCommand &command,
                      const IPV4Address &destination,
                      uint8_t universe);
  void UpdatePortFromSource(OutputPort *port, const DMXSource &source);
  bool CheckPacketVersion(const IPV4Address &source_address,
                          const string &packet_type,
                          uint16_t version);
  bool CheckPacketSize(const IPV4Address &source_address,
                       const string &packet_type,
                       unsigned int actual_size,
                       unsigned int expected_size);

  // methods for accessing Input & Output ports
  InputPort *GetInputPort(uint8_t port_id, bool warn = true);
  const InputPort *GetInputPort(uint8_t port_id) const;
  InputPort *GetEnabledInputPort(uint8_t port_id, const string &action);

  OutputPort *GetOutputPort(uint8_t port_id);
  const OutputPort *GetOutputPort(uint8_t port_id) const;
  OutputPort *GetEnabledOutputPort(uint8_t port_id, const string &action);

  void UpdatePortFromTodPacket(InputPort *port,
                               const IPV4Address &source_address,
                               const artnet_toddata_t &packet,
                               unsigned int packet_size);

  void ReleaseDiscoveryLock(InputPort *port);
  bool StartDiscoveryProcess(InputPort *port, RDMDiscoveryCallback *callback);

  bool InitNetwork();

  static const char ARTNET_ID[];
  static const uint16_t ARTNET_PORT = 6454;
  static const uint16_t OEM_CODE = 0x0431;
  static const uint16_t ARTNET_VERSION = 14;
  // after not receiving a PollReply after this many seconds we declare the
  // node as dead. This is set to 3x the POLL_INTERVAL in ArtNetDevice.
  static const uint8_t NODE_CODE = 0x00;
  static const uint16_t MAX_UIDS_PER_UNIVERSE = 0xffff;
  static const uint8_t RDM_VERSION = 0x01;  // v1.0 standard baby!
  static const uint8_t TOD_FLUSH_COMMAND = 0x01;
  static const unsigned int MERGE_TIMEOUT = 10;  // As per the spec
  // seconds after which a node is marked as inactive for the dmx merging
  static const unsigned int NODE_TIMEOUT = 31;
  // mseconds we wait for a TodData packet before declaring a node missing
  static const unsigned int RDM_TOD_TIMEOUT_MS = 4000;
  // Number of missed TODs before we decide a UID has gone
  static const unsigned int RDM_MISSED_TODDATA_LIMIT = 3;
  // The maximum number of requests we'll allow in the queue. This is a per
  // port (universe) limit.
  static const unsigned int RDM_REQUEST_QUEUE_LIMIT = 100;
  // How long to wait for a response to an RDM Request
  static const unsigned int RDM_REQUEST_TIMEOUT_MS = 2000;
};


class ArtNetNodeImplRDMWrapper
    : public ola::rdm::DiscoverableRDMControllerInterface {
 public:
  ArtNetNodeImplRDMWrapper(ArtNetNodeImpl *impl, uint8_t port_id):
      m_impl(impl),
      m_port_id(port_id) {
  }
  ~ArtNetNodeImplRDMWrapper() {}

  void SendRDMRequest(const ola::rdm::RDMRequest *request,
                      ola::rdm::RDMCallback *on_complete) {
    m_impl->SendRDMRequest(m_port_id, request, on_complete);
  }

  void RunFullDiscovery(RDMDiscoveryCallback *callback) {
    m_impl->RunFullDiscovery(m_port_id, callback);
  };

  void RunIncrementalDiscovery(RDMDiscoveryCallback *callback) {
    m_impl->RunIncrementalDiscovery(m_port_id, callback);
  }

 private:
  ArtNetNodeImpl *m_impl;
  uint8_t m_port_id;
};


class ArtNetNode {
 public:
  ArtNetNode(const ola::network::Interface &interface,
             ola::io::SelectServerInterface *ss,
             const ArtNetNodeOptions &options,
             ola::network::UDPSocketInterface *socket = NULL);
  virtual ~ArtNetNode();

  bool Start() { return m_impl.Start(); }
  bool Stop() { return m_impl.Stop(); }

  bool EnterConfigurationMode() {
    return m_impl.EnterConfigurationMode();
  }
  bool ExitConfigurationMode() {
    return m_impl.ExitConfigurationMode();
  }

  // Various parameters to control the behaviour
  bool SetShortName(const string &name) { return m_impl.SetShortName(name); }
  string ShortName() const { return m_impl.ShortName(); }
  bool SetLongName(const string &name) { return m_impl.SetLongName(name); }
  string LongName() const { return m_impl.LongName(); }

  uint8_t NetAddress() const { return m_impl.NetAddress(); }
  bool SetNetAddress(uint8_t net_address) {
    return m_impl.SetNetAddress(net_address);
  }
  bool SetSubnetAddress(uint8_t subnet_address) {
    return m_impl.SetSubnetAddress(subnet_address);
  }
  uint8_t SubnetAddress() const {
    return m_impl.SubnetAddress();
  }

  uint8_t InputPortCount() const {
    return m_impl.InputPortCount();
  }

  bool SetInputPortUniverse(uint8_t port_id, uint8_t universe_id) {
    return m_impl.SetInputPortUniverse(port_id, universe_id);
  }
  uint8_t GetInputPortUniverse(uint8_t port_id) const {
    return m_impl.GetInputPortUniverse(port_id);
  }
  void DisableInputPort(uint8_t port_id) {
    m_impl.DisableInputPort(port_id);
  }
  bool InputPortState(uint8_t port_id) const {
    return m_impl.InputPortState(port_id);
  }

  bool SetOutputPortUniverse(uint8_t port_id, uint8_t universe_id) {
    return m_impl.SetOutputPortUniverse(port_id, universe_id);
  }
  uint8_t GetOutputPortUniverse(uint8_t port_id) {
    return m_impl.GetOutputPortUniverse(port_id);
  }
  void DisableOutputPort(uint8_t port_id) {
    m_impl.DisableOutputPort(port_id);
  }
  bool OutputPortState(uint8_t port_id) const {
    return m_impl.OutputPortState(port_id);
  }

  void SetBroadcastThreshold(unsigned int threshold) {
    m_impl.SetBroadcastThreshold(threshold);
  }

  bool SetMergeMode(uint8_t port_id, artnet_merge_mode merge_mode) {
    return m_impl.SetMergeMode(port_id, merge_mode);
  }

  // Poll, this should be called periodically if we're sending data.
  bool SendPoll() {
    return m_impl.SendPoll();
  }

  // The following apply to Input Ports (those which send data)
  bool SendDMX(uint8_t port_id, const ola::DmxBuffer &buffer) {
    return m_impl.SendDMX(port_id, buffer);
  }
  void RunFullDiscovery(uint8_t port_id,
                        ola::rdm::RDMDiscoveryCallback *callback);
  void RunIncrementalDiscovery(uint8_t port_id,
                               ola::rdm::RDMDiscoveryCallback *callback);
  void SendRDMRequest(uint8_t port_id,
                      const RDMRequest *request,
                      ola::rdm::RDMCallback *on_complete);

  /*
   * This handler is called if we recieve ArtTod packets and a discovery
   * process isn't running.
   */
  bool SetUnsolicitedUIDSetHandler(
      uint8_t port_id,
      ola::Callback1<void, const ola::rdm::UIDSet&> *on_tod) {
    return m_impl.SetUnsolicitedUIDSetHandler(port_id, on_tod);
  }
  void GetSubscribedNodes(uint8_t port_id,
                          std::vector<IPV4Address> *node_addresses) {
    m_impl.GetSubscribedNodes(port_id, node_addresses);
  }

  // The following apply to Output Ports (those which receive data);
  bool SetDMXHandler(uint8_t port_id,
                     DmxBuffer *buffer,
                     ola::Callback0<void> *handler) {
    return m_impl.SetDMXHandler(port_id, buffer, handler);
  }
  bool SendTod(uint8_t port_id, const UIDSet &uid_set) {
    return m_impl.SendTod(port_id, uid_set);
  }
  bool SetOutputPortRDMHandlers(
      uint8_t port_id,
      ola::Callback0<void> *on_discover,
      ola::Callback0<void> *on_flush,
      ola::Callback2<void, const RDMRequest*, RDMCallback*> *on_rdm_request) {
    return m_impl.SetOutputPortRDMHandlers(port_id,
                                           on_discover,
                                           on_flush,
                                           on_rdm_request);
  }

  // Time Code methods
  bool SendTimeCode(const ola::timecode::TimeCode &timecode) {
    return m_impl.SendTimeCode(timecode);
  }

 private:
  ArtNetNodeImpl m_impl;
  vector<ArtNetNodeImplRDMWrapper*> m_wrappers;
  vector<ola::rdm::DiscoverableQueueingRDMController*> m_controllers;

  bool CheckInputPortId(uint8_t port_id);
};
}  // namespace artnet
}  // namespace plugin
}  // namespace ola
#endif  // PLUGINS_ARTNET_ARTNETNODE_H_