jamulus/src/server.cpp

242 lines
7.9 KiB
C++
Executable file

/******************************************************************************\
* Copyright (c) 2004-2009
*
* Author(s):
* Volker Fischer
*
******************************************************************************
*
* 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 2 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, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
\******************************************************************************/
#include "server.h"
/* Implementation *************************************************************/
CServer::CServer ( const QString& strLoggingFileName,
const quint16 iPortNumber,
const QString& strHTMLStatusFileName,
const QString& strServerNameForHTMLStatusFile,
const int iNewUploadRateLimitKbps ) :
Socket ( &ChannelSet, this, iPortNumber ),
ChannelSet ( iNewUploadRateLimitKbps )
{
vecsSendData.Init ( MIN_SERVER_BLOCK_SIZE_SAMPLES );
// init moving average buffer for response time evaluation
CycleTimeVariance.Init (
MIN_SERVER_BLOCK_SIZE_SAMPLES, TIME_MOV_AV_RESPONSE );
// connect timer timeout signal
QObject::connect ( &Timer, SIGNAL ( timeout() ),
this, SLOT ( OnTimer() ) );
// connection for protocol
QObject::connect ( &ChannelSet,
SIGNAL ( MessReadyForSending ( int, CVector<uint8_t> ) ),
this, SLOT ( OnSendProtMessage ( int, CVector<uint8_t> ) ) );
// connection for logging
QObject::connect ( &ChannelSet,
SIGNAL ( ChannelConnected ( CHostAddress ) ),
this, SLOT ( OnNewChannel ( CHostAddress ) ) );
#ifdef _WIN32
// event handling of custom events seems not to work under Windows in this
// class, do not use automatic start/stop of server in Windows version
Start();
#endif
// enable logging (if requested)
if ( !strLoggingFileName.isEmpty() )
{
Logging.Start ( strLoggingFileName );
}
// HTML status file writing
if ( !strHTMLStatusFileName.isEmpty() )
{
QString strCurServerNameForHTMLStatusFile = strServerNameForHTMLStatusFile;
// if server name is empty, substitude a default name
if ( strCurServerNameForHTMLStatusFile.isEmpty() )
{
strCurServerNameForHTMLStatusFile = "[server address]";
}
// (the static cast to integer of the port number is required so that it
// works correctly under Linux)
ChannelSet.StartStatusHTMLFileWriting ( strHTMLStatusFileName,
strCurServerNameForHTMLStatusFile + ":" +
QString().number( static_cast<int> ( iPortNumber ) ) );
}
}
void CServer::OnSendProtMessage ( int iChID, CVector<uint8_t> vecMessage )
{
// convert unsigned uint8_t in char, TODO convert all buffers in uint8_t
CVector<unsigned char> vecbyDataConv ( vecMessage.Size() );
for ( int i = 0; i < vecMessage.Size (); i++ ) {
vecbyDataConv[i] = static_cast<unsigned char> ( vecMessage[i] );
}
// the protocol queries me to call the function to send the message
// send it through the network
Socket.SendPacket ( vecbyDataConv, ChannelSet.GetAddress ( iChID ) );
}
void CServer::Start()
{
if ( !IsRunning() )
{
// start main timer
Timer.start ( MIN_SERVER_BLOCK_DURATION_MS );
// init time for response time evaluation
CycleTimeVariance.Reset();
}
}
void CServer::Stop()
{
// stop main timer
Timer.stop();
// logging
const QString strLogStr = CLogTimeDate::toString() + ",, server stopped "
"-------------------------------------";
QTextStream tsConsoloeStream ( stdout );
tsConsoloeStream << strLogStr << endl; // on console
Logging << strLogStr; // in log file
}
void CServer::OnNewChannel ( CHostAddress ChanAddr )
{
// logging of new connected channel
const QString strLogStr = CLogTimeDate::toString() + ", " +
ChanAddr.InetAddr.toString() + ", connected";
QTextStream tsConsoloeStream ( stdout );
tsConsoloeStream << strLogStr << endl; // on console
Logging << strLogStr; // in log file
}
void CServer::OnTimer()
{
CVector<int> vecChanID;
CVector<CVector<double> > vecvecdData ( MIN_SERVER_BLOCK_SIZE_SAMPLES );
CVector<CVector<double> > vecvecdGains;
// get data from all connected clients
ChannelSet.GetBlockAllConC ( vecChanID, vecvecdData, vecvecdGains );
const int iNumClients = vecChanID.Size();
// Check if at least one client is connected. If not, stop server until
// one client is connected
if ( iNumClients != 0 )
{
for ( int i = 0; i < iNumClients; i++ )
{
// generate a sparate mix for each channel
// actual processing of audio data -> mix
vecsSendData = ProcessData ( vecvecdData, vecvecdGains[i] );
// send separate mix to current clients
Socket.SendPacket (
ChannelSet.PrepSendPacket ( vecChanID[i], vecsSendData ),
ChannelSet.GetAddress ( vecChanID[i] ) );
}
}
else
{
// Disable server if no clients are connected. In this case the server
// does not consume any significant CPU when no client is connected.
#ifndef _WIN32
// event handling of custom events seems not to work under Windows in this
// class, do not use automatic start/stop of server in Windows version
Stop();
#endif
}
// update response time measurement
CycleTimeVariance.Update();
}
CVector<short> CServer::ProcessData ( CVector<CVector<double> >& vecvecdData,
CVector<double>& vecdGains )
{
CVector<short> vecsOutData ( MIN_SERVER_BLOCK_SIZE_SAMPLES );
const int iNumClients = vecvecdData.Size();
// some offset to avoid overload when mixing clients together
const double dNorm = (double) 1.25;
// mix all audio data from all clients together
for ( int i = 0; i < MIN_SERVER_BLOCK_SIZE_SAMPLES; i++ )
{
double dMixedData = 0.0;
for ( int j = 0; j < iNumClients; j++ )
{
dMixedData += vecvecdData[j][i] * vecdGains[j];
}
// normalization and truncating to short
vecsOutData[i] = Double2Short ( dMixedData / dNorm );
}
return vecsOutData;
}
bool CServer::GetTimingStdDev ( double& dCurTiStdDev )
{
dCurTiStdDev = 0.0; // init return value
// only return value if server is active and the actual measurement is
// updated
if ( IsRunning() )
{
// return the standard deviation
dCurTiStdDev = CycleTimeVariance.GetStdDev();
return true;
}
else
{
return false;
}
}
void CServer::customEvent ( QEvent* Event )
{
if ( Event->type() == QEvent::User + 11 )
{
const int iMessType = ( ( CLlconEvent* ) Event )->iMessType;
switch ( iMessType )
{
case MS_PACKET_RECEIVED:
// wake up the server if a packet was received
// if the server is still running, the call to Start() will have
// no effect
Start();
break;
}
}
}