/*****************************************************************************
* OpenTel Telephony Server & Framework
* Copyright (c) 1995-99 OpenComm do Brasil Ltda.
* Todos os direitos reservados.
* Este arquivo contem material confidencial de OpenComm do Brasil, e deve
* darse tratamento como tal.
******************************************************************************/

#ident "@(#) $Header: /cvsroot/opentel/opentel/server/drivers/dialogic/otdialtd.cpp,v 1.2 2000/03/24 05:16:43 jbernab Exp $"

#include <otconfig.h>

#ifdef _WINDOWS
#include <windows.h>
#include <io.h>
#endif

extern "C" {
#include <srllib.h>
#include <dxxxlib.h>
};

#include <otcallc.includes>
#include <dialogic/otdialogic.h>
#include <ottonedet.includes>
#include <dialogic/otdialdxx.h>
#include <dialogic/otdialtd.h>
#include <otarchive.includes>


OT_IMPLEMENT_DYNAMIC(OtDialogicToneDetector,OtToneDetector);

OtDialogicToneDetector::OtDialogicToneDetector( OtDialogicDxx *dxx ) :
        OtToneDetector(),
        m_dxx(dxx)
{
        m_dxx->addTarget(this);

        setName(OtString("OtDialogicToneDetector(") + OtString(ATDV_NAMEP(m_dxx->getFd())) + OtString(")"));

}

OtDialogicToneDetector::~OtDialogicToneDetector(void)
{
        m_dxx->removeTarget(this);
}

OtTimeSlotListener *OtDialogicToneDetector::getListener()
{
        return m_dxx->getListener();
}

OtTimeSlotTransmitter *OtDialogicToneDetector::getTransmitter()
{
        return m_dxx->getTransmitter();
}

void OtDialogicToneDetector::enableDetection(void)
{
        OtToneDetector::enableDetection();
        // Dialogic Stuff
        dx_setevtmsk(m_dxx->getFd(),DM_DIGITS);
        dx_setdigtyp(m_dxx->getFd(),DM_DTMF|DM_DPDZ);

//      DV_DIGIT digitp;
//      if(dx_getdig(m_dxx->getFd(),NULL,&digitp, EV_ASYNC)<0)
//              throw OtDialogException();
}

void OtDialogicToneDetector::disableDetection(void)
{
        OtToneDetector::disableDetection();
        // Dialogic Stuff
}

void OtDialogicToneDetector::enableDigits(void)
{
        // Dialogic Stuff
        dx_setevtmsk(m_dxx->getFd(),DM_DIGITS);
        dx_setdigtyp(m_dxx->getFd(),DM_DTMF|DM_DPDZ|DM_LPD);
}

void OtDialogicToneDetector::disableDigits(void)
{
        // Dialogic Stuff
        long msk=0;
#ifndef _WINDOWS			// CHECK Windows does not have dx_getevtmsk
		msk=dx_getevtmsk(m_dxx->getFd());
#endif
        msk&=(~DM_DIGITS);
        dx_setevtmsk(m_dxx->getFd(),msk);                       //????
}

int OtDialogicToneDetector::isEnabled(void)
{
        return OtToneDetector::isEnabled();
}

void OtDialogicToneDetector::addTone(OtToneTmpl *tmpl)
{
        // Dialogic Stuff
        static long nextTid=128;
        OtSingleTone st;
        OtDualTone dt;
        OtToneCadence tc;

        if(tmpl->getFlags()&OtToneTmpl::toneSingle) {   // ST
                st=tmpl->getSingleTone();
                if(tmpl->getFlags()&OtToneTmpl::toneCadence) {  // ST&CD
                        tc=tmpl->getCadence();
                        if(dx_bldstcad(nextTid,st.getFreq(),st.getFreqDev(),tc.getToneOn(),
                                tc.getToneOnDev(), tc.getToneOff(), tc.getToneOffDev(),
                                        tc.getRep())<0)
                                                throw OtDialogicException(m_dxx->getFd());
                } else {        // Simple ST
                        long mode;
                        switch(st.getMode()) {
                                case OtSingleTone::Leading:
                                        mode=TN_LEADING;
                                        break;
                                case OtSingleTone::Trailing:
                                        mode=TN_TRAILING;
                                        break;
                                }
                        if(dx_bldst(nextTid,st.getFreq(),st.getFreqDev(),mode)<0)
                                                throw OtDialogicException(m_dxx->getFd());
                }
        } else if(tmpl->getFlags()&OtToneTmpl::toneDual) {      // DT
                dt=tmpl->getDualTone();
                if(tmpl->getFlags()&OtToneTmpl::toneCadence) {  // DT&CD
                        tc=tmpl->getCadence();
                        if(dx_blddtcad(nextTid,dt.getFreq(),dt.getFreqDev(),// Freq1
                                dt.getFreq2(), dt.getFreqDev2(),                                // Freq2
                        tc.getToneOn(),tc.getToneOnDev(), tc.getToneOff(),      // Cadenca
                        tc.getToneOffDev(), tc.getRep())<0)
                                                throw OtDialogicException(m_dxx->getFd());
                } else {        // Simple DT
                        long mode;
                        switch(dt.getMode()) {
                                case OtSingleTone::Leading:
                                        mode=TN_LEADING;
                                        break;
                                case OtSingleTone::Trailing:
                                        mode=TN_TRAILING;
                                        break;
                                }
                        if(dx_blddt(nextTid,dt.getFreq(),dt.getFreqDev(),
                                dt.getFreq2(), dt.getFreqDev2(), mode)<0)
                                                throw OtDialogicException(m_dxx->getFd());
                }
        } else
                throw OtException("Invalid OtToneTmpl");


        if(dx_addtone(m_dxx->getFd(),NULL,DG_USER1)<0)
                throw OtDialogicException(m_dxx->getFd());

        tmpl->setTid(nextTid++);                // Set the Tone Id to the OtToneTmpl

        OtToneDetector::addTone(tmpl);
}

void OtDialogicToneDetector::removeTone(OtToneTmpl *tmpl)
{
        OtToneDetector::removeTone(tmpl);
        // Dialogic Stuff
}

const OtList<OtToneTmpl> &OtDialogicToneDetector::getTones(void)
{
        return OtToneDetector::getTones();
}

void OtDialogicToneDetector::removeAllTones(void)
{
        OtToneDetector::removeAllTones();
        // Dialogic Stuff
}

void OtDialogicToneDetector::enableTone(OtToneTmpl *t)
{
        // Dialogic Stuff
        if(dx_enbtone(m_dxx->getFd(),t->getTid(),DM_TONEOFF|DM_TONEON)<0)
                throw OtDialogicException(m_dxx->getFd());

        OtToneDetector::enableTone(t);
}

void OtDialogicToneDetector::disableTone(OtToneTmpl *t)
{
        OtToneDetector::disableTone(t);
        // Dialogic Stuff
}

void OtDialogicToneDetector::onMessage(OtMessage *msg)
{
        OtDialogicEvent *e=(OtDialogicEvent *)((OtDlgMsg *)msg)->getEv();

        if(e->getClass()==OtDialogicEvent::eventClass) {
                if(e->getType()==TDX_CST) {
                        DX_CST *cst=(DX_CST *)e->getDatap();
                        switch(cst->cst_event) {
                                case DE_TONEON:
                                        dispatchEvent(OtToneDetectorEvent::eventToneOn,cst->cst_data);
                                        break;
                                case DE_TONEOFF:
                                        dispatchEvent(OtToneDetectorEvent::eventToneOff,cst->cst_data);
                                        break;
                                case DE_SILON:
                                        dispatchEvent(OtToneDetectorEvent::eventSilenceOn,cst->cst_data);
                                        break;
                                case DE_SILOFF:
                                        dispatchEvent(OtToneDetectorEvent::eventSilenceOff,cst->cst_data);
                                        break;
                                case DE_DIGITS:
                                        dispatchEvent(OtToneDetectorEvent::eventDigit,cst->cst_data);
                                        dx_clrdigbuf(m_dxx->getFd());
                                        break;
                                }
                        }
                }
}

void OtDialogicToneDetector::dispatchEvent(OtEventType t,long toneId)
{
        OtToneDetectorEvent ev(*this,t,toneId);
        OtEventSource::postEvent(ev);
}