HostClient.cpp

#include "Headers.h"
#include "HostClient.h"
#include "EventClientWatch.h"
#include "Console.h"
#include "Debug.h"

CHostClient::CHostClient(
    __uint32        id,
    CSimHandler*    sim,
    CAddress        address,
    CInfo*          info,
    CData*          data,
    __bitrate       bw
    ) : CHost(id, sim, address, info, data)
{
    // Initial host state is off
    this->state = CHostClient::STATE_OFF;
    this->channel = NULL;

    // Stat
    this->statFramesRecv = 0;
    this->statFramesDiscarded = 0;
    this->statFramesExpected = 0;
}

CHostClient::~CHostClient()
{
}

void CHostClient::EventArrive()
{
    assert(CHostClient::STATE_OFF == this->state);

    // Change state to on-idle
    this->state = CHostClient::STATE_ON_IDLE;

    // Start watching first channel
        // Generate next channel to watch
    __uint32 channel;
    __time duration;

    this->info->ModelChannel()->GenerateUptime(channel, duration);
    
        // Call the watch event
    this->EventWatch(this->info->Channel(channel), duration);
}

void CHostClient::EventLeave()
{
    assert(CHostClient::STATE_OFF != this->state);

    if(CHostClient::STATE_ON_IDLE == this->state)
        // If host state is on-idle, change state to off
        this->state = CHostClient::STATE_OFF;
    else
        // If host state is on-watching, call disconnect method to terminate gracefully
        this->ChannelDisconnect();
}

void CHostClient::EventWatch(CChannel* channel, __time duration)
{
    assert(STATE_OFF != this->state);

    if(STATE_ON_IDLE == this->state)
        // If host state is on-idle, call connect method
        this->ChannelConnect(channel);
    else
        // If host state is on-watching, call switch method
        this->ChannelSwitch(channel);

    // Schedule watching the next channel
        // Generate next channel to watch
    __uint32 newChannel;
    __time newDuration;

    this->info->ModelChannel()->GenerateUptime(channel->Id(), duration, newChannel, newDuration);
    
        // Schedule the watch event
    CEventClientWatch* evt = new CEventClientWatch(
        this,
        this->info->Channel(newChannel),
        newDuration);

    this->sim->ScheduleEventAfter(duration, evt);
}

void CHostClient::ChannelConnect(CChannel* channel)
{
    assert(channel);
    assert(NULL == this->channel);

    switch(channel->Type())
    {
    case CChannel::CHANNEL_MULTICAST: this->ChannelConnectMcast(channel); break;
    case CChannel::CHANNEL_UNICAST: this->ChannelConnectUcast(channel); break;
    }

    // Set session stat
    this->sessionTimeStart = this->sim->Time();

    // Save the channel
    this->channel = channel;

    // Change the state
    this->state = CHostClient::STATE_ON_WATCHING;
}

void CHostClient::ChannelDisconnect()
{
    assert(this->channel);

    switch(channel->Type())
    {
    case CChannel::CHANNEL_MULTICAST: this->ChannelDisconnectMcast(); break;
    case CChannel::CHANNEL_UNICAST: this->ChannelDisconnectUcast(); break;
    }

    // Set session stat
    this->sessionTimeFinish = this->sim->Time();

    // Set the channel
    this->channel = NULL;

    // Change the state
    this->state = STATE_ON_IDLE;
}

void CHostClient::ChannelSwitch(CChannel* channel)
{
    CChannel* oldChannel = this->channel;

    // Disconnect from old channels
    this->ChannelDisconnect();

    __uint32 statFramesExpected = (__uint32)(oldChannel->Fps() * (this->sessionTimeFinish - this->sessionTimeStart));

    this->data->Session(
        this->id,
        oldChannel->Id(),
        this->sessionTimeFinish - this->sessionTimeStart,
        this->streamClient->StatTimeClientStart(),
        this->streamClient->StatTimeRecvStart(),
        this->streamClient->StatTimePlayStart(),
        this->streamClient->StatTimeFinish(),
        this->streamClient->StatTimeWait(),
        this->streamClient->StatSyncDelay(),
        this->streamClient->StatRecvFrames(),
        this->streamClient->StatPlayFrames(),
        this->streamClient->StatSuccessFrames(),
        this->streamClient->StatFailFrames()
        );

    // Statistics
    this->statFramesRecv += this->streamClient->StatRecvFrames();
    this->statFramesDiscarded += this->streamClient->StatDiscardedFrames();
    this->statFramesExpected += statFramesExpected;

#if (defined(_RELEASEASSERT) || defined(_RELEASELOG) || defined(_DEBUG)) && (!defined(LOG))

    // Move before ChannelConnect() to display correct information
    double quality = ((this->streamClient->StatPlayFrames() != 0) ? ((double)(
        this->streamClient->StatSuccessFrames()[0] +
        this->streamClient->StatSuccessFrames()[1] +
        this->streamClient->StatSuccessFrames()[2] ) /
        (double)this->streamClient->StatPlayFrames()) : 0);

    __time interrupt = (1 - quality) * (this->sessionTimeFinish - this->sessionTimeStart);
    bool play = this->streamClient->StatTimePlayStart() >= this->streamClient->StatTimeClientStart();

    //if(quality == 0)
    //{
    //  if(this->sessionTimeFinish - this->sessionTimeStart < 2.0)
    //      CConsole::SetColor(CConsole::LIGHT_GREEN);
    //  else
    //      CConsole::SetColor(CConsole::LIGHT_RED);
    //}
    //else if(quality == 1)
    //  CConsole::SetColor(CConsole::LIGHT_GRAY);
    //else if(quality < 0.9)
    //  CConsole::SetColor(CConsole::LIGHT_MAGENTA);
    //else
    //  CConsole::SetColor(CConsole::LIGHT_CYAN);

#ifndef LOG_VERBOSE
    switch(channel->Type())
    {
    case CChannel::CHANNEL_MULTICAST: CConsole::SetColor(CConsole::LIGHT_CYAN); printf("\n[M]  "); break;
    case CChannel::CHANNEL_UNICAST: CConsole::SetColor(CConsole::LIGHT_YELLOW); printf("\n[U]  "); break;
    }

#endif

    if(play)
    {
        if(interrupt == 0) CConsole::SetColor(CConsole::WHITE);
        else if(interrupt < 2) CConsole::SetColor(CConsole::LIGHT_GREEN);
        else if(interrupt < 4) CConsole::SetColor(CConsole::LIGHT_CYAN);
        else if(interrupt < 8) CConsole::SetColor(CConsole::LIGHT_YELLOW);
        else if(interrupt < 16) CConsole::SetColor(CConsole::LIGHT_MAGENTA);
        else CConsole::SetColor(CConsole::LIGHT_RED);
    }
    else
    {
        CConsole::SetColor(CConsole::LIGHT_BLUE);
    }

#ifdef LOG_VERBOSE
#ifdef LOG
    if((this->address.Address() == LOG_ADDRESS) && (oldChannel->Id() == LOG_CHANNEL))
//#else
//  if(quality < 1)
#endif
        printf("\nT = %8.3lf P = %4u C = %3u D = %5.0lf S = %u | %4u %4u %4d | %4u %4u %4u | %4u %4u %4u | %7.3lf %7.3lf %7.3lf %7.3lf %7.3lf %7.3lf | %.3lf %7.1lf",
            this->sim->Time(),
            this->address.Address(),
            oldChannel->Id(),
            this->sessionTimeFinish - this->sessionTimeStart,
            // Session time
            play,
            // Frames
            this->streamClient->StatRecvFrames(),
            this->streamClient->StatPlayFrames(),
            this->streamClient->StatRecvFrames() - this->streamClient->StatPlayFrames(),
            // Success frames
            this->streamClient->StatSuccessFrames()[0],
            this->streamClient->StatSuccessFrames()[1],
            this->streamClient->StatSuccessFrames()[2],
            // Failed frames
            this->streamClient->StatFailFrames()[0],
            this->streamClient->StatFailFrames()[1],
            this->streamClient->StatFailFrames()[2],
            // Session times (verbose)
            this->streamClient->StatTimeClientStart(),
            this->streamClient->StatTimeRecvStart(),
            this->streamClient->StatTimePlayStart(),
            this->streamClient->StatTimeFinish(),
            this->streamClient->StatTimeWait(),
            this->streamClient->StatSyncDelay(),
            // Quality
            quality,
            interrupt
            );
#else
        printf("T = %8.3lf PEER %4u WATCHED %3u for %5.0lf (%5.0lf - %5.0lf) | %7.3lf %7.3lf %7.3lf %7.3lf %7.3lf | %.3lf %7.1lf | %6.3lf",
            this->sim->Time(),
            this->address.Address(),
            oldChannel->Id(),
            this->sessionTimeFinish - this->sessionTimeStart,
            // Session time
            this->sessionTimeStart,
            this->sessionTimeFinish,
            // Session times (verbose)
            this->streamClient->StatTimeClientStart(),
            this->streamClient->StatTimeRecvStart(),
            this->streamClient->StatTimePlayStart(),
            this->streamClient->StatTimeFinish(),
            this->streamClient->StatTimeWait(),
            // Quality
            quality,
            interrupt,
            // Delay
            this->streamClient->StatSyncDelay()
            );
#endif

    CConsole::SetColor(CConsole::LIGHT_GRAY);
#endif

    // Connect to new channel
    this->ChannelConnect(channel);
}

void CHostClient::Finalize()
{
    // Call the base class finalizer
    CHost::Finalize();
}