mode.cpp

/*
	Copyright (C) 2019-2021 Doug McLain

	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 3 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 General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
#include "mode.h"
#include <iostream>
#ifdef Q_OS_WIN
#include <windows.h>
#else
#include <dlfcn.h>
#endif

#include "m17.h"
#include "ysf.h"
#include "dmr.h"
#include "p25.h"
#include "nxdn.h"
#include "ref.h"
#include "xrf.h"
#include "dcs.h"
#include "iax.h"

#ifdef USE_FLITE
extern "C" {
extern cst_voice * register_cmu_us_slt(const char *);
extern cst_voice * register_cmu_us_kal16(const char *);
extern cst_voice * register_cmu_us_awb(const char *);
}
#endif

Mode* Mode::create_mode(QString m)
{
	Mode *mode = nullptr;

	if(m == "M17"){
		mode = new M17();
	}
	else if(m == "YSF" || m == "FCS"){
		mode = new YSF();
	}
	else if(m == "DMR"){
		mode = new DMR();
	}
	else if(m == "P25"){
		mode = new P25();
	}
	else if(m == "NXDN"){
		mode = new NXDN();
	}
	else if(m == "REF"){
		mode = new REF();
	}
	else if(m == "XRF"){
		mode = new XRF();
	}
	else if(m == "DCS"){
		mode = new DCS();
	}
	else if(m == "IAX"){
		mode = new IAX();
	}
	return mode;
}

Mode::Mode()
{
}

Mode::~Mode()
{
}

void Mode::init(QString callsign, uint32_t dmrid, uint16_t nxdnid, char module, QString refname, QString host, int port, bool ipv6, QString vocoder, QString modem, QString audioin, QString audioout, bool mdirect)
{
	m_dmrid = dmrid;
	m_nxdnid = nxdnid;
	m_module = module;
	m_refname = refname;
	m_ipv6 = ipv6;
	m_vocoder = vocoder;
	m_modemport = modem;
	m_audioin = audioin;
	m_audioout = audioout;
    m_mdirect = mdirect;

	m_modem = nullptr;
	m_ambedev = nullptr;
    m_mbevocoder = nullptr;
	m_hwrx = false;
	m_hwtx = false;
	m_tx = false;
	m_ttsid = 0;
	m_rxwatchdog = 0;

	m_modeinfo.callsign = callsign;
	m_modeinfo.gwid = 0;
	m_modeinfo.srcid = dmrid;
	m_modeinfo.dstid = 0;
	m_modeinfo.host = host;
	m_modeinfo.port = port;
	m_modeinfo.count = 0;
	m_modeinfo.frame_number = 0;
	m_modeinfo.frame_total = 0;
	m_modeinfo.streamid = 0;
	m_modeinfo.stream_state = STREAM_IDLE;
	m_modeinfo.sw_vocoder_loaded = false;
	m_modeinfo.hw_vocoder_loaded = false;
#ifdef Q_OS_WIN
	m_rxtimerint = 19;
#else
	m_rxtimerint = 20;
#endif
	m_txtimerint = 19;
#ifdef USE_FLITE
	flite_init();
	voice_slt = register_cmu_us_slt(nullptr);
	voice_kal = register_cmu_us_kal16(nullptr);
	voice_awb = register_cmu_us_awb(nullptr);
#endif
    m_debug = false;
}

void Mode::ambe_connect_status(bool s)
{
	if(s){
#if !defined(Q_OS_IOS)
		m_modeinfo.ambedesc = m_ambedev->get_ambe_description();
		m_modeinfo.ambeprodid = m_ambedev->get_ambe_prodid();
		m_modeinfo.ambeverstr = m_ambedev->get_ambe_verstring();
#endif
	}
	else{
		m_modeinfo.ambeprodid = "Connect failed";
		m_modeinfo.ambeverstr = "Connect failed";
	}
	emit update(m_modeinfo);
}

void Mode::mmdvm_connect_status(bool s)
{
	if(s){
		//m_modeinfo.mmdvmdesc = m_modem->get_mmdvm_description();
#if !defined(Q_OS_IOS)
		m_modeinfo.mmdvm = m_modem->get_mmdvm_version();
#endif
	}
	else{
		m_modeinfo.mmdvm = "Connect failed";
	}
	emit update(m_modeinfo);
}

void Mode::in_audio_vol_changed(qreal v)
{
	m_audio->set_input_volume(v / m_attenuation);
}

void Mode::out_audio_vol_changed(qreal v)
{
	m_audio->set_output_volume(v);
}

void Mode::agc_state_changed(int s)
{
	m_audio->set_agc(s);
}

void Mode::begin_connect()
{
	m_modeinfo.status = CONNECTING;

    if((m_vocoder != "") && (m_mode != "M17")){
        m_hwrx = true;
        m_hwtx = true;
        m_modeinfo.hw_vocoder_loaded = true;
#if !defined(Q_OS_IOS)
        m_ambedev = new SerialAMBE(m_mode);
        connect(m_ambedev, SIGNAL(connected(bool)), this, SLOT(ambe_connect_status(bool)));
        connect(m_ambedev, SIGNAL(data_ready()), this, SLOT(get_ambe()));
        connect(m_ambedev, SIGNAL(ambedev_ready()), this, SLOT(host_lookup()));
        m_ambedev->connect_to_serial(m_vocoder);
#endif
    }
    else{
        m_hwrx = false;
        m_hwtx = false;
        if(m_modemport == ""){
            host_lookup();
        }
    }

    if(m_modemport != ""){
#if !defined(Q_OS_IOS)
        m_modem = new SerialModem(m_mode);
        m_modem->set_modem_flags(m_rxInvert, m_txInvert, m_pttInvert, m_useCOSAsLockout, m_duplex);
        m_modem->set_modem_params(m_baud, m_rxfreq, m_txfreq, m_txDelay, m_rxLevel, m_rfLevel, m_ysfTXHang, m_cwIdTXLevel, m_dstarTXLevel, m_dmrTXLevel, m_ysfTXLevel, m_p25TXLevel, m_nxdnTXLevel, m_pocsagTXLevel, m_m17TXLevel);
        connect(m_modem, SIGNAL(connected(bool)), this, SLOT(mmdvm_connect_status(bool)));
        connect(m_modem, SIGNAL(modem_data_ready(QByteArray)), this, SLOT(process_modem_data(QByteArray)));
        connect(m_modem, SIGNAL(modem_ready()), this, SLOT(host_lookup()));
        m_modem->connect_to_serial(m_modemport);
#endif
    }
}

void Mode::host_lookup()
{
    if(m_mdirect && (m_mode == "M17")){ // MMDVM_DIRECT currently only supported by M17
        mmdvm_direct_connect();
    }
    else if(m_ipv6 && (m_modeinfo.host != "none")){
        qDebug() << "Host == " << m_modeinfo.host;
        QList<QHostAddress> h;
        QHostInfo i;
        h.append(QHostAddress(m_modeinfo.host));
        i.setAddresses(h);
        hostname_lookup(i);
    }
    else{
        QHostInfo::lookupHost(m_modeinfo.host, this, SLOT(hostname_lookup(QHostInfo)));
    }
}

void Mode::toggle_tx(bool tx)
{
	tx ? start_tx() : stop_tx();
}

void Mode::start_tx()
{
#if !defined(Q_OS_IOS)
	if(m_hwtx){
		m_ambedev->clear_queue();
	}
#endif
	m_txcodecq.clear();
	m_tx = true;
	m_txcnt = 0;
	m_ttscnt = 0;
	m_rxtimer->stop();
	m_modeinfo.streamid = 0;
	m_modeinfo.stream_state = TRANSMITTING;
#ifdef USE_FLITE

	if(m_ttsid == 1){
		tts_audio = flite_text_to_wave(m_ttstext.toStdString().c_str(), voice_kal);
	}
	else if(m_ttsid == 2){
		tts_audio = flite_text_to_wave(m_ttstext.toStdString().c_str(), voice_awb);
	}
	else if(m_ttsid == 3){
		tts_audio = flite_text_to_wave(m_ttstext.toStdString().c_str(), voice_slt);
	}
#endif
	if(!m_txtimer->isActive()){
		if(m_ttsid == 0){
			m_audio->set_input_buffer_size(640);
			m_audio->start_capture();
			//audioin->start(&audio_buffer);
		}
		m_txtimer->start(m_txtimerint);
	}
}

void Mode::stop_tx()
{
	m_tx = false;
}

bool Mode::load_vocoder_plugin()
{
#ifdef VOCODER_PLUGIN
	QString config_path = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation);
#if !defined(Q_OS_ANDROID) && !defined(Q_OS_WIN)
	config_path += "/dudetronics";
#endif
#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
	QString voc = config_path + "/vocoder_plugin." + QSysInfo::productType() + "." + QSysInfo::currentCpuArchitecture();
#else
	QStringList l = QSysInfo::buildAbi().split('-');
	//QString voc = config_path + "/vocoder_plugin." + QSysInfo::kernelType() + "." + QSysInfo::currentCpuArchitecture();
	QString voc = config_path + "/vocoder_plugin." + QSysInfo::kernelType() + "." + l.at(0);
#endif
#if !defined(Q_OS_WIN)
	//QString voc = "/mnt/data/src/mbe_vocoder/vocoder_plugin.linux.x86_64.so";
	void* a = dlopen(voc.toLocal8Bit(), RTLD_LAZY);
	if (!a) {
		qDebug() << "Cannot load library: " << QString::fromLocal8Bit(dlerror());
		return false;
	}
	dlerror();

	create_t* create_a = (create_t*) dlsym(a, "create");
	const char* dlsym_error = dlerror();

	if (dlsym_error) {
		qDebug() << "Cannot load symbol create: " << QString::fromLocal8Bit(dlsym_error);
		return false;
	}

	m_mbevocoder = create_a();
	qDebug() << voc + " loaded";
	return true;
#else
	HINSTANCE hinstvoclib;
	hinstvoclib = LoadLibrary(reinterpret_cast<LPCWSTR>(voc.utf16()));

	if (hinstvoclib != NULL) {
		create_t* create_a = (create_t*)GetProcAddress(hinstvoclib, "create");

		if (create_a != NULL) {
			m_mbevocoder = create_a();
			qDebug() << voc + " loaded";
			return true;
		}
		else{
			return false;
		}
	}
	else{
		return false;
	}
#endif
#else
    m_mbevocoder = new VocoderPlugin();
    return true;
#endif
}

void Mode::deleteLater()
{
	if(m_modeinfo.status == CONNECTED_RW){
		//m_udp->disconnect();
		//m_ping_timer->stop();
		send_disconnect();
        delete m_audio;
        //if(m_mbevocoder != nullptr) delete m_mbevocoder;
#if !defined(Q_OS_IOS)
		if(m_hwtx){
			delete m_ambedev;
		}
		if(m_modem){
			delete m_modem;
		}
#endif
	}
	m_modeinfo.count = 0;
	QObject::deleteLater();
}