/* Opal endpoint interface for Freeswitch Modular Media Switching Software Library /
 * Soft-Switch Application
 *
 * Version: MPL 1.1
 *
 * Copyright (c) 2007 Tuyan Ozipek (tuyanozipek@gmail.com)
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * Contributor(s):
 * Tuyan Ozipek   (tuyanozipek@gmail.com)
 * Lukasz Zwierko (lzwierko@gmail.com)
 * Robert Jongbloed (robertj@voxlucida.com.au)
 *
 */

#include "mod_opal.h"
#include <opal/patch.h>
#include <h323/h323pdu.h>

SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_codec_string, mod_opal_globals.codec_string);
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_context, mod_opal_globals.context);
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_dialplan, mod_opal_globals.dialplan);


#define CF_NEED_FLUSH (1 << 1)

struct mod_opal_globals mod_opal_globals = { 0 };


static switch_call_cause_t create_outgoing_channel(switch_core_session_t *session, switch_event_t *var_event,
                                                   switch_caller_profile_t *outbound_profile, switch_core_session_t **new_session,
                                                   switch_memory_pool_t **pool, switch_originate_flag_t flags);


static FSProcess *opal_process = NULL;


static const char ModuleName[] = "opal";


static switch_io_routines_t opalfs_io_routines = {
    /*.outgoing_channel */ create_outgoing_channel,
    /*.read_frame */ FSConnection::read_audio_frame,
    /*.write_frame */ FSConnection::write_audio_frame,
    /*.kill_channel */ FSConnection::kill_channel,
    /*.send_dtmf */ FSConnection::send_dtmf,
    /*.receive_message */ FSConnection::receive_message,
    /*.receive_event */ FSConnection::receive_event,
    /*.state_change */ FSConnection::state_change,
    /*.read_video_frame */ FSConnection::read_video_frame,
    /*.write_video_frame */ FSConnection::write_video_frame
};

static switch_state_handler_table_t opalfs_event_handlers = {
    /*.on_init */ FSConnection::on_init,
    /*.on_routing */ FSConnection::on_routing,
    /*.on_execute */ FSConnection::on_execute,
    /*.on_hangup */ FSConnection::on_hangup,
    /*.on_loopback */ FSConnection::on_loopback,
    /*.on_transmit */ FSConnection::on_transmit
};


SWITCH_BEGIN_EXTERN_C
/*******************************************************************************/

SWITCH_MODULE_LOAD_FUNCTION(mod_opal_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_opal_shutdown);
SWITCH_MODULE_DEFINITION(mod_opal, mod_opal_load, mod_opal_shutdown, NULL);

SWITCH_MODULE_LOAD_FUNCTION(mod_opal_load) {
    switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Starting loading mod_opal\n");

    /* Prevent the loading of OPAL codecs via "plug ins", this is a directory
       full of DLLs that will be loaded automatically. */
    putenv((char *)"PTLIBPLUGINDIR=/no/thanks");


    *module_interface = switch_loadable_module_create_module_interface(pool, modname);
    if (!*module_interface) {
        return SWITCH_STATUS_MEMERR;
    }

    opal_process = new FSProcess();
    if (opal_process == NULL) {
        return SWITCH_STATUS_MEMERR;
    }

    if (opal_process->Initialise(*module_interface)) {
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Opal manager initialized and running\n");
        //unloading causes a seg in linux
        return SWITCH_STATUS_NOUNLOAD;
        //return SWITCH_STATUS_SUCCESS;
    }

    delete opal_process;
    opal_process = NULL;
    return SWITCH_STATUS_FALSE;
}


SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_opal_shutdown) {
    
    switch_safe_free(mod_opal_globals.context);
    switch_safe_free(mod_opal_globals.dialplan);
    switch_safe_free(mod_opal_globals.codec_string);
    delete opal_process;
    opal_process = NULL;
    return SWITCH_STATUS_SUCCESS;
}

SWITCH_END_EXTERN_C
/*******************************************************************************/



static switch_call_cause_t create_outgoing_channel(switch_core_session_t *session,
                                                   switch_event_t *var_event,
                                                   switch_caller_profile_t *outbound_profile,
                                                   switch_core_session_t **new_session, switch_memory_pool_t **pool, switch_originate_flag_t flags)
{
    if (opal_process == NULL) {
        return SWITCH_CAUSE_CRASH;
    }

    PString token;

    FSManager & manager = opal_process->GetManager();
    if (!manager.SetUpCall("local:", outbound_profile->destination_number, token)) {
        return SWITCH_CAUSE_INVALID_NUMBER_FORMAT;
    }

    PSafePtr < OpalCall > call = manager.FindCallWithLock(token);

    if (call == NULL) {
        return SWITCH_CAUSE_PROTOCOL_ERROR;
    }

    PSafePtr < FSConnection > connection = call->GetConnectionAs < FSConnection > (0);

    if (connection == NULL) {
        return SWITCH_CAUSE_PROTOCOL_ERROR;
    }

    *new_session = connection->GetSession();

    connection->SetLocalPartyName(outbound_profile->caller_id_number);
    connection->SetDisplayName(outbound_profile->caller_id_name);


    switch_caller_profile_t *caller_profile = switch_caller_profile_clone(*new_session, outbound_profile);
    switch_channel_t *channel = switch_core_session_get_channel(*new_session);
    char name[256] = "opal/";
    switch_copy_string(name + 5, outbound_profile->destination_number, sizeof(name)-5);
    switch_channel_set_name(channel, name);
    switch_channel_set_flag(channel, CF_OUTBOUND);
    switch_channel_set_caller_profile(channel, caller_profile);
    switch_channel_set_state(channel, CS_INIT);

    return SWITCH_CAUSE_SUCCESS;
}


///////////////////////////////////////////////////////////////////////

#if PTRACING

class FSTrace : public ostream {
 public:
 FSTrace()
     : ostream(&buffer)
        {
        }

 private:
 class Buffer : public streambuf {
        char buffer[250];

    public:
        Buffer()
            {
                setg(buffer, buffer, &buffer[sizeof(buffer)-2]);
                setp(buffer, &buffer[sizeof(buffer)-2]);
            }

        virtual int sync()
        {
            return overflow(EOF);
        }

        virtual int underflow()
        {
            return EOF;
        }

        virtual int overflow(int c)
        {
            const char *fmt = "%s";
            char *func = NULL;

            int bufSize = pptr() - pbase();

            if (c != EOF) {
                *pptr() = (char)c;
                bufSize++;
            }
            
            if (bufSize != 0) {
                char *bufPtr = pbase();
                char *bufEndPtr = NULL;
                setp(bufPtr, epptr());
                bufPtr[bufSize] = '\0';
                int line = 0;
                char *p;
                
                char *file = NULL;
                switch_log_level_t level;

                
                switch (strtoul(bufPtr, &file, 10)) {
                case 1 :
                    level = SWITCH_LOG_INFO;
                    break;
                default :
                    level = SWITCH_LOG_DEBUG;
                    break;
                }

                if (file) {
                    while (isspace(*file)) file++;
                    
                    if (file && (bufPtr = strchr(file, '(')) && (bufEndPtr = strchr(bufPtr, ')'))) {
                        char *e;

                        for(p = bufPtr; p && *p; p++) {
                            if (*p == '\t') {
                                *p = ' ';
                            }
                        }

                        *bufPtr++ = '\0';
                        line = atoi(bufPtr);
                        while (bufEndPtr && isspace(*(++bufEndPtr)));
                        bufPtr = bufEndPtr;
                        if (bufPtr && (e = strchr(bufPtr, ' ')) || (e = strchr(bufPtr, '\t'))) {
                            func = bufPtr;
                            bufPtr = e;
                            *bufPtr++ = '\0';
                        }
                    }
                }
                
                switch_text_channel_t tchannel = SWITCH_CHANNEL_ID_LOG;

                if (!bufPtr) {
                    bufPtr = pbase();
                    level = SWITCH_LOG_DEBUG;
                }

                if (bufPtr) {
                    if (end_of(bufPtr) != '\n') {
                        fmt = "%s\n";
                    }
                    if (!(file && func && line)) tchannel = SWITCH_CHANNEL_ID_LOG_CLEAN;

                    switch_log_printf(tchannel, file, func, line, NULL, level, fmt, bufPtr);
                }
                
            }

            return 0;
        }
    } buffer;
};

#endif


///////////////////////////////////////////////////////////////////////

FSProcess::FSProcess()
  : PLibraryProcess("Vox Lucida Pty. Ltd.", "mod_opal", 1, 0, AlphaCode, 1)
  , m_manager(NULL)
{
}


FSProcess::~FSProcess()
{
  delete m_manager;
}


bool FSProcess::Initialise(switch_loadable_module_interface_t *iface)
{
  m_manager = new FSManager();
  return m_manager != NULL && m_manager->Initialise(iface);
}


///////////////////////////////////////////////////////////////////////

FSManager::FSManager()
{
    // These are deleted by the OpalManager class, no need to have destructor
    m_h323ep = new H323EndPoint(*this);
    m_iaxep = new IAX2EndPoint(*this);
    m_fsep = new FSEndPoint(*this);
}


bool FSManager::Initialise(switch_loadable_module_interface_t *iface)
{
    ReadConfig(false);

#if PTRACING
    PTrace::SetLevel(mod_opal_globals.trace_level);        //just for fun and eyecandy ;)
    PTrace::SetOptions(PTrace::TraceLevel);
    PTrace::SetStream(new FSTrace);
#endif

    m_FreeSwitch = (switch_endpoint_interface_t *) switch_loadable_module_create_interface(iface, SWITCH_ENDPOINT_INTERFACE);
    m_FreeSwitch->interface_name = ModuleName;
    m_FreeSwitch->io_routines = &opalfs_io_routines;
    m_FreeSwitch->state_handler = &opalfs_event_handlers;

    SetAudioJitterDelay(800, 3000); // should be config option

    silenceDetectParams.m_mode = OpalSilenceDetector::NoSilenceDetection;

    if (m_listeners.empty()) {
        m_h323ep->StartListener("");
    } else {
        for (std::list < FSListener >::iterator it = m_listeners.begin(); it != m_listeners.end(); ++it) {
            if (!m_h323ep->StartListener(it->listenAddress)) {
                PTRACE(3, "mod_opal\tCannot start listener for " << it->name);
            }
        }
    }

    AddRouteEntry("h323:.* = local:<da>");  // config option for direct routing
    AddRouteEntry("iax2:.* = local:<da>");  // config option for direct routing
    AddRouteEntry("local:.* = h323:<da>");  // config option for direct routing

    /* For compatibility with the algorithm in FSConnection::SetCodecs() we need
       to set all audio media formats to be 1 frame per packet */
    OpalMediaFormatList allCodecs = OpalMediaFormat::GetAllRegisteredMediaFormats();
    for (OpalMediaFormatList::iterator it = allCodecs.begin(); it != allCodecs.end(); ++it) {
      if (it->GetMediaType() == OpalMediaType::Audio()) {
        it->SetOptionInteger(OpalAudioFormat::RxFramesPerPacketOption(), 1);
        it->SetOptionInteger(OpalAudioFormat::TxFramesPerPacketOption(), 1);
      }
    }

    return TRUE;
}


switch_status_t FSManager::ReadConfig(int reload)
{
    const char *cf = "opal.conf";
    switch_status_t status = SWITCH_STATUS_SUCCESS;

    switch_memory_pool_t *pool = NULL;
    if ((status = switch_core_new_memory_pool(&pool)) != SWITCH_STATUS_SUCCESS) {
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
        return status;
    }

    set_global_context("default");
    set_global_dialplan("XML");

    switch_event_t *params = NULL;
    switch_event_create(&params, SWITCH_EVENT_REQUEST_PARAMS);
    switch_assert(params);
    switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "profile", switch_str_nil(""));
    switch_xml_t cfg;
    switch_xml_t xml = switch_xml_open_cfg(cf, &cfg, params);
    if (xml == NULL) {
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "open of %s failed\n", cf);
        return SWITCH_STATUS_FALSE;
    } else {
        switch_xml_t xmlSettings = switch_xml_child(cfg, "settings");
        if (xmlSettings) {
            for (switch_xml_t xmlParam = switch_xml_child(xmlSettings, "param"); xmlParam != NULL; xmlParam = xmlParam->next) {
                const char *var = switch_xml_attr_soft(xmlParam, "name");
                const char *val = switch_xml_attr_soft(xmlParam, "value");

                if (!strcasecmp(var, "trace-level")) {
                    int level = atoi(val);
                    if (level > 0) {
                        mod_opal_globals.trace_level = level;
                    }
                } else if (!strcasecmp(var, "context")) {
                    set_global_context(val);
                } else if (!strcasecmp(var, "dialplan")) {
                    set_global_dialplan(val);
                } else if (!strcasecmp(var, "codec-prefs")) {
                    set_global_codec_string(val);
                }
            }
        }
    }


    switch_xml_t xmlListeners = switch_xml_child(cfg, "listeners");
    if (xmlListeners != NULL) {
        for (switch_xml_t xmlListener = switch_xml_child(xmlListeners, "listener"); xmlListener != NULL; xmlListener = xmlListener->next) {

            m_listeners.push_back(FSListener());
            FSListener & listener = m_listeners.back();

            listener.name = switch_xml_attr_soft(xmlListener, "name");
            if (listener.name.IsEmpty())
                listener.name = "unnamed";

            PIPSocket::Address ip;
            WORD port = 1720;

            for (switch_xml_t xmlParam = switch_xml_child(xmlListener, "param"); xmlParam != NULL; xmlParam = xmlParam->next) {
                const char *var = switch_xml_attr_soft(xmlParam, "name");
                const char *val = switch_xml_attr_soft(xmlParam, "value");
                //switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Var - '%s' and Val - '%s' \n", var, val);
                if (!strcasecmp(var, "h323-ip"))
                    ip = val;
                else if (!strcasecmp(var, "h323-port"))
                    port = (WORD) atoi(val);
            }

            listener.listenAddress = OpalTransportAddress(ip, port);
            switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Created Listener '%s'\n", (const char *) listener.name);
        }
    }

    if (xml)
        switch_xml_free(xml);

    return status;
}


///////////////////////////////////////////////////////////////////////

FSEndPoint::FSEndPoint(FSManager & manager)
:   OpalLocalEndPoint(manager)
{
    PTRACE(3, "mod_opal\t FSEndPoint Created!");
}


bool FSEndPoint::OnIncomingCall(OpalLocalConnection & connection)
{
    return ((FSConnection &) connection).OnIncoming();
}


OpalLocalConnection *FSEndPoint::CreateConnection(OpalCall & call, void *userData)
{
    return new FSConnection(call, *this);
}


bool FSEndPoint::AddMediaFormat(const switch_codec_implementation_t *codec)
{
    OpalMediaType mediaType;

    switch (codec->codec_type) {
      case SWITCH_CODEC_TYPE_AUDIO:
        mediaType = OpalMediaType::Audio();
        break;

      case SWITCH_CODEC_TYPE_VIDEO:
        mediaType = OpalMediaType::Video();
        break;

      case SWITCH_CODEC_TYPE_T38:
        mediaType = OpalMediaType::Fax();
        break;

      default:
        return false;
    }

    OpalMediaFormat * newMediaFormat = new OpalMediaFormat(codec->iananame,
                                                           mediaType,
                                                           (RTP_DataFrame::PayloadTypes) codec->ianacode,
                                                           codec->iananame,
                                                           codec->codec_type == SWITCH_CODEC_TYPE_AUDIO,
                                                           codec->bits_per_second,
                                                           codec->encoded_bytes_per_packet,
                                                           codec->samples_per_packet,
                                                           codec->samples_per_second);
    if (newMediaFormat == NULL || !newMediaFormat->IsValid()) {
        return false;
    }

    // Save pointer so will auto delete allocated objects on destruction.
    m_globalMediaFormats.Append(newMediaFormat);

    PTRACE(2, "mod_opal\tNew OPAL media format created for FS codec: iananame=" << codec->iananame
           << ", ianacode=" << codec->ianacode << ", rate=" << codec->samples_per_second);
    return true;
}


///////////////////////////////////////////////////////////////////////

FSConnection::FSConnection(OpalCall & call, FSEndPoint & endpoint)
  : OpalLocalConnection(call, endpoint, NULL)
  , m_endpoint(endpoint)
{
    FSManager & mgr = (FSManager &) endpoint.GetManager();
    m_fsSession = switch_core_session_request(mgr.GetSwitchInterface(), NULL);
    m_fsChannel = switch_core_session_get_channel(m_fsSession);
    switch_core_session_set_private(m_fsSession, this);
}


bool FSConnection::OnIncoming()
{
    if (m_fsSession == NULL) {
        PTRACE(1, "mod_opal\tSession request failed.");
        return false;
    }

    switch_core_session_add_stream(m_fsSession, NULL);

    switch_channel_t *channel = switch_core_session_get_channel(m_fsSession);
    if (channel == NULL) {
        PTRACE(1, "mod_opal\tSession does not have a channel");
        return false;
    }

    PURL url = GetRemotePartyURL();
    switch_caller_profile_t *caller_profile = switch_caller_profile_new(switch_core_session_get_pool(m_fsSession),
                                                                        url.GetUserName(),
                                                                        /** username */
                                                                        mod_opal_globals.dialplan,
                                                                        /** dial plan */
                                                                        GetRemotePartyName(),
                                                                        /** caller_id_name */
                                                                        GetRemotePartyNumber(),
                                                                        /** caller_id_number */
                                                                        url.GetHostName(),
                                                                        /** network addr */
                                                                        NULL,
                                                                        /** ANI */
                                                                        NULL,
                                                                        /** ANI II */
                                                                        NULL,
                                                                        /** RDNIS */
                                                                        ModuleName,
                                                                        /** source */
                                                                        mod_opal_globals.context,
                                                                        /** set context  */
                                                                        GetCalledPartyNumber()
                                                                        /** destination_number */
                                                                        );
    if (caller_profile == NULL) {
        PTRACE(1, "mod_opal\tCould not create caller profile");
        return false;
    }

    PTRACE(4, "mod_opal\tCreated switch caller profile:\n"
           "  username       = " << caller_profile->username << "\n"
           "  dialplan       = " << caller_profile->dialplan << "\n"
           "  caller_id_name     = " << caller_profile->caller_id_name << "\n"
           "  caller_id_number   = " << caller_profile->caller_id_number << "\n"
           "  network_addr   = " << caller_profile->network_addr << "\n"
           "  source         = " << caller_profile->source << "\n"
           "  context        = " << caller_profile->context << "\n" "  destination_number= " << caller_profile->destination_number);
    switch_channel_set_caller_profile(channel, caller_profile);

    char name[256] = "opal/in:";
    switch_copy_string(name + 8, caller_profile->destination_number, sizeof(name)-8);
    switch_channel_set_name(channel, name);
    switch_channel_set_state(channel, CS_INIT);

    if (switch_core_session_thread_launch(m_fsSession) != SWITCH_STATUS_SUCCESS) {
        PTRACE(1, "mod_opal\tCould not launch session thread");
        return false;
    }

    return true;
}


void FSConnection::OnReleased()
{
    m_rxAudioOpened.Signal();   // Just in case
    m_txAudioOpened.Signal();
    H225_ReleaseCompleteReason dummy;
    switch_channel_hangup(switch_core_session_get_channel(m_fsSession),
                          (switch_call_cause_t)H323TranslateFromCallEndReason(GetCallEndReason(), dummy));
    OpalLocalConnection::OnReleased();
}


void FSConnection::OnAlerting()
{
    switch_channel_mark_ring_ready(m_fsChannel);
    return OpalLocalConnection::OnAlerting();
}

PBoolean FSConnection::SetAlerting(const PString & calleeName, PBoolean withMedia)
{
    return OpalLocalConnection::SetAlerting(calleeName, withMedia);
}


void FSConnection::OnEstablished()
{
    OpalLocalConnection::OnEstablished();
}


OpalMediaFormatList FSConnection::GetMediaFormats() const
{
    if (m_switchMediaFormats.IsEmpty()) {
        const_cast<FSConnection *>(this)->SetCodecs();
    }
    
    return m_switchMediaFormats;
}


void FSConnection::SetCodecs()
{
    int numCodecs = 0;
    const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS];    
	const char *codec_string = NULL, *abs, *ocodec;
    char *tmp_codec_string = NULL;
    char *codec_order[SWITCH_MAX_CODECS];
    int codec_order_last;


	if ((abs = switch_channel_get_variable(m_fsChannel, "absolute_codec_string"))) {
		codec_string = abs;
	} else {
		if ((abs = switch_channel_get_variable(m_fsChannel, "codec_string"))) {
            codec_string = abs;
		}

		if ((ocodec = switch_channel_get_variable(m_fsChannel, SWITCH_ORIGINATOR_CODEC_VARIABLE))) {
            codec_string = switch_core_session_sprintf(m_fsSession, "%s,%s", ocodec, codec_string);
		}
	}
    
    if (!codec_string) {
        codec_string = mod_opal_globals.codec_string;
    }

	if (codec_string) {
		if ((tmp_codec_string = strdup(codec_string))) {
			codec_order_last = switch_separate_string(tmp_codec_string, ',', codec_order, SWITCH_MAX_CODECS);
            numCodecs = switch_loadable_module_get_codecs_sorted(codecs, SWITCH_MAX_CODECS, codec_order, codec_order_last);
            
		}
	} else {
		numCodecs = switch_loadable_module_get_codecs(codecs, sizeof(codecs) / sizeof(codecs[0]));
	}
    
    for (int i = 0; i < numCodecs; i++) {
        const switch_codec_implementation_t *codec = codecs[i];

        // See if we have a match by PayloadType/rate/name
        OpalMediaFormat switchFormat((RTP_DataFrame::PayloadTypes)codec->ianacode,
                                     codec->samples_per_second,
                                     codec->iananame);
        if (!switchFormat.IsValid()) {
            // See if we have a match by name alone
            switchFormat = codec->iananame;
            if (!switchFormat.IsValid()) {
                // Add the new name to OPAL's global lists
                if (m_endpoint.AddMediaFormat(codec)) {
                    // Now we finally have it
                    switchFormat = codec->iananame;
                }
            }
        }
        

        // Did we match or create a new media format?
        if (switchFormat.IsValid() && codec->codec_type == SWITCH_CODEC_TYPE_AUDIO) {
            PTRACE(2, "mod_opal\tMatched FS codec " << codec->iananame << " to OPAL media format " << switchFormat);

            // Calculate frames per packet, do not use codec->codec_frames_per_packet as that field
            // has slightly different semantics when used in streamed codecs such as G.711
            int fpp = codec->samples_per_packet/switchFormat.GetFrameTime();

            /* Set the frames/packet to maximum of what is in the FS table. The OPAL negotiations will
               drop the value from there. This might fail if there are "holes" in the FS table, e.g.
               if for some reason G.723.1 has 30ms and 90ms but not 60ms, then the OPAL negotiations
               could end up with 60ms and the codec cannot be created. The "holes" are unlikely in
               all but streamed codecs such as G.711, where it is theoretically possible for OPAL to
               come up with 32ms and there is only 30ms and 40ms in the FS table. We deem these
               scenarios succifiently rare that we can safely ignore them ... for now. */

            if (fpp > switchFormat.GetOptionInteger(OpalAudioFormat::RxFramesPerPacketOption())) {
                switchFormat.SetOptionInteger(OpalAudioFormat::RxFramesPerPacketOption(), fpp);
            }

            if (fpp > switchFormat.GetOptionInteger(OpalAudioFormat::TxFramesPerPacketOption())) {
                switchFormat.SetOptionInteger(OpalAudioFormat::TxFramesPerPacketOption(), fpp);
            }
        }

        m_switchMediaFormats += switchFormat;
    }
    
    switch_safe_free(tmp_codec_string);
}


OpalMediaStream *FSConnection::CreateMediaStream(const OpalMediaFormat & mediaFormat, unsigned sessionID, PBoolean isSource)
{
    return new FSMediaStream(*this, mediaFormat, sessionID, isSource);
}


PBoolean FSConnection::OnOpenMediaStream(OpalMediaStream & stream)
{
    if (!OpalConnection::OnOpenMediaStream(stream)) {
        return false;
    }

    if (stream.GetMediaFormat().GetMediaType() != OpalMediaType::Audio()) {
        return true;
    }

    if (stream.IsSource()) {
        m_rxAudioOpened.Signal();
    } else {
        m_txAudioOpened.Signal();
    }

    if (GetMediaStream(stream.GetSessionID(), stream.IsSink()) != NULL) {
        // Have open media in both directions.
        if (GetPhase() == AlertingPhase) {
            switch_channel_mark_pre_answered(m_fsChannel);
        } else if (GetPhase() < ReleasingPhase) {
            switch_channel_mark_answered(m_fsChannel);
        }
    }

    return true;
}


switch_status_t FSConnection::on_init()
{
    switch_channel_t *channel = switch_core_session_get_channel(m_fsSession);
    if (channel == NULL) {
        return SWITCH_STATUS_FALSE;
    }

    PTRACE(3, "mod_opal\tStarted routing for connection " << *this);
    switch_channel_set_state(channel, CS_ROUTING);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::on_routing()
{
    PTRACE(3, "mod_opal\tRouting connection " << *this);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::on_execute()
{
    PTRACE(3, "mod_opal\tExecuting connection " << *this);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::on_hangup()
{
    switch_channel_t *channel = switch_core_session_get_channel(m_fsSession);
    if (channel == NULL) {
        return SWITCH_STATUS_FALSE;
    }

    Q931::CauseValues cause = (Q931::CauseValues)switch_channel_get_cause_q850(channel);
    SetQ931Cause(cause);
    ClearCallSynchronous(NULL, H323TranslateToCallEndReason(cause, UINT_MAX));
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::on_loopback()
{
    PTRACE(3, "mod_opal\tLoopback on connection " << *this);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::on_transmit()
{
    PTRACE(3, "mod_opal\tTransmit on connection " << *this);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::kill_channel(int sig)
{
    PTRACE(3, "mod_opal\tKill " << sig << " on connection " << *this);

    switch (sig) {
    case SWITCH_SIG_BREAK:
        break;
    case SWITCH_SIG_KILL:
        m_rxAudioOpened.Signal();
        m_txAudioOpened.Signal();
        break;
    default:
        break;
    }

    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::send_dtmf(const switch_dtmf_t *dtmf)
{
    OnUserInputTone(dtmf->digit, dtmf->duration);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::receive_message(switch_core_session_message_t *msg)
{
    switch_core_session_t *session = GetSession();
    switch_channel_t *channel = switch_core_session_get_channel(session);


    /*
      SWITCH_MESSAGE_INDICATE_PROGRESS:  establish early media now and return SWITCH_STATUS_FALSE if you can't
      SWITCH_MESSAGE_INDICATE_ANSWER:  answer and set up media now if it's not already and return SWITCH_STATUS_FALSE if you can't

      Neither message means anything on an outbound call....

      It would only happen if someone called switch_channel_answer() instead of switch_channel_mark_answered() on an outbound call.
      it should not do anything if someone does it by accident somewhere hense this in both cases:

      if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
      return SWITCH_STATUS_FALSE;
      }


      When we get these messages the core will trust that you have triggered FSMediaStream::Open and are ready for media if we do not
      have media we MUST return SWITCH_STATUS_FALSE or it will cause a CRASH.



    */
    switch (msg->message_id) {
    case SWITCH_MESSAGE_INDICATE_BRIDGE:
    case SWITCH_MESSAGE_INDICATE_UNBRIDGE:
    case SWITCH_MESSAGE_INDICATE_AUDIO_SYNC:
        switch_channel_set_private_flag(channel, CF_NEED_FLUSH);
        break;
    default:
        break;
    }

    switch (msg->message_id) {
    case SWITCH_MESSAGE_INDICATE_RINGING:
        SetPhase(OpalConnection::AlertingPhase);
        OnAlerting();
        break;

    case SWITCH_MESSAGE_INDICATE_PROGRESS:
    case SWITCH_MESSAGE_INDICATE_ANSWER:
        {
            int fixed = 0;
            
            if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
                return SWITCH_STATUS_FALSE;
            }

            if (msg->message_id == SWITCH_MESSAGE_INDICATE_PROGRESS) {
                if (fixed) {
                    /* this should send alerting + media and wait for it to be established and return SUCCESS or FAIL
                       depending on if media was able to be established.  Need code to tell the other side we want early media here.
                    */
                    GetCall().OpenSourceMediaStreams(*this, OpalMediaType::Audio());
                    SetPhase(OpalConnection::AlertingPhase);
                    /* how do i say please establish early media ? */
                    OnAlerting();
                } else {
                    /* hack to avoid getting stuck, pre_answer will imply answer */
                    OnConnectedInternal();
                }
            } else {
                OnConnectedInternal();
            }

            // Wait for media
            PTRACE(2, "mod_opal\tAwaiting media start on connection " << *this);
            m_rxAudioOpened.Wait();
            m_txAudioOpened.Wait();
            
            if (GetPhase() >= ReleasingPhase) {
                // Call got aborted
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Call abandoned!\n");
                return SWITCH_STATUS_FALSE;
            }

            PTRACE(4, "mod_opal\tMedia started on connection " << *this);

            if (msg->message_id == SWITCH_MESSAGE_INDICATE_PROGRESS) {
                if (!switch_channel_test_flag(m_fsChannel, CF_EARLY_MEDIA)) {
                    switch_channel_mark_pre_answered(m_fsChannel);
                }
            } else {
                if (!switch_channel_test_flag(m_fsChannel, CF_EARLY_MEDIA)) {
                    switch_channel_mark_answered(m_fsChannel);
                }
            }

        }
        break;

    default:
        PTRACE(3, "mod_opal\tReceived message " << msg->message_id << " on connection " << *this);
    }

    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::receive_event(switch_event_t *event)
{
    PTRACE(3, "mod_opal\tReceived event " << event->event_id << " on connection " << *this);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::state_change()
{
    PTRACE(3, "mod_opal\tState changed on connection " << *this);
    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSConnection::read_audio_frame(switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
{
    return read_frame(OpalMediaType::Audio(), frame, flags);
}


switch_status_t FSConnection::write_audio_frame(switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
    return write_frame(OpalMediaType::Audio(), frame, flags);
}


switch_status_t FSConnection::read_video_frame(switch_frame_t **frame, switch_io_flag_t flag, int stream_id)
{
    return read_frame(OpalMediaType::Video(), frame, flag);
}


switch_status_t FSConnection::write_video_frame(switch_frame_t *frame, switch_io_flag_t flag, int stream_id)
{
    return write_frame(OpalMediaType::Video(), frame, flag);
}


switch_status_t FSConnection::read_frame(const OpalMediaType & mediaType, switch_frame_t **frame, switch_io_flag_t flags)
{
    PSafePtr < FSMediaStream > stream = PSafePtrCast < OpalMediaStream, FSMediaStream > (GetMediaStream(mediaType, false));
    return stream != NULL ? stream->read_frame(frame, flags) : SWITCH_STATUS_FALSE;
}


switch_status_t FSConnection::write_frame(const OpalMediaType & mediaType, const switch_frame_t *frame, switch_io_flag_t flags)
{
    PSafePtr < FSMediaStream > stream = PSafePtrCast < OpalMediaStream, FSMediaStream > (GetMediaStream(mediaType, true));
    return stream != NULL ? stream->write_frame(frame, flags) : SWITCH_STATUS_FALSE;
}


///////////////////////////////////////////////////////////////////////

FSMediaStream::FSMediaStream(FSConnection & conn, const OpalMediaFormat & mediaFormat, unsigned sessionID, bool isSource)
    : OpalMediaStream(conn, mediaFormat, sessionID, isSource)
    , m_fsSession(conn.GetSession())
    , m_callOnStart(true)
{
    memset(&m_readFrame, 0, sizeof(m_readFrame));
    m_readFrame.codec = &m_switchCodec;
    m_readFrame.flags = SFF_RAW_RTP;
}


PBoolean FSMediaStream::Open()
{
    if (IsOpen()) {
        return true;
    }

    bool isAudio;
    if (mediaFormat.GetMediaType() == OpalMediaType::Audio()) {
        isAudio = true;
    } else if (mediaFormat.GetMediaType() == OpalMediaType::Video()) {
        isAudio = false;
    } else {
        return OpalMediaStream::Open();
    }

    m_fsChannel = switch_core_session_get_channel(m_fsSession);
    
    int ptime = mediaFormat.GetOptionInteger(OpalAudioFormat::TxFramesPerPacketOption()) * mediaFormat.GetFrameTime() / mediaFormat.GetTimeUnits();

    // The following is performed on two different instances of this object.
    if (switch_core_codec_init(&m_switchCodec, mediaFormat.GetEncodingName(), NULL, // FMTP
                               mediaFormat.GetClockRate(), ptime, 1,  // Channels
                               SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,   // Settings
                               switch_core_session_get_pool(m_fsSession)) != SWITCH_STATUS_SUCCESS) {
        // Could not select a codecs using negotiated frames/packet, so try using default.
        if (switch_core_codec_init(&m_switchCodec, mediaFormat.GetEncodingName(), NULL, // FMTP
                                   mediaFormat.GetClockRate(), 0, 1,  // Channels
                                   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,   // Settings
                                   switch_core_session_get_pool(m_fsSession)) != SWITCH_STATUS_SUCCESS) {
            PTRACE(1, "mod_opal  " << switch_channel_get_name(m_fsChannel)<< " Cannot initialise " << (IsSink()? "read" : "write") << ' '
                   << mediaFormat.GetMediaType() << " codec " << mediaFormat << " for connection " << *this);
            switch_channel_hangup(m_fsChannel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
            return false;
        }
        PTRACE(2, "mod_opal " << switch_channel_get_name(m_fsChannel)<< " Unsupported ptime of " << ptime << " on " << (IsSink()? "read" : "write") << ' '
               << mediaFormat.GetMediaType() << " codec " << mediaFormat << " for connection " << *this);
    }

    PTRACE(1, "mod_opal " << switch_channel_get_name(m_fsChannel)<< " initialise " << 
           switch_channel_get_name(m_fsChannel) << (IsSink()? "read" : "write") << ' '
           << mediaFormat.GetMediaType() << " codec " << mediaFormat << " for connection " << *this);

    if (IsSink()) {
        m_readFrame.rate = mediaFormat.GetClockRate();

        if (isAudio) {
            switch_core_session_set_read_codec(m_fsSession, &m_switchCodec);
            if (switch_core_timer_init(&m_switchTimer,
                                       "soft",
                                       m_switchCodec.implementation->microseconds_per_packet / 1000,
                                       m_switchCodec.implementation->samples_per_packet,
                                       switch_core_session_get_pool(m_fsSession)) != SWITCH_STATUS_SUCCESS) {
                switch_core_codec_destroy(&m_switchCodec);
                return false;
            }
        } else {
            switch_core_session_set_video_read_codec(m_fsSession, &m_switchCodec);
            switch_channel_set_flag(m_fsChannel, CF_VIDEO);
        }
    } else {
        if (isAudio) {
            switch_core_session_set_write_codec(m_fsSession, &m_switchCodec);
        } else {
            switch_core_session_set_video_write_codec(m_fsSession, &m_switchCodec);
            switch_channel_set_flag(m_fsChannel, CF_VIDEO);
        }
    }

    PTRACE(3, "mod_opal\tSet " << (IsSink()? "read" : "write") << ' '
           << mediaFormat.GetMediaType() << " codec to << " << mediaFormat << " for connection " << *this);

    return OpalMediaStream::Open();
}


PBoolean FSMediaStream::Close()
{
    if (!IsOpen())
        return false;

    bool isAudio;

    if (mediaFormat.GetMediaType() == OpalMediaType::Audio()) {
        isAudio = true;
    } else if (mediaFormat.GetMediaType() == OpalMediaType::Video()) {
        isAudio = false;
    } else {
        return OpalMediaStream::Close();
    }

    if (IsSink()) {
        if (isAudio) {
            switch_core_session_unset_read_codec(m_fsSession);
            switch_core_timer_destroy(&m_switchTimer);
        } else {
            switch_core_session_set_video_read_codec(m_fsSession, NULL);
        }

        switch_core_codec_destroy(&m_switchCodec);
    } else {
        if (isAudio)
            switch_core_session_unset_write_codec(m_fsSession);
        else
            switch_core_session_set_video_write_codec(m_fsSession, NULL);
        switch_core_codec_destroy(&m_switchCodec);
    }

    PTRACE(3, "mod_opal\tReset & destroyed " << (IsSink()? "read" : "write")
           << ' ' << mediaFormat.GetMediaType() << " codec for connection " << *this);

    return OpalMediaStream::Close();
}


PBoolean FSMediaStream::IsSynchronous() const
{
    return true;
}


PBoolean FSMediaStream::RequiresPatchThread(OpalMediaStream *) const
{
    return false;
}


switch_status_t FSMediaStream::read_frame(switch_frame_t **frame, switch_io_flag_t flags)
{
    if (m_callOnStart) {
        /*
          There is a race here... sometimes we make it here and GetPatch() is NULL
          if we wait it shows up in 1ms, maybe there is a better way to wait.
          
        */
        while(!GetPatch()) {
            switch_cond_next();
        }
        GetPatch()->OnPatchStart();
        m_callOnStart = false;
    }

    m_readFrame.flags = 0;

    /*
    while (switch_channel_ready(m_fsChannel)) {
        if (!GetPatch()->GetSource().ReadPacket(m_readRTP)) {
            return SWITCH_STATUS_FALSE;
        }
        
        if ((m_readFrame.datalen = m_readRTP.GetPayloadSize()) || switch_core_timer_check(&m_switchTimer, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
            if (m_readFrame.datalen) {
            } else {
                m_readFrame.flags = SFF_CNG;
            }
            break;
        }

        switch_yield(1000);
    }
    */

    if (switch_channel_test_private_flag(m_fsChannel, CF_NEED_FLUSH)) {
        switch_channel_clear_private_flag(m_fsChannel, CF_NEED_FLUSH);
        for(;;) {
            if (!GetPatch()->GetSource().ReadPacket(m_readRTP)) {
                return SWITCH_STATUS_FALSE;
            }
            if (!m_readRTP.GetPayloadSize()) {
                m_readFrame.flags = SFF_CNG;
                break;
            }
        }
    } else {

        if (!GetPatch()->GetSource().ReadPacket(m_readRTP)) {
            return SWITCH_STATUS_FALSE;
        }
    
        switch_core_timer_next(&m_switchTimer);
    
        if (!(m_readFrame.datalen = m_readRTP.GetPayloadSize())) {
            m_readFrame.flags = SFF_CNG;
        }
    }

    if (!switch_channel_ready(m_fsChannel)) {
        return SWITCH_STATUS_FALSE;
    }

    //switch_core_timer_step(&m_switchTimer);

    m_readFrame.buflen = m_readRTP.GetSize();
    m_readFrame.data = m_readRTP.GetPayloadPtr();
    m_readFrame.packet = m_readRTP.GetPointer();
    m_readFrame.packetlen = m_readRTP.GetHeaderSize() + m_readFrame.datalen;
    m_readFrame.payload = (switch_payload_t) m_readRTP.GetPayloadType();
    m_readFrame.timestamp = m_readRTP.GetTimestamp();
    m_readFrame.m = (switch_bool_t) m_readRTP.GetMarker();
    m_readFrame.seq = m_readRTP.GetSequenceNumber();
    m_readFrame.ssrc = m_readRTP.GetSyncSource();
    *frame = &m_readFrame;

    return SWITCH_STATUS_SUCCESS;
}


switch_status_t FSMediaStream::write_frame(const switch_frame_t *frame, switch_io_flag_t flags)
{
    if (!switch_channel_ready(m_fsChannel)) {
        return SWITCH_STATUS_FALSE;
    }

    if (m_callOnStart) {
        GetPatch()->OnPatchStart();
        m_callOnStart = false;
    }

    if ((frame->flags & SFF_RAW_RTP) != 0) {
        RTP_DataFrame rtp((const BYTE *) frame->packet, frame->packetlen, false);
        if (GetPatch()->PushFrame(rtp))
            return SWITCH_STATUS_SUCCESS;
    } else if (frame->flags == 0) {
        RTP_DataFrame rtp;
        rtp.SetPayloadType(mediaFormat.GetPayloadType());
        rtp.SetPayloadSize(frame->datalen);
        memcpy(rtp.GetPayloadPtr(), frame->data, frame->datalen);
        if (GetPatch()->PushFrame(rtp))
            return SWITCH_STATUS_SUCCESS;
    }

    return SWITCH_STATUS_FALSE;
}


/* For Emacs:
 * Local Variables:
 * mode:c
 * indent-tabs-mode:nil
 * tab-width:4
 * c-basic-offset:4
 * End:
 * For VIM:
 * vim:set softtabstop=4 shiftwidth=4 tabstop=4: expandtabs:
 */
