HostServerPushMulti.cpp

#include "Headers.h"
#include "HostServerPushMulti.h"

CHostServerPushMulti::CHostServerPushMulti(
    __uint32        id,
    CSimHandler*    sim,
    CAddress        address,
    CInfoPushMulti* info,
    CData*          data
    ) : CHostServer(id, sim, address, info, data)
{
    // Global
    this->info = info;

    // Delegates
    this->delegateRecv = new Delegate4<CHostServerPushMulti, void, __uint32, CPacketIp*, CPacketUdp*, CPacket*>(this, &CHostServerPushMulti::Recv);
    this->delegateSendStream = new Delegate2<CHostServerPushMulti, void, CAddress, CPacketStream*>(this, &CHostServerPushMulti::SendStream);
    this->delegateSendMessage = new Delegate2<CHostServerPushMulti, void, CAddress, CStreamMessage*>(this, &CHostServerPushMulti::SendMessage);

    // Create stream servers for multicast channels
    this->streamServersMcast = new CStreamServerPushMcast*[this->info->NumChannelsMulticast()];

    for(__uint32 index = 0; index < this->info->NumChannelsMulticast(); index++)
    {
        this->streamServersMcast[index] = new CStreamServerPushMcast(
            this->sim,
            this->info->StreamSource(this->info->IndexMulticastToGlobal(index)),
            this->delegateSendStream,
            this->layerIgmp->DelegateJoin(),
            this->layerIgmp->DelegateLeave(),
            0
            );
    }

    // Create stream servers for unicast channels
    this->streamServersUcast = new CStreamServerPushUcastMulti*[this->info->NumChannelsUnicast()];

    for(__uint32 index = 0; index < this->info->NumChannelsUnicast(); index++)
    {
        this->streamServersUcast[index] = new CStreamServerPushUcastMulti(
            this->sim,
            this->info->StreamSource(this->info->IndexUnicastToGlobal(index)),
            this->delegateSendStream,
            this->delegateSendMessage,
            this->info->NumLayers(),
            this->info->MpegGopSize()
            );
    }

    // Create layer connections
        // Layer UDP -> this
    (*this->layerUdp->EventRecv()) += this->delegateRecv;
}

CHostServerPushMulti::~CHostServerPushMulti()
{
    // Delete stream servers
    for(__uint32 index = 0; index < this->info->NumChannelsMulticast(); index++)
        delete this->streamServersMcast[index];
    delete[] this->streamServersMcast;

    for(__uint32 index = 0; index < this->info->NumChannelsUnicast(); index++)
        delete this->streamServersUcast[index];
    delete[] this->streamServersUcast;

    // Delegates
    delete this->delegateRecv;
    delete this->delegateSendStream;
    delete this->delegateSendMessage;
}

void CHostServerPushMulti::Start()
{
    // Start the multicast channel servers
    for(__uint32 index = 0; index < this->info->NumChannelsMulticast(); index++)
        this->streamServersMcast[index]->Start();

    // Start the unicast channel servers
    for(__uint32 index = 0; index < this->info->NumChannelsUnicast(); index++)
        this->streamServersUcast[index]->Start();
}

void CHostServerPushMulti::Stop()
{
    // Start the multicast channel servers
    for(__uint32 index = 0; index < this->info->NumChannelsMulticast(); index++)
        this->streamServersMcast[index]->Stop();

    // Start the unicast channel servers
    for(__uint32 index = 0; index < this->info->NumChannelsUnicast(); index++)
        this->streamServersUcast[index]->Stop();
}

void CHostServerPushMulti::Finalize()
{
    // Call base class finalizer
    CHostServer::Finalize();

    // Call stream servers finalizer
    for(__uint32 index = 0; index < this->info->NumChannelsMulticast(); index++)
        this->streamServersMcast[index]->Finalize();
    for(__uint32 index = 0; index < this->info->NumChannelsUnicast(); index++)
        this->streamServersUcast[index]->Finalize();
}

void CHostServerPushMulti::Recv(__uint32 entry, CPacketIp* ip, CPacketUdp* udp, CPacket* packet)
{
    // Receive UDP packets : process only control messages for unicast servers

    if(NULL == packet) return;
    if(udp->Dst() != this->info->PortControl()) return;
    if(packet->Type() != PACKET_TYPE_MESSAGE) return;

    // Convert the packet to a message
    CStreamMessage* message = type_cast<CStreamMessage*>(packet);

    // Send the message to the upper layer : the server for the specified stream
    this->streamServersUcast[this->info->IndexGlobalToUnicast(message->Stream())]->Recv(ip->Src(), message);
}

void CHostServerPushMulti::SendStream(CAddress dst, CPacketStream* packet)
{
    // Send stream packet to the lower layer (TTL = 128)
    (*this->layerUdp->DelegateSend())(this->info->PortStream(), this->info->PortStream(), dst, 128, packet);
}

void CHostServerPushMulti::SendMessage(CAddress dst, CStreamMessage* message)
{
    // Send message packet to the lower layer (TTL = 128)
    (*this->layerUdp->DelegateSend())(this->info->PortControl(), this->info->PortControl(), dst, 128, message);
}