EchoLinkQso.h

Go to the documentation of this file.

#ifndef ECHOLINK_QSO_INCLUDED
#define ECHOLINK_QSO_INCLUDED


/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/

#include <sys/time.h>
#include <sigc++/sigc++.h>
#include <stdint.h>
#include <string>


/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/

extern "C" {
#include <gsm.h>
}
#include <AsyncTimer.h>
#include <AsyncIpAddress.h>
#include <AsyncAudioSink.h>
#include <AsyncAudioSource.h>


/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/

namespace EchoLink
{

/****************************************************************************
 *
 * Forward declarations inside the declared namespace
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/



/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/

class Qso
  : public sigc::trackable, public Async::AudioSink, public Async::AudioSource
{
  public:
    struct VoicePacket
    {
      struct {
        uint8_t version;
        uint8_t pt;
        uint16_t seqNum;
        uint32_t time;
        uint32_t ssrc;
      } header;
      uint8_t data[1024];
    } __attribute__ ((packed));
    
    struct RawPacket
    {
      VoicePacket *voice_packet;
      int length;
      short *samples;
    };

    typedef enum
    {
      STATE_DISCONNECTED, 
      STATE_CONNECTING,   
      STATE_BYE_RECEIVED, 
      STATE_CONNECTED     
    } State;

    Qso(const Async::IpAddress& ip, const std::string& callsign="",
        const std::string& name="", const std::string& info="");
    
    ~Qso(void);
  
    bool initOk(void) { return init_ok; }
    
    bool setLocalCallsign(const std::string& callsign);
    
    const std::string& localCallsign(void) const { return callsign; }
    
    bool setLocalName(const std::string& name);

    const std::string& localName(void) const { return name; }
    
    void setLocalInfo(const std::string& info);
        
    const std::string& localInfo(void) const { return local_stn_info; }
    
    bool connect(void);
    
    bool accept(void);
    
    bool disconnect(void);
    
    bool sendInfoData(const std::string& info="");
    
    bool sendChatData(const std::string& msg);
    
    const Async::IpAddress& remoteIp(void) const
    {
      return remote_ip;
    }
    
    bool sendAudioRaw(RawPacket *raw_packet);

    void setRemoteParams(const std::string& priv);
    
    void setRemoteName(const std::string& name) { remote_name = name; }
    
    const std::string& remoteName(void) const { return remote_name; }
    
    void setRemoteCallsign(const std::string& call) { remote_call = call; }
    
    const std::string& remoteCallsign(void) const { return remote_call; }
    
    bool isRemoteInitiated(void) const { return is_remote_initiated; }
    
    bool receivingAudio(void) const { return receiving_audio; }

    State currentState(void) const { return state; }
    
    sigc::signal<void, const std::string&> infoMsgReceived;
    
    sigc::signal<void, const std::string&> chatMsgReceived;
    
    sigc::signal<void, State> stateChange;
    
    sigc::signal<void, bool> isReceiving;
    
    sigc::signal<void, RawPacket*>  audioReceivedRaw;
    

    virtual int writeSamples(const float *samples, int count);
    
    virtual void flushSamples(void);

    virtual void resumeOutput(void);
    
    void setUseGsmOnly(void);

  protected:
    virtual void allSamplesFlushed(void);

    
  private:
    struct Private;

    static const int    KEEP_ALIVE_TIME         = 10000;
    static const int    MAX_CONNECT_RETRY_CNT   = 5;
    static const int    CON_TIMEOUT_TIME        = 50000;
    static const int    RX_INDICATOR_POLL_TIME  = 100;  // 10 times/s
    static const int    RX_INDICATOR_SLACK      = 100;  // 100ms extra time
    static const int    RX_INDICATOR_MAX_TIME   = 1000; // Max 1s timeout
    static const int    FRAME_COUNT             = 4;
    static const int    BUFFER_SIZE             = FRAME_COUNT*160;
    static const int    BLOCK_TIME              = FRAME_COUNT*1000*160/8000;

    bool                init_ok;
    unsigned char       sdes_packet[1500];
    int                 sdes_length;
    State               state;
    gsm                 gsmh;
    uint16_t            next_audio_seq;
    Async::Timer *      keep_alive_timer;
    int                 connect_retry_cnt;
    Async::Timer *      con_timeout_timer;
    std::string         callsign;
    std::string         name;
    std::string         local_stn_info;
    short               receive_buffer[BUFFER_SIZE];
    short               send_buffer[BUFFER_SIZE];
    int                 send_buffer_cnt;
    Async::IpAddress    remote_ip;
    Async::Timer *      rx_indicator_timer;
    std::string         remote_name;
    std::string         remote_call;
    bool                is_remote_initiated;
    bool                receiving_audio;
    bool                use_gsm_only;
    Private             *p;
    int                 rx_timeout_left;

    Qso(const Qso&);
    Qso& operator=(const Qso&);
    void printData(const unsigned char *buf, int len);
    void handleCtrlInput(unsigned char *buf, int len);
    inline void handleByePacket(unsigned char *buf, int len);
    inline void handleSdesPacket(unsigned char *buf, int len);
    void handleAudioInput(unsigned char *buf, int len);
    inline void handleNonAudioPacket(unsigned char *buf, int len);
    inline void handleAudioPacket(unsigned char *buf, int len);
    void micAudioRead(void *buf, size_t len);
    bool sendSdesPacket(void);
    void sendKeepAlive(Async::Timer *timer);
    void setState(State state);
    void connectionTimeout(Async::Timer *timer);
    bool setupConnection(void);
    void cleanupConnection(void);
    bool sendVoicePacket(void);
    void checkRxActivity(Async::Timer *timer);
    bool sendByePacket(void);
    
};  /* class Qso */


} /* namespace */

#endif /* ECHOLINK_QSO_INCLUDED */



/*
 * This file has not been truncated
 */