3pp-mirror/snapcast
1
0
Fork 0
mirror of https://github.com/badaix/snapcast.git synced 2025-05-22 21:46:15 +02:00
Code Issues Projects Releases Packages Wiki Activity

Tidy up

Browse source
This commit is contained in:
badaix 2021-02-10 18:36:40 +01:00
parent 1aa8831416
commit f5d4fcaf43
34 changed files with 274 additions and 273 deletions
Download patch file Download diff file Expand all files Collapse all files

69
client/browseZeroConf/browse_avahi.cpp
View file

@ -1,30 +1,29 @@
/***
This file is part of avahi.
This file is part of snapcast
Copyright (C) 2014-2021 Johannes Pohl
avahi is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
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 3 of the License, or
(at your option) any later version.
avahi 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 Lesser General
Public License for more details.
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 Lesser General Public
License along with avahi; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include "browse_avahi.hpp"
#include "common/aixlog.hpp"
#include "common/snap_exception.hpp"
#include <assert.h>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
static AvahiSimplePoll* simple_poll = nullptr;
@ -45,15 +44,15 @@ BrowseAvahi::~BrowseAvahi()
void BrowseAvahi::cleanUp()
{
if (sb_)
if (sb_ != nullptr)
avahi_service_browser_free(sb_);
sb_ = nullptr;
if (client_)
if (client_ != nullptr)
avahi_client_free(client_);
client_ = nullptr;
if (simple_poll)
if (simple_poll != nullptr)
avahi_simple_poll_free(simple_poll);
simple_poll = nullptr;
}
@ -64,7 +63,7 @@ void BrowseAvahi::resolve_callback(AvahiServiceResolver* r, AVAHI_GCC_UNUSED Ava
const AvahiAddress* address, uint16_t port, AvahiStringList* txt, AvahiLookupResultFlags flags,
AVAHI_GCC_UNUSED void* userdata)
{
BrowseAvahi* browseAvahi = static_cast<BrowseAvahi*>(userdata);
auto* browseAvahi = static_cast<BrowseAvahi*>(userdata);
assert(r);
/* Called whenever a service has been resolved successfully or timed out */
@ -87,20 +86,20 @@ void BrowseAvahi::resolve_callback(AvahiServiceResolver* r, AVAHI_GCC_UNUSED Ava
browseAvahi->result_.ip = a;
browseAvahi->result_.port = port;
// protocol seems to be unreliable (0 for IPv4 and for IPv6)
browseAvahi->result_.ip_version = (browseAvahi->result_.ip.find(":") == std::string::npos) ? (IPVersion::IPv4) : (IPVersion::IPv6);
browseAvahi->result_.ip_version = (browseAvahi->result_.ip.find(':') == std::string::npos) ? (IPVersion::IPv4) : (IPVersion::IPv6);
browseAvahi->result_.valid = true;
browseAvahi->result_.iface_idx = interface;
t = avahi_string_list_to_string(txt);
LOG(INFO, LOG_TAG) << "\t" << host_name << ":" << port << " (" << a << ")\n";
LOG(DEBUG, LOG_TAG) << "\tTXT=" << t << "\n";
LOG(DEBUG, LOG_TAG) << "\tProto=" << (int)protocol << "\n";
LOG(DEBUG, LOG_TAG) << "\tProto=" << static_cast<int>(protocol) << "\n";
LOG(DEBUG, LOG_TAG) << "\tcookie is " << avahi_string_list_get_service_cookie(txt) << "\n";
LOG(DEBUG, LOG_TAG) << "\tis_local: " << !!(flags & AVAHI_LOOKUP_RESULT_LOCAL) << "\n";
LOG(DEBUG, LOG_TAG) << "\tour_own: " << !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN) << "\n";
LOG(DEBUG, LOG_TAG) << "\twide_area: " << !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA) << "\n";
LOG(DEBUG, LOG_TAG) << "\tmulticast: " << !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST) << "\n";
LOG(DEBUG, LOG_TAG) << "\tcached: " << !!(flags & AVAHI_LOOKUP_RESULT_CACHED) << "\n";
LOG(DEBUG, LOG_TAG) << "\tis_local: " << !((flags & AVAHI_LOOKUP_RESULT_LOCAL) == 0) << "\n";
LOG(DEBUG, LOG_TAG) << "\tour_own: " << !((flags & AVAHI_LOOKUP_RESULT_OUR_OWN) == 0) << "\n";
LOG(DEBUG, LOG_TAG) << "\twide_area: " << !((flags & AVAHI_LOOKUP_RESULT_WIDE_AREA) == 0) << "\n";
LOG(DEBUG, LOG_TAG) << "\tmulticast: " << !((flags & AVAHI_LOOKUP_RESULT_MULTICAST) == 0) << "\n";
LOG(DEBUG, LOG_TAG) << "\tcached: " << !((flags & AVAHI_LOOKUP_RESULT_CACHED) == 0) << "\n";
avahi_free(t);
}
}
@ -114,7 +113,7 @@ void BrowseAvahi::browse_callback(AvahiServiceBrowser* b, AvahiIfIndex interface
{
// AvahiClient* client = (AvahiClient*)userdata;
BrowseAvahi* browseAvahi = static_cast<BrowseAvahi*>(userdata);
auto* browseAvahi = static_cast<BrowseAvahi*>(userdata);
assert(b);
/* Called whenever a new services becomes available on the LAN or is removed from the LAN */
@ -134,8 +133,8 @@ void BrowseAvahi::browse_callback(AvahiServiceBrowser* b, AvahiIfIndex interface
the callback function is called the server will free
the resolver for us. */
if (!(avahi_service_resolver_new(browseAvahi->client_, interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, (AvahiLookupFlags)0,
resolve_callback, userdata)))
if ((avahi_service_resolver_new(browseAvahi->client_, interface, protocol, name, type, domain, AVAHI_PROTO_UNSPEC, static_cast<AvahiLookupFlags>(0),
resolve_callback, userdata)) == nullptr)
LOG(ERROR, LOG_TAG) << "Failed to resolve service '" << name << "': " << avahi_strerror(avahi_client_errno(browseAvahi->client_)) << "\n";
break;
@ -172,17 +171,17 @@ bool BrowseAvahi::browse(const std::string& serviceName, mDNSResult& result, int
try
{
/* Allocate main loop object */
if (!(simple_poll = avahi_simple_poll_new()))
if ((simple_poll = avahi_simple_poll_new()) == nullptr)
throw SnapException("BrowseAvahi - Failed to create simple poll object");
/* Allocate a new client */
int error;
if (!(client_ = avahi_client_new(avahi_simple_poll_get(simple_poll), (AvahiClientFlags)0, client_callback, this, &error)))
if ((client_ = avahi_client_new(avahi_simple_poll_get(simple_poll), static_cast<AvahiClientFlags>(0), client_callback, this, &error)) == nullptr)
throw SnapException("BrowseAvahi - Failed to create client: " + std::string(avahi_strerror(error)));
/* Create the service browser */
if (!(sb_ = avahi_service_browser_new(client_, AVAHI_IF_UNSPEC, AVAHI_PROTO_INET, serviceName.c_str(), nullptr, (AvahiLookupFlags)0, browse_callback,
this)))
if ((sb_ = avahi_service_browser_new(client_, AVAHI_IF_UNSPEC, AVAHI_PROTO_INET, serviceName.c_str(), nullptr, static_cast<AvahiLookupFlags>(0),
browse_callback, this)) == nullptr)
throw SnapException("BrowseAvahi - Failed to create service browser: " + std::string(avahi_strerror(avahi_client_errno(client_))));
result_.valid = false;

6
client/controller.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -278,8 +278,8 @@ void Controller::sendTimeSyncMessage(int quick_syncs)
if (quick_syncs > 0)
{
if (--quick_syncs == 0)
LOG(INFO, LOG_TAG) << "diff to server [ms]: " << (float)TimeProvider::getInstance().getDiffToServer<chronos::usec>().count() / 1000.f
<< "\n";
LOG(INFO, LOG_TAG) << "diff to server [ms]: "
<< static_cast<float>(TimeProvider::getInstance().getDiffToServer<chronos::usec>().count()) / 1000.f << "\n";
next = 100us;
}
timer_.expires_after(next);

22
client/decoder/flac_decoder.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -70,15 +70,15 @@ bool FlacDecoder::decode(msg::PcmChunk* chunk)
std::lock_guard<std::mutex> lock(mutex_);
cacheInfo_.reset();
pcmChunk = chunk;
flacChunk->payload = (char*)realloc(flacChunk->payload, chunk->payloadSize);
flacChunk->payload = static_cast<char*>(realloc(flacChunk->payload, chunk->payloadSize));
memcpy(flacChunk->payload, chunk->payload, chunk->payloadSize);
flacChunk->payloadSize = chunk->payloadSize;
pcmChunk->payload = (char*)realloc(pcmChunk->payload, 0);
pcmChunk->payload = static_cast<char*>(realloc(pcmChunk->payload, 0));
pcmChunk->payloadSize = 0;
while (flacChunk->payloadSize > 0)
{
if (!FLAC__stream_decoder_process_single(decoder))
if (FLAC__stream_decoder_process_single(decoder) == 0)
{
return false;
}
@ -147,7 +147,7 @@ FLAC__StreamDecoderReadStatus read_callback(const FLAC__StreamDecoder* /*decoder
memcpy(buffer, flacChunk->payload, *bytes);
memmove(flacChunk->payload, flacChunk->payload + *bytes, flacChunk->payloadSize - *bytes);
flacChunk->payloadSize = flacChunk->payloadSize - static_cast<uint32_t>(*bytes);
flacChunk->payload = (char*)realloc(flacChunk->payload, flacChunk->payloadSize);
flacChunk->payload = static_cast<char*>(realloc(flacChunk->payload, flacChunk->payloadSize));
}
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}
@ -160,11 +160,11 @@ FLAC__StreamDecoderWriteStatus write_callback(const FLAC__StreamDecoder* /*decod
{
size_t bytes = frame->header.blocksize * sampleFormat.frameSize();
FlacDecoder* flacDecoder = static_cast<FlacDecoder*>(client_data);
auto* flacDecoder = static_cast<FlacDecoder*>(client_data);
if (flacDecoder->cacheInfo_.isCachedChunk_)
flacDecoder->cacheInfo_.cachedBlocks_ += frame->header.blocksize;
pcmChunk->payload = (char*)realloc(pcmChunk->payload, pcmChunk->payloadSize + bytes);
pcmChunk->payload = static_cast<char*>(realloc(pcmChunk->payload, pcmChunk->payloadSize + bytes));
for (size_t channel = 0; channel < sampleFormat.channels(); ++channel)
{
@ -176,19 +176,19 @@ FLAC__StreamDecoderWriteStatus write_callback(const FLAC__StreamDecoder* /*decod
if (sampleFormat.sampleSize() == 1)
{
int8_t* chunkBuffer = (int8_t*)(pcmChunk->payload + pcmChunk->payloadSize);
auto* chunkBuffer = reinterpret_cast<int8_t*>(pcmChunk->payload + pcmChunk->payloadSize);
for (size_t i = 0; i < frame->header.blocksize; i++)
chunkBuffer[sampleFormat.channels() * i + channel] = (int8_t)(buffer[channel][i]);
chunkBuffer[sampleFormat.channels() * i + channel] = static_cast<int8_t>(buffer[channel][i]);
}
else if (sampleFormat.sampleSize() == 2)
{
int16_t* chunkBuffer = (int16_t*)(pcmChunk->payload + pcmChunk->payloadSize);
auto* chunkBuffer = reinterpret_cast<int16_t*>(pcmChunk->payload + pcmChunk->payloadSize);
for (size_t i = 0; i < frame->header.blocksize; i++)
chunkBuffer[sampleFormat.channels() * i + channel] = SWAP_16((int16_t)(buffer[channel][i]));
}
else if (sampleFormat.sampleSize() == 4)
{
int32_t* chunkBuffer = (int32_t*)(pcmChunk->payload + pcmChunk->payloadSize);
auto* chunkBuffer = reinterpret_cast<int32_t*>(pcmChunk->payload + pcmChunk->payloadSize);
for (size_t i = 0; i < frame->header.blocksize; i++)
chunkBuffer[sampleFormat.channels() * i + channel] = SWAP_32((int32_t)(buffer[channel][i]));
}

16
client/decoder/ogg_decoder.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -81,7 +81,7 @@ bool OggDecoder::decode(msg::PcmChunk* chunk)
}
ogg_stream_pagein(&os, &og); /* can safely ignore errors at this point */
while (1)
while (true)
{
result = ogg_stream_packetout(&os, &op);
@ -108,12 +108,12 @@ bool OggDecoder::decode(msg::PcmChunk* chunk)
while ((samples = vorbis_synthesis_pcmout(&vd, &pcm)) > 0)
{
uint32_t bytes = sampleFormat_.sampleSize() * vi.channels * samples;
chunk->payload = (char*)realloc(chunk->payload, chunk->payloadSize + bytes);
chunk->payload = static_cast<char*>(realloc(chunk->payload, chunk->payloadSize + bytes));
for (int channel = 0; channel < vi.channels; ++channel)
{
if (sampleFormat_.sampleSize() == 1)
{
int8_t* chunkBuffer = (int8_t*)(chunk->payload + chunk->payloadSize);
auto* chunkBuffer = reinterpret_cast<int8_t*>(chunk->payload + chunk->payloadSize);
for (int i = 0; i < samples; i++)
{
int8_t& val = chunkBuffer[sampleFormat_.channels() * i + channel];
@ -126,7 +126,7 @@ bool OggDecoder::decode(msg::PcmChunk* chunk)
}
else if (sampleFormat_.sampleSize() == 2)
{
int16_t* chunkBuffer = (int16_t*)(chunk->payload + chunk->payloadSize);
auto* chunkBuffer = reinterpret_cast<int16_t*>(chunk->payload + chunk->payloadSize);
for (int i = 0; i < samples; i++)
{
int16_t& val = chunkBuffer[sampleFormat_.channels() * i + channel];
@ -139,7 +139,7 @@ bool OggDecoder::decode(msg::PcmChunk* chunk)
}
else if (sampleFormat_.sampleSize() == 4)
{
int32_t* chunkBuffer = (int32_t*)(chunk->payload + chunk->payloadSize);
auto* chunkBuffer = reinterpret_cast<int32_t*>(chunk->payload + chunk->payloadSize);
for (int i = 0; i < samples; i++)
{
int32_t& val = chunkBuffer[sampleFormat_.channels() * i + channel];
@ -229,11 +229,11 @@ SampleFormat OggDecoder::setHeader(msg::CodecHeader* chunk)
/* Throw the comments plus a few lines about the bitstream we're decoding */
char** ptr = vc.user_comments;
while (*ptr)
while (*ptr != nullptr)
{
std::string comment(*ptr);
if (comment.find("SAMPLE_FORMAT=") == 0)
sampleFormat_.setFormat(comment.substr(comment.find("=") + 1));
sampleFormat_.setFormat(comment.substr(comment.find('=') + 1));
LOG(INFO, LOG_TAG) << "comment: " << comment << "\n";
;
++ptr;

31
client/decoder/opus_decoder.cpp
View file

@ -1,19 +1,20 @@
/***
This file is part of snapcast
Copyright (C) 2015 Hannes Ellinger
This file is part of snapcast
Copyright (C) 2015 Hannes Ellinger
Copyright (C) 2016-2021 Johannes Pohl
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 3 of the License, or
(at your option) any later version.
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 3 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.
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, see <http://www.gnu.org/licenses/>.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include "opus_decoder.hpp"
@ -51,7 +52,7 @@ bool OpusDecoder::decode(msg::PcmChunk* chunk)
{
int decoded_frames = 0;
while ((decoded_frames = opus_decode(dec_, (unsigned char*)chunk->payload, chunk->payloadSize, pcm_.data(),
while ((decoded_frames = opus_decode(dec_, reinterpret_cast<unsigned char*>(chunk->payload), chunk->payloadSize, pcm_.data(),
static_cast<int>(pcm_.size()) / sample_format_.channels(), 0)) == OPUS_BUFFER_TOO_SMALL)
{
if (pcm_.size() < const_max_frame_size * sample_format_.channels())
@ -76,8 +77,8 @@ bool OpusDecoder::decode(msg::PcmChunk* chunk)
// copy encoded data to chunk
chunk->payloadSize = decoded_frames * sample_format_.frameSize(); // decoded_frames * sample_format_.channels() * sizeof(opus_int16);
chunk->payload = (char*)realloc(chunk->payload, chunk->payloadSize);
memcpy(chunk->payload, (char*)pcm_.data(), chunk->payloadSize);
chunk->payload = static_cast<char*>(realloc(chunk->payload, chunk->payloadSize));
memcpy(chunk->payload, reinterpret_cast<char*>(pcm_.data()), chunk->payloadSize);
return true;
}
}

14
client/player/alsa_player.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -195,7 +195,7 @@ void AlsaPlayer::waitForEvent()
unsigned short revents;
snd_ctl_poll_descriptors_revents(ctl_, fd_.get(), 1, &revents);
if (revents & POLLIN || (revents == 0))
if (((revents & POLLIN) != 0) || (revents == 0))
{
snd_ctl_event_t* event;
snd_ctl_event_alloca(&event);
@ -266,7 +266,7 @@ void AlsaPlayer::initMixer()
if ((err = snd_mixer_load(mixer_)) < 0)
throw SnapException(std::string("Failed to load mixer, error: ") + snd_strerror(err));
elem_ = snd_mixer_find_selem(mixer_, sid);
if (!elem_)
if (elem_ == nullptr)
throw SnapException("Failed to find mixer: " + mixer_name_);
sd_ = boost::asio::posix::stream_descriptor(io_context_, fd_->fd);
@ -345,9 +345,9 @@ void AlsaPlayer::initAlsa()
{
stringstream ss;
ss << "Can't set format: " << string(snd_strerror(err)) << ", supported: ";
for (int format = 0; format <= (int)SND_PCM_FORMAT_LAST; format++)
for (int format = 0; format <= static_cast<int>(SND_PCM_FORMAT_LAST); format++)
{
snd_pcm_format_t snd_pcm_format = static_cast<snd_pcm_format_t>(format);
auto snd_pcm_format = static_cast<snd_pcm_format_t>(format);
if (snd_pcm_hw_params_test_format(handle_, params, snd_pcm_format) == 0)
ss << snd_pcm_format_name(snd_pcm_format) << " ";
}
@ -416,7 +416,7 @@ void AlsaPlayer::initAlsa()
// Resume information
// uint32_t periods;
if (snd_pcm_hw_params_get_periods(params, &periods, nullptr) < 0)
periods = round((double)buffer_time / (double)period_time);
periods = round(static_cast<double>(buffer_time) / static_cast<double>(period_time));
snd_pcm_hw_params_get_period_size(params, &frames_, nullptr);
LOG(INFO, LOG_TAG) << "PCM name: " << snd_pcm_name(handle_) << ", sample rate: " << rate << " Hz, channels: " << channels
<< ", buffer time: " << buffer_time << " us, periods: " << periods << ", period time: " << period_time
@ -617,7 +617,7 @@ void AlsaPlayer::worker()
}
// LOG(TRACE, LOG_TAG) << "res: " << result << ", framesAvail: " << framesAvail << ", delay: " << framesDelay << ", frames: " << frames_ << "\n";
chronos::usec delay(static_cast<chronos::usec::rep>(1000 * (double)framesDelay / format.msRate()));
chronos::usec delay(static_cast<chronos::usec::rep>(1000 * static_cast<double>(framesDelay) / format.msRate()));
// LOG(TRACE, LOG_TAG) << "delay: " << framesDelay << ", delay[ms]: " << delay.count() / 1000 << ", avail: " << framesAvail << "\n";
if (buffer_.size() < static_cast<size_t>(framesAvail * format.frameSize()))

4
client/player/file_player.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -16,7 +16,7 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include <assert.h>
#include <cassert>
#include <iostream>
#include "common/aixlog.hpp"

38
client/player/pulse_player.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -16,7 +16,7 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include <assert.h>
#include <cassert>
#include <iostream>
#include "common/aixlog.hpp"
@ -96,7 +96,7 @@ vector<PcmDevice> PulsePlayer::pcm_list(const std::string& parameter)
throw SnapException("PulseAudio context failed, error: " + std::string(pa_strerror(pa_context_errno(pa_ctx.get()))));
static std::vector<PcmDevice> devices;
auto op = pa_context_get_sink_info_list(
auto* op = pa_context_get_sink_info_list(
pa_ctx.get(),
[](pa_context* ctx, const pa_sink_info* i, int eol, void* userdata) mutable {
std::ignore = ctx;
@ -194,10 +194,10 @@ void PulsePlayer::triggerVolumeUpdate()
[](pa_context* ctx, const pa_sink_input_info* info, int eol, void* userdata) {
std::ignore = ctx;
LOG(DEBUG, LOG_TAG) << "pa_context_get_sink_info_by_index info: " << (info != nullptr) << ", eol: " << eol << "\n";
if (info)
if (info != nullptr)
{
auto self = static_cast<PulsePlayer*>(userdata);
self->volume_ = (double)pa_cvolume_avg(&(info->volume)) / (double)PA_VOLUME_NORM;
auto* self = static_cast<PulsePlayer*>(userdata);
self->volume_ = static_cast<double>(pa_cvolume_avg(&(info->volume))) / static_cast<double>(PA_VOLUME_NORM);
self->muted_ = (info->mute != 0);
LOG(DEBUG, LOG_TAG) << "Volume changed: " << self->volume_ << ", muted: " << self->muted_ << "\n";
@ -225,7 +225,7 @@ void PulsePlayer::subscribeCallback(pa_context* ctx, pa_subscription_event_type_
if (facility == PA_SUBSCRIPTION_EVENT_SINK_INPUT)
{
LOG(DEBUG, LOG_TAG) << "event_type: " << event_type << ", facility: " << facility << "\n";
if (playstream_ && (idx == pa_stream_get_index(playstream_)))
if ((playstream_ != nullptr) && (idx == pa_stream_get_index(playstream_)))
triggerVolumeUpdate();
}
}
@ -351,7 +351,7 @@ void PulsePlayer::start()
pa_context_set_state_callback(
pa_ctx_,
[](pa_context* c, void* userdata) {
auto self = static_cast<PulsePlayer*>(userdata);
auto* self = static_cast<PulsePlayer*>(userdata);
self->stateCallback(c);
},
this);
@ -373,7 +373,7 @@ void PulsePlayer::start()
throw SnapException("PulseAudio is not ready, error: " + std::string(pa_strerror(pa_context_errno(pa_ctx_))));
playstream_ = pa_stream_new(pa_ctx_, "Playback", &pa_ss_, nullptr);
if (!playstream_)
if (playstream_ == nullptr)
throw SnapException("Failed to create PulseAudio stream");
if (settings_.mixer.mode == ClientSettings::Mixer::Mode::hardware)
@ -381,19 +381,19 @@ void PulsePlayer::start()
pa_context_set_subscribe_callback(
pa_ctx_,
[](pa_context* ctx, pa_subscription_event_type_t event_type, uint32_t idx, void* userdata) {
auto self = static_cast<PulsePlayer*>(userdata);
auto* self = static_cast<PulsePlayer*>(userdata);
self->subscribeCallback(ctx, event_type, idx);
},
this);
const pa_subscription_mask_t mask = static_cast<pa_subscription_mask_t>(PA_SUBSCRIPTION_MASK_SINK_INPUT);
const auto mask = static_cast<pa_subscription_mask_t>(PA_SUBSCRIPTION_MASK_SINK_INPUT);
pa_context_subscribe(
pa_ctx_, mask,
[](pa_context* ctx, int success, void* userdata) {
std::ignore = ctx;
if (success)
if (success != 0)
{
auto self = static_cast<PulsePlayer*>(userdata);
auto* self = static_cast<PulsePlayer*>(userdata);
self->triggerVolumeUpdate();
}
},
@ -403,7 +403,7 @@ void PulsePlayer::start()
pa_stream_set_write_callback(
playstream_,
[](pa_stream* stream, size_t length, void* userdata) {
auto self = static_cast<PulsePlayer*>(userdata);
auto* self = static_cast<PulsePlayer*>(userdata);
self->writeCallback(stream, length);
},
this);
@ -411,7 +411,7 @@ void PulsePlayer::start()
pa_stream_set_underflow_callback(
playstream_,
[](pa_stream* stream, void* userdata) {
auto self = static_cast<PulsePlayer*>(userdata);
auto* self = static_cast<PulsePlayer*>(userdata);
self->underflowCallback(stream);
},
this);
@ -445,27 +445,27 @@ void PulsePlayer::start()
void PulsePlayer::stop()
{
LOG(INFO, LOG_TAG) << "Stop\n";
if (pa_ml_)
if (pa_ml_ != nullptr)
{
pa_mainloop_quit(pa_ml_, 0);
}
Player::stop();
if (pa_ctx_)
if (pa_ctx_ != nullptr)
{
pa_context_disconnect(pa_ctx_);
pa_context_unref(pa_ctx_);
pa_ctx_ = nullptr;
}
if (pa_ml_)
if (pa_ml_ != nullptr)
{
pa_mainloop_free(pa_ml_);
pa_ml_ = nullptr;
}
if (playstream_)
if (playstream_ != nullptr)
{
pa_stream_set_state_callback(playstream_, nullptr, nullptr);
pa_stream_set_read_callback(playstream_, nullptr, nullptr);

8
client/snapclient.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -19,7 +19,7 @@
#include <chrono>
#include <iostream>
#ifndef WINDOWS
#include <signal.h>
#include <csignal>
#include <sys/resource.h>
#endif
@ -282,7 +282,7 @@ int main(int argc, char** argv)
string logformat = "%Y-%m-%d %H-%M-%S.#ms [#severity] (#tag_func)";
if (settings.logging.sink.find("file:") != string::npos)
{
string logfile = settings.logging.sink.substr(settings.logging.sink.find(":") + 1);
string logfile = settings.logging.sink.substr(settings.logging.sink.find(':') + 1);
AixLog::Log::init<AixLog::SinkFile>(logfilter, logfile, logformat);
}
else if (settings.logging.sink == "stdout")
@ -315,7 +315,7 @@ int main(int argc, char** argv)
if (userValue->is_set())
{
if (userValue->value().empty())
std::invalid_argument("user must not be empty");
throw std::invalid_argument("user must not be empty");
vector<string> user_group = utils::string::split(userValue->value(), ':');
user = user_group[0];

8
client/stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -27,8 +27,8 @@
#include "common/utils/logging.hpp"
#include "time_provider.hpp"
#include <cmath>
#include <cstring>
#include <iostream>
#include <string.h>
using namespace std;
@ -334,7 +334,7 @@ bool Stream::getPlayerChunk(void* outputBuffer, const cs::usec& outputBufferDacT
<< ", age: " << std::chrono::duration_cast<cs::usec>(age).count() / 1000. << "\n";
getSilentPlayerChunk(outputBuffer, silent_frames);
}
getNextPlayerChunk((char*)outputBuffer + (chunk_->format.frameSize() * silent_frames), frames - silent_frames);
getNextPlayerChunk(static_cast<char*>(outputBuffer) + (chunk_->format.frameSize() * silent_frames), frames - silent_frames);
if (result)
{
@ -353,7 +353,7 @@ bool Stream::getPlayerChunk(void* outputBuffer, const cs::usec& outputBufferDacT
if (correctAfterXFrames_ != 0)
{
playedFrames_ += frames;
if (playedFrames_ >= (uint32_t)abs(correctAfterXFrames_))
if (playedFrames_ >= static_cast<uint32_t>(abs(correctAfterXFrames_)))
{
framesCorrection = static_cast<int32_t>(playedFrames_) / correctAfterXFrames_;
playedFrames_ %= abs(correctAfterXFrames_);

5
client/time_provider.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -33,7 +33,8 @@ void TimeProvider::setDiff(const tv& c2s, const tv& s2c)
{
// tv latency = c2s - s2c;
// double diff = (latency.sec * 1000. + latency.usec / 1000.) / 2.;
double diff = ((double)c2s.sec / 2. - (double)s2c.sec / 2.) * 1000. + ((double)c2s.usec / 2. - (double)s2c.usec / 2.) / 1000.;
double diff = (static_cast<double>(c2s.sec) / 2. - static_cast<double>(s2c.sec) / 2.) * 1000. +
(static_cast<double>(c2s.usec) / 2. - static_cast<double>(s2c.usec) / 2.) / 1000.;
setDiffToServer(diff);
}

20
common/daemon.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -22,12 +22,12 @@
#include "common/str_compat.hpp"
#include "common/utils.hpp"
#include "common/utils/file_utils.hpp"
#include <cstdlib>
#include <cstring>
#include <fcntl.h>
#include <grp.h>
#include <iostream>
#include <pwd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <syslog.h>
@ -62,8 +62,8 @@ void Daemon::daemonize()
throw SnapException("Could not open PID lock file \"" + pidfile_ + "\"");
}
uid_t user_uid = (uid_t)-1;
gid_t user_gid = (gid_t)-1;
auto user_uid = static_cast<uid_t>(-1);
auto user_gid = static_cast<gid_t>(-1);
std::string user_name;
// #ifdef FREEBSD
// bool had_group = false;
@ -78,7 +78,7 @@ void Daemon::daemonize()
user_gid = pwd->pw_gid;
user_name = strdup(user_.c_str());
/// this is needed by libs such as arts
setenv("HOME", pwd->pw_dir, true);
setenv("HOME", pwd->pw_dir, 1);
}
if (!group_.empty())
@ -99,8 +99,8 @@ void Daemon::daemonize()
}
/// set gid
if (user_gid != (gid_t)-1 && user_gid != getgid() && setgid(user_gid) == -1)
throw SnapException("Failed to set group " + cpt::to_string((int)user_gid));
if (user_gid != static_cast<gid_t>(-1) && user_gid != getgid() && setgid(user_gid) == -1)
throw SnapException("Failed to set group " + cpt::to_string(static_cast<int>(user_gid)));
//#if defined(FREEBSD) && !defined(MACOS)
//#ifdef FREEBSD
@ -111,7 +111,7 @@ void Daemon::daemonize()
// throw SnapException("Failed to set supplementary groups of user \"" + user + "\"");
//#endif
/// set uid
if (user_uid != (uid_t)-1 && user_uid != getuid() && setuid(user_uid) == -1)
if (user_uid != static_cast<uid_t>(-1) && user_uid != getuid() && setuid(user_uid) == -1)
throw SnapException("Failed to set user " + user_);
/// Our process ID and Session ID
@ -155,7 +155,7 @@ void Daemon::daemonize()
sprintf(str, "%d\n", getpid());
/// write pid to lockfile
if (write(pidFilehandle_, str, strlen(str)) != (int)strlen(str))
if (write(pidFilehandle_, str, strlen(str)) != static_cast<int>(strlen(str)))
throw SnapException("Could not write PID to lock file \"" + pidfile_ + "\"");
/// Close out the standard file descriptors

8
common/message/message.hpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -16,8 +16,8 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#ifndef MESSAGE_H
#define MESSAGE_H
#ifndef MESSAGE_HPP
#define MESSAGE_HPP
#include "common/endian.hpp"
#include "common/time_defs.hpp"
@ -232,7 +232,7 @@ protected:
void writeVal(std::ostream& stream, const std::string& val) const
{
uint32_t size = static_cast<uint32_t>(val.size());
auto size = static_cast<uint32_t>(val.size());
writeVal(stream, val.c_str(), size);
}

16
common/resampler.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -46,7 +46,7 @@ Resampler::Resampler(const SampleFormat& in_format, const SampleFormat& out_form
soxr_quality_spec_t q_spec = soxr_quality_spec(SOXR_HQ, 0);
soxr_ =
soxr_create(static_cast<double>(in_format_.rate()), static_cast<double>(out_format_.rate()), in_format_.channels(), &error, &iospec, &q_spec, NULL);
if (error)
if (error != nullptr)
{
LOG(ERROR, LOG_TAG) << "Error soxr_create: " << error << "\n";
soxr_ = nullptr;
@ -118,7 +118,7 @@ std::shared_ptr<msg::PcmChunk> Resampler::resample(const msg::PcmChunk& chunk)
if (in_format_.bits() == 24)
{
// sox expects 32 bit input, shift 8 bits left
int32_t* frames = (int32_t*)chunk.payload;
auto* frames = reinterpret_cast<int32_t*>(chunk.payload);
for (size_t n = 0; n < chunk.getSampleCount(); ++n)
frames[n] = frames[n] << 8;
}
@ -126,8 +126,8 @@ std::shared_ptr<msg::PcmChunk> Resampler::resample(const msg::PcmChunk& chunk)
size_t idone;
size_t odone;
auto resample_buffer_framesize = resample_buffer_.size() / out_format_.frameSize();
auto error = soxr_process(soxr_, chunk.payload, chunk.getFrameCount(), &idone, resample_buffer_.data(), resample_buffer_framesize, &odone);
if (error)
const auto* error = soxr_process(soxr_, chunk.payload, chunk.getFrameCount(), &idone, resample_buffer_.data(), resample_buffer_framesize, &odone);
if (error != nullptr)
{
LOG(ERROR, LOG_TAG) << "Error soxr_process: " << error << "\n";
}
@ -151,13 +151,13 @@ std::shared_ptr<msg::PcmChunk> Resampler::resample(const msg::PcmChunk& chunk)
// copy from the resample_buffer to the resampled chunk
resampled_chunk->payloadSize = static_cast<uint32_t>(odone * out_format_.frameSize());
resampled_chunk->payload = (char*)realloc(resampled_chunk->payload, resampled_chunk->payloadSize);
resampled_chunk->payload = static_cast<char*>(realloc(resampled_chunk->payload, resampled_chunk->payloadSize));
memcpy(resampled_chunk->payload, resample_buffer_.data(), resampled_chunk->payloadSize);
if (out_format_.bits() == 24)
{
// sox has quantized to 32 bit, shift 8 bits right
int32_t* frames = (int32_t*)resampled_chunk->payload;
auto* frames = reinterpret_cast<int32_t*>(resampled_chunk->payload);
for (size_t n = 0; n < resampled_chunk->getSampleCount(); ++n)
{
// +128 to round to the nearest so that quantisation steps are distributed evenly
@ -211,7 +211,7 @@ shared_ptr<msg::PcmChunk> Resampler::resample(shared_ptr<msg::PcmChunk> chunk)
Resampler::~Resampler()
{
#ifdef HAS_SOXR
if (soxr_)
if (soxr_ != nullptr)
soxr_delete(soxr_);
#endif
}

10
server/config.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -94,7 +94,7 @@ void Config::init(const std::string& root_directory, const std::string& user, co
{
json j;
ifs >> j;
if (j.count("ConfigVersion"))
if (j.count("ConfigVersion") != 0u)
{
json jGroups = j["Groups"];
for (auto& jGroup : jGroups)
@ -132,7 +132,7 @@ ClientInfoPtr Config::getClientInfo(const std::string& clientId) const
if (clientId.empty())
return nullptr;
for (auto group : groups)
for (const auto& group : groups)
{
for (auto client : group->clients)
{
@ -183,7 +183,7 @@ GroupPtr Config::getGroupFromClient(const std::string& clientId)
{
for (auto group : groups)
{
for (auto c : group->clients)
for (const auto& c : group->clients)
{
if (c->id == clientId)
return group;
@ -219,7 +219,7 @@ json Config::getServerStatus(const json& streams) const
json Config::getGroups() const
{
json result = json::array();
for (auto group : groups)
for (const auto& group : groups)
result.push_back(group->toJson());
return result;
}

6
server/control_server.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -62,7 +62,7 @@ void ControlServer::cleanup()
void ControlServer::send(const std::string& message, const ControlSession* excludeSession)
{
std::lock_guard<std::recursive_mutex> mlock(session_mutex_);
for (auto s : sessions_)
for (const auto& s : sessions_)
{
if (auto session = s.lock())
{
@ -199,7 +199,7 @@ void ControlServer::stop()
std::lock_guard<std::recursive_mutex> mlock(session_mutex_);
cleanup();
for (auto s : sessions_)
for (const auto& s : sessions_)
{
if (auto session = s.lock())
session->stop();

8
server/encoder/encoder_factory.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -42,10 +42,10 @@ std::unique_ptr<Encoder> EncoderFactory::createEncoder(const std::string& codecS
{
std::string codec(codecSettings);
std::string codecOptions;
if (codec.find(":") != std::string::npos)
if (codec.find(':') != std::string::npos)
{
codecOptions = utils::string::trim_copy(codec.substr(codec.find(":") + 1));
codec = utils::string::trim_copy(codec.substr(0, codec.find(":")));
codecOptions = utils::string::trim_copy(codec.substr(codec.find(':') + 1));
codec = utils::string::trim_copy(codec.substr(0, codec.find(':')));
}
if (codec == "pcm")
return std::make_unique<PcmEncoder>(codecOptions);

40
server/encoder/flac_encoder.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -33,7 +33,7 @@ namespace encoder
FlacEncoder::FlacEncoder(const std::string& codecOptions) : Encoder(codecOptions), encoder_(nullptr), pcmBufferSize_(0), encodedSamples_(0), flacChunk_(nullptr)
{
headerChunk_.reset(new msg::CodecHeader("flac"));
pcmBuffer_ = (FLAC__int32*)malloc(pcmBufferSize_ * sizeof(FLAC__int32));
pcmBuffer_ = static_cast<FLAC__int32*>(malloc(pcmBufferSize_ * sizeof(FLAC__int32)));
}
@ -82,26 +82,26 @@ void FlacEncoder::encode(const msg::PcmChunk& chunk)
if (pcmBufferSize_ < samples)
{
pcmBufferSize_ = samples;
pcmBuffer_ = (FLAC__int32*)realloc(pcmBuffer_, pcmBufferSize_ * sizeof(FLAC__int32));
pcmBuffer_ = static_cast<FLAC__int32*>(realloc(pcmBuffer_, pcmBufferSize_ * sizeof(FLAC__int32)));
}
if (sampleFormat_.sampleSize() == 1)
{
FLAC__int8* buffer = (FLAC__int8*)chunk.payload;
auto* buffer = reinterpret_cast<FLAC__int8*>(chunk.payload);
for (int i = 0; i < samples; i++)
pcmBuffer_[i] = (FLAC__int32)(buffer[i]);
pcmBuffer_[i] = static_cast<FLAC__int32>(buffer[i]);
}
else if (sampleFormat_.sampleSize() == 2)
{
FLAC__int16* buffer = (FLAC__int16*)chunk.payload;
auto* buffer = reinterpret_cast<FLAC__int16*>(chunk.payload);
for (int i = 0; i < samples; i++)
pcmBuffer_[i] = (FLAC__int32)(buffer[i]);
pcmBuffer_[i] = static_cast<FLAC__int32>(buffer[i]);
}
else if (sampleFormat_.sampleSize() == 4)
{
FLAC__int32* buffer = (FLAC__int32*)chunk.payload;
auto* buffer = reinterpret_cast<FLAC__int32*>(chunk.payload);
for (int i = 0; i < samples; i++)
pcmBuffer_[i] = (FLAC__int32)(buffer[i]);
pcmBuffer_[i] = buffer[i];
}
@ -124,13 +124,13 @@ FLAC__StreamEncoderWriteStatus FlacEncoder::write_callback(const FLAC__StreamEnc
// LOG(INFO, LOG_TAG) << "write_callback: " << bytes << ", " << samples << ", " << current_frame << "\n";
if ((current_frame == 0) && (bytes > 0) && (samples == 0))
{
headerChunk_->payload = (char*)realloc(headerChunk_->payload, headerChunk_->payloadSize + bytes);
headerChunk_->payload = static_cast<char*>(realloc(headerChunk_->payload, headerChunk_->payloadSize + bytes));
memcpy(headerChunk_->payload + headerChunk_->payloadSize, buffer, bytes);
headerChunk_->payloadSize += bytes;
}
else
{
flacChunk_->payload = (char*)realloc(flacChunk_->payload, flacChunk_->payloadSize + bytes);
flacChunk_->payload = static_cast<char*>(realloc(flacChunk_->payload, flacChunk_->payloadSize + bytes));
memcpy(flacChunk_->payload + flacChunk_->payloadSize, buffer, bytes);
flacChunk_->payloadSize += bytes;
encodedSamples_ += samples;
@ -143,7 +143,7 @@ namespace callback
FLAC__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder* encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples,
unsigned current_frame, void* client_data)
{
FlacEncoder* flacEncoder = (FlacEncoder*)client_data;
auto* flacEncoder = static_cast<FlacEncoder*>(client_data);
return flacEncoder->write_callback(encoder, buffer, bytes, samples, current_frame);
}
} // namespace callback
@ -164,7 +164,7 @@ void FlacEncoder::initEncoder()
throw SnapException("compression level has to be between 0 and 8");
}
FLAC__bool ok = true;
FLAC__bool ok = 1;
FLAC__StreamEncoderInitStatus init_status;
FLAC__StreamMetadata_VorbisComment_Entry entry;
@ -172,7 +172,7 @@ void FlacEncoder::initEncoder()
if ((encoder_ = FLAC__stream_encoder_new()) == nullptr)
throw SnapException("error allocating encoder");
ok &= FLAC__stream_encoder_set_verify(encoder_, true);
ok &= FLAC__stream_encoder_set_verify(encoder_, 1);
// compression levels (0-8):
// https://xiph.org/flac/api/group__flac__stream__encoder.html#gae49cf32f5256cb47eecd33779493ac85
// latency:
@ -183,22 +183,22 @@ void FlacEncoder::initEncoder()
ok &= FLAC__stream_encoder_set_bits_per_sample(encoder_, sampleFormat_.bits());
ok &= FLAC__stream_encoder_set_sample_rate(encoder_, sampleFormat_.rate());
if (!ok)
if (ok == 0)
throw SnapException("error setting up encoder");
// now add some metadata; we'll add some tags and a padding block
if ((metadata_[0] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT)) == nullptr ||
(metadata_[1] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)) == nullptr ||
// there are many tag (vorbiscomment) functions but these are convenient for this particular use:
!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "TITLE", "SnapStream") ||
!FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, false) ||
!FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "VERSION", VERSION) ||
!FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, false))
(FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "TITLE", "SnapStream") == 0) ||
(FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, 0) == 0) ||
(FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "VERSION", VERSION) == 0) ||
(FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, 0) == 0))
throw SnapException("out of memory or tag error");
metadata_[1]->length = 1234; // set the padding length
ok = FLAC__stream_encoder_set_metadata(encoder_, metadata_, 2);
if (!ok)
if (ok == 0)
throw SnapException("error setting meta data");
// initialize encoder

28
server/encoder/ogg_encoder.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -80,19 +80,19 @@ void OggEncoder::encode(const msg::PcmChunk& chunk)
{
if (sampleFormat_.sampleSize() == 1)
{
int8_t* chunkBuffer = (int8_t*)chunk.payload;
auto* chunkBuffer = reinterpret_cast<int8_t*>(chunk.payload);
for (int i = 0; i < frames; i++)
buffer[channel][i] = chunkBuffer[sampleFormat_.channels() * i + channel] / 128.f;
}
else if (sampleFormat_.sampleSize() == 2)
{
int16_t* chunkBuffer = (int16_t*)chunk.payload;
auto* chunkBuffer = reinterpret_cast<int16_t*>(chunk.payload);
for (int i = 0; i < frames; i++)
buffer[channel][i] = chunkBuffer[sampleFormat_.channels() * i + channel] / 32768.f;
}
else if (sampleFormat_.sampleSize() == 4)
{
int32_t* chunkBuffer = (int32_t*)chunk.payload;
auto* chunkBuffer = reinterpret_cast<int32_t*>(chunk.payload);
for (int i = 0; i < frames; i++)
buffer[channel][i] = chunkBuffer[sampleFormat_.channels() * i + channel] / 2147483648.f;
}
@ -113,7 +113,7 @@ void OggEncoder::encode(const msg::PcmChunk& chunk)
vorbis_analysis(&vb_, nullptr);
vorbis_bitrate_addblock(&vb_);
while (vorbis_bitrate_flushpacket(&vd_, &op_))
while (vorbis_bitrate_flushpacket(&vd_, &op_) != 0)
{
/* weld the packet into the bitstream */
ogg_stream_packetin(&os_, &op_);
@ -129,14 +129,14 @@ void OggEncoder::encode(const msg::PcmChunk& chunk)
size_t nextLen = pos + og_.header_len + og_.body_len;
// make chunk larger
if (oggChunk->payloadSize < nextLen)
oggChunk->payload = (char*)realloc(oggChunk->payload, nextLen);
oggChunk->payload = static_cast<char*>(realloc(oggChunk->payload, nextLen));
memcpy(oggChunk->payload + pos, og_.header, og_.header_len);
pos += og_.header_len;
memcpy(oggChunk->payload + pos, og_.body, og_.body_len);
pos += og_.body_len;
if (ogg_page_eos(&og_))
if (ogg_page_eos(&og_) != 0)
break;
}
}
@ -148,7 +148,7 @@ void OggEncoder::encode(const msg::PcmChunk& chunk)
// LOG(INFO, LOG_TAG) << "res: " << res << "\n";
lastGranulepos_ = os_.granulepos;
// make oggChunk smaller
oggChunk->payload = (char*)realloc(oggChunk->payload, pos);
oggChunk->payload = static_cast<char*>(realloc(oggChunk->payload, pos));
oggChunk->payloadSize = pos;
encoded_callback_(*this, oggChunk, res);
}
@ -157,13 +157,13 @@ void OggEncoder::encode(const msg::PcmChunk& chunk)
void OggEncoder::initEncoder()
{
if (codecOptions_.find(":") == string::npos)
if (codecOptions_.find(':') == string::npos)
throw SnapException("Invalid codec options: \"" + codecOptions_ + "\"");
string mode = utils::string::trim_copy(codecOptions_.substr(0, codecOptions_.find(":")));
string mode = utils::string::trim_copy(codecOptions_.substr(0, codecOptions_.find(':')));
if (mode != "VBR")
throw SnapException("Unsupported codec mode: \"" + mode + "\". Available: \"VBR\"");
throw SnapException("Unsupported codec mode: \"" + mode + R"(". Available: "VBR")");
string qual = utils::string::trim_copy(codecOptions_.substr(codecOptions_.find(":") + 1));
string qual = utils::string::trim_copy(codecOptions_.substr(codecOptions_.find(':') + 1));
double quality = 1.0;
try
{
@ -216,7 +216,7 @@ void OggEncoder::initEncoder()
mode that libVorbis does not support (eg, too low a bitrate, etc,
will return 'OV_EIMPL') */
if (ret)
if (ret != 0)
throw SnapException("failed to init encoder");
/* add a comment */
@ -262,7 +262,7 @@ void OggEncoder::initEncoder()
if (result == 0)
break;
headerChunk_->payloadSize += og_.header_len + og_.body_len;
headerChunk_->payload = (char*)realloc(headerChunk_->payload, headerChunk_->payloadSize);
headerChunk_->payload = static_cast<char*>(realloc(headerChunk_->payload, headerChunk_->payloadSize));
LOG(DEBUG, LOG_TAG) << "HeadLen: " << og_.header_len << ", bodyLen: " << og_.body_len << ", result: " << result << "\n";
memcpy(headerChunk_->payload + pos, og_.header, og_.header_len);
pos += og_.header_len;

31
server/encoder/opus_encoder.cpp
View file

@ -1,19 +1,20 @@
/***
This file is part of snapcast
Copyright (C) 2015 Hannes Ellinger
This file is part of snapcast
Copyright (C) 2015 Hannes Ellinger
Copyright (C) 2016-2021 Johannes Pohl
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 3 of the License, or
(at your option) any later version.
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 3 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.
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, see <http://www.gnu.org/licenses/>.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include "opus_encoder.hpp"
@ -157,7 +158,7 @@ void OpusEncoder::initEncoder()
// create some opus pseudo header to let the decoder know about the sample format
headerChunk_->payloadSize = 12;
headerChunk_->payload = (char*)realloc(headerChunk_->payload, headerChunk_->payloadSize);
headerChunk_->payload = static_cast<char*>(realloc(headerChunk_->payload, headerChunk_->payloadSize));
char* payload = headerChunk_->payload;
assign(payload, SWAP_32(ID_OPUS));
assign(payload + 4, SWAP_32(sampleFormat_.rate()));
@ -249,9 +250,9 @@ void OpusEncoder::encode(const SampleFormat& format, const char* data, size_t si
// copy encoded data to chunk
auto opusChunk = make_shared<msg::PcmChunk>(format, 0);
opusChunk->payloadSize = len;
opusChunk->payload = (char*)realloc(opusChunk->payload, opusChunk->payloadSize);
opusChunk->payload = static_cast<char*>(realloc(opusChunk->payload, opusChunk->payloadSize));
memcpy(opusChunk->payload, encoded_.data(), len);
encoded_callback_(*this, opusChunk, (double)samples_per_channel / sampleFormat_.msRate());
encoded_callback_(*this, opusChunk, static_cast<double>(samples_per_channel) / sampleFormat_.msRate());
}
else
{

4
server/encoder/pcm_encoder.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -58,7 +58,7 @@ void PcmEncoder::encode(const msg::PcmChunk& chunk)
void PcmEncoder::initEncoder()
{
headerChunk_->payloadSize = 44;
headerChunk_->payload = (char*)realloc(headerChunk_->payload, headerChunk_->payloadSize);
headerChunk_->payload = static_cast<char*>(realloc(headerChunk_->payload, headerChunk_->payloadSize));
char* payload = headerChunk_->payload;
assign(payload, SWAP_32(ID_RIFF));
assign(payload + 4, SWAP_32(36));

41
server/publishZeroConf/publish_avahi.cpp
View file

@ -1,20 +1,19 @@
/***
This file is part of avahi.
This file is part of snapcast
Copyright (C) 2014-2021 Johannes Pohl
avahi is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version 2.1 of the
License, or (at your option) any later version.
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 3 of the License, or
(at your option) any later version.
avahi 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 Lesser General
Public License for more details.
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 Lesser General Public
License along with avahi; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
***/
#include "publish_avahi.hpp"
@ -42,7 +41,7 @@ void PublishAvahi::publish(const std::vector<mDNSService>& services)
services_ = services;
/// Allocate main loop object
if (!(simple_poll = avahi_simple_poll_new()))
if ((simple_poll = avahi_simple_poll_new()) == nullptr)
{
/// TODO: error handling
LOG(ERROR, LOG_TAG) << "Failed to create simple poll object.\n";
@ -53,7 +52,7 @@ void PublishAvahi::publish(const std::vector<mDNSService>& services)
client_ = avahi_client_new(avahi_simple_poll_get(simple_poll), AVAHI_CLIENT_IGNORE_USER_CONFIG, client_callback, this, &error);
/// Check wether creating the client object succeeded
if (!client_)
if (client_ == nullptr)
{
LOG(ERROR, LOG_TAG) << "Failed to create client: " << avahi_strerror(error) << "\n";
}
@ -76,10 +75,10 @@ PublishAvahi::~PublishAvahi()
{
timer_.cancel();
if (client_)
if (client_ != nullptr)
avahi_client_free(client_);
if (simple_poll)
if (simple_poll != nullptr)
avahi_simple_poll_free(simple_poll);
avahi_free(name);
@ -134,9 +133,9 @@ void PublishAvahi::create_services(AvahiClient* c)
char* n;
/// If this is the first time we're called, let's create a new entry group if necessary
if (!group)
if (group == nullptr)
{
if (!(group = avahi_entry_group_new(c, entry_group_callback, this)))
if ((group = avahi_entry_group_new(c, entry_group_callback, this)) == nullptr)
{
LOG(ERROR, LOG_TAG) << "avahi_entry_group_new() failed: " << avahi_strerror(avahi_client_errno(c)) << "\n";
goto fail;
@ -145,7 +144,7 @@ void PublishAvahi::create_services(AvahiClient* c)
/// If the group is empty (either because it was just created, or because it was reset previously, add our entries.
int ret;
if (avahi_entry_group_is_empty(group))
if (avahi_entry_group_is_empty(group) != 0)
{
LOG(INFO, LOG_TAG) << "Adding service '" << name << "'\n";
@ -230,7 +229,7 @@ void PublishAvahi::client_callback(AvahiClient* c, AvahiClientState state, AVAHI
/// The server records are now being established. This might be caused by a host name change. We need to wait
/// for our own records to register until the host name is properly esatblished.
if (group)
if (group != nullptr)
avahi_entry_group_reset(group);
break;

6
server/server.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -250,7 +250,7 @@ void Server::processRequest(const jsonrpcpp::request_ptr request, jsonrpcpp::ent
group->muted = muted;
/// Update clients
for (auto client : group->clients)
for (const auto& client : group->clients)
{
session_ptr session = streamServer_->getStreamSession(client->id);
if (session != nullptr)
@ -283,7 +283,7 @@ void Server::processRequest(const jsonrpcpp::request_ptr request, jsonrpcpp::ent
group->streamId = streamId;
// Update clients
for (auto client : group->clients)
for (const auto& client : group->clients)
{
session_ptr session = streamServer_->getStreamSession(client->id);
if (session && (session->pcmStream() != stream))

4
server/snapserver.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -209,7 +209,7 @@ int main(int argc, char* argv[])
string logformat = "%Y-%m-%d %H-%M-%S.#ms [#severity] (#tag_func)";
if (settings.logging.sink.find("file:") != string::npos)
{
string logfile = settings.logging.sink.substr(settings.logging.sink.find(":") + 1);
string logfile = settings.logging.sink.substr(settings.logging.sink.find(':') + 1);
AixLog::Log::init<AixLog::SinkFile>(logfilter, logfile, logformat);
}
else if (settings.logging.sink == "stdout")

18
server/stream_server.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -75,7 +75,7 @@ void StreamServer::onMetaChanged(const PcmStream* pcmStream, std::shared_ptr<msg
// Send meta to all connected clients
std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_);
for (auto s : sessions_)
for (const auto& s : sessions_)
{
if (auto session = s.lock())
{
@ -95,12 +95,12 @@ void StreamServer::onChunkEncoded(const PcmStream* pcmStream, bool isDefaultStre
std::vector<std::shared_ptr<StreamSession>> sessions;
{
std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_);
for (auto session : sessions_)
for (const auto& session : sessions_)
if (auto s = session.lock())
sessions.push_back(s);
}
for (auto session : sessions)
for (const auto& session : sessions)
{
if (!settings_.stream.sendAudioToMutedClients)
{
@ -131,7 +131,7 @@ void StreamServer::onChunkEncoded(const PcmStream* pcmStream, bool isDefaultStre
void StreamServer::onMessageReceived(StreamSession* streamSession, const msg::BaseMessage& baseMessage, char* buffer)
{
if (messageReceiver_)
if (messageReceiver_ != nullptr)
messageReceiver_->onMessageReceived(streamSession, baseMessage, buffer);
}
@ -153,7 +153,7 @@ void StreamServer::onDisconnect(StreamSession* streamSession)
}),
sessions_.end());
LOG(DEBUG, LOG_TAG) << "sessions: " << sessions_.size() << "\n";
if (messageReceiver_)
if (messageReceiver_ != nullptr)
messageReceiver_->onDisconnect(streamSession);
cleanup();
}
@ -163,7 +163,7 @@ session_ptr StreamServer::getStreamSession(StreamSession* streamSession) const
{
std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_);
for (auto session : sessions_)
for (const auto& session : sessions_)
{
if (auto s = session.lock())
if (s.get() == streamSession)
@ -177,7 +177,7 @@ session_ptr StreamServer::getStreamSession(const std::string& clientId) const
{
// LOG(INFO, LOG_TAG) << "getStreamSession: " << mac << "\n";
std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_);
for (auto session : sessions_)
for (const auto& session : sessions_)
{
if (auto s = session.lock())
if (s->clientId == clientId)
@ -254,7 +254,7 @@ void StreamServer::stop()
std::lock_guard<std::recursive_mutex> mlock(sessionsMutex_);
cleanup();
for (auto s : sessions_)
for (const auto& s : sessions_)
{
if (auto session = s.lock())
session->stop();

4
server/stream_session_ws.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -111,7 +111,7 @@ void StreamSessionWebsocket::on_read_ws(beast::error_code ec, std::size_t bytes_
return;
}
auto data = boost::asio::buffer_cast<char*>(buffer_.data());
auto* data = boost::asio::buffer_cast<char*>(buffer_.data());
baseMessage_.deserialize(data);
LOG(DEBUG, LOG_TAG) << "getNextMessage: " << baseMessage_.type << ", size: " << baseMessage_.size << ", id: " << baseMessage_.id
<< ", refers: " << baseMessage_.refersTo << "\n";

22
server/streamreader/airplay_stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -38,7 +38,7 @@ string hex2str(string input)
using byte = unsigned char;
unsigned long x = strtoul(input.c_str(), nullptr, 16);
byte a[] = {byte(x >> 24), byte(x >> 16), byte(x >> 8), byte(x), 0};
return string((char*)a);
return string(reinterpret_cast<char*>(a));
}
} // namespace
@ -92,7 +92,7 @@ int AirplayStream::parse(string line)
{
enum XML_Status result;
if ((result = XML_Parse(parser_, line.c_str(), line.length(), false)) == XML_STATUS_ERROR)
if ((result = XML_Parse(parser_, line.c_str(), line.length(), 0)) == XML_STATUS_ERROR)
{
XML_ParserFree(parser_);
createParser();
@ -288,10 +288,10 @@ void AirplayStream::initExeAndPath(const string& filename)
throw SnapException("shairport-sync not found");
}
if (exe_.find("/") != string::npos)
if (exe_.find('/') != string::npos)
{
path_ = exe_.substr(0, exe_.find_last_of("/") + 1);
exe_ = exe_.substr(exe_.find_last_of("/") + 1);
path_ = exe_.substr(0, exe_.find_last_of('/') + 1);
exe_ = exe_.substr(exe_.find_last_of('/') + 1);
}
}
@ -317,14 +317,14 @@ void AirplayStream::onStderrMsg(const std::string& line)
#ifdef HAS_EXPAT
void XMLCALL AirplayStream::element_start(void* userdata, const char* element_name, const char** attr)
{
AirplayStream* self = (AirplayStream*)userdata;
auto* self = static_cast<AirplayStream*>(userdata);
string name(element_name);
self->buf_.assign("");
if (name == "item")
self->entry_.reset(new TageEntry);
for (int i = 0; attr[i]; i += 2)
for (int i = 0; attr[i] != nullptr; i += 2)
{
string name(attr[i]);
string value(attr[i + 1]);
@ -335,7 +335,7 @@ void XMLCALL AirplayStream::element_start(void* userdata, const char* element_na
void XMLCALL AirplayStream::element_end(void* userdata, const char* element_name)
{
AirplayStream* self = (AirplayStream*)userdata;
auto* self = static_cast<AirplayStream*>(userdata);
string name(element_name);
if (name == "code")
@ -361,8 +361,8 @@ void XMLCALL AirplayStream::element_end(void* userdata, const char* element_name
void XMLCALL AirplayStream::data(void* userdata, const char* content, int length)
{
AirplayStream* self = (AirplayStream*)userdata;
string value(content, (size_t)length);
auto* self = static_cast<AirplayStream*>(userdata);
string value(content, static_cast<size_t>(length));
self->buf_.append(value);
}

4
server/streamreader/alsa_stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -162,7 +162,7 @@ void AlsaStream::initAlsa()
void AlsaStream::uninitAlsa()
{
if (handle_)
if (handle_ != nullptr)
{
snd_pcm_close(handle_);
handle_ = nullptr;

10
server/streamreader/base64.cpp
View file

@ -33,7 +33,7 @@ static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
static inline bool is_base64(unsigned char c)
{
return (isalnum(c) || (c == '+') || (c == '/'));
return ((isalnum(c) != 0) || (c == '+') || (c == '/'));
}
std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len)
@ -44,7 +44,7 @@ std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_
unsigned char char_array_3[3];
unsigned char char_array_4[4];
while (in_len--)
while ((in_len--) != 0u)
{
char_array_3[i++] = *(bytes_to_encode++);
if (i == 3)
@ -60,7 +60,7 @@ std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_
}
}
if (i)
if (i != 0)
{
for (j = i; j < 3; j++)
char_array_3[j] = '\0';
@ -88,7 +88,7 @@ std::string base64_decode(std::string const& encoded_string)
unsigned char char_array_4[4], char_array_3[3];
std::string ret;
while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_]))
while (((in_len--) != 0) && (encoded_string[in_] != '=') && is_base64(encoded_string[in_]))
{
char_array_4[i++] = encoded_string[in_];
in_++;
@ -107,7 +107,7 @@ std::string base64_decode(std::string const& encoded_string)
}
}
if (i)
if (i != 0)
{
for (j = i; j < 4; j++)
char_array_4[j] = 0;

12
server/streamreader/librespot_stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -49,7 +49,7 @@ LibrespotStream::LibrespotStream(PcmListener* pcmListener, boost::asio::io_conte
killall_ = (uri_.getQuery("killall", "false") == "true");
if (username.empty() != password.empty())
throw SnapException("missing parameter \"username\" or \"password\" (must provide both, or neither)");
throw SnapException(R"(missing parameter "username" or "password" (must provide both, or neither))");
if (!params_.empty())
params_ += " ";
@ -90,10 +90,10 @@ void LibrespotStream::initExeAndPath(const std::string& filename)
throw SnapException("librespot not found");
}
if (exe_.find("/") != string::npos)
if (exe_.find('/') != string::npos)
{
path_ = exe_.substr(0, exe_.find_last_of("/") + 1);
exe_ = exe_.substr(exe_.find_last_of("/") + 1);
path_ = exe_.substr(0, exe_.find_last_of('/') + 1);
exe_ = exe_.substr(exe_.find_last_of('/') + 1);
}
if (killall_)
@ -149,7 +149,7 @@ void LibrespotStream::onStderrMsg(const std::string& line)
{
LOG(INFO, LOG_TAG) << "metadata: <" << m[1] << ">\n";
json jtag = {{"TITLE", (string)m[1]}};
json jtag = {{"TITLE", string(m[1])}};
setMeta(jtag);
}
}

12
server/streamreader/pcm_stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -130,7 +130,7 @@ void PcmStream::setState(ReaderState newState)
state_ = newState;
for (auto* listener : pcmListeners_)
{
if (listener)
if (listener != nullptr)
listener->onStateChanged(this, newState);
}
}
@ -154,7 +154,7 @@ void PcmStream::chunkEncoded(const encoder::Encoder& encoder, std::shared_ptr<ms
tvEncodedChunk_ += std::chrono::nanoseconds(static_cast<std::chrono::nanoseconds::rep>(duration * 1000000));
for (auto* listener : pcmListeners_)
{
if (listener)
if (listener != nullptr)
listener->onChunkEncoded(this, chunk, duration);
}
}
@ -164,7 +164,7 @@ void PcmStream::chunkRead(const msg::PcmChunk& chunk)
{
for (auto* listener : pcmListeners_)
{
if (listener)
if (listener != nullptr)
listener->onChunkRead(this, chunk);
}
encoder_->encode(chunk);
@ -175,7 +175,7 @@ void PcmStream::resync(const std::chrono::nanoseconds& duration)
{
for (auto* listener : pcmListeners_)
{
if (listener)
if (listener != nullptr)
listener->onResync(this, duration.count() / 1000000.);
}
}
@ -225,7 +225,7 @@ void PcmStream::setMeta(const json& jtag)
// Trigger a stream update
for (auto* listener : pcmListeners_)
{
if (listener)
if (listener != nullptr)
listener->onMetaChanged(this);
}
}

4
server/streamreader/pipe_stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -43,7 +43,7 @@ PipeStream::PipeStream(PcmListener* pcmListener, boost::asio::io_context& ioc, c
LOG(INFO, LOG_TAG) << "PipeStream mode: " << mode << "\n";
if ((mode != "read") && (mode != "create"))
throw SnapException("create mode for fifo must be \"read\" or \"create\"");
throw SnapException(R"(create mode for fifo must be "read" or "create")");
if (mode == "create")
{

14
server/streamreader/process_stream.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -22,8 +22,8 @@
#include "common/snap_exception.hpp"
#include "common/utils.hpp"
#include "common/utils/string_utils.hpp"
#include <climits>
#include <fcntl.h>
#include <limits.h>
#include <sys/stat.h>
@ -58,8 +58,8 @@ std::string ProcessStream::findExe(const std::string& filename) const
return filename;
std::string exe = filename;
if (exe.find("/") != string::npos)
exe = exe.substr(exe.find_last_of("/") + 1);
if (exe.find('/') != string::npos)
exe = exe.substr(exe.find_last_of('/') + 1);
/// check with "which"
string which = execGetOutput("which " + exe);
@ -85,10 +85,10 @@ void ProcessStream::initExeAndPath(const std::string& filename)
{
path_ = "";
exe_ = findExe(filename);
if (exe_.find("/") != string::npos)
if (exe_.find('/') != string::npos)
{
path_ = exe_.substr(0, exe_.find_last_of("/") + 1);
exe_ = exe_.substr(exe_.find_last_of("/") + 1);
path_ = exe_.substr(0, exe_.find_last_of('/') + 1);
exe_ = exe_.substr(exe_.find_last_of('/') + 1);
}
if (!fileExists(path_ + exe_))

4
server/streamreader/stream_manager.cpp
View file

@ -1,6 +1,6 @@
/***
This file is part of snapcast
Copyright (C) 2014-2020 Johannes Pohl
Copyright (C) 2014-2021 Johannes Pohl
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
@ -202,7 +202,7 @@ void StreamManager::stop()
json StreamManager::toJson() const
{
json result = json::array();
for (auto stream : streams_)
for (const auto& stream : streams_)
if (stream->getCodec() != "null")
result.push_back(stream->toJson());
return result;