Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2026-01-27 04:40:48 +03:00
Code Issues Packages Projects Releases Wiki Activity

try to fix misc cspot issues + silence network manager log

Browse Source
This commit is contained in:
philippe44
2022-09-12 11:54:49 -07:00
parent a8e28f9ff0
commit 922889fee2
9 changed files with 45 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
components/spotify/Shim.cpp
View File

@@ -126,9 +126,12 @@ static void cspotTask(void *pvParameters) {
case CSpotEventType::PLAY_PAUSE: { case CSpotEventType::PLAY_PAUSE: {
bool isPaused = std::get<bool>(event.data); bool isPaused = std::get<bool>(event.data);
if (isPaused) cspot.cHandler(CSPOT_PAUSE); if (isPaused) cspot.cHandler(CSPOT_PAUSE);
else cspot.cHandler(CSPOT_PLAY); else cspot.cHandler(CSPOT_PLAY, false);
break; break;
} }
case CSpotEventType::PLAYBACK_START:
cspot.cHandler(CSPOT_PLAY, (int) std::get<bool>(event.data));
break;
case CSpotEventType::LOAD: case CSpotEventType::LOAD:
cspot.cHandler(CSPOT_LOAD, std::get<int>(event.data), -1); cspot.cHandler(CSPOT_LOAD, std::get<int>(event.data), -1);
break; break;
@@ -347,7 +350,7 @@ void ShimHTTPServer::registerHandler(bell::RequestType requestType, const std::s
.user_ctx = NULL, .user_ctx = NULL,
}; };
// find athe first free spot and register handler // find the first free spot and register handler
for (int i = 0; i < sizeof(uriHandlers)/sizeof(bell::httpHandler); i++) { for (int i = 0; i < sizeof(uriHandlers)/sizeof(bell::httpHandler); i++) {
if (!uriHandlers[i]) { if (!uriHandlers[i]) {
uriHandlers[i] = handler; uriHandlers[i] = handler;

4
components/spotify/cspot/include/Player.h
View File

@@ -32,19 +32,19 @@ public:
std::function<void()> endOfFileCallback; std::function<void()> endOfFileCallback;
int volume = 255; int volume = 255;
uint32_t logVolume; uint32_t logVolume;
bool needFlush = false;
std::atomic<bool> isRunning = false; std::atomic<bool> isRunning = false;
trackChangedCallback trackChanged; trackChangedCallback trackChanged;
std::mutex runningMutex; std::mutex runningMutex;
void setVolume(uint32_t volume); void setVolume(uint32_t volume);
void handleLoad(std::shared_ptr<TrackReference> track, std::function<void()> &trackLoadedCallback, uint32_t position_ms, bool isPaused); void handleLoad(std::shared_ptr<TrackReference> track, std::function<void(bool)> &trackLoadedCallback, uint32_t position_ms, bool isPaused);
void pause(); void pause();
void cancelCurrentTrack(); void cancelCurrentTrack();
void seekMs(size_t positionMs); void seekMs(size_t positionMs);
void feedPCM(uint8_t *data, size_t len); void feedPCM(uint8_t *data, size_t len);
void play(); void play();
void stop(); void stop();
}; };
#endif #endif

9
components/spotify/cspot/src/ChunkedAudioStream.cpp
View File

@@ -5,8 +5,13 @@
static size_t vorbisReadCb(void *ptr, size_t size, size_t nmemb, ChunkedAudioStream *self) static size_t vorbisReadCb(void *ptr, size_t size, size_t nmemb, ChunkedAudioStream *self)
{ {
size_t readSize = 0; size_t readSize = 0;
while (readSize < nmemb * size && self->byteStream->position() < self->byteStream->size()) { while (readSize < nmemb * size && self->byteStream->position() < self->byteStream->size() && self->isRunning) {
readSize += self->byteStream->read((uint8_t *) ptr + readSize, (size * nmemb) - readSize); size_t bytes = self->byteStream->read((uint8_t *) ptr + readSize, (size * nmemb) - readSize);
if (bytes <= 0) {
CSPOT_LOG(info, "unexpected end/error of stream");
return readSize;
}
readSize += bytes;
} }
return readSize; return readSize;
} }

1
components/spotify/cspot/src/MercuryManager.cpp
View File

@@ -115,7 +115,6 @@ std::shared_ptr<AudioChunk> MercuryManager::fetchAudioChunk(std::vector<uint8_t>
this->session->shanConn->sendPacket(static_cast<uint8_t>(MercuryType::AUDIO_CHUNK_REQUEST_COMMAND), buffer); this->session->shanConn->sendPacket(static_cast<uint8_t>(MercuryType::AUDIO_CHUNK_REQUEST_COMMAND), buffer);
// Used for broken connection detection // Used for broken connection detection
CSPOT_LOG(info, "requesting Chunk %hu", this->audioChunkSequence - 1);
this->lastRequestTimestamp = this->timeProvider->getSyncedTimestamp(); this->lastRequestTimestamp = this->timeProvider->getSyncedTimestamp();
return this->audioChunkManager->registerNewChunk(this->audioChunkSequence - 1, audioKey, startPos, endPos); return this->audioChunkManager->registerNewChunk(this->audioChunkSequence - 1, audioKey, startPos, endPos);
} }

9
components/spotify/cspot/src/Player.cpp
View File

@@ -114,7 +114,7 @@ void Player::runTask()
} }
else else
{ {
usleep(10000); usleep(20000);
} }
} }
@@ -147,7 +147,7 @@ void Player::cancelCurrentTrack()
} }
} }
void Player::handleLoad(std::shared_ptr<TrackReference> trackReference, std::function<void()>& trackLoadedCallback, uint32_t position_ms, bool isPaused) void Player::handleLoad(std::shared_ptr<TrackReference> trackReference, std::function<void(bool)>& trackLoadedCallback, uint32_t position_ms, bool isPaused)
{ {
std::lock_guard<std::mutex> guard(loadTrackMutex); std::lock_guard<std::mutex> guard(loadTrackMutex);
@@ -166,7 +166,9 @@ void Player::handleLoad(std::shared_ptr<TrackReference> trackReference, std::fun
this->nextTrack->trackInfoReceived = this->trackChanged; this->nextTrack->trackInfoReceived = this->trackChanged;
this->nextTrack->loadedTrackCallback = [this, framesCallback, trackLoadedCallback]() { this->nextTrack->loadedTrackCallback = [this, framesCallback, trackLoadedCallback]() {
trackLoadedCallback(); bool needFlush = currentTrack != nullptr && currentTrack->audioStream != nullptr && currentTrack->audioStream->isRunning;
cancelCurrentTrack();
trackLoadedCallback(needFlush);
this->nextTrackMutex.lock(); this->nextTrackMutex.lock();
this->nextTrack->audioStream->streamFinishedCallback = this->endOfFileCallback; this->nextTrack->audioStream->streamFinishedCallback = this->endOfFileCallback;
@@ -175,7 +177,6 @@ void Player::handleLoad(std::shared_ptr<TrackReference> trackReference, std::fun
this->nextTrack->loaded = true; this->nextTrack->loaded = true;
this->nextTrackMutex.unlock(); this->nextTrackMutex.unlock();
cancelCurrentTrack();
}; };
this->nextTrackMutex.unlock(); this->nextTrackMutex.unlock();
} }

4
components/spotify/cspot/src/SpircController.cpp
View File

@@ -190,10 +190,10 @@ void SpircController::handleFrame(std::vector<uint8_t> &data) {
void SpircController::loadTrack(uint32_t position_ms, bool isPaused) { void SpircController::loadTrack(uint32_t position_ms, bool isPaused) {
sendEvent(CSpotEventType::LOAD, (int) position_ms); sendEvent(CSpotEventType::LOAD, (int) position_ms);
state->setPlaybackState(PlaybackState::Loading); state->setPlaybackState(PlaybackState::Loading);
std::function<void()> loadedLambda = [=]() { std::function<void(bool)> loadedLambda = [=](bool needFlush) {
// Loading finished, notify that playback started // Loading finished, notify that playback started
setPause(isPaused, false); setPause(isPaused, false);
sendEvent(CSpotEventType::PLAYBACK_START); sendEvent(CSpotEventType::PLAYBACK_START, needFlush);
}; };
player->handleLoad(state->getCurrentTrack(), loadedLambda, position_ms, player->handleLoad(state->getCurrentTrack(), loadedLambda, position_ms,

2
components/spotify/cspot/src/SpotifyTrack.cpp
View File

@@ -106,7 +106,7 @@ void SpotifyTrack::trackInformationCallback(std::unique_ptr<MercuryResponse> res
altIndex++; altIndex++;
CSPOT_LOG(info, "Trying alternative %d", altIndex); CSPOT_LOG(info, "Trying alternative %d", altIndex);
if(altIndex > trackInfo.alternative_count) { if(altIndex >= trackInfo.alternative_count) {
// no alternatives for song // no alternatives for song
return; return;
} }

37
components/squeezelite/decode_external.c
View File

@@ -47,7 +47,7 @@ static EXT_RAM_ATTR struct {
} raop_sync; } raop_sync;
#endif #endif
static bool abort_sink ; static enum { SINK_RUNNING, SINK_ABORT, SINK_DISCARD } sink_state;
#define LOCK_O mutex_lock(outputbuf->mutex) #define LOCK_O mutex_lock(outputbuf->mutex)
#define UNLOCK_O mutex_unlock(outputbuf->mutex) #define UNLOCK_O mutex_unlock(outputbuf->mutex)
@@ -77,10 +77,10 @@ static void sink_data_handler(const uint8_t *data, uint32_t len)
} }
LOCK_O; LOCK_O;
abort_sink = false; if (sink_state == SINK_ABORT) sink_state = SINK_RUNNING;
// there will always be room at some point // there will always be room at some point
while (len && wait && !abort_sink) { while (len && wait && sink_state == SINK_RUNNING) {
bytes = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)) / (BYTES_PER_FRAME / 4); bytes = min(_buf_space(outputbuf), _buf_cont_write(outputbuf)) / (BYTES_PER_FRAME / 4);
bytes = min(len, bytes); bytes = min(len, bytes);
#if BYTES_PER_FRAME == 4 #if BYTES_PER_FRAME == 4
@@ -95,7 +95,7 @@ static void sink_data_handler(const uint8_t *data, uint32_t len)
#endif #endif
_buf_inc_writep(outputbuf, bytes * BYTES_PER_FRAME / 4); _buf_inc_writep(outputbuf, bytes * BYTES_PER_FRAME / 4);
space = _buf_space(outputbuf); space = _buf_space(outputbuf);
len -= bytes; len -= bytes;
data += bytes; data += bytes;
@@ -156,7 +156,7 @@ static bool bt_sink_cmd_handler(bt_sink_cmd_t cmd, va_list args)
_buf_flush(outputbuf); _buf_flush(outputbuf);
output.state = OUTPUT_STOPPED; output.state = OUTPUT_STOPPED;
output.stop_time = gettime_ms(); output.stop_time = gettime_ms();
abort_sink = true; sink_state = SINK_ABORT;
LOG_INFO("BT stop"); LOG_INFO("BT stop");
break; break;
case BT_SINK_PAUSE: case BT_SINK_PAUSE:
@@ -295,7 +295,7 @@ static bool raop_sink_cmd_handler(raop_event_t event, va_list args)
_buf_flush(outputbuf); _buf_flush(outputbuf);
raop_state = event; raop_state = event;
if (output.state > OUTPUT_STOPPED) output.state = OUTPUT_STOPPED; if (output.state > OUTPUT_STOPPED) output.state = OUTPUT_STOPPED;
abort_sink = true; sink_state = SINK_ABORT;
output.frames_played = 0; output.frames_played = 0;
output.stop_time = gettime_ms(); output.stop_time = gettime_ms();
break; break;
@@ -357,35 +357,42 @@ static bool cspot_cmd_handler(cspot_event_t cmd, va_list args)
break; break;
case CSPOT_DISC: case CSPOT_DISC:
_buf_flush(outputbuf); _buf_flush(outputbuf);
abort_sink = true; sink_state = SINK_ABORT;
output.external = 0; output.external = 0;
output.state = OUTPUT_STOPPED; output.state = OUTPUT_STOPPED;
output.stop_time = gettime_ms(); output.stop_time = gettime_ms();
LOG_INFO("CSpot disconnected"); LOG_INFO("CSpot disconnected");
break; break;
case CSPOT_TRACK: case CSPOT_TRACK:
_buf_flush(outputbuf);
abort_sink = true;
LOG_INFO("CSpot sink new track rate %d", output.next_sample_rate); LOG_INFO("CSpot sink new track rate %d", output.next_sample_rate);
break; break;
case CSPOT_PLAY: case CSPOT_PLAY: {
int flush = va_arg(args, int);
if (flush) {
_buf_flush(outputbuf);
sink_state = SINK_ABORT;
} else {
sink_state = SINK_RUNNING;
}
output.state = OUTPUT_RUNNING; output.state = OUTPUT_RUNNING;
LOG_INFO("CSpot play"); LOG_INFO("CSpot play");
break; break;
}
case CSPOT_SEEK: case CSPOT_SEEK:
//TODO: can it be merged with flush (shall we stop)
_buf_flush(outputbuf); _buf_flush(outputbuf);
abort_sink = true; sink_state = SINK_ABORT;
LOG_INFO("CSpot seek by %d", va_arg(args, int)); LOG_INFO("CSpot seek by %d", va_arg(args, int));
break; break;
case CSPOT_FLUSH: case CSPOT_FLUSH:
_buf_flush(outputbuf); _buf_flush(outputbuf);
abort_sink = true; sink_state = SINK_DISCARD;
__attribute__ ((fallthrough)); output.state = OUTPUT_STOPPED;
LOG_INFO("CSpot flush");
break;
case CSPOT_PAUSE: case CSPOT_PAUSE:
output.state = OUTPUT_STOPPED; output.state = OUTPUT_STOPPED;
output.stop_time = gettime_ms(); output.stop_time = gettime_ms();
LOG_INFO("CSpot pause/flush"); LOG_INFO("CSpot pause");
break; break;
case CSPOT_VOLUME: { case CSPOT_VOLUME: {
u32_t volume = va_arg(args, u32_t); u32_t volume = va_arg(args, u32_t);

2
components/wifi-manager/network_manager.c
View File

@@ -294,7 +294,7 @@ void network_start() {
} }
static void event_logger(uint32_t state_machine, uint32_t state, uint32_t event) { static void event_logger(uint32_t state_machine, uint32_t state, uint32_t event) {
ESP_LOGI(TAG, "Handling network manager event state Id %d->[%s]", state, event_to_string(event)); ESP_LOGD(TAG, "Handling network manager event state Id %d->[%s]", state, event_to_string(event));
} }
static const char * get_state_machine_result_string(state_machine_result_t result) { static const char * get_state_machine_result_string(state_machine_result_t result) {
switch(result) { switch(result) {