3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-07-20 18:07:34 +02:00
Code Issues Projects Releases Packages Wiki Activity

refactoring

Browse source 
git-svn-id: svn://elaine/murooma/trunk@328 d8a302eb-03bc-478d-80e4-98257eca68ef
This commit is contained in:
(no author) 2014-12-29 12:34:33 +00:00
parent 611b2a6c9f
commit c40bfda64c
35 changed files with 192 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

38
server/controlServer.cpp
View file

@ -1,8 +1,8 @@
#include "controlServer.h"
#include "message/timeMsg.h"
#include "message/ackMsg.h"
#include "message/requestMsg.h"
#include "message/commandMsg.h"
#include "message/time.h"
#include "message/ack.h"
#include "message/request.h"
#include "message/command.h"
#include <iostream>
@ -13,7 +13,7 @@ ControlServer::ControlServer(unsigned short port) : port_(port), headerChunk(NUL
void ControlServer::send(shared_ptr<BaseMessage> message)
void ControlServer::send(shared_ptr<msg::BaseMessage> message)
{
std::unique_lock<std::mutex> mlock(mutex);
for (std::set<shared_ptr<ServerSession>>::iterator it = sessions.begin(); it != sessions.end(); )
@ -33,47 +33,47 @@ void ControlServer::send(shared_ptr<BaseMessage> message)
}
void ControlServer::onMessageReceived(ServerSession* connection, const BaseMessage& baseMessage, char* buffer)
void ControlServer::onMessageReceived(ServerSession* connection, const msg::BaseMessage& baseMessage, char* buffer)
{
// cout << "onMessageReceived: " << baseMessage.type << ", size: " << baseMessage.size << ", sent: " << baseMessage.sent.sec << "," << baseMessage.sent.usec << ", recv: " << baseMessage.received.sec << "," << baseMessage.received.usec << "\n";
if (baseMessage.type == message_type::requestmsg)
if (baseMessage.type == message_type::kRequest)
{
RequestMsg requestMsg;
msg::Request requestMsg;
requestMsg.deserialize(baseMessage, buffer);
// cout << "request: " << requestMsg.request << "\n";
if (requestMsg.request == timemsg)
if (requestMsg.request == kTime)
{
// timeMsg.latency = (timeMsg.received.sec - timeMsg.sent.sec) * 1000000 + (timeMsg.received.usec - timeMsg.sent.usec);
TimeMsg timeMsg;
msg::Time timeMsg;
timeMsg.refersTo = requestMsg.id;
timeMsg.latency = (requestMsg.received.sec - requestMsg.sent.sec) + (requestMsg.received.usec - requestMsg.sent.usec) / 1000000.;
// tv diff = timeMsg.received - timeMsg.sent;
// cout << "Latency: " << diff.sec << "." << diff.usec << "\n";
connection->send(&timeMsg);
}
else if (requestMsg.request == serversettings)
else if (requestMsg.request == kServerSettings)
{
serverSettings->refersTo = requestMsg.id;
connection->send(serverSettings);
}
else if (requestMsg.request == sampleformat)
else if (requestMsg.request == kSampleFormat)
{
sampleFormat->refersTo = requestMsg.id;
connection->send(sampleFormat);
}
else if (requestMsg.request == header)
else if (requestMsg.request == kHeader)
{
headerChunk->refersTo = requestMsg.id;
connection->send(headerChunk);
}
}
else if (baseMessage.type == message_type::commandmsg)
else if (baseMessage.type == message_type::kCommand)
{
CommandMsg commandMsg;
msg::Command commandMsg;
commandMsg.deserialize(baseMessage, buffer);
if (commandMsg.command == "startStream")
{
AckMsg ackMsg;
msg::Ack ackMsg;
ackMsg.refersTo = commandMsg.id;
connection->send(&ackMsg);
connection->setStreamActive(true);
@ -117,14 +117,14 @@ void ControlServer::stop()
}
void ControlServer::setHeader(HeaderMessage* header)
void ControlServer::setHeader(msg::Header* header)
{
if (header)
headerChunk = header;
}
void ControlServer::setFormat(SampleFormat* format)
void ControlServer::setFormat(msg::SampleFormat* format)
{
if (format)
sampleFormat = format;
@ -132,7 +132,7 @@ void ControlServer::setFormat(SampleFormat* format)
void ControlServer::setServerSettings(ServerSettings* settings)
void ControlServer::setServerSettings(msg::ServerSettings* settings)
{
if (settings)
serverSettings = settings;

20
server/controlServer.h
View file

@ -12,7 +12,7 @@
#include "serverSession.h"
#include "common/queue.h"
#include "message/message.h"
#include "message/headerMessage.h"
#include "message/header.h"
#include "message/sampleFormat.h"
#include "message/serverSettings.h"
@ -29,11 +29,11 @@ public:
void start();
void stop();
void send(shared_ptr<BaseMessage> message);
virtual void onMessageReceived(ServerSession* connection, const BaseMessage& baseMessage, char* buffer);
void setHeader(HeaderMessage* header);
void setFormat(SampleFormat* format);
void setServerSettings(ServerSettings* settings);
void send(shared_ptr<msg::BaseMessage> message);
virtual void onMessageReceived(ServerSession* connection, const msg::BaseMessage& baseMessage, char* buffer);
void setHeader(msg::Header* header);
void setFormat(msg::SampleFormat* format);
void setServerSettings(msg::ServerSettings* settings);
private:
void acceptor();
@ -41,11 +41,11 @@ private:
set<shared_ptr<ServerSession>> sessions;
boost::asio::io_service io_service_;
unsigned short port_;
HeaderMessage* headerChunk;
SampleFormat* sampleFormat;
ServerSettings* serverSettings;
msg::Header* headerChunk;
msg::SampleFormat* sampleFormat;
msg::ServerSettings* serverSettings;
thread* acceptThread;
Queue<shared_ptr<BaseMessage>> messages;
Queue<shared_ptr<msg::BaseMessage>> messages;
};

12
server/encoder.h
View file

@ -1,14 +1,14 @@
#ifndef ENCODER_H
#define ENCODER_H
#include "message/pcmChunk.h"
#include "message/headerMessage.h"
#include "message/header.h"
#include "message/sampleFormat.h"
class Encoder
{
public:
Encoder(const SampleFormat& format) : sampleFormat(format), headerChunk(NULL)
Encoder(const msg::SampleFormat& format) : sampleFormat(format), headerChunk(NULL)
{
}
@ -18,16 +18,16 @@ public:
delete headerChunk;
}
virtual double encode(PcmChunk* chunk) = 0;
virtual double encode(msg::PcmChunk* chunk) = 0;
virtual HeaderMessage* getHeader()
virtual msg::Header* getHeader()
{
return headerChunk;
}
protected:
SampleFormat sampleFormat;
HeaderMessage* headerChunk;
msg::SampleFormat sampleFormat;
msg::Header* headerChunk;
};

4
server/flacEncoder.cpp
View file

@ -4,13 +4,13 @@
using namespace std;
FlacEncoder::FlacEncoder(const SampleFormat& format) : Encoder(format)
FlacEncoder::FlacEncoder(const msg::SampleFormat& format) : Encoder(format)
{
headerChunk = new HeaderMessage("flac");
}
double FlacEncoder::encode(PcmChunk* chunk)
double FlacEncoder::encode(msg::PcmChunk* chunk)
{
return chunk->duration<chronos::msec>().count();
}

4
server/flacEncoder.h
View file

@ -12,8 +12,8 @@
class FlacEncoder : public Encoder
{
public:
FlacEncoder(const SampleFormat& format);
virtual double encode(PcmChunk* chunk);
FlacEncoder(const msg::SampleFormat& format);
virtual double encode(msg::PcmChunk* chunk);
protected:
void initEncoder();

8
server/oggEncoder.cpp
View file

@ -5,7 +5,7 @@
using namespace std;
OggEncoder::OggEncoder(const SampleFormat& format) : Encoder(format)
OggEncoder::OggEncoder(const msg::SampleFormat& format) : Encoder(format)
{
init();
lastGranulepos = -1;
@ -13,7 +13,7 @@ OggEncoder::OggEncoder(const SampleFormat& format) : Encoder(format)
double OggEncoder::encode(PcmChunk* chunk)
double OggEncoder::encode(msg::PcmChunk* chunk)
{
double res = 0;
if (tv_sec == 0)
@ -126,7 +126,7 @@ void OggEncoder::init()
*********************************************************************/
ret=vorbis_encode_init_vbr(&vi, sampleFormat.channels, sampleFormat.rate, 0.9);
ret=vorbis_encode_init_vbr(&vi, sampleFormat.channels, sampleFormat.rate, 1.0);
/* do not continue if setup failed; this can happen if we ask for a
mode that libVorbis does not support (eg, too low a bitrate, etc,
@ -165,7 +165,7 @@ void OggEncoder::init()
*/
// while(!eos){
size_t pos(0);
headerChunk = new HeaderMessage("ogg");
headerChunk = new msg::Header("ogg");
while (true)
{
int result=ogg_stream_flush(&os,&og);

4
server/oggEncoder.h
View file

@ -7,8 +7,8 @@
class OggEncoder : public Encoder
{
public:
OggEncoder(const SampleFormat& format);
virtual double encode(PcmChunk* chunk);
OggEncoder(const msg::SampleFormat& format);
virtual double encode(msg::PcmChunk* chunk);
private:
void init();

6
server/pcmEncoder.cpp
View file

@ -1,12 +1,12 @@
#include "pcmEncoder.h"
PcmEncoder::PcmEncoder(const SampleFormat& format) : Encoder(format)
PcmEncoder::PcmEncoder(const msg::SampleFormat& format) : Encoder(format)
{
headerChunk = new HeaderMessage("pcm");
headerChunk = new msg::Header("pcm");
}
double PcmEncoder::encode(PcmChunk* chunk)
double PcmEncoder::encode(msg::PcmChunk* chunk)
{
return chunk->duration<chronos::msec>().count();
}

4
server/pcmEncoder.h
View file

@ -6,8 +6,8 @@
class PcmEncoder : public Encoder
{
public:
PcmEncoder(const SampleFormat& format);
virtual double encode(PcmChunk* chunk);
PcmEncoder(const msg::SampleFormat& format);
virtual double encode(msg::PcmChunk* chunk);
};

8
server/serverSession.cpp
View file

@ -78,7 +78,7 @@ void ServerSession::socketRead(void* _to, size_t _bytes)
}
void ServerSession::add(shared_ptr<BaseMessage> message)
void ServerSession::add(shared_ptr<msg::BaseMessage> message)
{
if (!message || !streamActive)
return;
@ -89,7 +89,7 @@ void ServerSession::add(shared_ptr<BaseMessage> message)
}
bool ServerSession::send(BaseMessage* message)
bool ServerSession::send(msg::BaseMessage* message)
{
std::unique_lock<std::mutex> mlock(mutex_);
if (!socket)
@ -107,7 +107,7 @@ bool ServerSession::send(BaseMessage* message)
void ServerSession::getNextMessage()
{
//cout << "getNextMessage\n";
BaseMessage baseMessage;
msg::BaseMessage baseMessage;
size_t baseMsgSize = baseMessage.getSize();
vector<char> buffer(baseMsgSize);
socketRead(&buffer[0], baseMsgSize);
@ -151,7 +151,7 @@ void ServerSession::writer()
{
boost::asio::streambuf streambuf;
std::ostream stream(&streambuf);
shared_ptr<BaseMessage> message;
shared_ptr<msg::BaseMessage> message;
while (active_)
{
if (messages.try_pop(message, std::chrono::milliseconds(500)))

8
server/serverSession.h
View file

@ -21,7 +21,7 @@ class ServerSession;
class MessageReceiver
{
public:
virtual void onMessageReceived(ServerSession* connection, const BaseMessage& baseMessage, char* buffer) = 0;
virtual void onMessageReceived(ServerSession* connection, const msg::BaseMessage& baseMessage, char* buffer) = 0;
};
@ -32,8 +32,8 @@ public:
~ServerSession();
void start();
void stop();
bool send(BaseMessage* message);
void add(std::shared_ptr<BaseMessage> message);
bool send(msg::BaseMessage* message);
void add(std::shared_ptr<msg::BaseMessage> message);
virtual bool active()
{
@ -59,7 +59,7 @@ protected:
std::thread* writerThread;
std::shared_ptr<tcp::socket> socket;
MessageReceiver* messageReceiver;
Queue<std::shared_ptr<BaseMessage>> messages;
Queue<std::shared_ptr<msg::BaseMessage>> messages;
};

10
server/snapServer.cpp
View file

@ -40,7 +40,7 @@ int main(int argc, char* argv[])
("codec,c", po::value<string>(&codec)->default_value("ogg"), "transport codec [ogg|pcm]")
("fifo,f", po::value<string>(&fifoName)->default_value("/tmp/snapfifo"), "name of the input fifo file")
("daemon,d", po::bool_switch(&runAsDaemon)->default_value(false), "daemonize")
("buffer,b", po::value<int32_t>(&bufferMs)->default_value(500), "buffer [ms]")
("buffer,b", po::value<int32_t>(&bufferMs)->default_value(1000), "buffer [ms]")
;
po::variables_map vm;
@ -69,7 +69,7 @@ int main(int argc, char* argv[])
long nextTick = chronos::getTickCount();
mkfifo(fifoName.c_str(), 0777);
SampleFormat format(sampleFormat);
msg::SampleFormat format(sampleFormat);
size_t duration = 50;
//size_t chunkSize = duration*format.rate*format.frameSize / 1000;
std::auto_ptr<Encoder> encoder;
@ -88,7 +88,7 @@ int main(int argc, char* argv[])
return 1;
}
ServerSettings serverSettings;
msg::ServerSettings serverSettings;
serverSettings.bufferMs = bufferMs;
ControlServer* controlServer = new ControlServer(port);
@ -106,10 +106,10 @@ int main(int argc, char* argv[])
int fd = open(fifoName.c_str(), O_RDONLY | O_NONBLOCK);
try
{
shared_ptr<PcmChunk> chunk;//(new WireChunk());
shared_ptr<msg::PcmChunk> chunk;//(new WireChunk());
while (!g_terminated)//cin.good())
{
chunk.reset(new PcmChunk(sampleFormat, duration));//2*WIRE_CHUNK_SIZE));
chunk.reset(new msg::PcmChunk(sampleFormat, duration));//2*WIRE_CHUNK_SIZE));
int toRead = chunk->payloadSize;
int len = 0;
do