3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-05-16 10:36:17 +02:00
Code Issues Projects Releases Packages Wiki Activity

use less raw pointers

Browse source
This commit is contained in:
badaix 2017-11-05 13:24:26 +01:00
parent 8645643a16
commit c9b0a15dc0
7 changed files with 30 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

4
message/message.h
View file

@ -111,6 +111,10 @@ namespace msg
const size_t max_size = 1000000; const size_t max_size = 1000000;
struct BaseMessage;
using message_ptr = std::shared_ptr<msg::BaseMessage>;
struct BaseMessage struct BaseMessage
{ {
BaseMessage() : type(kBase), id(0), refersTo(0) BaseMessage() : type(kBase), id(0), refersTo(0)

32
server/streamServer.cpp
View file

@ -49,12 +49,12 @@ void StreamServer::onStateChanged(const PcmStream* pcmStream, const ReaderState&
} }
void StreamServer::onChunkRead(const PcmStream* pcmStream, const msg::PcmChunk* chunk, double duration) void StreamServer::onChunkRead(const PcmStream* pcmStream, msg::PcmChunk* chunk, double duration)
{ {
// LOG(INFO) << "onChunkRead (" << pcmStream->getName() << "): " << duration << "ms\n"; // LOG(INFO) << "onChunkRead (" << pcmStream->getName() << "): " << duration << "ms\n";
bool isDefaultStream(pcmStream == streamManager_->getDefaultStream().get()); bool isDefaultStream(pcmStream == streamManager_->getDefaultStream().get());
std::shared_ptr<const msg::BaseMessage> shared_message(chunk); msg::message_ptr shared_message(chunk);
std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_); std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_);
for (auto s : sessions_) for (auto s : sessions_)
{ {
@ -183,13 +183,13 @@ void StreamServer::ProcessRequest(const jsonrpcpp::request_ptr request, jsonrpcp
session_ptr session = getStreamSession(clientInfo->id); session_ptr session = getStreamSession(clientInfo->id);
if (session != nullptr) if (session != nullptr)
{ {
msg::ServerSettings serverSettings; auto serverSettings = make_shared<msg::ServerSettings>();
serverSettings.setBufferMs(settings_.bufferMs); serverSettings->setBufferMs(settings_.bufferMs);
serverSettings.setVolume(clientInfo->config.volume.percent); serverSettings->setVolume(clientInfo->config.volume.percent);
GroupPtr group = Config::instance().getGroupFromClient(clientInfo); GroupPtr group = Config::instance().getGroupFromClient(clientInfo);
serverSettings.setMuted(clientInfo->config.volume.muted || group->muted); serverSettings->setMuted(clientInfo->config.volume.muted || group->muted);
serverSettings.setLatency(clientInfo->config.latency); serverSettings->setLatency(clientInfo->config.latency);
session->send(&serverSettings); session->send(serverSettings);
} }
} }
} }
@ -219,13 +219,13 @@ void StreamServer::ProcessRequest(const jsonrpcpp::request_ptr request, jsonrpcp
session_ptr session = getStreamSession(client->id); session_ptr session = getStreamSession(client->id);
if (session != nullptr) if (session != nullptr)
{ {
msg::ServerSettings serverSettings; auto serverSettings = make_shared<msg::ServerSettings>();
serverSettings.setBufferMs(settings_.bufferMs); serverSettings->setBufferMs(settings_.bufferMs);
serverSettings.setVolume(client->config.volume.percent); serverSettings->setVolume(client->config.volume.percent);
GroupPtr group = Config::instance().getGroupFromClient(client); GroupPtr group = Config::instance().getGroupFromClient(client);
serverSettings.setMuted(client->config.volume.muted || group->muted); serverSettings->setMuted(client->config.volume.muted || group->muted);
serverSettings.setLatency(client->config.latency); serverSettings->setLatency(client->config.latency);
session->send(&serverSettings); session->send(serverSettings);
} }
} }
@ -448,7 +448,7 @@ void StreamServer::onMessageReceived(StreamSession* connection, const msg::BaseM
// LOG(DEBUG) << "onMessageReceived: " << baseMessage.type << ", size: " << baseMessage.size << ", id: " << baseMessage.id << ", refers: " << baseMessage.refersTo << ", sent: " << baseMessage.sent.sec << "," << baseMessage.sent.usec << ", recv: " << baseMessage.received.sec << "," << baseMessage.received.usec << "\n"; // LOG(DEBUG) << "onMessageReceived: " << baseMessage.type << ", size: " << baseMessage.size << ", id: " << baseMessage.id << ", refers: " << baseMessage.refersTo << ", sent: " << baseMessage.sent.sec << "," << baseMessage.sent.usec << ", recv: " << baseMessage.received.sec << "," << baseMessage.received.usec << "\n";
if (baseMessage.type == message_type::kTime) if (baseMessage.type == message_type::kTime)
{ {
msg::Time* timeMsg = new msg::Time(); auto timeMsg = make_shared<msg::Time>();
timeMsg->deserialize(baseMessage, buffer); timeMsg->deserialize(baseMessage, buffer);
timeMsg->refersTo = timeMsg->id; timeMsg->refersTo = timeMsg->id;
timeMsg->latency = timeMsg->received - timeMsg->sent; timeMsg->latency = timeMsg->received - timeMsg->sent;
@ -485,7 +485,7 @@ void StreamServer::onMessageReceived(StreamSession* connection, const msg::BaseM
ClientInfoPtr client = group->getClient(connection->clientId); ClientInfoPtr client = group->getClient(connection->clientId);
LOG(DEBUG) << "request kServerSettings\n"; LOG(DEBUG) << "request kServerSettings\n";
msg::ServerSettings* serverSettings = new msg::ServerSettings(); auto serverSettings = make_shared<msg::ServerSettings>();
serverSettings->setVolume(client->config.volume.percent); serverSettings->setVolume(client->config.volume.percent);
serverSettings->setMuted(client->config.volume.muted || group->muted); serverSettings->setMuted(client->config.volume.muted || group->muted);
serverSettings->setLatency(client->config.latency); serverSettings->setLatency(client->config.latency);

2
server/streamServer.h
View file

@ -93,7 +93,7 @@ public:
/// Implementation of PcmListener /// Implementation of PcmListener
virtual void onStateChanged(const PcmStream* pcmStream, const ReaderState& state); virtual void onStateChanged(const PcmStream* pcmStream, const ReaderState& state);
virtual void onChunkRead(const PcmStream* pcmStream, const msg::PcmChunk* chunk, double duration); virtual void onChunkRead(const PcmStream* pcmStream, msg::PcmChunk* chunk, double duration);
virtual void onResync(const PcmStream* pcmStream, double ms); virtual void onResync(const PcmStream* pcmStream, double ms);
private: private:

15
server/streamSession.cpp
View file

@ -118,14 +118,7 @@ void StreamSession::socketRead(void* _to, size_t _bytes)
} }
void StreamSession::sendAsync(const msg::BaseMessage* message, bool sendNow) void StreamSession::sendAsync(const msg::message_ptr& message, bool sendNow)
{
std::shared_ptr<const msg::BaseMessage> shared_message(message);
sendAsync(shared_message, sendNow);
}
void StreamSession::sendAsync(const shared_ptr<const msg::BaseMessage>& message, bool sendNow)
{ {
if (!message) if (!message)
return; return;
@ -153,7 +146,7 @@ void StreamSession::setBufferMs(size_t bufferMs)
} }
bool StreamSession::send(const msg::BaseMessage* message) const bool StreamSession::send(const msg::message_ptr& message) const
{ {
//TODO on exception: set active = false //TODO on exception: set active = false
// LOG(INFO) << "send: " << message->type << ", size: " << message->getSize() << ", id: " << message->id << ", refers: " << message->refersTo << "\n"; // LOG(INFO) << "send: " << message->type << ", size: " << message->getSize() << ", id: " << message->id << ", refers: " << message->refersTo << "\n";
@ -235,7 +228,7 @@ void StreamSession::writer()
{ {
asio::streambuf streambuf; asio::streambuf streambuf;
std::ostream stream(&streambuf); std::ostream stream(&streambuf);
shared_ptr<const msg::BaseMessage> message; shared_ptr<msg::BaseMessage> message;
while (active_) while (active_)
{ {
if (messages_.try_pop(message, std::chrono::milliseconds(500))) if (messages_.try_pop(message, std::chrono::milliseconds(500)))
@ -254,7 +247,7 @@ void StreamSession::writer()
continue; continue;
} }
} }
send(message.get()); send(message);
} }
} }
} }

7
server/streamSession.h
View file

@ -63,11 +63,10 @@ public:
void stop(); void stop();
/// Sends a message to the client (synchronous) /// Sends a message to the client (synchronous)
bool send(const msg::BaseMessage* message) const; bool send(const msg::message_ptr& message) const;
/// Sends a message to the client (asynchronous) /// Sends a message to the client (asynchronous)
void sendAsync(const std::shared_ptr<const msg::BaseMessage>& message, bool sendNow = false); void sendAsync(const msg::message_ptr& message, bool sendNow = false);
void sendAsync(const msg::BaseMessage* message, bool sendNow = false);
bool active() const; bool active() const;
@ -98,7 +97,7 @@ protected:
mutable std::mutex socketMutex_; mutable std::mutex socketMutex_;
std::shared_ptr<tcp::socket> socket_; std::shared_ptr<tcp::socket> socket_;
MessageReceiver* messageReceiver_; MessageReceiver* messageReceiver_;
Queue<std::shared_ptr<const msg::BaseMessage>> messages_; Queue<std::shared_ptr<msg::BaseMessage>> messages_;
size_t bufferMs_; size_t bufferMs_;
PcmStreamPtr pcmStream_; PcmStreamPtr pcmStream_;
}; };

2
server/streamreader/pcmStream.h
View file

@ -51,7 +51,7 @@ class PcmListener
{ {
public: public:
virtual void onStateChanged(const PcmStream* pcmStream, const ReaderState& state) = 0; virtual void onStateChanged(const PcmStream* pcmStream, const ReaderState& state) = 0;
virtual void onChunkRead(const PcmStream* pcmStream, const msg::PcmChunk* chunk, double duration) = 0; virtual void onChunkRead(const PcmStream* pcmStream, msg::PcmChunk* chunk, double duration) = 0;
virtual void onResync(const PcmStream* pcmStream, double ms) = 0; virtual void onResync(const PcmStream* pcmStream, double ms) = 0;
}; };

1
server/streamreader/pipeStream.cpp
View file

@ -113,6 +113,7 @@ void PipeStream::worker()
if (!active_) break; if (!active_) break;
/// TODO: use less raw pointers, make this encoding more transparent
encoder_->encode(chunk.get()); encoder_->encode(chunk.get());
if (!active_) break; if (!active_) break;