radioManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/

#pragma once

#include <makRadio/export.h>
#include <makRadio/radio.h>
#include <makRadio/radioSystemInitializer.h>
#include <vlutil/vlLockfreeQueue.h>
#include <vlutil/vlTime.h>
#include <vlpi/entityIdentifier.h>
#include <vrfutil/rwUUID.h>

#include <vector>
#include <list>

class DtFilename;

namespace makAudio
{
   class DtAudioBuffer;
}

namespace makRadio
{
   class DtRadio;
   class DtRadioInterface;
   class StreamAudioMessage;
   class ControlMessage;
   class ConfigureRadioMessage;
   class RemoveRadioMessage;
   class ChangeEntityMessage;

   typedef DtLockfreeQueue<ControlMessage*> DtControlQueue;
   typedef DtLockfreeQueue<StreamAudioMessage*> DtStreamQueue;

   struct DtRadioConnectionBundle
   {
      DtControlQueue* controlQueue;  //handed in net thread
      DtStreamQueue* toNetQueue;  //handled in net thread
      DtStreamQueue* fromNetQueue; //handled in main thread
   };

   class DT_DLL_MAKRADIO DtRadioManager
   {
   public:
      DtRadioManager();
      virtual ~DtRadioManager();

      virtual void init(const DtFilename&);
      virtual void init(const DtRadioSystemInitializer& init, const std::string& captureDevice = "");
      virtual void tick();
      virtual void shutdown();

      virtual void addReference();

      virtual void removeReference();

      virtual void setEnabled(bool enable);

      virtual void setSystemEnabled(bool b, bool save = true);
      virtual bool systemEnabled() const;

      virtual void registerConnection(DtRadioConnectionBundle* connection);
      virtual void unregisterConnection(DtRadioConnectionBundle* connection);

      virtual void audioOut(makAudio::DtAudioBuffer* buffer);

      virtual void setActiveEntity(const DtUUID& entityId, const DtEntityIdentifier& id);
      virtual const DtUUID& activeEntity() const;
      virtual const DtEntityIdentifier& vrlinkEntityId() const;

      virtual DtRadio* findRadio(int idx);

      virtual void setRadios(const std::vector<DtRwRadioState>&, bool save = true);

      virtual std::vector<DtRadio*>& radios() {return myRadios;}
      virtual DtRadio* createRadio(DtRwRadioState& state);
      virtual void removeRadio(int idx);
      virtual void removeRadio(DtRadio* radio);
      virtual void clearRadios();

      virtual void sendRadioStreamMessage(StreamAudioMessage* msg);
      virtual void sendControlMessage(ControlMessage* msg);

      virtual bool changeCaptureDevice(const std::string&);

      virtual int nextRadioId();

      virtual float voxThreshold() const;
      virtual void setVoxThreshold(float val);

      virtual bool jammersEnabled() const;
      virtual void setJammersEnabled(bool set);

      virtual bool setAutoSave(bool);
      virtual bool autoSave() const;

      virtual void setSampleRate(int, bool save = true, bool reinitialize = true);
      virtual int sampleRate() const;

      virtual void setFormat(const std::string&, bool save = true, bool reinitialize = true);
      virtual std::string format() const;

      virtual double captureFrequency() const;
      virtual void setCaputreFrequency(double hertz, bool save = true);

      virtual bool jammerEnabled(DtRadio*) const;

      virtual void changeJammerFrequency(double oldFrequency, double newFrequency);

      virtual bool setJammed(DtRadio*, bool);

      virtual void clearJammers();

      virtual DtRadio* findCurrentRadio();
      virtual void setCurrentRadio(DtRadio* radio);

   protected:
      virtual void configureRadios(const DtRadioSystemInitializer::Radios& radios);
      virtual void recreateRadios();
      virtual void handleNetStreamMessage(StreamAudioMessage* msg);

      std::vector<DtRwRadioState> myRadioInit;
      std::vector<DtRadio*> myRadios;
      
      std::map<double, DtRadio*> myJammers;
      unsigned int myNextRadioId;

      DtUUID myActiveEntityId;
      DtEntityIdentifier myVrlinkEntityId;
      typedef std::list<DtRadioConnectionBundle*> ConnectionList;
      ConnectionList myConnections;

      float myVoxThreshold;
      bool myJammersEnabled;

      double myCaptureFrequency;
      double myNextCaptureTime;

      int myReferenceCount;

      DtRadio* myCurrentRadio;
      DtRadioSystemInitializer* myRadioSystemInitializer;

      bool myAutoSave;
      bool myEnabled;
      bool mySystemEnabled;

      DtClock myClock;
   };
}