Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-06 19:47:02 +03:00
Code Issues Packages Projects Releases Wiki Activity

new cspot/bell

Browse Source
This commit is contained in:
philippe44
2023-05-06 23:50:26 +02:00
parent e0e7e718ba
commit 8bad480112
163 changed files with 6611 additions and 6739 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
components/spotify/CMakeLists.txt
View File

@@ -17,6 +17,7 @@ set(BELL_DISABLE_SINKS ON)
set(BELL_DISABLE_FMT ON)
set(BELL_DISABLE_REGEX ON)
set(BELL_ONLY_CJSON ON)
set(BELL_DISABLE_MQTT ON)
set(CSPOT_TARGET_ESP32 ON)
# because CMake is so broken, the cache set below overrides a normal "set" for the first build

131
components/spotify/Shim.cpp
View File

@@ -34,78 +34,6 @@
static class cspotPlayer *player;
/****************************************************************************************
* Chunk manager class (task)
*/
class chunkManager : public bell::Task {
public:
std::atomic<bool> isRunning = true;
std::atomic<bool> isPaused = true;
chunkManager(std::function<void()> trackHandler, std::function<void(const uint8_t*, size_t)> dataHandler);
size_t writePCM(uint8_t* data, size_t bytes, std::string_view trackId, size_t sequence);
void flush();
void teardown();
private:
std::unique_ptr<bell::CentralAudioBuffer> centralAudioBuffer;
std::function<void()> trackHandler;
std::function<void(const uint8_t*, size_t)> dataHandler;
std::mutex runningMutex;
void runTask() override;
};
chunkManager::chunkManager(std::function<void()> trackHandler, std::function<void(const uint8_t*, size_t)> dataHandler)
: bell::Task("chunker", 4 * 1024, 0, 0) {
this->centralAudioBuffer = std::make_unique<bell::CentralAudioBuffer>(32);
this->trackHandler = trackHandler;
this->dataHandler = dataHandler;
startTask();
}
size_t chunkManager::writePCM(uint8_t* data, size_t bytes, std::string_view trackId, size_t sequence) {
return centralAudioBuffer->writePCM(data, bytes, sequence);
}
void chunkManager::teardown() {
isRunning = false;
std::scoped_lock lock(runningMutex);
}
void chunkManager::flush() {
centralAudioBuffer->clearBuffer();
}
void chunkManager::runTask() {
std::scoped_lock lock(runningMutex);
size_t lastHash = 0;
while (isRunning) {
if (isPaused) {
BELL_SLEEP_MS(100);
continue;
}
auto chunk = centralAudioBuffer->readChunk();
if (!chunk || chunk->pcmSize == 0) {
BELL_SLEEP_MS(50);
continue;
}
// receiving first chunk of new track from Spotify server
if (lastHash != chunk->trackHash) {
CSPOT_LOG(info, "hash update %x => %x", lastHash, chunk->trackHash);
lastHash = chunk->trackHash;
trackHandler();
}
dataHandler(chunk->pcmData, chunk->pcmSize);
}
}
/****************************************************************************************
* Player's main class & task
*/
@@ -114,19 +42,21 @@ class cspotPlayer : public bell::Task {
private:
std::string name;
bell::WrappedSemaphore clientConnected;
std::atomic<bool> isPaused, isConnected;
int startOffset, volume = 0, bitrate = 160;
httpd_handle_t serverHandle;
int serverPort;
cspot_cmd_cb_t cmdHandler;
cspot_data_cb_t dataHandler;
std::string lastTrackId;
std::shared_ptr<cspot::LoginBlob> blob;
std::unique_ptr<cspot::SpircHandler> spirc;
std::unique_ptr<chunkManager> chunker;
void eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event);
void trackHandler(void);
size_t pcmWrite(uint8_t *pcm, size_t bytes, std::string_view trackId);
void runTask();
@@ -155,6 +85,17 @@ cspotPlayer::cspotPlayer(const char* name, httpd_handle_t server, int port, cspo
if (bitrate != 96 && bitrate != 160 && bitrate != 320) bitrate = 160;
}
size_t cspotPlayer::pcmWrite(uint8_t *pcm, size_t bytes, std::string_view trackId) {
if (lastTrackId != trackId) {
CSPOT_LOG(info, "new track started <%s> => <%s>", lastTrackId.c_str(), trackId.data());
lastTrackId = trackId;
trackHandler();
}
dataHandler(pcm, bytes);
return bytes;
}
extern "C" {
static esp_err_t handleGET(httpd_req_t *request) {
return player->handleGET(request);
@@ -233,8 +174,7 @@ esp_err_t cspotPlayer::handlePOST(httpd_req_t *request) {
void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event) {
switch (event->eventType) {
case cspot::SpircHandler::EventType::PLAYBACK_START: {
chunker->flush();
lastTrackId.clear();
// we are not playing anymore
trackStatus = TRACK_INIT;
// memorize position for when track's beginning will be detected
@@ -247,13 +187,12 @@ void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event
break;
}
case cspot::SpircHandler::EventType::PLAY_PAUSE: {
bool pause = std::get<bool>(event->data);
cmdHandler(pause ? CSPOT_PAUSE : CSPOT_PLAY);
chunker->isPaused = pause;
isPaused = std::get<bool>(event->data);
cmdHandler(isPaused ? CSPOT_PAUSE : CSPOT_PLAY);
break;
}
case cspot::SpircHandler::EventType::TRACK_INFO: {
auto trackInfo = std::get<cspot::CDNTrackStream::TrackInfo>(event->data);
auto trackInfo = std::get<cspot::TrackInfo>(event->data);
cmdHandler(CSPOT_TRACK_INFO, trackInfo.duration, startOffset, trackInfo.artist.c_str(),
trackInfo.album.c_str(), trackInfo.name.c_str(), trackInfo.imageUrl.c_str());
spirc->updatePositionMs(startOffset);
@@ -264,17 +203,14 @@ void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event
case cspot::SpircHandler::EventType::PREV:
case cspot::SpircHandler::EventType::FLUSH: {
// FLUSH is sent when there is no next, just clean everything
chunker->flush();
cmdHandler(CSPOT_FLUSH);
break;
}
case cspot::SpircHandler::EventType::DISC:
chunker->flush();
cmdHandler(CSPOT_DISC);
chunker->teardown();
isConnected = false;
break;
case cspot::SpircHandler::EventType::SEEK: {
chunker->flush();
cmdHandler(CSPOT_SEEK, std::get<int>(event->data));
break;
}
@@ -293,10 +229,9 @@ void cspotPlayer::eventHandler(std::unique_ptr<cspot::SpircHandler::Event> event
void cspotPlayer::trackHandler(void) {
// this is just informative
auto trackInfo = spirc->getTrackPlayer()->getCurrentTrackInfo();
uint32_t remains;
cmdHandler(CSPOT_QUERY_REMAINING, &remains);
CSPOT_LOG(info, "next track <%s> will play in %d ms", trackInfo.name.c_str(), remains);
CSPOT_LOG(info, "next track will play in %d ms", remains);
// inform sink of track beginning
trackStatus = TRACK_NOTIFY;
@@ -317,7 +252,8 @@ void cspotPlayer::command(cspot_event_t event) {
break;
// setPause comes back through cspot::event with PLAY/PAUSE
case CSPOT_TOGGLE:
spirc->setPause(!chunker->isPaused);
isPaused = !isPaused;
spirc->setPause(isPaused);
break;
case CSPOT_STOP:
case CSPOT_PAUSE:
@@ -326,12 +262,11 @@ void cspotPlayer::command(cspot_event_t event) {
case CSPOT_PLAY:
spirc->setPause(false);
break;
// calling spirc->disconnect() might have been logical but it does not
// generate any cspot::event, so we need to manually force exiting player
// loop through chunker which will eventually do the disconnect
/* Calling spirc->disconnect() might have been logical but it does not
* generate any cspot::event */
case CSPOT_DISC:
cmdHandler(CSPOT_DISC);
chunker->teardown();
isConnected = false;
break;
// spirc->setRemoteVolume does not generate a cspot::event so call cmdHandler
case CSPOT_VOLUME_UP:
@@ -391,20 +326,12 @@ void cspotPlayer::runTask() {
// Auth successful
if (token.size() > 0) {
spirc = std::make_unique<cspot::SpircHandler>(ctx);
// Create a player, pass the track handler
chunker = std::make_unique<chunkManager>(
[this](void) {
return trackHandler();
},
[this](const uint8_t* data, size_t bytes) {
return dataHandler(data, bytes);
});
isConnected = true;
// set call back to calculate a hash on trackId
spirc->getTrackPlayer()->setDataCallback(
[this](uint8_t* data, size_t bytes, std::string_view trackId, size_t sequence) {
return chunker->writePCM(data, bytes, trackId, sequence);
[this](uint8_t* data, size_t bytes, std::string_view trackId) {
return pcmWrite(data, bytes, trackId);
});
// set event (PLAY, VOLUME...) handler
@@ -420,7 +347,7 @@ void cspotPlayer::runTask() {
cmdHandler(CSPOT_VOLUME, volume);
// exit when player has stopped (received a DISC)
while (chunker->isRunning) {
while (isConnected) {
ctx->session->handlePacket();
// low-accuracy polling events

1
components/spotify/cspot/bell/.clangd
View File

@@ -1,2 +1,3 @@
CompileFlags:
CompilationDatabase: example/build # Search build/ directory for compile_commands.json

37
components/spotify/cspot/bell/CMakeLists.txt
View File

@@ -7,6 +7,7 @@ project(bell)
option(BELL_DISABLE_CODECS "Disable the entire audio codec wrapper" OFF)
option(BELL_CODEC_AAC "Support libhelix-aac codec" ON)
option(BELL_CODEC_MP3 "Support libhelix-mp3 codec" ON)
option(BELL_DISABLE_MQTT "Disable the built-in MQTT wrapper" OFF)
option(BELL_CODEC_VORBIS "Support tremor Vorbis codec" ON)
option(BELL_CODEC_ALAC "Support Apple ALAC codec" ON)
option(BELL_CODEC_OPUS "Support Opus codec" ON)
@@ -63,13 +64,14 @@ endif()
message(STATUS " Use cJSON only: ${BELL_ONLY_CJSON}")
message(STATUS " Disable Fmt: ${BELL_DISABLE_FMT}")
message(STATUS " Disable Mqtt: ${BELL_DISABLE_MQTT}")
message(STATUS " Disable Regex: ${BELL_DISABLE_REGEX}")
# Include nanoPB library
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/external/nanopb/extra")
find_package(Nanopb REQUIRED)
message(${NANOPB_INCLUDE_DIRS})
list(APPEND EXTRA_INCLUDES ${NANOPB_INCLUDE_DIRS})
list(APPEND EXTERNAL_INCLUDES ${NANOPB_INCLUDE_DIRS})
# CMake options
set(CMAKE_CXX_STANDARD 20)
@@ -84,7 +86,7 @@ set(IO_DIR "${CMAKE_CURRENT_SOURCE_DIR}/main/io")
set(PLATFORM_DIR "${CMAKE_CURRENT_SOURCE_DIR}/main/platform")
set(UTILITIES_DIR "${CMAKE_CURRENT_SOURCE_DIR}/main/utilities")
add_definitions("-DUSE_DEFAULT_STDLIB=1")
add_definitions("-DUSE_DEFAULT_STDLIB=1 -DTARGET_OS_IPHONE=0")
# Main library sources
file(GLOB SOURCES
@@ -111,7 +113,7 @@ endif()
if(APPLE)
file(GLOB APPLE_PLATFORM_SOURCES "main/platform/apple/*.cpp" "main/platform/apple/*.c")
list(APPEND SOURCES ${APPLE_PLATFORM_SOURCES})
list(APPEND EXTRA_INCLUDES "/usr/local/opt/mbedtls@3/include")
list(APPEND EXTERNAL_INCLUDES "/usr/local/opt/mbedtls@3/include")
endif()
if(UNIX AND NOT APPLE)
@@ -122,7 +124,7 @@ endif()
if(WIN32)
file(GLOB WIN32_PLATFORM_SOURCES "main/platform/win32/*.cpp" "main/platform/win32/*.c")
list(APPEND SOURCES ${WIN32_PLATFORM_SOURCES})
list(APPEND EXTRA_INCLUDES "main/platform/win32")
list(APPEND EXTERNAL_INCLUDES "main/platform/win32")
endif()
# A hack to make Opus keep quiet
@@ -139,7 +141,7 @@ if(ESP_PLATFORM)
else()
find_package(Threads REQUIRED)
find_package(MbedTLS REQUIRED)
list(APPEND EXTRA_INCLUDES ${MBEDTLS_INCLUDE_DIRS})
list(APPEND EXTERNAL_INCLUDES ${MBEDTLS_INCLUDE_DIRS})
set(THREADS_PREFER_PTHREAD_FLAG ON)
list(APPEND EXTRA_LIBS ${MBEDTLS_LIBRARIES} Threads::Threads)
@@ -149,6 +151,14 @@ else()
endif()
endif()
if (NOT BELL_DISABLE_MQTT)
file(GLOB MQTT_SOURCES "external/mqtt/*.c")
list(APPEND SOURCES ${MQTT_SOURCES})
list(APPEND EXTRA_INCLUDES "external/mqtt/include")
else()
list(REMOVE_ITEM SOURCES "${IO_DIR}/BellMQTTClient.cpp")
endif()
if(NOT BELL_DISABLE_CODECS)
file(GLOB EXTRA_SOURCES "main/audio-containers/*.cpp" "main/audio-codec/*.cpp" "main/audio-codec/*.c" "main/audio-dsp/*.cpp" "main/audio-dsp/*.c")
@@ -162,7 +172,7 @@ if(NOT BELL_DISABLE_CODECS)
if(BELL_CODEC_AAC)
file(GLOB LIBHELIX_AAC_SOURCES "external/libhelix-aac/*.c")
list(APPEND LIBHELIX_SOURCES ${LIBHELIX_AAC_SOURCES})
list(APPEND EXTRA_INCLUDES "external/libhelix-aac")
list(APPEND EXTERNAL_INCLUDES "external/libhelix-aac")
list(APPEND SOURCES "${AUDIO_CODEC_DIR}/AACDecoder.cpp")
list(APPEND CODEC_FLAGS "-DBELL_CODEC_AAC")
endif()
@@ -171,7 +181,7 @@ if(NOT BELL_DISABLE_CODECS)
if(BELL_CODEC_MP3)
file(GLOB LIBHELIX_MP3_SOURCES "external/libhelix-mp3/*.c")
list(APPEND LIBHELIX_SOURCES ${LIBHELIX_MP3_SOURCES})
list(APPEND EXTRA_INCLUDES "external/libhelix-mp3")
list(APPEND EXTERNAL_INCLUDES "external/libhelix-mp3")
list(APPEND SOURCES "${AUDIO_CODEC_DIR}/MP3Decoder.cpp")
list(APPEND CODEC_FLAGS "-DBELL_CODEC_MP3")
endif()
@@ -230,7 +240,7 @@ else()
file(GLOB TREMOR_SOURCES "external/tremor/*.c")
list(REMOVE_ITEM TREMOR_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/external/tremor/ivorbisfile_example.c")
list(APPEND SOURCES ${TREMOR_SOURCES})
list(APPEND EXTRA_INCLUDES "external/tremor")
list(APPEND EXTERNAL_INCLUDES "external/tremor")
endif()
if(NOT BELL_DISABLE_SINKS)
@@ -247,7 +257,7 @@ if(NOT BELL_DISABLE_SINKS)
# Find ALSA if required, else remove the sink
if(BELL_SINK_ALSA)
find_package(ALSA REQUIRED)
list(APPEND EXTRA_INCLUDES ${ALSA_INCLUDE_DIRS})
list(APPEND EXTERNAL_INCLUDES ${ALSA_INCLUDE_DIRS})
list(APPEND EXTRA_LIBS ${ALSA_LIBRARIES})
else()
list(REMOVE_ITEM SINK_SOURCES "${AUDIO_SINKS_DIR}/unix/ALSAAudioSink.cpp")
@@ -256,7 +266,7 @@ if(NOT BELL_DISABLE_SINKS)
# Find PortAudio if required, else remove the sink
if(BELL_SINK_PORTAUDIO)
find_package(Portaudio REQUIRED)
list(APPEND EXTRA_INCLUDES ${PORTAUDIO_INCLUDE_DIRS})
list(APPEND EXTERNAL_INCLUDES ${PORTAUDIO_INCLUDE_DIRS})
list(APPEND EXTRA_LIBS ${PORTAUDIO_LIBRARIES})
else()
list(REMOVE_ITEM SINK_SOURCES "${AUDIO_SINKS_DIR}/unix/PortAudioSink.cpp")
@@ -274,16 +284,16 @@ if(BELL_EXTERNAL_CJSON)
list(APPEND EXTRA_LIBS ${BELL_EXTERNAL_CJSON})
else()
list(APPEND SOURCES "external/cJSON/cJSON.c")
list(APPEND EXTRA_INCLUDES "external/cJSON")
list(APPEND EXTERNAL_INCLUDES "external/cJSON")
endif()
if (NOT BELL_DISABLE_FMT)
list(APPEND EXTRA_INCLUDES "external/fmt/include")
list(APPEND EXTERNAL_INCLUDES "external/fmt/include")
endif()
if(WIN32 OR UNIX)
list(APPEND SOURCES "external/mdnssvc/mdns.c" "external/mdnssvc/mdnsd.c")
list(APPEND EXTRA_INCLUDES "external/mdnssvc")
list(APPEND EXTERNAL_INCLUDES "external/mdnssvc")
endif()
# file(GLOB CIVET_SRC "external/civetweb/*.c" "external/civetweb/*.inl" "external/civetweb/*.cpp")
@@ -305,6 +315,7 @@ endif()
# PUBLIC to propagate esp-idf includes to bell dependents
target_link_libraries(bell PUBLIC ${EXTRA_LIBS})
target_include_directories(bell PUBLIC ${EXTRA_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(bell SYSTEM PUBLIC ${EXTERNAL_INCLUDES})
target_compile_definitions(bell PUBLIC PB_ENABLE_MALLOC FMT_HEADER_ONLY)
if(BELL_DISABLE_CODECS)

2
components/spotify/cspot/bell/example/CMakeLists.txt
View File

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.18)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_BUILD_TYPE Debug)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES})
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../ ${CMAKE_CURRENT_BINARY_DIR}/bell)
file(GLOB SOURCES "*.cpp")

31
components/spotify/cspot/bell/example/main.cpp
View File

@@ -1,26 +1,14 @@
#include <memory.h>
#include <atomic>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <memory>
#include <vector>
#include "AudioCodecs.h"
#include "AudioContainers.h"
#include "BellHTTPServer.h"
#include "BellTar.h"
#include <string>
#include <type_traits>
#include "BellTask.h"
#include "CentralAudioBuffer.h"
#include "Compressor.h"
#include "DecoderGlobals.h"
#include "EncodedAudioStream.h"
#include "HTTPClient.h"
#include "PortAudioSink.h"
#define DEBUG_LEVEL 4
#include "X509Bundle.h"
#include "mbedtls/debug.h"
#include "StreamInfo.h"
#define DEBUG_LEVEL 4
#include <BellDSP.h>
#include <BellLogger.h>
@@ -58,13 +46,8 @@ class AudioPlayer : bell::Task {
int main() {
bell::setDefaultLogger();
std::fstream file("system.tar", std::ios::in | std::ios::binary);
if (!file.is_open()) {
std::cout << "file not open" << std::endl;
return 1;
}
BellTar::reader reader(file);
reader.extract_all_files("./dupa2");
BELL_LOG(info, "cock", "Published?");
return 0;
}

9
components/spotify/cspot/bell/main/audio-codec/AACDecoder.cpp
View File

@@ -1,5 +1,12 @@
#include "AACDecoder.h"
#include <iostream>
#include <stdlib.h> // for free, malloc
#include "CodecType.h" // for bell
namespace bell {
class AudioContainer;
} // namespace bell
using namespace bell;

24
components/spotify/cspot/bell/main/audio-codec/AudioCodecs.cpp
View File

@@ -1,27 +1,37 @@
#include "AudioCodecs.h"
#include <cstring>
#include <iostream>
#include <map>
#include <map> // for map, operator!=, map<>::iterator, map<>:...
#include <type_traits> // for remove_extent_t
#include "AudioContainer.h" // for AudioContainer
namespace bell {
class BaseCodec;
} // namespace bell
using namespace bell;
#ifdef BELL_CODEC_AAC
#include "AACDecoder.h"
#include "AACDecoder.h" // for AACDecoder
static std::shared_ptr<AACDecoder> codecAac;
#endif
#ifdef BELL_CODEC_MP3
#include "MP3Decoder.h"
#include "MP3Decoder.h" // for MP3Decoder
static std::shared_ptr<MP3Decoder> codecMp3;
#endif
#ifdef BELL_CODEC_VORBIS
#include "VorbisDecoder.h"
#include "VorbisDecoder.h" // for VorbisDecoder
static std::shared_ptr<VorbisDecoder> codecVorbis;
#endif
#ifdef BELL_CODEC_OPUS
#include "OPUSDecoder.h"
#include "OPUSDecoder.h" // for OPUSDecoder
static std::shared_ptr<OPUSDecoder> codecOpus;
#endif

4
components/spotify/cspot/bell/main/audio-codec/BaseCodec.cpp
View File

@@ -1,5 +1,7 @@
#include "BaseCodec.h"
#include <iostream>
#include "AudioContainer.h" // for AudioContainer
#include "CodecType.h" // for bell
using namespace bell;

3
components/spotify/cspot/bell/main/audio-codec/DecoderGlobals.cpp
View File

@@ -2,7 +2,6 @@
bell::DecodersInstance* bell::decodersInstance;
void bell::createDecoders()
{
void bell::createDecoders() {
bell::decodersInstance = new bell::DecodersInstance();
}

8
components/spotify/cspot/bell/main/audio-codec/MP3Decoder.cpp
View File

@@ -1,5 +1,13 @@
#include "MP3Decoder.h"
#include <stdlib.h> // for free, malloc
#include "CodecType.h" // for bell
namespace bell {
class AudioContainer;
} // namespace bell
using namespace bell;
MP3Decoder::MP3Decoder() {

6
components/spotify/cspot/bell/main/audio-codec/OPUSDecoder.cpp
View File

@@ -1,5 +1,9 @@
#include "OPUSDecoder.h"
#include "opus.h"
#include <stdlib.h> // for free, malloc
#include "CodecType.h" // for bell
#include "opus.h" // for opus_decoder_destroy, opus_decode, opus_decod...
using namespace bell;

10
components/spotify/cspot/bell/main/audio-codec/VorbisDecoder.cpp
View File

@@ -1,5 +1,13 @@
#include "VorbisDecoder.h"
#include "AudioCodecs.h"
#include <stdlib.h> // for free, malloc
#include "CodecType.h" // for bell
#include "config_types.h" // for ogg_int16_t
namespace bell {
class AudioContainer;
} // namespace bell
using namespace bell;

7
components/spotify/cspot/bell/main/audio-codec/include/AACDecoder.h
View File

@@ -1,9 +1,12 @@
#pragma once
#include "BaseCodec.h"
#include "aacdec.h"
#include <stdint.h> // for uint8_t, uint32_t, int16_t
#include "BaseCodec.h" // for BaseCodec
#include "aacdec.h" // for AACFrameInfo, HAACDecoder
namespace bell {
class AudioContainer;
class AACDecoder : public BaseCodec {
private:

9
components/spotify/cspot/bell/main/audio-codec/include/AudioCodecs.h
View File

@@ -1,11 +1,12 @@
#pragma once
#include <memory>
#include "BaseCodec.h"
#include "AudioContainer.h"
#include <memory> // for shared_ptr
#include "AudioContainer.h" // for AudioContainer
#include "BaseCodec.h" // for BaseCodec
#include "CodecType.h" // for AudioCodec
namespace bell {
class AudioCodecs {
public:
static std::shared_ptr<BaseCodec> getCodec(AudioCodec type);

3
components/spotify/cspot/bell/main/audio-codec/include/BaseCodec.h
View File

@@ -1,8 +1,9 @@
#pragma once
#include "AudioContainer.h"
#include <stdint.h> // for uint32_t, uint8_t
namespace bell {
class AudioContainer;
class BaseCodec {
private:

32
components/spotify/cspot/bell/main/audio-codec/include/DecoderGlobals.h
View File

@@ -5,20 +5,16 @@
#define AAC_READBUF_SIZE (4 * AAC_MAINBUF_SIZE * AAC_MAX_NCHANS)
#define MP3_READBUF_SIZE (2 * 1024);
#include <stdio.h>
#include <stdlib.h>
#include <memory>
#include "aacdec.h"
#include "mp3dec.h"
#include <stdio.h> // for NULL
namespace bell
{
class DecodersInstance
{
#include "aacdec.h" // for AACFreeDecoder, AACInitDecoder, HAACDecoder
#include "mp3dec.h" // for MP3FreeDecoder, MP3InitDecoder, HMP3Decoder
namespace bell {
class DecodersInstance {
public:
DecodersInstance(){};
~DecodersInstance()
{
~DecodersInstance() {
MP3FreeDecoder(mp3Decoder);
AACFreeDecoder(aacDecoder);
};
@@ -26,18 +22,14 @@ namespace bell
HAACDecoder aacDecoder = NULL;
HMP3Decoder mp3Decoder = NULL;
void ensureAAC()
{
if (aacDecoder == NULL)
{
void ensureAAC() {
if (aacDecoder == NULL) {
aacDecoder = AACInitDecoder();
}
}
void ensureMP3()
{
if (mp3Decoder == NULL)
{
void ensureMP3() {
if (mp3Decoder == NULL) {
mp3Decoder = MP3InitDecoder();
}
}
@@ -46,7 +38,7 @@ namespace bell
extern bell::DecodersInstance* decodersInstance;
void createDecoders();
}
} // namespace bell
#endif
#endif

8
components/spotify/cspot/bell/main/audio-codec/include/MP3Decoder.h
View File

@@ -1,9 +1,13 @@
#pragma once
#include "BaseCodec.h"
#include "mp3dec.h"
#include <stdint.h> // for uint8_t, uint32_t, int16_t
#include "BaseCodec.h" // for BaseCodec
#include "mp3dec.h" // for HMP3Decoder, MP3FrameInfo
namespace bell {
class AudioContainer;
class MP3Decoder : public BaseCodec {
private:
HMP3Decoder mp3;

4
components/spotify/cspot/bell/main/audio-codec/include/OPUSDecoder.h
View File

@@ -1,6 +1,8 @@
#pragma once
#include "BaseCodec.h"
#include <stdint.h> // for uint8_t, uint32_t, int16_t
#include "BaseCodec.h" // for BaseCodec
struct OpusDecoder;

9
components/spotify/cspot/bell/main/audio-codec/include/VorbisDecoder.h
View File

@@ -1,9 +1,14 @@
#pragma once
#include "BaseCodec.h"
#include "ivorbiscodec.h"
#include <stdint.h> // for uint8_t, uint32_t, int16_t
#include "BaseCodec.h" // for BaseCodec
#include "ivorbiscodec.h" // for vorbis_comment, vorbis_dsp_state, vorbis_info
#include "ogg.h" // for ogg_packet
namespace bell {
class AudioContainer;
class VorbisDecoder : public BaseCodec {
private:
vorbis_info* vi = nullptr;

7
components/spotify/cspot/bell/main/audio-containers/AACContainer.cpp
View File

@@ -1,5 +1,10 @@
#include "AACContainer.h"
#include "iostream"
#include <cstring> // for memmove
#include "StreamInfo.h" // for BitWidth, BitWidth::BW_16, SampleRate, Sampl...
#include "aacdec.h" // for AACFindSyncWord
using namespace bell;
#define SYNC_WORLD_LEN 4

14
components/spotify/cspot/bell/main/audio-containers/AudioContainers.cpp
View File

@@ -1,5 +1,16 @@
#include "AudioContainers.h"
#include <string.h> // for memcmp
#include <cstddef> // for byte
#include "AACContainer.h" // for AACContainer
#include "CodecType.h" // for bell
#include "MP3Container.h" // for MP3Container
namespace bell {
class AudioContainer;
} // namespace bell
using namespace bell;
std::unique_ptr<bell::AudioContainer> AudioContainers::guessAudioContainer(
@@ -7,8 +18,7 @@ std::unique_ptr<bell::AudioContainer> AudioContainers::guessAudioContainer(
std::byte tmp[14];
istr.read((char*)tmp, sizeof(tmp));
if (memcmp(tmp, "\xFF\xF1", 2) == 0 ||
memcmp(tmp, "\xFF\xF9", 2) == 0) {
if (memcmp(tmp, "\xFF\xF1", 2) == 0 || memcmp(tmp, "\xFF\xF9", 2) == 0) {
// AAC found
std::cout << "AAC" << std::endl;
return std::make_unique<bell::AACContainer>(istr);

5
components/spotify/cspot/bell/main/audio-containers/MP3Container.cpp
View File

@@ -1,5 +1,10 @@
#include "MP3Container.h"
#include <cstring> // for memmove
#include "StreamInfo.h" // for BitWidth, BitWidth::BW_16, SampleRate, Sampl...
#include "mp3dec.h" // for MP3FindSyncWord
using namespace bell;
MP3Container::MP3Container(std::istream& istr) : bell::AudioContainer(istr) {}

12
components/spotify/cspot/bell/main/audio-containers/include/AACContainer.h
View File

@@ -1,10 +1,12 @@
#pragma once
#include <cstring>
#include <cstddef>
#include <vector>
#include "AudioContainer.h"
#include "aacdec.h"
#include <stdint.h> // for uint32_t
#include <cstddef> // for byte, size_t
#include <istream> // for istream
#include <vector> // for vector
#include "AudioContainer.h" // for AudioContainer
#include "CodecType.h" // for AudioCodec, AudioCodec::AAC
namespace bell {
class AACContainer : public AudioContainer {

2
components/spotify/cspot/bell/main/audio-containers/include/AudioContainer.h
View File

@@ -1,8 +1,8 @@
#pragma once
#include <cstddef>
#include <istream>
#include <cstring>
#include <istream>
#include "CodecType.h"
#include "StreamInfo.h"

11
components/spotify/cspot/bell/main/audio-containers/include/AudioContainers.h
View File

@@ -1,10 +1,11 @@
#pragma once
#include <iostream>
#include <memory>
#include "AACContainer.h"
#include "AudioContainer.h"
#include "MP3Container.h"
#include <iostream> // for istream
#include <memory> // for unique_ptr
namespace bell {
class AudioContainer;
} // namespace bell
namespace bell::AudioContainers {
std::unique_ptr<bell::AudioContainer> guessAudioContainer(std::istream& istr);

12
components/spotify/cspot/bell/main/audio-containers/include/MP3Container.h
View File

@@ -1,10 +1,12 @@
#pragma once
#include <cstring>
#include <cstddef>
#include <vector>
#include "AudioContainer.h"
#include "mp3dec.h"
#include <stdint.h> // for uint32_t
#include <cstddef> // for byte, size_t
#include <istream> // for istream
#include <vector> // for vector
#include "AudioContainer.h" // for AudioContainer
#include "CodecType.h" // for AudioCodec, AudioCodec::MP3
namespace bell {
class MP3Container : public AudioContainer {

17
components/spotify/cspot/bell/main/audio-dsp/AudioMixer.cpp
View File

@@ -1,14 +1,17 @@
#include "AudioMixer.h"
#include <mutex> // for scoped_lock
using namespace bell;
AudioMixer::AudioMixer() {
}
AudioMixer::AudioMixer() {}
std::unique_ptr<StreamInfo> AudioMixer::process(std::unique_ptr<StreamInfo> info) {
std::unique_ptr<StreamInfo> AudioMixer::process(
std::unique_ptr<StreamInfo> info) {
std::scoped_lock lock(this->accessMutex);
if (info->numChannels != from) {
throw std::runtime_error("AudioMixer: Input channel count does not match configuration");
throw std::runtime_error(
"AudioMixer: Input channel count does not match configuration");
}
info->numChannels = to;
@@ -19,7 +22,8 @@ std::unique_ptr<StreamInfo> AudioMixer::process(std::unique_ptr<StreamInfo> info
}
// Copy channel
for (int i = 0; i < info->numSamples; i++) {
info->data[singleConf.destination][i] = info->data[singleConf.source[0]][i];
info->data[singleConf.destination][i] =
info->data[singleConf.source[0]][i];
}
} else {
// Mix channels
@@ -30,7 +34,8 @@ std::unique_ptr<StreamInfo> AudioMixer::process(std::unique_ptr<StreamInfo> info
sample += info->data[source][i];
}
info->data[singleConf.destination][i] = sample / (float) singleConf.source.size();
info->data[singleConf.destination][i] =
sample / (float)singleConf.source.size();
}
}
}

12
components/spotify/cspot/bell/main/audio-dsp/AudioPipeline.cpp
View File

@@ -1,6 +1,11 @@
#include "AudioPipeline.h"
#include <iostream>
#include "BellLogger.h"
#include <type_traits> // for remove_extent_t
#include <utility> // for move
#include "AudioTransform.h" // for AudioTransform
#include "BellLogger.h" // for AbstractLogger, BELL_LOG
#include "TransformConfig.h" // for TransformConfig
using namespace bell;
@@ -37,7 +42,8 @@ void AudioPipeline::volumeUpdated(int volume) {
BELL_LOG(debug, "AudioPipeline", "Volume applied, DSP reconfigured");
}
std::unique_ptr<StreamInfo> AudioPipeline::process(std::unique_ptr<StreamInfo> data) {
std::unique_ptr<StreamInfo> AudioPipeline::process(
std::unique_ptr<StreamInfo> data) {
std::scoped_lock lock(this->accessMutex);
for (auto& transform : transforms) {
data = transform->process(std::move(data));

8
components/spotify/cspot/bell/main/audio-dsp/BellDSP.cpp
View File

@@ -1,6 +1,10 @@
#include "BellDSP.h"
#include <iostream>
#include "CentralAudioBuffer.h"
#include <type_traits> // for remove_extent_t
#include <utility> // for move
#include "AudioPipeline.h" // for CentralAudioBuffer
#include "CentralAudioBuffer.h" // for CentralAudioBuffer
using namespace bell;

103
components/spotify/cspot/bell/main/audio-dsp/Biquad.cpp
View File

@@ -1,25 +1,23 @@
#include "Biquad.h"
#include <cmath> // for pow, cosf, sinf, M_PI, sqrtf, tanf, logf, sinh
using namespace bell;
Biquad::Biquad()
{
Biquad::Biquad() {
this->filterType = "biquad";
}
void Biquad::sampleRateChanged(uint32_t sampleRate)
{
void Biquad::sampleRateChanged(uint32_t sampleRate) {
this->sampleRate = sampleRate;
//this->configure(this->type, this->currentConfig);
}
void Biquad::configure(Type type, std::map<std::string, float> &newConf)
{
void Biquad::configure(Type type, std::map<std::string, float>& newConf) {
this->type = type;
this->currentConfig = newConf;
switch (type)
{
switch (type) {
case Type::Free:
coeffs[0] = newConf["a1"];
coeffs[1] = newConf["a2"];
@@ -41,12 +39,10 @@ void Biquad::configure(Type type, std::map<std::string, float> &newConf)
break;
case Type::Highshelf:
// check if config has slope key
if (newConf.find("slope") != newConf.end())
{
highShelfCoEffsSlope(newConf["freq"], newConf["gain"], newConf["slope"]);
}
else
{
if (newConf.find("slope") != newConf.end()) {
highShelfCoEffsSlope(newConf["freq"], newConf["gain"],
newConf["slope"]);
} else {
highShelfCoEffs(newConf["freq"], newConf["gain"], newConf["q"]);
}
break;
@@ -55,12 +51,9 @@ void Biquad::configure(Type type, std::map<std::string, float> &newConf)
break;
case Type::Lowshelf:
// check if config has slope key
if (newConf.find("slope") != newConf.end())
{
if (newConf.find("slope") != newConf.end()) {
lowShelfCoEffsSlope(newConf["freq"], newConf["gain"], newConf["slope"]);
}
else
{
} else {
lowShelfCoEffs(newConf["freq"], newConf["gain"], newConf["q"]);
}
break;
@@ -69,42 +62,32 @@ void Biquad::configure(Type type, std::map<std::string, float> &newConf)
break;
case Type::Peaking:
// check if config has bandwidth key
if (newConf.find("bandwidth") != newConf.end())
{
peakCoEffsBandwidth(newConf["freq"], newConf["gain"], newConf["bandwidth"]);
}
else
{
if (newConf.find("bandwidth") != newConf.end()) {
peakCoEffsBandwidth(newConf["freq"], newConf["gain"],
newConf["bandwidth"]);
} else {
peakCoEffs(newConf["freq"], newConf["gain"], newConf["q"]);
}
break;
case Type::Notch:
if (newConf.find("bandwidth") != newConf.end())
{
notchCoEffsBandwidth(newConf["freq"], newConf["gain"], newConf["bandwidth"]);
}
else
{
if (newConf.find("bandwidth") != newConf.end()) {
notchCoEffsBandwidth(newConf["freq"], newConf["gain"],
newConf["bandwidth"]);
} else {
notchCoEffs(newConf["freq"], newConf["gain"], newConf["q"]);
}
break;
case Type::Bandpass:
if (newConf.find("bandwidth") != newConf.end())
{
if (newConf.find("bandwidth") != newConf.end()) {
bandPassCoEffsBandwidth(newConf["freq"], newConf["bandwidth"]);
}
else
{
} else {
bandPassCoEffs(newConf["freq"], newConf["q"]);
}
break;
case Type::Allpass:
if (newConf.find("bandwidth") != newConf.end())
{
if (newConf.find("bandwidth") != newConf.end()) {
allPassCoEffsBandwidth(newConf["freq"], newConf["bandwidth"]);
}
else
{
} else {
allPassCoEffs(newConf["freq"], newConf["q"]);
}
break;
@@ -115,8 +98,7 @@ void Biquad::configure(Type type, std::map<std::string, float> &newConf)
}
// coefficients for a high pass biquad filter
void Biquad::highPassCoEffs(float f, float q)
{
void Biquad::highPassCoEffs(float f, float q) {
float w0 = 2 * M_PI * f / this->sampleRate;
float c = cosf(w0);
float s = sinf(w0);
@@ -133,8 +115,7 @@ void Biquad::highPassCoEffs(float f, float q)
}
// coefficients for a high pass first order biquad filter
void Biquad::highPassFOCoEffs(float f)
{
void Biquad::highPassFOCoEffs(float f) {
float w0 = 2 * M_PI * f / this->sampleRate;
float k = tanf(w0 / 2.0);
@@ -151,8 +132,7 @@ void Biquad::highPassFOCoEffs(float f)
}
// coefficients for a low pass biquad filter
void Biquad::lowPassCoEffs(float f, float q)
{
void Biquad::lowPassCoEffs(float f, float q) {
float w0 = 2 * M_PI * f / this->sampleRate;
float c = cosf(w0);
float s = sinf(w0);
@@ -169,8 +149,7 @@ void Biquad::lowPassCoEffs(float f, float q)
}
// coefficients for a low pass first order biquad filter
void Biquad::lowPassFOCoEffs(float f)
{
void Biquad::lowPassFOCoEffs(float f) {
float w0 = 2 * M_PI * f / this->sampleRate;
float k = tanf(w0 / 2.0);
@@ -187,8 +166,7 @@ void Biquad::lowPassFOCoEffs(float f)
}
// coefficients for a peak biquad filter
void Biquad::peakCoEffs(float f, float gain, float q)
{
void Biquad::peakCoEffs(float f, float gain, float q) {
float w0 = 2 * M_PI * f / this->sampleRate;
float c = cosf(w0);
float s = sinf(w0);
@@ -204,8 +182,7 @@ void Biquad::peakCoEffs(float f, float gain, float q)
this->normalizeCoEffs(a0, a1, a2, b0, b1, b2);
}
void Biquad::peakCoEffsBandwidth(float f, float gain, float bandwidth)
{
void Biquad::peakCoEffsBandwidth(float f, float gain, float bandwidth) {
float w0 = 2 * M_PI * f / this->sampleRate;
float c = cosf(w0);
float s = sinf(w0);
@@ -222,8 +199,7 @@ void Biquad::peakCoEffsBandwidth(float f, float gain, float bandwidth)
this->normalizeCoEffs(a0, a1, a2, b0, b1, b2);
}
void Biquad::highShelfCoEffs(float f, float gain, float q)
{
void Biquad::highShelfCoEffs(float f, float gain, float q) {
float A = std::pow(10.0f, gain / 40.0f);
float w0 = 2 * M_PI * f / this->sampleRate;
float c = cosf(w0);
@@ -239,8 +215,7 @@ void Biquad::highShelfCoEffs(float f, float gain, float q)
this->normalizeCoEffs(a0, a1, a2, b0, b1, b2);
}
void Biquad::highShelfCoEffsSlope(float f, float gain, float slope)
{
void Biquad::highShelfCoEffsSlope(float f, float gain, float slope) {
float A = std::pow(10.0f, gain / 40.0f);
float w0 = 2 * M_PI * f / this->sampleRate;
float c = cosf(w0);
@@ -257,8 +232,7 @@ void Biquad::highShelfCoEffsSlope(float f, float gain, float slope)
this->normalizeCoEffs(a0, a1, a2, b0, b1, b2);
}
void Biquad::highShelfFOCoEffs(float f, float gain)
{
void Biquad::highShelfFOCoEffs(float f, float gain) {
float A = std::pow(10.0f, gain / 40.0f);
float w0 = 2 * M_PI * f / this->sampleRate;
float tn = tanf(w0 / 2.0);
@@ -433,8 +407,8 @@ void Biquad::allPassFOCoEffs(float f) {
this->normalizeCoEffs(a0, a1, a2, b0, b1, b2);
}
void Biquad::normalizeCoEffs(float a0, float a1, float a2, float b0, float b1, float b2)
{
void Biquad::normalizeCoEffs(float a0, float a1, float a2, float b0, float b1,
float b2) {
coeffs[0] = b0 / a0;
coeffs[1] = b1 / a0;
coeffs[2] = b2 / a0;
@@ -442,8 +416,8 @@ void Biquad::normalizeCoEffs(float a0, float a1, float a2, float b0, float b1, f
coeffs[4] = a2 / a0;
}
std::unique_ptr<StreamInfo> Biquad::process(std::unique_ptr<StreamInfo> stream)
{
std::unique_ptr<StreamInfo> Biquad::process(
std::unique_ptr<StreamInfo> stream) {
std::scoped_lock lock(accessMutex);
auto input = stream->data[this->channel];
@@ -453,8 +427,7 @@ std::unique_ptr<StreamInfo> Biquad::process(std::unique_ptr<StreamInfo> stream)
dsps_biquad_f32_ae32(input, input, numSamples, coeffs, w);
#else
// Apply the set coefficients
for (int i = 0; i < numSamples; i++)
{
for (int i = 0; i < numSamples; i++) {
float d0 = input[i] - coeffs[3] * w[0] - coeffs[4] * w[1];
input[i] = coeffs[0] * d0 + coeffs[1] * w[0] + coeffs[2] * w[1];
w[1] = w[0];

70
components/spotify/cspot/bell/main/audio-dsp/BiquadCombo.cpp
View File

@@ -1,31 +1,28 @@
#include "BiquadCombo.h"
#include <stdio.h> // for printf
#include <cmath> // for sinf, M_PI
#include <utility> // for move
using namespace bell;
BiquadCombo::BiquadCombo()
{
}
BiquadCombo::BiquadCombo() {}
void BiquadCombo::sampleRateChanged(uint32_t sampleRate)
{
for (auto &biquad : biquads)
{
void BiquadCombo::sampleRateChanged(uint32_t sampleRate) {
for (auto& biquad : biquads) {
biquad->sampleRateChanged(sampleRate);
}
}
std::vector<float> BiquadCombo::calculateBWQ(int order)
{
std::vector<float> BiquadCombo::calculateBWQ(int order) {
std::vector<float> qValues;
for (int n = 0; n < order / 2; n++)
{
for (int n = 0; n < order / 2; n++) {
float q = 1.0f / (2.0f * sinf(M_PI / order * (((float)n) + 0.5)));
qValues.push_back(q);
}
if (order % 2 > 0)
{
if (order % 2 > 0) {
qValues.push_back(-1.0);
}
@@ -34,37 +31,28 @@ std::vector<float> BiquadCombo::calculateBWQ(int order)
return qValues;
}
std::vector<float> BiquadCombo::calculateLRQ(int order)
{
std::vector<float> BiquadCombo::calculateLRQ(int order) {
auto qValues = calculateBWQ(order / 2);
if (order % 4 > 0)
{
if (order % 4 > 0) {
qValues.pop_back();
qValues.insert(qValues.end(), qValues.begin(), qValues.end());
qValues.push_back(0.5);
}
else
{
} else {
qValues.insert(qValues.end(), qValues.begin(), qValues.end());
}
return qValues;
}
void BiquadCombo::butterworth(float freq, int order, FilterType type)
{
void BiquadCombo::butterworth(float freq, int order, FilterType type) {
std::vector<float> qValues = calculateBWQ(order);
for (auto &q : qValues)
{
}
for (auto& q : qValues) {}
}
void BiquadCombo::linkwitzRiley(float freq, int order, FilterType type)
{
void BiquadCombo::linkwitzRiley(float freq, int order, FilterType type) {
std::vector<float> qValues = calculateLRQ(order);
for (auto &q : qValues)
{
for (auto& q : qValues) {
auto filter = std::make_unique<Biquad>();
filter->channel = channel;
@@ -72,25 +60,16 @@ void BiquadCombo::linkwitzRiley(float freq, int order, FilterType type)
config["freq"] = freq;
config["q"] = q;
if (q >= 0.0)
{
if (type == FilterType::Highpass)
{
if (q >= 0.0) {
if (type == FilterType::Highpass) {
filter->configure(Biquad::Type::Highpass, config);
}
else
{
} else {
filter->configure(Biquad::Type::Lowpass, config);
}
}
else
{
if (type == FilterType::Highpass)
{
} else {
if (type == FilterType::Highpass) {
filter->configure(Biquad::Type::HighpassFO, config);
}
else
{
} else {
filter->configure(Biquad::Type::LowpassFO, config);
}
}
@@ -99,7 +78,8 @@ void BiquadCombo::linkwitzRiley(float freq, int order, FilterType type)
}
}
std::unique_ptr<StreamInfo> BiquadCombo::process(std::unique_ptr<StreamInfo> data) {
std::unique_ptr<StreamInfo> BiquadCombo::process(
std::unique_ptr<StreamInfo> data) {
std::scoped_lock lock(this->accessMutex);
for (auto& transform : this->biquads) {
data = transform->process(std::move(data));

2
components/spotify/cspot/bell/main/audio-dsp/Compressor.cpp
View File

@@ -1,5 +1,7 @@
#include "Compressor.h"
#include <cstdlib> // for abs
using namespace bell;
float log2f_approx(float X) {

18
components/spotify/cspot/bell/main/audio-dsp/Gain.cpp
View File

@@ -1,28 +1,26 @@
#include "Gain.h"
#include <cmath> // for pow
#include <string> // for string
using namespace bell;
Gain::Gain() : AudioTransform()
{
Gain::Gain() : AudioTransform() {
this->gainFactor = 1.0f;
this->filterType = "gain";
}
void Gain::configure(std::vector<int> channels, float gainDB)
{
void Gain::configure(std::vector<int> channels, float gainDB) {
this->channels = channels;
this->gainDb = gainDB;
this->gainFactor = std::pow(10.0f, gainDB / 20.0f);
}
std::unique_ptr<StreamInfo> Gain::process(std::unique_ptr<StreamInfo> data)
{
std::unique_ptr<StreamInfo> Gain::process(std::unique_ptr<StreamInfo> data) {
std::scoped_lock lock(this->accessMutex);
for (int i = 0; i < data->numSamples; i++)
{
for (int i = 0; i < data->numSamples; i++) {
// Apply gain to all channels
for (auto &channel : channels)
{
for (auto& channel : channels) {
data->data[channel][i] *= gainFactor;
}
}

65
components/spotify/cspot/bell/main/audio-dsp/include/AudioMixer.h
View File

@@ -1,23 +1,22 @@
#pragma once
#include <vector>
#include <algorithm>
#include <cJSON.h>
#include <cJSON.h> // for cJSON_GetObjectItem, cJSON, cJSON_IsArray
#include <stddef.h> // for NULL
#include <algorithm> // for find
#include <cstdint> // for uint8_t
#include <memory> // for unique_ptr
#include <stdexcept> // for invalid_argument
#include <vector> // for vector
#include "AudioTransform.h"
#include "AudioTransform.h" // for AudioTransform
#include "StreamInfo.h" // for StreamInfo
namespace bell
{
class AudioMixer : public bell::AudioTransform
{
namespace bell {
class AudioMixer : public bell::AudioTransform {
public:
enum DownmixMode
{
DEFAULT
};
enum DownmixMode { DEFAULT };
struct MixerConfig
{
struct MixerConfig {
std::vector<int> source;
int destination;
};
@@ -33,50 +32,42 @@ namespace bell
// Configuration of each channels in the mixer
std::vector<MixerConfig> mixerConfig;
std::unique_ptr<StreamInfo> process(std::unique_ptr<StreamInfo> data) override;
std::unique_ptr<StreamInfo> process(
std::unique_ptr<StreamInfo> data) override;
void reconfigure() override
{
}
void reconfigure() override {}
void fromJSON(cJSON *json)
{
void fromJSON(cJSON* json) {
cJSON* mappedChannels = cJSON_GetObjectItem(json, "mapped_channels");
if (mappedChannels == NULL || !cJSON_IsArray(mappedChannels))
{
if (mappedChannels == NULL || !cJSON_IsArray(mappedChannels)) {
throw std::invalid_argument("Mixer configuration invalid");
}
this->mixerConfig = std::vector<MixerConfig>();
cJSON* iterator = NULL;
cJSON_ArrayForEach(iterator, mappedChannels)
{
cJSON_ArrayForEach(iterator, mappedChannels) {
std::vector<int> sources(0);
cJSON* iteratorNested = NULL;
cJSON_ArrayForEach(iteratorNested, cJSON_GetObjectItem(iterator, "source"))
{
cJSON_ArrayForEach(iteratorNested,
cJSON_GetObjectItem(iterator, "source")) {
sources.push_back(iteratorNested->valueint);
}
int destination = cJSON_GetObjectItem(iterator, "destination")->valueint;
this->mixerConfig.push_back(MixerConfig{
.source = sources,
.destination = destination
});
this->mixerConfig.push_back(
MixerConfig{.source = sources, .destination = destination});
}
std::vector<uint8_t> sources(0);
for (auto &config : mixerConfig)
{
for (auto& config : mixerConfig) {
for (auto &source : config.source)
{
if (std::find(sources.begin(), sources.end(), source) == sources.end())
{
for (auto& source : config.source) {
if (std::find(sources.begin(), sources.end(), source) ==
sources.end()) {
sources.push_back(source);
}
}
@@ -86,4 +77,4 @@ namespace bell
this->to = mixerConfig.size();
}
};
}
} // namespace bell

19
components/spotify/cspot/bell/main/audio-dsp/include/AudioPipeline.h
View File

@@ -1,15 +1,16 @@
#pragma once
#include "AudioTransform.h"
#include "StreamInfo.h"
#include <memory>
#include "Gain.h"
#include <mutex>
#include <memory> // for shared_ptr, unique_ptr
#include <mutex> // for mutex
#include <vector> // for vector
namespace bell
{
class AudioPipeline
{
#include "StreamInfo.h" // for StreamInfo
namespace bell {
class AudioTransform;
class Gain;
class AudioPipeline {
private:
std::shared_ptr<Gain> headroomGainTransform;

13
components/spotify/cspot/bell/main/audio-dsp/include/AudioTransform.h
View File

@@ -1,20 +1,19 @@
#pragma once
#include <memory>
#include <thread>
#include <mutex>
#include <thread>
#include "StreamInfo.h"
#include "TransformConfig.h"
namespace bell
{
class AudioTransform
{
namespace bell {
class AudioTransform {
protected:
std::mutex accessMutex;
public:
virtual std::unique_ptr<StreamInfo> process(std::unique_ptr<StreamInfo> data) = 0;
virtual std::unique_ptr<StreamInfo> process(
std::unique_ptr<StreamInfo> data) = 0;
virtual void sampleRateChanged(uint32_t sampleRate){};
virtual float calculateHeadroom() { return 0; };
@@ -26,4 +25,4 @@ namespace bell
AudioTransform() = default;
virtual ~AudioTransform() = default;
};
};
}; // namespace bell

28
components/spotify/cspot/bell/main/audio-dsp/include/BellDSP.h
View File

@@ -1,12 +1,18 @@
#pragma once
#include <memory>
#include <mutex>
#include <vector>
#include "AudioPipeline.h"
#include "CentralAudioBuffer.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint8_t
#include <functional> // for function
#include <memory> // for shared_ptr, unique_ptr
#include <mutex> // for mutex
#include <vector> // for vector
#include "StreamInfo.h" // for BitWidth
namespace bell {
class AudioPipeline;
class CentralAudioBuffer;
#define MAX_INT16 32767
class BellDSP {
@@ -19,15 +25,18 @@ class BellDSP {
AudioEffect() = default;
~AudioEffect() = default;
size_t duration;
virtual void apply(float* sampleData, size_t samples, size_t relativePosition) = 0;
virtual void apply(float* sampleData, size_t samples,
size_t relativePosition) = 0;
};
class FadeEffect : public AudioEffect {
private:
std::function<void()> onFinish;
bool isFadeIn;
public:
FadeEffect(size_t duration, bool isFadeIn, std::function<void()> onFinish = nullptr);
FadeEffect(size_t duration, bool isFadeIn,
std::function<void()> onFinish = nullptr);
~FadeEffect(){};
void apply(float* sampleData, size_t samples, size_t relativePosition);
@@ -38,8 +47,8 @@ class BellDSP {
std::shared_ptr<AudioPipeline> getActivePipeline();
size_t process(uint8_t* data, size_t bytes, int channels,
uint32_t sampleRate, BitWidth bitWidth);
size_t process(uint8_t* data, size_t bytes, int channels, uint32_t sampleRate,
BitWidth bitWidth);
private:
std::shared_ptr<AudioPipeline> activePipeline;
@@ -48,7 +57,6 @@ class BellDSP {
std::vector<float> dataLeft = std::vector<float>(1024);
std::vector<float> dataRight = std::vector<float>(1024);
std::unique_ptr<AudioEffect> underflowEffect = nullptr;
std::unique_ptr<AudioEffect> startEffect = nullptr;
std::unique_ptr<AudioEffect> instantEffect = nullptr;

58
components/spotify/cspot/bell/main/audio-dsp/include/Biquad.h
View File

@@ -1,23 +1,29 @@
#pragma once
#include <cmath>
#include <mutex>
#include <map>
#include <unordered_map>
#include <stdint.h> // for uint32_t
#include <map> // for map
#include <memory> // for unique_ptr, allocator
#include <mutex> // for scoped_lock
#include <stdexcept> // for invalid_argument
#include <string> // for string, operator<, hash, operator==
#include <unordered_map> // for operator!=, unordered_map, __hash_map_c...
#include <utility> // for pair
#include <vector> // for vector
#include "AudioTransform.h"
extern "C" int dsps_biquad_f32_ae32(const float *input, float *output, int len, float *coef, float *w);
#include "AudioTransform.h" // for AudioTransform
#include "StreamInfo.h" // for StreamInfo
#include "TransformConfig.h" // for TransformConfig
namespace bell
{
class Biquad : public bell::AudioTransform
{
extern "C" int dsps_biquad_f32_ae32(const float* input, float* output, int len,
float* coef, float* w);
namespace bell {
class Biquad : public bell::AudioTransform {
public:
Biquad();
~Biquad(){};
enum class Type
{
enum class Type {
Free,
Highpass,
Lowpass,
@@ -58,14 +64,14 @@ namespace bell
int channel;
Biquad::Type type;
std::unique_ptr<StreamInfo> process(std::unique_ptr<StreamInfo> data) override;
std::unique_ptr<StreamInfo> process(
std::unique_ptr<StreamInfo> data) override;
void configure(Type type, std::map<std::string, float>& config);
void sampleRateChanged(uint32_t sampleRate) override;
void reconfigure() override
{
void reconfigure() override {
std::scoped_lock lock(this->accessMutex);
std::map<std::string, float> biquadConfig;
this->channel = config->getChannels()[0];
@@ -80,11 +86,8 @@ namespace bell
float q = config->getFloat("q", false, invalid);
if (currentConfig["bandwidth"] == bandwidth &&
currentConfig["slope"] == slope &&
currentConfig["gain"] == gain &&
currentConfig["frequency"] == frequency &&
currentConfig["q"] == q)
{
currentConfig["slope"] == slope && currentConfig["gain"] == gain &&
currentConfig["frequency"] == frequency && currentConfig["q"] == q) {
return;
}
@@ -99,8 +102,7 @@ namespace bell
if (q != invalid)
biquadConfig["q"] = q;
if (type == "free")
{
if (type == "free") {
biquadConfig["a1"] = config->getFloat("a1");
biquadConfig["a2"] = config->getFloat("a2");
biquadConfig["b0"] = config->getFloat("b0");
@@ -109,12 +111,9 @@ namespace bell
}
auto typeElement = strMapType.find(type);
if (typeElement != strMapType.end())
{
if (typeElement != strMapType.end()) {
this->configure(typeElement->second, biquadConfig);
}
else
{
} else {
throw std::invalid_argument("No biquad of type " + type);
}
}
@@ -152,7 +151,8 @@ namespace bell
void allPassCoEffsBandwidth(float f, float bandwidth);
void allPassFOCoEffs(float f);
void normalizeCoEffs(float a0, float a1, float a2, float b0, float b1, float b2);
void normalizeCoEffs(float a0, float a1, float a2, float b0, float b1,
float b2);
};
}
} // namespace bell

66
components/spotify/cspot/bell/main/audio-dsp/include/BiquadCombo.h
View File

@@ -1,18 +1,20 @@
#pragma once
#include <vector>
#include <memory>
#include <cmath>
#include <mutex>
#include <map>
#include <stdint.h> // for uint32_t
#include <map> // for map
#include <memory> // for unique_ptr, allocator
#include <mutex> // for scoped_lock
#include <stdexcept> // for invalid_argument
#include <string> // for string, operator==, char_traits, basic_...
#include <vector> // for vector
#include "Biquad.h"
#include "AudioTransform.h"
#include "AudioTransform.h" // for AudioTransform
#include "Biquad.h" // for Biquad
#include "StreamInfo.h" // for StreamInfo
#include "TransformConfig.h" // for TransformConfig
namespace bell
{
class BiquadCombo : public bell::AudioTransform
{
namespace bell {
class BiquadCombo : public bell::AudioTransform {
private:
std::vector<std::unique_ptr<bell::Biquad>> biquads;
@@ -25,32 +27,25 @@ namespace bell
~BiquadCombo(){};
int channel;
std::map<std::string, float> paramCache = {
{"order", 0.0f},
{"frequency", 0.0f}
};
std::map<std::string, float> paramCache = {{"order", 0.0f},
{"frequency", 0.0f}};
enum class FilterType
{
Highpass,
Lowpass
};
enum class FilterType { Highpass, Lowpass };
void linkwitzRiley(float freq, int order, FilterType type);
void butterworth(float freq, int order, FilterType type);
std::unique_ptr<StreamInfo> process(std::unique_ptr<StreamInfo> data) override;
std::unique_ptr<StreamInfo> process(
std::unique_ptr<StreamInfo> data) override;
void sampleRateChanged(uint32_t sampleRate) override;
void reconfigure() override
{
void reconfigure() override {
std::scoped_lock lock(this->accessMutex);
float freq = config->getFloat("frequency");
int order = config->getInt("order");
if (paramCache["frequency"] == freq && paramCache["order"] == order)
{
if (paramCache["frequency"] == freq && paramCache["order"] == order) {
return;
} else {
paramCache["frequency"] = freq;
@@ -60,26 +55,17 @@ namespace bell
this->channel = config->getChannels()[0];
this->biquads = std::vector<std::unique_ptr<bell::Biquad>>();
auto type = config->getString("combo_type");
if (type == "lr_lowpass")
{
if (type == "lr_lowpass") {
this->linkwitzRiley(freq, order, FilterType::Lowpass);
}
else if (type == "lr_highpass")
{
} else if (type == "lr_highpass") {
this->linkwitzRiley(freq, order, FilterType::Highpass);
}
else if (type == "bw_highpass")
{
} else if (type == "bw_highpass") {
this->butterworth(freq, order, FilterType::Highpass);
}
else if (type == "bw_lowpass")
{
} else if (type == "bw_lowpass") {
this->butterworth(freq, order, FilterType::Highpass);
}
else
{
} else {
throw std::invalid_argument("Invalid combo filter type");
}
}
};
};
}; // namespace bell

6
components/spotify/cspot/bell/main/audio-dsp/include/CentralAudioBuffer.h
View File

@@ -2,10 +2,10 @@
#include <atomic>
#include <cmath>
#include <functional>
#include <iostream>
#include <memory>
#include <mutex>
#include <functional>
#include "BellUtils.h"
#include "CircularBuffer.h"
@@ -70,9 +70,9 @@ class CentralAudioBuffer {
*/
void clearBuffer() {
std::scoped_lock lock(this->dataAccessMutex);
//size_t exceptSize = currentSampleRate + (sizeof(AudioChunk) - (currentSampleRate % sizeof(AudioChunk)));
hasChunk = false;
audioBuffer->emptyBuffer();
hasChunk = false;
}
void emptyCompletely() {

49
components/spotify/cspot/bell/main/audio-dsp/include/Compressor.h
View File

@@ -1,16 +1,16 @@
#pragma once
#include <vector>
#include <memory>
#include <algorithm>
#include <cmath>
#include <math.h>
#include <iostream>
#include <mutex>
#include <map>
#include <math.h> // for expf
#include <stdint.h> // for uint32_t
#include <map> // for map
#include <memory> // for unique_ptr
#include <mutex> // for scoped_lock
#include <string> // for string, operator<
#include <vector> // for vector
#include "Biquad.h"
#include "AudioTransform.h"
#include "AudioTransform.h" // for AudioTransform
#include "StreamInfo.h" // for StreamInfo
#include "TransformConfig.h" // for TransformConfig
#define pow10f(x) expf(2.302585092994046f * x)
@@ -20,10 +20,8 @@ float log2f_approx(float X);
#define log10f_fast(x) (log2f_approx(x) * 0.3010299956639812f)
namespace bell
{
class Compressor : public bell::AudioTransform
{
namespace bell {
class Compressor : public bell::AudioTransform {
private:
std::vector<int> channels;
std::vector<float> tmp;
@@ -45,7 +43,8 @@ namespace bell
Compressor();
~Compressor(){};
void configure(std::vector<int> channels, float attack, float release, float threshold, float factor, float makeupGain);
void configure(std::vector<int> channels, float attack, float release,
float threshold, float factor, float makeupGain);
void sumChannels(std::unique_ptr<StreamInfo>& data);
void calLoudness();
@@ -53,8 +52,7 @@ namespace bell
void applyGain(std::unique_ptr<StreamInfo>& data);
void reconfigure() override
{
void reconfigure() override {
std::scoped_lock lock(this->accessMutex);
auto newChannels = config->getChannels();
@@ -68,12 +66,9 @@ namespace bell
paramCache["release"] == newRelease &&
paramCache["threshold"] == newThreshold &&
paramCache["factor"] == newFactor &&
paramCache["makeup_gain"] == newMakeupGain)
{
paramCache["makeup_gain"] == newMakeupGain) {
return;
}
else
{
} else {
paramCache["attack"] = newAttack;
paramCache["release"] = newRelease;
@@ -82,7 +77,8 @@ namespace bell
paramCache["makeup_gain"] = newMakeupGain;
}
this->configure(newChannels, newAttack, newRelease, newThreshold, newFactor, newMakeupGain);
this->configure(newChannels, newAttack, newRelease, newThreshold, newFactor,
newMakeupGain);
}
// void fromJSON(cJSON* json) override {
@@ -97,7 +93,10 @@ namespace bell
// this->configure(attack, release, clipLimit, threshold, factor, makeupGain);
// }
std::unique_ptr<StreamInfo> process(std::unique_ptr<StreamInfo> data) override;
void sampleRateChanged(uint32_t sampleRate) override { this->sampleRate = sampleRate; };
std::unique_ptr<StreamInfo> process(
std::unique_ptr<StreamInfo> data) override;
void sampleRateChanged(uint32_t sampleRate) override {
this->sampleRate = sampleRate;
};
};
}; // namespace bell

21
components/spotify/cspot/bell/main/audio-dsp/include/Gain.h
View File

@@ -1,15 +1,15 @@
#pragma once
#include <cmath>
#include <mutex>
#include <iostream>
#include <memory> // for unique_ptr
#include <mutex> // for scoped_lock
#include <vector> // for vector
#include "AudioTransform.h"
#include "AudioTransform.h" // for AudioTransform
#include "StreamInfo.h" // for StreamInfo
#include "TransformConfig.h" // for TransformConfig
namespace bell
{
class Gain : public bell::AudioTransform
{
namespace bell {
class Gain : public bell::AudioTransform {
private:
float gainFactor = 1.0f;
@@ -23,7 +23,8 @@ namespace bell
void configure(std::vector<int> channels, float gainDB);
std::unique_ptr<StreamInfo> process(std::unique_ptr<StreamInfo> data) override;
std::unique_ptr<StreamInfo> process(
std::unique_ptr<StreamInfo> data) override;
void reconfigure() override {
std::scoped_lock lock(this->accessMutex);
@@ -37,4 +38,4 @@ namespace bell
this->configure(channels, gain);
}
};
}
} // namespace bell

61
components/spotify/cspot/bell/main/audio-dsp/include/JSONTransformConfig.h
View File

@@ -3,45 +3,34 @@
#include "TransformConfig.h"
#include "cJSON.h"
namespace bell
{
class JSONTransformConfig : public bell::TransformConfig
{
namespace bell {
class JSONTransformConfig : public bell::TransformConfig {
private:
cJSON* json;
public:
JSONTransformConfig(cJSON *body)
{
this->json = body;
};
JSONTransformConfig(cJSON* body) { this->json = body; };
~JSONTransformConfig(){};
std::string rawGetString(const std::string &field) override
{
std::string rawGetString(const std::string& field) override {
cJSON* value = cJSON_GetObjectItem(json, field.c_str());
if (value != NULL && cJSON_IsString(value))
{
if (value != NULL && cJSON_IsString(value)) {
return std::string(value->valuestring);
}
return "invalid";
}
std::vector<int> rawGetIntArray(const std::string &field) override
{
std::vector<int> rawGetIntArray(const std::string& field) override {
std::vector<int> result;
cJSON* value = cJSON_GetObjectItem(json, field.c_str());
if (value != NULL && cJSON_IsArray(value))
{
for (int i = 0; i < cJSON_GetArraySize(value); i++)
{
if (value != NULL && cJSON_IsArray(value)) {
for (int i = 0; i < cJSON_GetArraySize(value); i++) {
cJSON* item = cJSON_GetArrayItem(value, i);
if (item != NULL && cJSON_IsNumber(item))
{
if (item != NULL && cJSON_IsNumber(item)) {
result.push_back(item->valueint);
}
}
@@ -50,19 +39,15 @@ namespace bell
return result;
}
std::vector<float> rawGetFloatArray(const std::string &field) override
{
std::vector<float> rawGetFloatArray(const std::string& field) override {
std::vector<float> result;
cJSON* value = cJSON_GetObjectItem(json, field.c_str());
if (value != NULL && cJSON_IsArray(value))
{
for (int i = 0; i < cJSON_GetArraySize(value); i++)
{
if (value != NULL && cJSON_IsArray(value)) {
for (int i = 0; i < cJSON_GetArraySize(value); i++) {
cJSON* item = cJSON_GetArrayItem(value, i);
if (item != NULL && cJSON_IsNumber(item))
{
if (item != NULL && cJSON_IsNumber(item)) {
result.push_back(item->valuedouble);
}
}
@@ -71,40 +56,34 @@ namespace bell
return result;
}
int rawGetInt(const std::string &field) override
{
int rawGetInt(const std::string& field) override {
cJSON* value = cJSON_GetObjectItem(json, field.c_str());
if (value != NULL && cJSON_IsNumber(value))
{
if (value != NULL && cJSON_IsNumber(value)) {
return (int)value->valueint;
}
return invalidInt;
}
bool isArray(const std::string &field) override
{
bool isArray(const std::string& field) override {
cJSON* value = cJSON_GetObjectItem(json, field.c_str());
if (value != NULL && cJSON_IsArray(value))
{
if (value != NULL && cJSON_IsArray(value)) {
return true;
}
return false;
}
float rawGetFloat(const std::string &field) override
{
float rawGetFloat(const std::string& field) override {
cJSON* value = cJSON_GetObjectItem(json, field.c_str());
if (value != NULL && cJSON_IsNumber(value))
{
if (value != NULL && cJSON_IsNumber(value)) {
return (float)value->valuedouble;
}
return invalidInt;
}
};
}
} // namespace bell

22
components/spotify/cspot/bell/main/audio-dsp/include/StreamInfo.h
View File

@@ -1,36 +1,28 @@
#pragma once
#include <memory>
#include <vector>
#include <string>
#include <vector>
namespace bell
{
enum class Channels {
LEFT,
RIGHT,
LEFT_RIGHT
};
namespace bell {
enum class Channels { LEFT, RIGHT, LEFT_RIGHT };
enum class SampleRate : uint32_t
{
enum class SampleRate : uint32_t {
SR_44100 = 44100,
SR_48000 = 48000,
};
enum class BitWidth : uint32_t
{
enum class BitWidth : uint32_t {
BW_16 = 16,
BW_24 = 24,
BW_32 = 32,
};
typedef struct
{
typedef struct {
float** data;
BitWidth bitwidth;
int numChannels;
SampleRate sampleRate;
size_t numSamples;
} StreamInfo;
};
}; // namespace bell

84
components/spotify/cspot/bell/main/audio-dsp/include/TransformConfig.h
View File

@@ -1,16 +1,14 @@
#pragma once
#include <memory>
#include <vector>
#include <string>
#include <variant>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <variant>
#include <vector>
namespace bell
{
class TransformConfig
{
namespace bell {
class TransformConfig {
protected:
int invalidInt = -0x7C;
std::string invalidString = "_invalid";
@@ -33,102 +31,82 @@ namespace bell
typedef std::variant<int, float, std::string> Value;
std::map<std::string, std::vector<Value>> rawValues;
Value getRawValue(const std::string &field)
{
Value getRawValue(const std::string& field) {
int index = this->currentVolume * (rawValues[field].size()) / 100;
if (index >= rawValues[field].size())
index = rawValues[field].size() - 1;
return rawValues[field][index];
}
std::string getString(const std::string &field, bool isRequired = false, std::string defaultValue = "")
{
if (rawValues.count(field) == 0)
{
std::string getString(const std::string& field, bool isRequired = false,
std::string defaultValue = "") {
if (rawValues.count(field) == 0) {
rawValues[field] = std::vector<Value>({Value(rawGetString(field))});
}
auto val = std::get<std::string>(getRawValue(field));
if (val == invalidString)
{
if (val == invalidString) {
if (isRequired)
throw std::invalid_argument("Field " + field + " is required");
else
return defaultValue;
}
else
} else
return val;
}
int getInt(const std::string &field, bool isRequired = false, int defaultValue = 0)
{
if (rawValues.count(field) == 0)
{
if (isArray(field))
{
int getInt(const std::string& field, bool isRequired = false,
int defaultValue = 0) {
if (rawValues.count(field) == 0) {
if (isArray(field)) {
rawValues[field] = std::vector<Value>();
for (auto f : rawGetIntArray(field))
{
for (auto f : rawGetIntArray(field)) {
rawValues[field].push_back(f);
}
}
else
{
} else {
rawValues[field] = std::vector<Value>({Value(rawGetInt(field))});
}
}
auto val = std::get<int>(getRawValue(field));
if (val == invalidInt)
{
if (val == invalidInt) {
if (isRequired)
throw std::invalid_argument("Field " + field + " is required");
else
return defaultValue;
}
else
} else
return val;
}
float getFloat(const std::string &field, bool isRequired = false, float defaultValue = 0)
{
if (rawValues.count(field) == 0)
{
if (isArray(field))
{
float getFloat(const std::string& field, bool isRequired = false,
float defaultValue = 0) {
if (rawValues.count(field) == 0) {
if (isArray(field)) {
rawValues[field] = std::vector<Value>();
for (auto f : rawGetFloatArray(field))
{
for (auto f : rawGetFloatArray(field)) {
rawValues[field].push_back(f);
}
}
else
{
} else {
rawValues[field] = std::vector<Value>({Value(rawGetFloat(field))});
}
}
auto val = std::get<float>(getRawValue(field));
if (val == invalidInt)
{
if (val == invalidInt) {
if (isRequired)
throw std::invalid_argument("Field " + field + " is required");
else
return defaultValue;
}
else
} else
return val;
}
std::vector<int> getChannels()
{
std::vector<int> getChannels() {
auto channel = getInt("channel", false, invalidInt);
if (channel != invalidInt)
{
if (channel != invalidInt) {
return std::vector<int>({channel});
}
return rawGetIntArray("channels");
}
};
}
} // namespace bell

7
components/spotify/cspot/bell/main/audio-sinks/esp/AC101AudioSink.cpp
View File

@@ -2,8 +2,7 @@
#include "driver/i2s.h"
AC101AudioSink::AC101AudioSink()
{
AC101AudioSink::AC101AudioSink() {
// Disable software volume control, all handled by ::volumeChanged
softwareVolumeControl = false;
@@ -37,9 +36,7 @@ AC101AudioSink::AC101AudioSink()
startI2sFeed();
}
AC101AudioSink::~AC101AudioSink()
{
}
AC101AudioSink::~AC101AudioSink() {}
void AC101AudioSink::volumeChanged(uint16_t volume) {
dac->volume(volume, volume);

36
components/spotify/cspot/bell/main/audio-sinks/esp/BufferedAudioSink.cpp
View File

@@ -1,22 +1,19 @@
#include "BufferedAudioSink.h"
#include "driver/i2s.h"
#include "freertos/task.h"
#include "freertos/ringbuf.h"
#include "freertos/task.h"
RingbufHandle_t dataBuffer;
static void i2sFeed(void *pvParameters)
{
while (true)
{
static void i2sFeed(void* pvParameters) {
while (true) {
size_t itemSize;
char *item = (char *)xRingbufferReceiveUpTo(dataBuffer, &itemSize, portMAX_DELAY, 512);
if (item != NULL)
{
char* item = (char*)xRingbufferReceiveUpTo(dataBuffer, &itemSize,
portMAX_DELAY, 512);
if (item != NULL) {
size_t written = 0;
while (written < itemSize)
{
while (written < itemSize) {
i2s_write((i2s_port_t)0, item, itemSize, &written, portMAX_DELAY);
}
vRingbufferReturnItem(dataBuffer, (void*)item);
@@ -24,24 +21,25 @@ static void i2sFeed(void *pvParameters)
}
}
void BufferedAudioSink::startI2sFeed(size_t buf_size)
{
void BufferedAudioSink::startI2sFeed(size_t buf_size) {
dataBuffer = xRingbufferCreate(buf_size, RINGBUF_TYPE_BYTEBUF);
xTaskCreatePinnedToCore(&i2sFeed, "i2sFeed", 4096, NULL, 10, NULL, tskNO_AFFINITY);
xTaskCreatePinnedToCore(&i2sFeed, "i2sFeed", 4096, NULL, 10, NULL,
tskNO_AFFINITY);
}
void BufferedAudioSink::feedPCMFrames(const uint8_t *buffer, size_t bytes)
{
void BufferedAudioSink::feedPCMFrames(const uint8_t* buffer, size_t bytes) {
feedPCMFramesInternal(buffer, bytes);
}
void BufferedAudioSink::feedPCMFramesInternal(const void *pvItem, size_t xItemSize)
{
void BufferedAudioSink::feedPCMFramesInternal(const void* pvItem,
size_t xItemSize) {
xRingbufferSend(dataBuffer, pvItem, xItemSize, portMAX_DELAY);
}
bool BufferedAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) {
bool BufferedAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount,
uint8_t bitDepth) {
// TODO override this for sinks with custom mclk
i2s_set_clk((i2s_port_t)0, sampleRate, (i2s_bits_per_sample_t)bitDepth, (i2s_channel_t)channelCount);
i2s_set_clk((i2s_port_t)0, sampleRate, (i2s_bits_per_sample_t)bitDepth,
(i2s_channel_t)channelCount);
return true;
}

29
components/spotify/cspot/bell/main/audio-sinks/esp/ES8311AudioSink.cpp
View File

@@ -2,21 +2,22 @@
extern "C" {
#include "es8311.h"
}
ES8311AudioSink::ES8311AudioSink()
{
ES8311AudioSink::ES8311AudioSink() {
this->softwareVolumeControl = false;
esp_err_t ret_val = ESP_OK;
Es8311Config cfg = {
.esMode = ES_MODE_SLAVE,
.i2c_port_num = I2C_NUM_0,
.i2c_cfg = {
.i2c_cfg =
{
.mode = I2C_MODE_MASTER,
.sda_io_num = 1,
.scl_io_num = 2,
.sda_pullup_en = GPIO_PULLUP_ENABLE,
.scl_pullup_en = GPIO_PULLUP_ENABLE,
},
.dacOutput = (DacOutput) (DAC_OUTPUT_LOUT1 | DAC_OUTPUT_LOUT2 | DAC_OUTPUT_ROUT1 | DAC_OUTPUT_ROUT2),
.dacOutput = (DacOutput)(DAC_OUTPUT_LOUT1 | DAC_OUTPUT_LOUT2 |
DAC_OUTPUT_ROUT1 | DAC_OUTPUT_ROUT2),
.adcInput = ADC_INPUT_LINPUT1_RINPUT1,
};
cfg.i2c_cfg.master.clk_speed = 100000;
@@ -68,14 +69,12 @@ ES8311AudioSink::ES8311AudioSink()
int err;
err = i2s_driver_install((i2s_port_t)0, &i2s_config, 0, NULL);
if (err != ESP_OK)
{
if (err != ESP_OK) {
ESP_LOGE("OI", "i2s driver installation error: %d", err);
}
err = i2s_set_pin((i2s_port_t)0, &pin_config);
if (err != ESP_OK)
{
if (err != ESP_OK) {
ESP_LOGE("OI", "i2s set pin error: %d", err);
}
@@ -86,21 +85,17 @@ ES8311AudioSink::ES8311AudioSink()
startI2sFeed();
}
void ES8311AudioSink::volumeChanged(uint16_t volume)
{
void ES8311AudioSink::volumeChanged(uint16_t volume) {
Es8311SetVoiceVolume(volume);
}
void ES8311AudioSink::writeReg(uint8_t reg_add, uint8_t data)
{
}
void ES8311AudioSink::writeReg(uint8_t reg_add, uint8_t data) {}
void ES8311AudioSink::setSampleRate(uint32_t sampleRate) {
std::cout << "ES8311AudioSink::setSampleRate(" << sampleRate << ")" << std::endl;
std::cout << "ES8311AudioSink::setSampleRate(" << sampleRate << ")"
<< std::endl;
// i2s set sample rate
es8311_Codec_Startup(0, sampleRate);
}
ES8311AudioSink::~ES8311AudioSink()
{
}
ES8311AudioSink::~ES8311AudioSink() {}

13
components/spotify/cspot/bell/main/audio-sinks/esp/ES8388AudioSink.cpp
View File

@@ -5,8 +5,7 @@ struct es8388_cmd_s {
uint8_t value;
};
ES8388AudioSink::ES8388AudioSink()
{
ES8388AudioSink::ES8388AudioSink() {
// configure i2c
i2c_config = {
.mode = I2C_MODE_MASTER,
@@ -29,8 +28,7 @@ ES8388AudioSink::ES8388AudioSink()
.dma_buf_len = 512,
.use_apll = true,
.tx_desc_auto_clear = true, //Auto clear tx descriptor on underflow
.fixed_mclk = 256 * 44100
};
.fixed_mclk = 256 * 44100};
i2s_pin_config_t pin_config = {
.bck_io_num = 27,
@@ -125,8 +123,7 @@ ES8388AudioSink::ES8388AudioSink()
startI2sFeed();
}
void ES8388AudioSink::writeReg(uint8_t reg_add, uint8_t data)
{
void ES8388AudioSink::writeReg(uint8_t reg_add, uint8_t data) {
int res = 0;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
@@ -145,6 +142,4 @@ void ES8388AudioSink::writeReg(uint8_t reg_add, uint8_t data)
}
}
ES8388AudioSink::~ES8388AudioSink()
{
}
ES8388AudioSink::~ES8388AudioSink() {}

10
components/spotify/cspot/bell/main/audio-sinks/esp/ES9018AudioSink.cpp
View File

@@ -2,8 +2,7 @@
#include "driver/i2s.h"
ES9018AudioSink::ES9018AudioSink()
{
ES9018AudioSink::ES9018AudioSink() {
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX), // Only TX
@@ -16,8 +15,7 @@ ES9018AudioSink::ES9018AudioSink()
.dma_buf_len = 512,
.use_apll = true,
.tx_desc_auto_clear = true, //Auto clear tx descriptor on underflow
.fixed_mclk = 384 * 44100
};
.fixed_mclk = 384 * 44100};
i2s_pin_config_t pin_config = {
.bck_io_num = 27,
@@ -31,6 +29,4 @@ ES9018AudioSink::ES9018AudioSink()
startI2sFeed();
}
ES9018AudioSink::~ES9018AudioSink()
{
}
ES9018AudioSink::~ES9018AudioSink() {}

13
components/spotify/cspot/bell/main/audio-sinks/esp/InternalAudioSink.cpp
View File

@@ -1,14 +1,14 @@
#include "InternalAudioSink.h"
#include "driver/i2s.h"
InternalAudioSink::InternalAudioSink()
{
InternalAudioSink::InternalAudioSink() {
softwareVolumeControl = true;
usign = true;
#ifdef I2S_MODE_DAC_BUILT_IN
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX | I2S_MODE_DAC_BUILT_IN), // Only TX
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX |
I2S_MODE_DAC_BUILT_IN), // Only TX
.sample_rate = (i2s_bits_per_sample_t)44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
.channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
@@ -18,8 +18,7 @@ InternalAudioSink::InternalAudioSink()
.dma_buf_len = 512,
.use_apll = true,
.tx_desc_auto_clear = true, //Auto clear tx descriptor on underflow
.fixed_mclk=-1
};
.fixed_mclk = -1};
//install and start i2s driver
i2s_driver_install((i2s_port_t)0, &i2s_config, 0, NULL);
@@ -30,6 +29,4 @@ InternalAudioSink::InternalAudioSink()
startI2sFeed();
}
InternalAudioSink::~InternalAudioSink()
{
}
InternalAudioSink::~InternalAudioSink() {}

10
components/spotify/cspot/bell/main/audio-sinks/esp/PCM5102AudioSink.cpp
View File

@@ -2,8 +2,7 @@
#include "driver/i2s.h"
PCM5102AudioSink::PCM5102AudioSink()
{
PCM5102AudioSink::PCM5102AudioSink() {
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX), // Only TX
@@ -16,8 +15,7 @@ PCM5102AudioSink::PCM5102AudioSink()
.dma_buf_len = 512,
.use_apll = true,
.tx_desc_auto_clear = true, //Auto clear tx descriptor on underflow
.fixed_mclk = 384 * 44100
};
.fixed_mclk = 384 * 44100};
i2s_pin_config_t pin_config = {
.bck_io_num = 27,
@@ -31,6 +29,4 @@ PCM5102AudioSink::PCM5102AudioSink()
startI2sFeed();
}
PCM5102AudioSink::~PCM5102AudioSink()
{
}
PCM5102AudioSink::~PCM5102AudioSink() {}

82
components/spotify/cspot/bell/main/audio-sinks/esp/SPDIFAudioSink.cpp
View File

@@ -5,38 +5,35 @@
// See http://www.hardwarebook.info/S/PDIF for more info on this protocol
// Conversion table to biphase code mark (LSB first, ending in 1)
static const uint16_t bmc_convert[256] = {
0x3333, 0xb333, 0xd333, 0x5333, 0xcb33, 0x4b33, 0x2b33, 0xab33,
0xcd33, 0x4d33, 0x2d33, 0xad33, 0x3533, 0xb533, 0xd533, 0x5533,
0xccb3, 0x4cb3, 0x2cb3, 0xacb3, 0x34b3, 0xb4b3, 0xd4b3, 0x54b3,
0x32b3, 0xb2b3, 0xd2b3, 0x52b3, 0xcab3, 0x4ab3, 0x2ab3, 0xaab3,
0xccd3, 0x4cd3, 0x2cd3, 0xacd3, 0x34d3, 0xb4d3, 0xd4d3, 0x54d3,
0x32d3, 0xb2d3, 0xd2d3, 0x52d3, 0xcad3, 0x4ad3, 0x2ad3, 0xaad3,
0x3353, 0xb353, 0xd353, 0x5353, 0xcb53, 0x4b53, 0x2b53, 0xab53,
0xcd53, 0x4d53, 0x2d53, 0xad53, 0x3553, 0xb553, 0xd553, 0x5553,
0xcccb, 0x4ccb, 0x2ccb, 0xaccb, 0x34cb, 0xb4cb, 0xd4cb, 0x54cb,
0x32cb, 0xb2cb, 0xd2cb, 0x52cb, 0xcacb, 0x4acb, 0x2acb, 0xaacb,
0x334b, 0xb34b, 0xd34b, 0x534b, 0xcb4b, 0x4b4b, 0x2b4b, 0xab4b,
0xcd4b, 0x4d4b, 0x2d4b, 0xad4b, 0x354b, 0xb54b, 0xd54b, 0x554b,
0x332b, 0xb32b, 0xd32b, 0x532b, 0xcb2b, 0x4b2b, 0x2b2b, 0xab2b,
0xcd2b, 0x4d2b, 0x2d2b, 0xad2b, 0x352b, 0xb52b, 0xd52b, 0x552b,
0xccab, 0x4cab, 0x2cab, 0xacab, 0x34ab, 0xb4ab, 0xd4ab, 0x54ab,
0x32ab, 0xb2ab, 0xd2ab, 0x52ab, 0xcaab, 0x4aab, 0x2aab, 0xaaab,
0xcccd, 0x4ccd, 0x2ccd, 0xaccd, 0x34cd, 0xb4cd, 0xd4cd, 0x54cd,
0x32cd, 0xb2cd, 0xd2cd, 0x52cd, 0xcacd, 0x4acd, 0x2acd, 0xaacd,
0x334d, 0xb34d, 0xd34d, 0x534d, 0xcb4d, 0x4b4d, 0x2b4d, 0xab4d,
0xcd4d, 0x4d4d, 0x2d4d, 0xad4d, 0x354d, 0xb54d, 0xd54d, 0x554d,
0x332d, 0xb32d, 0xd32d, 0x532d, 0xcb2d, 0x4b2d, 0x2b2d, 0xab2d,
0xcd2d, 0x4d2d, 0x2d2d, 0xad2d, 0x352d, 0xb52d, 0xd52d, 0x552d,
0xccad, 0x4cad, 0x2cad, 0xacad, 0x34ad, 0xb4ad, 0xd4ad, 0x54ad,
0x32ad, 0xb2ad, 0xd2ad, 0x52ad, 0xcaad, 0x4aad, 0x2aad, 0xaaad,
0x3335, 0xb335, 0xd335, 0x5335, 0xcb35, 0x4b35, 0x2b35, 0xab35,
0xcd35, 0x4d35, 0x2d35, 0xad35, 0x3535, 0xb535, 0xd535, 0x5535,
0xccb5, 0x4cb5, 0x2cb5, 0xacb5, 0x34b5, 0xb4b5, 0xd4b5, 0x54b5,
0x32b5, 0xb2b5, 0xd2b5, 0x52b5, 0xcab5, 0x4ab5, 0x2ab5, 0xaab5,
0xccd5, 0x4cd5, 0x2cd5, 0xacd5, 0x34d5, 0xb4d5, 0xd4d5, 0x54d5,
0x32d5, 0xb2d5, 0xd2d5, 0x52d5, 0xcad5, 0x4ad5, 0x2ad5, 0xaad5,
0x3355, 0xb355, 0xd355, 0x5355, 0xcb55, 0x4b55, 0x2b55, 0xab55,
0xcd55, 0x4d55, 0x2d55, 0xad55, 0x3555, 0xb555, 0xd555, 0x5555,
0x3333, 0xb333, 0xd333, 0x5333, 0xcb33, 0x4b33, 0x2b33, 0xab33, 0xcd33,
0x4d33, 0x2d33, 0xad33, 0x3533, 0xb533, 0xd533, 0x5533, 0xccb3, 0x4cb3,
0x2cb3, 0xacb3, 0x34b3, 0xb4b3, 0xd4b3, 0x54b3, 0x32b3, 0xb2b3, 0xd2b3,
0x52b3, 0xcab3, 0x4ab3, 0x2ab3, 0xaab3, 0xccd3, 0x4cd3, 0x2cd3, 0xacd3,
0x34d3, 0xb4d3, 0xd4d3, 0x54d3, 0x32d3, 0xb2d3, 0xd2d3, 0x52d3, 0xcad3,
0x4ad3, 0x2ad3, 0xaad3, 0x3353, 0xb353, 0xd353, 0x5353, 0xcb53, 0x4b53,
0x2b53, 0xab53, 0xcd53, 0x4d53, 0x2d53, 0xad53, 0x3553, 0xb553, 0xd553,
0x5553, 0xcccb, 0x4ccb, 0x2ccb, 0xaccb, 0x34cb, 0xb4cb, 0xd4cb, 0x54cb,
0x32cb, 0xb2cb, 0xd2cb, 0x52cb, 0xcacb, 0x4acb, 0x2acb, 0xaacb, 0x334b,
0xb34b, 0xd34b, 0x534b, 0xcb4b, 0x4b4b, 0x2b4b, 0xab4b, 0xcd4b, 0x4d4b,
0x2d4b, 0xad4b, 0x354b, 0xb54b, 0xd54b, 0x554b, 0x332b, 0xb32b, 0xd32b,
0x532b, 0xcb2b, 0x4b2b, 0x2b2b, 0xab2b, 0xcd2b, 0x4d2b, 0x2d2b, 0xad2b,
0x352b, 0xb52b, 0xd52b, 0x552b, 0xccab, 0x4cab, 0x2cab, 0xacab, 0x34ab,
0xb4ab, 0xd4ab, 0x54ab, 0x32ab, 0xb2ab, 0xd2ab, 0x52ab, 0xcaab, 0x4aab,
0x2aab, 0xaaab, 0xcccd, 0x4ccd, 0x2ccd, 0xaccd, 0x34cd, 0xb4cd, 0xd4cd,
0x54cd, 0x32cd, 0xb2cd, 0xd2cd, 0x52cd, 0xcacd, 0x4acd, 0x2acd, 0xaacd,
0x334d, 0xb34d, 0xd34d, 0x534d, 0xcb4d, 0x4b4d, 0x2b4d, 0xab4d, 0xcd4d,
0x4d4d, 0x2d4d, 0xad4d, 0x354d, 0xb54d, 0xd54d, 0x554d, 0x332d, 0xb32d,
0xd32d, 0x532d, 0xcb2d, 0x4b2d, 0x2b2d, 0xab2d, 0xcd2d, 0x4d2d, 0x2d2d,
0xad2d, 0x352d, 0xb52d, 0xd52d, 0x552d, 0xccad, 0x4cad, 0x2cad, 0xacad,
0x34ad, 0xb4ad, 0xd4ad, 0x54ad, 0x32ad, 0xb2ad, 0xd2ad, 0x52ad, 0xcaad,
0x4aad, 0x2aad, 0xaaad, 0x3335, 0xb335, 0xd335, 0x5335, 0xcb35, 0x4b35,
0x2b35, 0xab35, 0xcd35, 0x4d35, 0x2d35, 0xad35, 0x3535, 0xb535, 0xd535,
0x5535, 0xccb5, 0x4cb5, 0x2cb5, 0xacb5, 0x34b5, 0xb4b5, 0xd4b5, 0x54b5,
0x32b5, 0xb2b5, 0xd2b5, 0x52b5, 0xcab5, 0x4ab5, 0x2ab5, 0xaab5, 0xccd5,
0x4cd5, 0x2cd5, 0xacd5, 0x34d5, 0xb4d5, 0xd4d5, 0x54d5, 0x32d5, 0xb2d5,
0xd2d5, 0x52d5, 0xcad5, 0x4ad5, 0x2ad5, 0xaad5, 0x3355, 0xb355, 0xd355,
0x5355, 0xcb55, 0x4b55, 0x2b55, 0xab55, 0xcd55, 0x4d55, 0x2d55, 0xad55,
0x3555, 0xb555, 0xd555, 0x5555,
};
#define I2S_BUG_MAGIC (26 * 1000 * 1000) // magic number for avoiding I2S bug
@@ -53,21 +50,18 @@ static const uint16_t bmc_convert[256] = {
static uint32_t spdif_buf[SPDIF_BUF_ARRAY_SIZE];
static uint32_t* spdif_ptr;
static void spdif_buf_init(void)
{
static void spdif_buf_init(void) {
// first bllock has W preamble
spdif_buf[0] = BMC_B;
// all other blocks are alternating M, then W preamble
uint32_t bmc_mw = BMC_M;
for (int i = 2; i < SPDIF_BUF_ARRAY_SIZE; i += 2)
{
for (int i = 2; i < SPDIF_BUF_ARRAY_SIZE; i += 2) {
spdif_buf[i] = bmc_mw ^= BMC_MW_DIF;
}
}
SPDIFAudioSink::SPDIFAudioSink(uint8_t spdifPin)
{
SPDIFAudioSink::SPDIFAudioSink(uint8_t spdifPin) {
// initialize S/PDIF buffer
spdif_buf_init();
spdif_ptr = spdif_buf;
@@ -76,8 +70,10 @@ SPDIFAudioSink::SPDIFAudioSink(uint8_t spdifPin)
startI2sFeed(SPDIF_BUF_SIZE * 16);
}
bool SPDIFAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) {
if (bitDepth != 16 || channelCount != 2) // TODO support mono playback and different bit widths
bool SPDIFAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount,
uint8_t bitDepth) {
if (bitDepth != 16 ||
channelCount != 2) // TODO support mono playback and different bit widths
return false;
int sample_rate = (int)sampleRate * 2;
int bclk = sample_rate * 64 * 2;
@@ -118,10 +114,8 @@ SPDIFAudioSink::~SPDIFAudioSink() {
int num_frames = 0;
void SPDIFAudioSink::feedPCMFrames(const uint8_t *buffer, size_t bytes)
{
for (int i = 0; i < bytes; i += 2)
{
void SPDIFAudioSink::feedPCMFrames(const uint8_t* buffer, size_t bytes) {
for (int i = 0; i < bytes; i += 2) {
/**
* What is this, and why does it work?
*

24
components/spotify/cspot/bell/main/audio-sinks/esp/TAS5711AudioSink.cpp
View File

@@ -1,6 +1,5 @@
#include "TAS5711AudioSink.h"
struct tas5711_cmd_s {
uint8_t reg;
uint8_t value;
@@ -17,8 +16,7 @@ static const struct tas5711_cmd_s tas5711_init_sequence[] = {
};
i2c_ack_type_t ACK_CHECK_EN = (i2c_ack_type_t)0x1;
TAS5711AudioSink::TAS5711AudioSink()
{
TAS5711AudioSink::TAS5711AudioSink() {
i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX), // Only TX
@@ -31,9 +29,7 @@ TAS5711AudioSink::TAS5711AudioSink()
.dma_buf_len = 512,
.use_apll = true,
.tx_desc_auto_clear = true, //Auto clear tx descriptor on underflow
.fixed_mclk = 256 * 44100
};
.fixed_mclk = 256 * 44100};
i2s_pin_config_t pin_config = {
.bck_io_num = 5,
@@ -75,15 +71,13 @@ TAS5711AudioSink::TAS5711AudioSink()
if (ret == ESP_OK) {
ESP_LOGI("RR", "Detected TAS");
}
else {
} else {
ESP_LOGI("RR", "Unable to detect dac");
}
writeReg(0x1b, 0x00);
vTaskDelay(100 / portTICK_PERIOD_MS);
for (int i = 0; tas5711_init_sequence[i].reg != 0xff; i++) {
writeReg(tas5711_init_sequence[i].reg, tas5711_init_sequence[i].value);
vTaskDelay(1 / portTICK_PERIOD_MS);
@@ -92,8 +86,7 @@ TAS5711AudioSink::TAS5711AudioSink()
startI2sFeed();
}
void TAS5711AudioSink::writeReg(uint8_t reg, uint8_t value)
{
void TAS5711AudioSink::writeReg(uint8_t reg, uint8_t value) {
i2c_cmd_handle_t i2c_cmd = i2c_cmd_link_create();
i2c_master_start(i2c_cmd);
@@ -101,17 +94,14 @@ void TAS5711AudioSink::writeReg(uint8_t reg, uint8_t value)
i2c_master_write_byte(i2c_cmd, reg, ACK_CHECK_EN);
i2c_master_write_byte(i2c_cmd, value, ACK_CHECK_EN);
i2c_master_stop(i2c_cmd);
esp_err_t res = i2c_master_cmd_begin(i2c_port, i2c_cmd, 500 / portTICK_PERIOD_MS);
esp_err_t res =
i2c_master_cmd_begin(i2c_port, i2c_cmd, 500 / portTICK_PERIOD_MS);
if (res != ESP_OK) {
ESP_LOGE("RR", "Unable to write to TAS5711");
}
i2c_cmd_link_delete(i2c_cmd);
}
TAS5711AudioSink::~TAS5711AudioSink()
{
}
TAS5711AudioSink::~TAS5711AudioSink() {}

152
components/spotify/cspot/bell/main/audio-sinks/esp/ac101.c
View File

@@ -22,16 +22,16 @@
*
*/
#include <string.h>
#include <esp_log.h>
#include <esp_types.h>
#include <esp_system.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include "ac101.h"
#include <driver/i2c.h>
#include <driver/i2s.h>
#include <esp_log.h>
#include <esp_system.h>
#include <esp_types.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <string.h>
#include "adac.h"
#include "ac101.h"
const static char TAG[] = "AC101";
@@ -43,8 +43,7 @@ const static char TAG[] = "AC101";
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define AC_ASSERT(a, format, b, ...) \
if ((a) != 0) \
{ \
if ((a) != 0) { \
ESP_LOGE(TAG, format, ##__VA_ARGS__); \
return b; \
}
@@ -71,8 +70,7 @@ static int i2c_port;
/****************************************************************************************
* init
*/
static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)
{
static bool init(int i2c_port_num, int i2s_num, i2s_config_t* i2s_config) {
esp_err_t res = ESP_OK;
i2c_port = i2c_port_num;
@@ -92,59 +90,79 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)
res = i2c_read_reg(CHIP_AUDIO_RS);
if (!res)
{
if (!res) {
ESP_LOGW(TAG, "No AC101 detected");
i2c_driver_delete(i2c_port);
return 0;
}
ESP_LOGI(TAG, "AC101 DAC using I2C sda:%u, scl:%u", i2c_config.sda_io_num, i2c_config.scl_io_num);
ESP_LOGI(TAG, "AC101 DAC using I2C sda:%u, scl:%u", i2c_config.sda_io_num,
i2c_config.scl_io_num);
res = i2c_write_reg(CHIP_AUDIO_RS, 0x123);
// huh?
vTaskDelay(100 / portTICK_PERIOD_MS);
// enable the PLL from BCLK source
i2c_write_reg(PLL_CTRL1, BIN(0000, 0001, 0100, 1111)); // F=1,M=1,PLL,INT=31 (medium)
i2c_write_reg(PLL_CTRL2, BIN(1000, 0110, 0000, 0000)); // PLL, F=96,N_i=1024-96,F=0,N_f=0*0.2;
i2c_write_reg(PLL_CTRL1,
BIN(0000, 0001, 0100, 1111)); // F=1,M=1,PLL,INT=31 (medium)
i2c_write_reg(PLL_CTRL2, BIN(1000, 0110, 0000,
0000)); // PLL, F=96,N_i=1024-96,F=0,N_f=0*0.2;
// i2c_write_reg(PLL_CTRL2, BIN(1000,0011,1100,0000));
// clocking system
i2c_write_reg(SYSCLK_CTRL, BIN(1010, 1010, 0000, 1000)); // PLLCLK, BCLK1, IS1CLK, PLL, SYSCLK
i2c_write_reg(SYSCLK_CTRL, BIN(1010, 1010, 0000,
1000)); // PLLCLK, BCLK1, IS1CLK, PLL, SYSCLK
i2c_write_reg(MOD_CLK_ENA, BIN(1000, 0000, 0000, 1100)); // IS21, ADC, DAC
i2c_write_reg(MOD_RST_CTRL, BIN(1000, 0000, 0000, 1100)); // IS21, ADC, DAC
i2c_write_reg(I2S_SR_CTRL, BIN(0111, 0000, 0000, 0000)); // 44.1kHz
// analogue config
i2c_write_reg(I2S1LCK_CTRL, BIN(1000, 1000, 0101, 0000)); // Slave, BCLK=I2S/8,LRCK=32,16bits,I2Smode, Stereo
i2c_write_reg(I2S1LCK_CTRL,
BIN(1000, 1000, 0101,
0000)); // Slave, BCLK=I2S/8,LRCK=32,16bits,I2Smode, Stereo
i2c_write_reg(I2S1_SDOUT_CTRL, BIN(1100, 0000, 0000, 0000)); // I2S1ADC (R&L)
i2c_write_reg(I2S1_SDIN_CTRL, BIN(1100, 0000, 0000, 0000)); // IS21DAC (R&L)
i2c_write_reg(I2S1_MXR_SRC, BIN(0010, 0010, 0000, 0000)); // ADCL, ADCR
i2c_write_reg(ADC_SRCBST_CTRL, BIN(0100, 0100, 0100, 0000)); // disable all boost (default)
i2c_write_reg(ADC_SRCBST_CTRL,
BIN(0100, 0100, 0100, 0000)); // disable all boost (default)
#if ENABLE_ADC
i2c_write_reg(ADC_SRC, BIN(0000, 0100, 0000, 1000)); // source=linein(R/L)
i2c_write_reg(ADC_DIG_CTRL, BIN(1000, 0000, 0000, 0000)); // enable digital ADC
i2c_write_reg(ADC_ANA_CTRL, BIN(1011, 1011, 0000, 0000)); // enable analogue R/L, 0dB
i2c_write_reg(ADC_DIG_CTRL,
BIN(1000, 0000, 0000, 0000)); // enable digital ADC
i2c_write_reg(ADC_ANA_CTRL,
BIN(1011, 1011, 0000, 0000)); // enable analogue R/L, 0dB
#else
i2c_write_reg(ADC_SRC, BIN(0000, 0000, 0000, 0000)); // source=none
i2c_write_reg(ADC_DIG_CTRL, BIN(0000, 0000, 0000, 0000)); // disable digital ADC
i2c_write_reg(ADC_ANA_CTRL, BIN(0011, 0011, 0000, 0000)); // disable analogue R/L, 0dB
i2c_write_reg(ADC_DIG_CTRL,
BIN(0000, 0000, 0000, 0000)); // disable digital ADC
i2c_write_reg(ADC_ANA_CTRL,
BIN(0011, 0011, 0000, 0000)); // disable analogue R/L, 0dB
#endif
//Path Configuration
i2c_write_reg(DAC_MXR_SRC, BIN(1000, 1000, 0000, 0000)); // DAC from I2S
i2c_write_reg(DAC_DIG_CTRL, BIN(1000, 0000, 0000, 0000)); // enable DAC
i2c_write_reg(OMIXER_DACA_CTRL, BIN(1111, 0000, 0000, 0000)); // enable DAC/Analogue (see note on offset removal and PA)
i2c_write_reg(OMIXER_DACA_CTRL, BIN(1111, 1111, 0000, 0000)); // this toggle is needed for headphone PA offset
i2c_write_reg(
OMIXER_DACA_CTRL,
BIN(1111, 0000, 0000,
0000)); // enable DAC/Analogue (see note on offset removal and PA)
i2c_write_reg(OMIXER_DACA_CTRL,
BIN(1111, 1111, 0000,
0000)); // this toggle is needed for headphone PA offset
#if ENABLE_ADC
i2c_write_reg(OMIXER_SR, BIN(0000, 0001, 0000, 0010)); // source=DAC(R/L) (are DACR and DACL really inverted in bitmap?)
i2c_write_reg(
OMIXER_SR,
BIN(0000, 0001, 0000,
0010)); // source=DAC(R/L) (are DACR and DACL really inverted in bitmap?)
#else
i2c_write_reg(OMIXER_SR, BIN(0000, 0101, 0000, 1010)); // source=DAC(R/L) and LINEIN(R/L)
i2c_write_reg(OMIXER_SR, BIN(0000, 0101, 0000,
1010)); // source=DAC(R/L) and LINEIN(R/L)
#endif
// configure I2S pins & install driver
i2s_pin_config_t i2s_pin_config = (i2s_pin_config_t){.bck_io_num = 27, .ws_io_num = 26, .data_out_num = 25, .data_in_num = -1};
i2s_pin_config_t i2s_pin_config = (i2s_pin_config_t){
.bck_io_num = 27, .ws_io_num = 26, .data_out_num = 25, .data_in_num = -1};
res |= i2s_driver_install(i2s_num, i2s_config, 0, NULL);
res |= i2s_set_pin(i2s_num, &i2s_pin_config);
@@ -156,7 +174,8 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)
ac101_set_spk_volume(70);
ac101_set_earph_volume(70);
ESP_LOGI(TAG, "DAC using I2S bck:%d, ws:%d, do:%d", i2s_pin_config.bck_io_num, i2s_pin_config.ws_io_num, i2s_pin_config.data_out_num);
ESP_LOGI(TAG, "DAC using I2S bck:%d, ws:%d, do:%d", i2s_pin_config.bck_io_num,
i2s_pin_config.ws_io_num, i2s_pin_config.data_out_num);
return (res == ESP_OK);
}
@@ -164,16 +183,14 @@ static bool init(int i2c_port_num, int i2s_num, i2s_config_t *i2s_config)
/****************************************************************************************
* init
*/
static void deinit(void)
{
static void deinit(void) {
i2c_driver_delete(i2c_port);
}
/****************************************************************************************
* change volume
*/
static void volume(unsigned left, unsigned right)
{
static void volume(unsigned left, unsigned right) {
ac101_set_earph_volume(left);
// nothing at that point, volume is handled by backend
}
@@ -181,10 +198,8 @@ static void volume(unsigned left, unsigned right)
/****************************************************************************************
* power
*/
static void power(adac_power_e mode)
{
switch (mode)
{
static void power(adac_power_e mode) {
switch (mode) {
case ADAC_STANDBY:
case ADAC_OFF:
ac101_stop();
@@ -201,8 +216,7 @@ static void power(adac_power_e mode)
/****************************************************************************************
* speaker
*/
static void speaker(bool active)
{
static void speaker(bool active) {
uint16_t value = i2c_read_reg(SPKOUT_CTRL);
if (active)
i2c_write_reg(SPKOUT_CTRL, value | SPKOUT_EN);
@@ -213,8 +227,7 @@ static void speaker(bool active)
/****************************************************************************************
* headset
*/
static void headset(bool active)
{
static void headset(bool active) {
// there might be aneed to toggle OMIXER_DACA_CTRL 11:8, not sure
uint16_t value = i2c_read_reg(HPOUT_CTRL);
if (active)
@@ -226,8 +239,7 @@ static void headset(bool active)
/****************************************************************************************
*
*/
static esp_err_t i2c_write_reg(uint8_t reg, uint16_t val)
{
static esp_err_t i2c_write_reg(uint8_t reg, uint16_t val) {
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
esp_err_t ret = 0;
uint8_t send_buff[4];
@@ -246,8 +258,7 @@ static esp_err_t i2c_write_reg(uint8_t reg, uint16_t val)
/****************************************************************************************
*
*/
static uint16_t i2c_read_reg(uint8_t reg)
{
static uint16_t i2c_read_reg(uint8_t reg) {
uint8_t data[2] = {0};
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
@@ -255,7 +266,8 @@ static uint16_t i2c_read_reg(uint8_t reg)
i2c_master_write_byte(cmd, (AC101_ADDR << 1) | WRITE_BIT, ACK_CHECK_EN);
i2c_master_write_byte(cmd, reg, ACK_CHECK_EN);
i2c_master_start(cmd);
i2c_master_write_byte(cmd, (AC101_ADDR << 1) | READ_BIT, ACK_CHECK_EN); //check or not
i2c_master_write_byte(cmd, (AC101_ADDR << 1) | READ_BIT,
ACK_CHECK_EN); //check or not
i2c_master_read(cmd, data, 2, ACK_VAL);
i2c_master_stop(cmd);
i2c_master_cmd_begin(i2c_port, cmd, 1000 / portTICK_PERIOD_MS);
@@ -268,8 +280,7 @@ static uint16_t i2c_read_reg(uint8_t reg)
/****************************************************************************************
*
*/
void set_sample_rate(int rate)
{
void set_sample_rate(int rate) {
if (rate == 8000)
rate = SAMPLE_RATE_8000;
else if (rate == 11025)
@@ -292,8 +303,7 @@ void set_sample_rate(int rate)
rate = SAMPLE_RATE_96000;
else if (rate == 192000)
rate = SAMPLE_RATE_192000;
else
{
else {
ESP_LOGW(TAG, "Unknown sample rate %hu", rate);
rate = SAMPLE_RATE_44100;
}
@@ -303,16 +313,14 @@ void set_sample_rate(int rate)
/****************************************************************************************
* Get normalized (0..100) speaker volume
*/
static int ac101_get_spk_volume(void)
{
static int ac101_get_spk_volume(void) {
return ((i2c_read_reg(SPKOUT_CTRL) & 0x1f) * 100) / 0x1f;
}
/****************************************************************************************
* Set normalized (0..100) volume
*/
static void ac101_set_spk_volume(uint8_t volume)
{
static void ac101_set_spk_volume(uint8_t volume) {
uint16_t value = min(volume, 100);
value = ((int)value * 0x1f) / 100;
value |= i2c_read_reg(SPKOUT_CTRL) & ~0x1f;
@@ -322,16 +330,14 @@ static void ac101_set_spk_volume(uint8_t volume)
/****************************************************************************************
* Get normalized (0..100) earphone volume
*/
static int ac101_get_earph_volume(void)
{
static int ac101_get_earph_volume(void) {
return (((i2c_read_reg(HPOUT_CTRL) >> 4) & 0x3f) * 100) / 0x3f;
}
/****************************************************************************************
* Set normalized (0..100) earphone volume
*/
static void ac101_set_earph_volume(uint8_t volume)
{
static void ac101_set_earph_volume(uint8_t volume) {
uint16_t value = min(volume, 255);
value = (((int)value * 0x3f) / 255) << 4;
value |= i2c_read_reg(HPOUT_CTRL) & ~(0x3f << 4);
@@ -341,12 +347,11 @@ static void ac101_set_earph_volume(uint8_t volume)
/****************************************************************************************
*
*/
static void ac101_set_output_mixer_gain(ac_output_mixer_gain_t gain, ac_output_mixer_source_t source)
{
static void ac101_set_output_mixer_gain(ac_output_mixer_gain_t gain,
ac_output_mixer_source_t source) {
uint16_t regval, temp, clrbit;
regval = i2c_read_reg(OMIXER_BST1_CTRL);
switch (source)
{
switch (source) {
case SRC_MIC1:
temp = (gain & 0x7) << 6;
clrbit = ~(0x7 << 6);
@@ -370,24 +375,22 @@ static void ac101_set_output_mixer_gain(ac_output_mixer_gain_t gain, ac_output_m
/****************************************************************************************
*
*/
static void ac101_start(ac_module_t mode)
{
if (mode == AC_MODULE_LINE)
{
static void ac101_start(ac_module_t mode) {
if (mode == AC_MODULE_LINE) {
i2c_write_reg(0x51, 0x0408);
i2c_write_reg(0x40, 0x8000);
i2c_write_reg(0x50, 0x3bc0);
}
if (mode == AC_MODULE_ADC || mode == AC_MODULE_ADC_DAC || mode == AC_MODULE_LINE)
{
if (mode == AC_MODULE_ADC || mode == AC_MODULE_ADC_DAC ||
mode == AC_MODULE_LINE) {
// I2S1_SDOUT_CTRL
// i2c_write_reg(PLL_CTRL2, 0x8120);
i2c_write_reg(0x04, 0x800c);
i2c_write_reg(0x05, 0x800c);
// res |= i2c_write_reg(0x06, 0x3000);
}
if (mode == AC_MODULE_DAC || mode == AC_MODULE_ADC_DAC || mode == AC_MODULE_LINE)
{
if (mode == AC_MODULE_DAC || mode == AC_MODULE_ADC_DAC ||
mode == AC_MODULE_LINE) {
uint16_t value = i2c_read_reg(PLL_CTRL2);
value |= 0x8000;
i2c_write_reg(PLL_CTRL2, value);
@@ -397,8 +400,7 @@ static void ac101_start(ac_module_t mode)
/****************************************************************************************
*
*/
static void ac101_stop(void)
{
static void ac101_stop(void) {
uint16_t value = i2c_read_reg(PLL_CTRL2);
value &= ~0x8000;
i2c_write_reg(PLL_CTRL2, value);
@@ -407,16 +409,14 @@ static void ac101_stop(void)
/****************************************************************************************
*
*/
static void ac101_deinit(void)
{
static void ac101_deinit(void) {
i2c_write_reg(CHIP_AUDIO_RS, 0x123); //soft reset
}
/****************************************************************************************
* Don't know when this one is supposed to be called
*/
static void ac101_i2s_config_clock(ac_i2s_clock_t *cfg)
{
static void ac101_i2s_config_clock(ac_i2s_clock_t* cfg) {
uint16_t regval = 0;
regval = i2c_read_reg(I2S1LCK_CTRL);
regval &= 0xe03f;

300
components/spotify/cspot/bell/main/audio-sinks/esp/es8311.c
View File

@@ -22,9 +22,9 @@
*
*/
#include "es8311.h"
#include <string.h>
#include "esp_log.h"
#include "es8311.h"
// #include "board.h"
/* ES8311 address
@@ -93,9 +93,12 @@ struct _coeff_div {
static const struct _coeff_div coeff_div[] = {
//mclk rate prediv mult adcdiv dacdiv fsmode lrch lrcl bckdiv osr
/* 8k */
{12288000, 8000 , 0x06, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 8000 , 0x03, 0x02, 0x03, 0x03, 0x00, 0x05, 0xff, 0x18, 0x10, 0x10},
{16384000, 8000 , 0x08, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{12288000, 8000, 0x06, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 8000, 0x03, 0x02, 0x03, 0x03, 0x00, 0x05, 0xff, 0x18, 0x10,
0x10},
{16384000, 8000, 0x08, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{8192000, 8000, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 8000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{4096000, 8000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
@@ -105,91 +108,156 @@ static const struct _coeff_div coeff_div[] = {
{1024000, 8000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 11.025k */
{11289600, 11025, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800 , 11025, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400 , 11025, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200 , 11025, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{11289600, 11025, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{5644800, 11025, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{2822400, 11025, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1411200, 11025, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 12k */
{12288000, 12000, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 12000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 12000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 12000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{12288000, 12000, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 12000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 12000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 12000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 16k */
{12288000, 16000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 16000, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, 0xff, 0x0c, 0x10, 0x10},
{16384000, 16000, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000 , 16000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 16000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{4096000 , 16000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 16000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2048000 , 16000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 16000, 0x03, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1024000 , 16000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{12288000, 16000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 16000, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, 0xff, 0x0c, 0x10,
0x10},
{16384000, 16000, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{8192000, 16000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 16000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{4096000, 16000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 16000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{2048000, 16000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 16000, 0x03, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1024000, 16000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 22.05k */
{11289600, 22050, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800 , 22050, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400 , 22050, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200 , 22050, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{11289600, 22050, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{5644800, 22050, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{2822400, 22050, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1411200, 22050, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 24k */
{12288000, 24000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 24000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 24000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 24000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 24000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{12288000, 24000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 24000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 24000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 24000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 24000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 32k */
{12288000, 32000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 32000, 0x03, 0x04, 0x03, 0x03, 0x00, 0x02, 0xff, 0x0c, 0x10, 0x10},
{16384000, 32000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000 , 32000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 32000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{4096000 , 32000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 32000, 0x03, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2048000 , 32000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 32000, 0x03, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
{1024000 , 32000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{12288000, 32000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 32000, 0x03, 0x04, 0x03, 0x03, 0x00, 0x02, 0xff, 0x0c, 0x10,
0x10},
{16384000, 32000, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{8192000, 32000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 32000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{4096000, 32000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 32000, 0x03, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{2048000, 32000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 32000, 0x03, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10,
0x10},
{1024000, 32000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 44.1k */
{11289600, 44100, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800 , 44100, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400 , 44100, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200 , 44100, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{11289600, 44100, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{5644800, 44100, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{2822400, 44100, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1411200, 44100, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 48k */
{12288000, 48000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 48000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 48000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 48000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 48000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{12288000, 48000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 48000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 48000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 48000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 48000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
/* 64k */
{12288000, 64000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 64000, 0x03, 0x04, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10, 0x10},
{16384000, 64000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000 , 64000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 64000, 0x01, 0x04, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10, 0x10},
{4096000 , 64000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 64000, 0x01, 0x08, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10, 0x10},
{2048000 , 64000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 64000, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0xbf, 0x03, 0x18, 0x18},
{1024000 , 64000, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
{12288000, 64000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 64000, 0x03, 0x04, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10,
0x10},
{16384000, 64000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{8192000, 64000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 64000, 0x01, 0x04, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10,
0x10},
{4096000, 64000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 64000, 0x01, 0x08, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10,
0x10},
{2048000, 64000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 64000, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0xbf, 0x03, 0x18,
0x18},
{1024000, 64000, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10,
0x10},
/* 88.2k */
{11289600, 88200, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800 , 88200, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400 , 88200, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200 , 88200, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
{11289600, 88200, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{5644800, 88200, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{2822400, 88200, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1411200, 88200, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10,
0x10},
/* 96k */
{12288000, 96000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 96000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000 , 96000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000 , 96000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000 , 96000, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
{12288000, 96000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{18432000, 96000, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{6144000, 96000, 0x01, 0x04, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{3072000, 96000, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10,
0x10},
{1536000, 96000, 0x01, 0x08, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10,
0x10},
};
static char* TAG = "DRV8311";
@@ -200,8 +268,7 @@ static char *TAG = "DRV8311";
return b; \
}
static int Es8311WriteReg(uint8_t regAdd, uint8_t data)
{
static int Es8311WriteReg(uint8_t regAdd, uint8_t data) {
int res = 0;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
res |= i2c_master_start(cmd);
@@ -215,8 +282,7 @@ static int Es8311WriteReg(uint8_t regAdd, uint8_t data)
return res;
}
int Es8311ReadReg(uint8_t regAdd)
{
int Es8311ReadReg(uint8_t regAdd) {
uint8_t data;
int res = 0;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
@@ -240,8 +306,7 @@ int Es8311ReadReg(uint8_t regAdd)
return (int)data;
}
static int Es7243WriteReg(uint8_t regAdd, uint8_t data)
{
static int Es7243WriteReg(uint8_t regAdd, uint8_t data) {
int res = 0;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
res |= i2c_master_start(cmd);
@@ -255,9 +320,7 @@ static int Es7243WriteReg(uint8_t regAdd, uint8_t data)
return res;
}
int Es7243ReadReg(uint8_t regAdd)
{
int Es7243ReadReg(uint8_t regAdd) {
uint8_t data;
int res = 0;
i2c_cmd_handle_t cmd = i2c_cmd_link_create();
@@ -281,8 +344,7 @@ int Es7243ReadReg(uint8_t regAdd)
return (int)data;
}
esp_err_t Es7243Init(void)
{
esp_err_t Es7243Init(void) {
esp_err_t ret = ESP_OK;
ret |= Es7243WriteReg(0x00, 0x01);
ret |= Es7243WriteReg(0x06, 0x00);
@@ -297,8 +359,7 @@ esp_err_t Es7243Init(void)
return ret;
}
static int I2cInit(i2c_config_t *conf, int i2cMasterPort)
{
static int I2cInit(i2c_config_t* conf, int i2cMasterPort) {
int res;
res = i2c_param_config(i2cMasterPort, conf);
res |= i2c_driver_install(i2cMasterPort, conf->mode, 0, 0, 0);
@@ -309,8 +370,7 @@ static int I2cInit(i2c_config_t *conf, int i2cMasterPort)
/*
* look for the coefficient in coeff_div[] table
*/
static int get_coeff(uint32_t mclk, uint32_t rate)
{
static int get_coeff(uint32_t mclk, uint32_t rate) {
for (int i = 0; i < (sizeof(coeff_div) / sizeof(coeff_div[0])); i++) {
if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
return i;
@@ -320,14 +380,14 @@ static int get_coeff(uint32_t mclk, uint32_t rate)
/*
* set es8311 clock parameter and PCM/I2S interface
*/
static void es8311_pcm_hw_params(uint32_t mclk, uint32_t lrck)
{
static void es8311_pcm_hw_params(uint32_t mclk, uint32_t lrck) {
int coeff;
uint8_t regv, datmp;
ESP_LOGI(TAG, "Enter into es8311_pcm_hw_params()\n");
coeff = get_coeff(mclk, lrck);
if (coeff < 0) {
ESP_LOGE(TAG, "Unable to configure sample rate %dHz with %dHz MCLK\n", lrck, mclk);
ESP_LOGE(TAG, "Unable to configure sample rate %dHz with %dHz MCLK\n", lrck,
mclk);
return;
}
@@ -412,8 +472,7 @@ static void es8311_pcm_hw_params(uint32_t mclk, uint32_t lrck)
* if mute = 0, dac un-mute
* if mute = 1, dac mute
*/
static void es8311_mute(int mute)
{
static void es8311_mute(int mute) {
uint8_t regv;
ESP_LOGI(TAG, "Enter into es8311_mute(), mute = %d\n", mute);
regv = Es8311ReadReg(ES8311_DAC_REG31) & 0x9f;
@@ -450,8 +509,7 @@ static void es8311_mute(int mute)
/*
* initialize es8311 codec
*/
static void es8311_init(uint32_t mclk_freq, uint32_t lrck_freq)
{
static void es8311_init(uint32_t mclk_freq, uint32_t lrck_freq) {
int regv;
Es8311WriteReg(ES8311_GP_REG45, 0x00);
Es8311WriteReg(ES8311_CLK_MANAGER_REG01, 0x30);
@@ -561,8 +619,7 @@ static void es8311_init(uint32_t mclk_freq, uint32_t lrck_freq)
/*
* set codec private data and initialize codec
*/
void es8311_Codec_Startup(uint32_t mclk_freq, uint32_t lrck_freq)
{
void es8311_Codec_Startup(uint32_t mclk_freq, uint32_t lrck_freq) {
ESP_LOGI(TAG, "Enter into es8311_Codec_Startup()\n");
es8311_priv->dmic_enable = false;
es8311_priv->mclkinv = false;
@@ -596,8 +653,7 @@ void es8311_Codec_Startup(uint32_t mclk_freq, uint32_t lrck_freq)
// return res;
// }
esp_err_t Es8311GetRef(bool flag)
{
esp_err_t Es8311GetRef(bool flag) {
esp_err_t ret = ESP_OK;
uint8_t regv = 0;
if (flag) {
@@ -610,23 +666,20 @@ esp_err_t Es8311GetRef(bool flag)
return ret;
}
int Es8311Init(Es8311Config *cfg)
{
int Es8311Init(Es8311Config* cfg) {
es8311_priv = calloc(1, sizeof(struct es8311_private));
I2cInit(&cfg->i2c_cfg, cfg->i2c_port_num); // ESP32 in master mode
es8311_Codec_Startup(11289600, 44100);
return 0;
}
void Es8311Uninit()
{
void Es8311Uninit() {
Es8311WriteReg(ES8311_RESET_REG00, 0x3f);
free(es8311_priv);
es8311_priv = NULL;
}
int Es8311ConfigFmt(ESCodecModule mode, ESCodecI2SFmt fmt)
{
int Es8311ConfigFmt(ESCodecModule mode, ESCodecI2SFmt fmt) {
int res = 0;
uint8_t regAdc = 0, regDac = 0;
if (mode == ES_MODULE_ADC || mode == ES_MODULE_ADC_DAC) {
@@ -665,14 +718,12 @@ int Es8311ConfigFmt(ESCodecModule mode, ESCodecI2SFmt fmt)
return res;
}
int Es8311I2sConfigClock(ESCodecI2sClock cfg)
{
int Es8311I2sConfigClock(ESCodecI2sClock cfg) {
int res = 0;
return res;
}
int Es8311SetBitsPerSample(ESCodecModule mode, BitsLength bitPerSample)
{
int Es8311SetBitsPerSample(ESCodecModule mode, BitsLength bitPerSample) {
int res = 0;
uint8_t reg = 0;
int bits = (int)bitPerSample;
@@ -690,32 +741,31 @@ int Es8311SetBitsPerSample(ESCodecModule mode, BitsLength bitPerSample)
return res;
}
int Es8311Start(ESCodecModule mode)
{
int Es8311Start(ESCodecModule mode) {
int res = 0;
if (mode == ES_MODULE_ADC || mode == ES_MODULE_ADC_DAC) {
res |= Es8311WriteReg(ES8311_ADC_REG17, 0xBF);
}
if (mode == ES_MODULE_DAC || mode == ES_MODULE_ADC_DAC) {
res |= Es8311WriteReg(ES8311_SYSTEM_REG12, Es8311ReadReg(ES8311_SYSTEM_REG12) & 0xfd);
res |= Es8311WriteReg(ES8311_SYSTEM_REG12,
Es8311ReadReg(ES8311_SYSTEM_REG12) & 0xfd);
}
return res;
}
int Es8311Stop(ESCodecModule mode)
{
int Es8311Stop(ESCodecModule mode) {
int res = 0;
if (mode == ES_MODULE_ADC || mode == ES_MODULE_ADC_DAC) {
res |= Es8311WriteReg(ES8311_ADC_REG17, 0x00);
}
if (mode == ES_MODULE_DAC || mode == ES_MODULE_ADC_DAC) {
res |= Es8311WriteReg(ES8311_SYSTEM_REG12, Es8311ReadReg(ES8311_SYSTEM_REG12) | 0x02);
res |= Es8311WriteReg(ES8311_SYSTEM_REG12,
Es8311ReadReg(ES8311_SYSTEM_REG12) | 0x02);
}
return res;
}
int Es8311SetVoiceVolume(int volume)
{
int Es8311SetVoiceVolume(int volume) {
int res = 0;
if (volume == 0) {
@@ -726,8 +776,7 @@ int Es8311SetVoiceVolume(int volume)
return res;
}
int Es8311GetVoiceVolume(int *volume)
{
int Es8311GetVoiceVolume(int* volume) {
int res = ESP_OK;
int regv = Es8311ReadReg(ES8311_DAC_REG32);
if (regv == ESP_FAIL) {
@@ -740,16 +789,14 @@ int Es8311GetVoiceVolume(int *volume)
return res;
}
int Es8311SetVoiceMute(int enable)
{
int Es8311SetVoiceMute(int enable) {
int res = 0;
ESP_LOGI(TAG, "Es8311SetVoiceMute volume:%d\n", enable);
es8311_mute(enable);
return res;
}
int Es8311GetVoiceMute(int *mute)
{
int Es8311GetVoiceMute(int* mute) {
int res = -1;
uint8_t reg = 0;
res = Es8311ReadReg(ES8311_DAC_REG31);
@@ -760,8 +807,7 @@ int Es8311GetVoiceMute(int *mute)
return res;
}
int Es8311SetMicGain(MicGain gain)
{
int Es8311SetMicGain(MicGain gain) {
int res = 0;
uint8_t gain_n = Es8311ReadReg(ES8311_ADC_REG16) & 0x07;
gain_n |= gain / 6;
@@ -769,26 +815,22 @@ int Es8311SetMicGain(MicGain gain)
return res;
}
int Es8311ConfigAdcInput(AdcInput input)
{
int Es8311ConfigAdcInput(AdcInput input) {
int res = 0;
return res;
}
int Es8311SetAdcVolume(uint8_t adc_vol)
{
int Es8311SetAdcVolume(uint8_t adc_vol) {
int res = 0;
res = Es8311WriteReg(ES8311_ADC_REG17, adc_vol); // MIC ADC Volume
return res;
}
int ES8311WriteReg(uint8_t regAdd, uint8_t data)
{
int ES8311WriteReg(uint8_t regAdd, uint8_t data) {
return Es8311WriteReg(regAdd, data);
}
void Es8311ReadAll()
{
void Es8311ReadAll() {
for (int i = 0; i < 0x4A; i++) {
uint8_t reg = Es8311ReadReg(i);
// ets_printf("REG:%02x, %02x\n", reg, i);

8
components/spotify/cspot/bell/main/audio-sinks/include/AudioSink.h
View File

@@ -5,15 +5,17 @@
#include <cstdlib>
#include <vector>
class AudioSink
{
class AudioSink {
public:
AudioSink() {}
virtual ~AudioSink() {}
virtual void feedPCMFrames(const uint8_t* buffer, size_t bytes) = 0;
virtual void volumeChanged(uint16_t volume) {}
// Return false if the sink doesn't support reconfiguration.
virtual bool setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) { return false; }
virtual bool setParams(uint32_t sampleRate, uint8_t channelCount,
uint8_t bitDepth) {
return false;
}
// Deprecated. Implement/use setParams() instead.
virtual inline bool setRate(uint16_t sampleRate) {
return setParams(sampleRate, 2, 16);

16
components/spotify/cspot/bell/main/audio-sinks/include/esp/AC101AudioSink.h
View File

@@ -1,24 +1,24 @@
#ifndef AC101AUDIOSINK_H
#define AC101AUDIOSINK_H
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include "esp_err.h"
#include "esp_log.h"
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "ac101.h"
#include "adac.h"
#include "esp_err.h"
#include "esp_log.h"
class AC101AudioSink : public BufferedAudioSink
{
class AC101AudioSink : public BufferedAudioSink {
public:
AC101AudioSink();
~AC101AudioSink();
void volumeChanged(uint16_t volume);
private:
adac_s* dac;
};

16
components/spotify/cspot/bell/main/audio-sinks/include/esp/BufferedAudioSink.h
View File

@@ -1,24 +1,26 @@
#ifndef BUFFEREDAUDIOSINK_H
#define BUFFEREDAUDIOSINK_H
#include <vector>
#include <iostream>
#include "AudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "AudioSink.h"
#include "esp_err.h"
#include "esp_log.h"
class BufferedAudioSink : public AudioSink
{
class BufferedAudioSink : public AudioSink {
public:
void feedPCMFrames(const uint8_t* buffer, size_t bytes) override;
bool setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) override;
bool setParams(uint32_t sampleRate, uint8_t channelCount,
uint8_t bitDepth) override;
protected:
void startI2sFeed(size_t buf_size = 4096 * 8);
void feedPCMFramesInternal(const void* pvItem, size_t xItemSize);
private:
};

16
components/spotify/cspot/bell/main/audio-sinks/include/esp/ES8311AudioSink.h
View File

@@ -1,27 +1,27 @@
#ifndef ES8311AUDIOSINK_H
#define ES8311AUDIOSINK_H
#include "driver/i2s.h"
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "driver/gpio.h"
#include "driver/i2c.h"
#include <sys/unistd.h>
#include <sys/stat.h>
#include "driver/i2s.h"
#include "esp_err.h"
#include "esp_log.h"
class ES8311AudioSink : public BufferedAudioSink
{
class ES8311AudioSink : public BufferedAudioSink {
public:
ES8311AudioSink();
~ES8311AudioSink();
void writeReg(uint8_t reg_add, uint8_t data);
void volumeChanged(uint16_t volume);
void setSampleRate(uint32_t sampleRate);
private:
};

20
components/spotify/cspot/bell/main/audio-sinks/include/esp/ES8388AudioSink.h
View File

@@ -1,20 +1,19 @@
#ifndef ES8388AUDIOSINK_H
#define ES8388AUDIOSINK_H
#include "driver/i2s.h"
#include <driver/i2c.h>
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "driver/i2s.h"
#include "esp_err.h"
#include "esp_log.h"
#define ES8388_ADDR 0x20
#define ACK_CHECK_EN 0x1
@@ -78,16 +77,14 @@
#define ES8388_DACCONTROL29 0x33
#define ES8388_DACCONTROL30 0x34
class ES8388AudioSink : public BufferedAudioSink
{
class ES8388AudioSink : public BufferedAudioSink {
public:
ES8388AudioSink();
~ES8388AudioSink();
bool begin(int sda = -1, int scl = -1, uint32_t frequency = 400000U);
enum ES8388_OUT
{
enum ES8388_OUT {
ES_MAIN, // this is the DAC output volume (both outputs)
ES_OUT1, // this is the additional gain for OUT1
ES_OUT2 // this is the additional gain for OUT2
@@ -97,6 +94,7 @@ public:
void volume(const ES8388_OUT out, const uint8_t vol);
void writeReg(uint8_t reg_add, uint8_t data);
private:
i2c_config_t i2c_config;
i2c_port_t i2c_port = 0;

12
components/spotify/cspot/bell/main/audio-sinks/include/esp/ES9018AudioSink.h
View File

@@ -1,21 +1,21 @@
#ifndef ES9018AUDIOSINK_H
#define ES9018AUDIOSINK_H
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "esp_err.h"
#include "esp_log.h"
class ES9018AudioSink : public BufferedAudioSink
{
class ES9018AudioSink : public BufferedAudioSink {
public:
ES9018AudioSink();
~ES9018AudioSink();
private:
};

12
components/spotify/cspot/bell/main/audio-sinks/include/esp/InternalAudioSink.h
View File

@@ -1,21 +1,21 @@
#ifndef INTERNALAUDIOSINK_H
#define INTERNALAUDIOSINK_H
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "esp_err.h"
#include "esp_log.h"
class InternalAudioSink : public BufferedAudioSink
{
class InternalAudioSink : public BufferedAudioSink {
public:
InternalAudioSink();
~InternalAudioSink();
private:
};

12
components/spotify/cspot/bell/main/audio-sinks/include/esp/PCM5102AudioSink.h
View File

@@ -1,21 +1,21 @@
#ifndef PCM5102AUDIOSINK_H
#define PCM5102AUDIOSINK_H
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "esp_err.h"
#include "esp_log.h"
class PCM5102AudioSink : public BufferedAudioSink
{
class PCM5102AudioSink : public BufferedAudioSink {
public:
PCM5102AudioSink();
~PCM5102AudioSink();
private:
};

16
components/spotify/cspot/bell/main/audio-sinks/include/esp/SPDIFAudioSink.h
View File

@@ -1,25 +1,27 @@
#ifndef SPDIFAUDIOSINK_H
#define SPDIFAUDIOSINK_H
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "esp_err.h"
#include "esp_log.h"
class SPDIFAudioSink : public BufferedAudioSink
{
class SPDIFAudioSink : public BufferedAudioSink {
private:
uint8_t spdifPin;
public:
explicit SPDIFAudioSink(uint8_t spdifPin);
~SPDIFAudioSink() override;
void feedPCMFrames(const uint8_t* buffer, size_t bytes) override;
bool setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) override;
bool setParams(uint32_t sampleRate, uint8_t channelCount,
uint8_t bitDepth) override;
private:
};

16
components/spotify/cspot/bell/main/audio-sinks/include/esp/TAS5711AudioSink.h
View File

@@ -1,27 +1,25 @@
#ifndef TAS5711AUDIOSINK_H
#define TAS5711AUDIOSINK_H
#include "driver/i2s.h"
#include <driver/i2c.h>
#include <vector>
#include <iostream>
#include "BufferedAudioSink.h"
#include <stdio.h>
#include <string.h>
#include <sys/unistd.h>
#include <sys/stat.h>
#include <sys/unistd.h>
#include <iostream>
#include <vector>
#include "BufferedAudioSink.h"
#include "driver/i2s.h"
#include "esp_err.h"
#include "esp_log.h"
class TAS5711AudioSink : public BufferedAudioSink
{
class TAS5711AudioSink : public BufferedAudioSink {
public:
TAS5711AudioSink();
~TAS5711AudioSink();
void writeReg(uint8_t reg, uint8_t value);
private:
i2c_config_t i2c_config;
i2c_port_t i2c_port = 0;

2
components/spotify/cspot/bell/main/audio-sinks/include/esp/adac.h
View File

@@ -9,8 +9,8 @@
*
*/
#include "freertos/FreeRTOS.h"
#include "driver/i2s.h"
#include "freertos/FreeRTOS.h"
typedef enum { ADAC_ON = 0, ADAC_STANDBY, ADAC_OFF } adac_power_e;

20
components/spotify/cspot/bell/main/audio-sinks/include/esp/es8311.h
View File

@@ -23,7 +23,8 @@
/*
* Clock Scheme Register definition
*/
#define ES8311_CLK_MANAGER_REG01 0x01 /* select clk src for mclk, enable clock for codec */
#define ES8311_CLK_MANAGER_REG01 \
0x01 /* select clk src for mclk, enable clock for codec */
#define ES8311_CLK_MANAGER_REG02 0x02 /* clk divider and clk multiplier */
#define ES8311_CLK_MANAGER_REG03 0x03 /* adc fsmode and osr */
#define ES8311_CLK_MANAGER_REG04 0x04 /* dac osr */
@@ -42,7 +43,8 @@
#define ES8311_SYSTEM_REG11 0x11 /* system */
#define ES8311_SYSTEM_REG12 0x12 /* system, Enable DAC */
#define ES8311_SYSTEM_REG13 0x13 /* system */
#define ES8311_SYSTEM_REG14 0x14 /* system, select DMIC, select analog pga gain */
#define ES8311_SYSTEM_REG14 \
0x14 /* system, select DMIC, select analog pga gain */
#define ES8311_ADC_REG15 0x15 /* ADC, adc ramp rate, dmic sense */
#define ES8311_ADC_REG16 0x16 /* ADC */
#define ES8311_ADC_REG17 0x17 /* ADC, volume */
@@ -66,7 +68,6 @@
#define ES8311_MAX_REGISTER 0xFF
typedef struct {
ESCodecMode esMode;
i2c_port_t i2c_port_num;
@@ -75,20 +76,19 @@ typedef struct {
AdcInput adcInput;
} Es8311Config;
#define AUDIO_CODEC_ES8311_DEFAULT(){ \
#define AUDIO_CODEC_ES8311_DEFAULT() \
{ \
.esMode = ES_MODE_SLAVE, \
.i2c_port_num = I2C_NUM_0, \
.i2c_cfg = { \
.mode = I2C_MODE_MASTER, \
.i2c_cfg = {.mode = I2C_MODE_MASTER, \
.sda_io_num = IIC_DATA, \
.scl_io_num = IIC_CLK, \
.sda_pullup_en = GPIO_PULLUP_ENABLE, \
.scl_pullup_en = GPIO_PULLUP_ENABLE, \
.master.clk_speed = 100000\
}, \
.master.clk_speed = 100000}, \
.adcInput = ADC_INPUT_LINPUT1_RINPUT1, \
.dacOutput = DAC_OUTPUT_LOUT1 | DAC_OUTPUT_LOUT2 | DAC_OUTPUT_ROUT1 | DAC_OUTPUT_ROUT2,\
.dacOutput = DAC_OUTPUT_LOUT1 | DAC_OUTPUT_LOUT2 | DAC_OUTPUT_ROUT1 | \
DAC_OUTPUT_ROUT2, \
};
int Es8311Init(Es8311Config* cfg);

50
components/spotify/cspot/bell/main/audio-sinks/include/unix/ALSAAudioSink.h
View File

@@ -1,34 +1,30 @@
#pragma once
#include <vector>
#include <fstream>
#include "AudioSink.h"
#include <BellTask.h>
#include <alsa/asoundlib.h>
#include <stdio.h>
#include <BellTask.h>
#include <unistd.h>
#include <fstream>
#include <memory>
#include <mutex>
#include <vector>
#include "AudioSink.h"
#define PCM_DEVICE "default"
template <typename T, int SIZE>
class RingbufferPointer
{
class RingbufferPointer {
typedef std::unique_ptr<T> TPointer;
public:
explicit RingbufferPointer()
{
explicit RingbufferPointer() {
// create objects
for (int i = 0; i < SIZE; i++)
{
for (int i = 0; i < SIZE; i++) {
buf_[i] = std::make_unique<T>();
}
}
bool push(TPointer &item)
{
bool push(TPointer& item) {
std::lock_guard<std::mutex> lock(mutex_);
if (full())
return false;
@@ -44,8 +40,7 @@ public:
return true;
}
bool pop(TPointer &item)
{
bool pop(TPointer& item) {
std::lock_guard<std::mutex> lock(mutex_);
if (empty())
return false;
@@ -58,34 +53,22 @@ public:
return true;
}
void reset()
{
void reset() {
std::lock_guard<std::mutex> lock(mutex_);
head_ = tail_;
full_ = false;
}
bool empty() const
{
return (!full_ && (head_ == tail_));
}
bool empty() const { return (!full_ && (head_ == tail_)); }
bool full() const
{
return full_;
}
bool full() const { return full_; }
int capacity() const
{
return max_size_;
}
int capacity() const { return max_size_; }
int size() const
{
int size() const {
int size = max_size_;
if (!full_)
{
if (!full_) {
if (head_ >= tail_)
size = head_ - tail_;
else
@@ -105,8 +88,7 @@ private:
bool full_ = 0;
};
class ALSAAudioSink : public AudioSink, public bell::Task
{
class ALSAAudioSink : public AudioSink, public bell::Task {
public:
ALSAAudioSink();
~ALSAAudioSink();

11
components/spotify/cspot/bell/main/audio-sinks/include/unix/NamedPipeAudioSink.h
View File

@@ -1,11 +1,12 @@
#pragma once
#include <vector>
#include <fstream>
#include "AudioSink.h"
#include <stddef.h> // for size_t
#include <stdint.h> // for uint8_t
#include <fstream> // for ofstream
class NamedPipeAudioSink : public AudioSink
{
#include "AudioSink.h" // for AudioSink
class NamedPipeAudioSink : public AudioSink {
public:
NamedPipeAudioSink();
~NamedPipeAudioSink();

47
components/spotify/cspot/bell/main/audio-sinks/unix/ALSAAudioSink.cpp
View File

@@ -1,13 +1,11 @@
#include "ALSAAudioSink.h"
ALSAAudioSink::ALSAAudioSink() : Task("", 0, 0, 0)
{
ALSAAudioSink::ALSAAudioSink() : Task("", 0, 0, 0) {
/* Open the PCM device in playback mode */
if (pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE,
SND_PCM_STREAM_PLAYBACK, 0) < 0)
{
printf("ERROR: Can't open \"%s\" PCM device. %s\n",
PCM_DEVICE, snd_strerror(pcm));
if (pcm = snd_pcm_open(&pcm_handle, PCM_DEVICE, SND_PCM_STREAM_PLAYBACK, 0) <
0) {
printf("ERROR: Can't open \"%s\" PCM device. %s\n", PCM_DEVICE,
snd_strerror(pcm));
}
/* Allocate parameters object and fill it with default values*/
@@ -57,44 +55,37 @@ ALSAAudioSink::ALSAAudioSink() : Task("", 0, 0, 0)
this->startTask();
}
ALSAAudioSink::~ALSAAudioSink()
{
ALSAAudioSink::~ALSAAudioSink() {
snd_pcm_drain(pcm_handle);
snd_pcm_close(pcm_handle);
}
void ALSAAudioSink::runTask()
{
void ALSAAudioSink::runTask() {
std::unique_ptr<std::vector<uint8_t>> dataPtr;
while (true)
{
if (!this->ringbuffer.pop(dataPtr))
{
while (true) {
if (!this->ringbuffer.pop(dataPtr)) {
usleep(100);
continue;
}
if (pcm = snd_pcm_writei(pcm_handle, dataPtr->data(), this->frames) == -EPIPE)
{
if (pcm = snd_pcm_writei(pcm_handle, dataPtr->data(), this->frames) ==
-EPIPE) {
snd_pcm_prepare(pcm_handle);
}
else if (pcm < 0)
{
} else if (pcm < 0) {
printf("ERROR. Can't write to PCM device. %s\n", snd_strerror(pcm));
}
}
}
void ALSAAudioSink::feedPCMFrames(const uint8_t *buffer, size_t bytes)
{
void ALSAAudioSink::feedPCMFrames(const uint8_t* buffer, size_t bytes) {
buff.insert(buff.end(), buffer, buffer + bytes);
while (buff.size() > this->buff_size)
{
auto ptr = std::make_unique<std::vector<uint8_t>>(this->buff.begin(), this->buff.begin() + this->buff_size);
this->buff = std::vector<uint8_t>(this->buff.begin() + this->buff_size, this->buff.end());
while (!this->ringbuffer.push(ptr))
{
while (buff.size() > this->buff_size) {
auto ptr = std::make_unique<std::vector<uint8_t>>(
this->buff.begin(), this->buff.begin() + this->buff_size);
this->buff = std::vector<uint8_t>(this->buff.begin() + this->buff_size,
this->buff.end());
while (!this->ringbuffer.push(ptr)) {
usleep(100);
};
}

12
components/spotify/cspot/bell/main/audio-sinks/unix/NamedPipeAudioSink.cpp
View File

@@ -1,20 +1,18 @@
#include "NamedPipeAudioSink.h"
NamedPipeAudioSink::NamedPipeAudioSink()
{
#include <stdio.h> // for printf
NamedPipeAudioSink::NamedPipeAudioSink() {
printf("Start\n");
this->namedPipeFile = std::ofstream("outputFifo", std::ios::binary);
printf("stop\n");
}
NamedPipeAudioSink::~NamedPipeAudioSink()
{
NamedPipeAudioSink::~NamedPipeAudioSink() {
this->namedPipeFile.close();
}
void NamedPipeAudioSink::feedPCMFrames(const uint8_t *buffer, size_t bytes)
{
void NamedPipeAudioSink::feedPCMFrames(const uint8_t* buffer, size_t bytes) {
// Write the actual data
this->namedPipeFile.write((char*)buffer, (long)bytes);
this->namedPipeFile.flush();

24
components/spotify/cspot/bell/main/audio-sinks/unix/PortAudioSink.cpp
View File

@@ -1,12 +1,12 @@
#include "PortAudioSink.h"
PortAudioSink::PortAudioSink()
{
PortAudioSink::PortAudioSink() {
Pa_Initialize();
this->setParams(44100, 2, 16);
}
bool PortAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t bitDepth) {
bool PortAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount,
uint8_t bitDepth) {
if (stream) {
Pa_StopStream(stream);
}
@@ -39,27 +39,19 @@ bool PortAudioSink::setParams(uint32_t sampleRate, uint8_t channelCount, uint8_t
outputParameters.suggestedLatency = 0.050;
outputParameters.hostApiSpecificStreamInfo = NULL;
PaError err = Pa_OpenStream(
&stream,
NULL,
&outputParameters,
sampleRate,
4096 / (channelCount * bitDepth / 8),
paClipOff,
PaError err = Pa_OpenStream(&stream, NULL, &outputParameters, sampleRate,
4096 / (channelCount * bitDepth / 8), paClipOff,
NULL, // blocking api
NULL
);
NULL);
Pa_StartStream(stream);
return !err;
}
PortAudioSink::~PortAudioSink()
{
PortAudioSink::~PortAudioSink() {
Pa_StopStream(stream);
Pa_Terminate();
}
void PortAudioSink::feedPCMFrames(const uint8_t *buffer, size_t bytes)
{
void PortAudioSink::feedPCMFrames(const uint8_t* buffer, size_t bytes) {
Pa_WriteStream(stream, buffer, bytes / 4);
}

23
components/spotify/cspot/bell/main/io/BellHTTPServer.cpp
View File

@@ -1,8 +1,14 @@
#include "BellHTTPServer.h"
#include <mutex>
#include <regex>
#include "CivetServer.h"
#include "civetweb.h"
#include <string.h> // for memcpy
#include <cassert> // for assert
#include <exception> // for exception
#include <mutex> // for scoped_lock
#include <regex> // for sregex_token_iterator, regex
#include "BellLogger.h" // for AbstractLogger, BELL_LOG, bell
#include "CivetServer.h" // for CivetServer, CivetWebSocketHandler
#include "civetweb.h" // for mg_get_request_info, mg_printf, mg_set_user...
using namespace bell;
@@ -195,7 +201,8 @@ std::unique_ptr<BellHTTPServer::HTTPResponse> BellHTTPServer::makeJsonResponse(
return response;
}
std::unique_ptr<BellHTTPServer::HTTPResponse> BellHTTPServer::makeEmptyResponse() {
std::unique_ptr<BellHTTPServer::HTTPResponse>
BellHTTPServer::makeEmptyResponse() {
auto response = std::make_unique<BellHTTPServer::HTTPResponse>();
return response;
}
@@ -225,8 +232,10 @@ void BellHTTPServer::registerNotFound(HTTPHandler handler) {
std::unordered_map<std::string, std::string> BellHTTPServer::extractParams(
struct mg_connection* conn) {
void* data = mg_get_user_connection_data(conn);
assert(data != nullptr);
std::unordered_map<std::string, std::string>& params =
*(std::unordered_map<std::string, std::string>*)
mg_get_user_connection_data(conn);
*(std::unordered_map<std::string, std::string>*)data;
return params;
}

14
components/spotify/cspot/bell/main/io/BellTar.cpp
View File

@@ -1,14 +1,18 @@
#include "BellTar.h"
#include <sys/stat.h>
#include <fstream>
#include <sys/stat.h> // for mkdir
using namespace bell::BellTar;
#include <cassert>
#include <cstdio> // for sprintf, snprintf and sscanf
#include <algorithm> // for min
#include <cassert> // for assert
#include <cstdint> // for uint8_t
#include <cstdio> // for sprintf, size_t, sscanf, EOF, NULL
#include <cstdlib> // for rand
#include <cstring> // for strlen and memset
#include <cstring> // for memset, strlen
#include <ctime> // for time
#include <fstream> // for ofstream
#include <vector> // for vector
#ifdef _WIN32
#include <direct.h>
#endif

21
components/spotify/cspot/bell/main/io/BinaryReader.cpp
View File

@@ -1,5 +1,10 @@
#include "BinaryReader.h"
#include <stdlib.h>
#include <stdlib.h> // for size_t
#include <cstdint> // for uint8_t
#include <type_traits> // for remove_extent_t
#include "ByteStream.h" // for ByteStream
bell::BinaryReader::BinaryReader(std::shared_ptr<ByteStream> stream) {
this->stream = stream;
@@ -27,10 +32,7 @@ int32_t bell::BinaryReader::readInt() {
if (stream->read((uint8_t*)b, 4) != 4)
return 0;
return static_cast<int32_t>(
(b[3]) |
(b[2] << 8) |
(b[1] << 16)|
return static_cast<int32_t>((b[3]) | (b[2] << 8) | (b[1] << 16) |
(b[0] << 24));
}
@@ -39,12 +41,9 @@ int16_t bell::BinaryReader::readShort() {
if (stream->read((uint8_t*)b, 2) != 2)
return 0;
return static_cast<int16_t>(
(b[1]) |
(b[0] << 8));
return static_cast<int16_t>((b[1]) | (b[0] << 8));
}
uint32_t bell::BinaryReader::readUInt() {
return readInt() & 0xffffffffL;
}
@@ -66,7 +65,5 @@ long long bell::BinaryReader::readLong() {
long high = readInt();
long low = readInt();
return static_cast<long long>(
((long long) high << 32) | low );
return static_cast<long long>(((long long)high << 32) | low);
}

2
components/spotify/cspot/bell/main/io/BinaryStream.cpp
View File

@@ -1,5 +1,5 @@
#include <BinaryStream.h>
#include <sstream>
#include <stdexcept> // for runtime_error
using namespace bell;

38
components/spotify/cspot/bell/main/io/BufferedStream.cpp
View File

@@ -1,14 +1,15 @@
#include "BufferedStream.h"
#include <cstring>
BufferedStream::BufferedStream(
const std::string &taskName,
uint32_t bufferSize,
uint32_t readThreshold,
uint32_t readSize,
#include <stdlib.h> // for free, malloc
#include <algorithm> // for min
#include <cstdint> // for uint32_t
#include <cstring> // for memcpy
#include <type_traits> // for remove_extent_t
BufferedStream::BufferedStream(const std::string& taskName, uint32_t bufferSize,
uint32_t readThreshold, uint32_t readSize,
uint32_t readyThreshold,
uint32_t notReadyThreshold,
bool waitForReady)
uint32_t notReadyThreshold, bool waitForReady)
: bell::Task(taskName, 4096, 5, 0) {
this->bufferSize = bufferSize;
this->readAt = bufferSize - readThreshold;
@@ -53,7 +54,8 @@ bool BufferedStream::open(const std::shared_ptr<bell::ByteStream> &stream) {
return source.get();
}
bool BufferedStream::open(const StreamReader &newReader, uint32_t initialOffset) {
bool BufferedStream::open(const StreamReader& newReader,
uint32_t initialOffset) {
if (this->running)
this->close();
reset();
@@ -97,16 +99,19 @@ uint32_t BufferedStream::lengthBetween(uint8_t *me, uint8_t *other) {
size_t BufferedStream::read(uint8_t* dst, size_t len) {
if (waitForReady && isNotReady()) {
while ((source || reader) && !isReady()) {} // end waiting after termination
while ((source || reader) && !isReady()) {
} // end waiting after termination
}
if (!running && !readAvailable) {
reset();
return 0;
}
uint32_t read = 0;
uint32_t toReadTotal = std::min(readAvailable.load(), static_cast<uint32_t>(len));
uint32_t toReadTotal =
std::min(readAvailable.load(), static_cast<uint32_t>(len));
while (toReadTotal > 0) {
uint32_t toRead = std::min(toReadTotal, lengthBetween(bufReadPtr, bufWritePtr));
uint32_t toRead =
std::min(toReadTotal, lengthBetween(bufReadPtr, bufWritePtr));
if (dst) {
memcpy(dst, bufReadPtr, toRead);
dst += toRead;
@@ -145,7 +150,8 @@ void BufferedStream::runTask() {
uint32_t len;
bool wasReady = isReady();
do {
uint32_t toRead = std::min(readSize, lengthBetween(bufWritePtr, bufReadPtr));
uint32_t toRead =
std::min(readSize, lengthBetween(bufWritePtr, bufReadPtr));
if (!source) {
len = 0;
break;
@@ -156,7 +162,11 @@ void BufferedStream::runTask() {
bufWritePtr += len;
if (bufWritePtr >= bufEnd) // TODO is == enough here?
bufWritePtr = buf;
} while (len && readSize < bufferSize - readAvailable); // loop until there's no more free space in the buffer
} while (
len &&
readSize <
bufferSize -
readAvailable); // loop until there's no more free space in the buffer
if (!len && reader)
source = reader(bufferTotal);
else if (!len)

20
components/spotify/cspot/bell/main/io/CircularBuffer.cpp
View File

@@ -1,24 +1,23 @@
#include "CircularBuffer.h"
#include <algorithm> // for min
using namespace bell;
CircularBuffer::CircularBuffer(size_t dataCapacity)
{
CircularBuffer::CircularBuffer(size_t dataCapacity) {
this->dataCapacity = dataCapacity;
buffer = std::vector<uint8_t>(dataCapacity);
this->dataSemaphore = std::make_unique<bell::WrappedSemaphore>(5);
};
size_t CircularBuffer::write(const uint8_t *data, size_t bytes)
{
size_t CircularBuffer::write(const uint8_t* data, size_t bytes) {
if (bytes == 0)
return 0;
std::lock_guard<std::mutex> guard(bufferMutex);
size_t bytesToWrite = std::min(bytes, dataCapacity - dataSize);
// Write in a single step
if (bytesToWrite <= dataCapacity - endIndex)
{
if (bytesToWrite <= dataCapacity - endIndex) {
memcpy(buffer.data() + endIndex, data, bytesToWrite);
endIndex += bytesToWrite;
if (endIndex == dataCapacity)
@@ -58,8 +57,7 @@ void CircularBuffer::emptyExcept(size_t sizeToSet) {
}
}
size_t CircularBuffer::read(uint8_t *data, size_t bytes)
{
size_t CircularBuffer::read(uint8_t* data, size_t bytes) {
if (bytes == 0)
return 0;
@@ -67,16 +65,14 @@ size_t CircularBuffer::read(uint8_t *data, size_t bytes)
size_t bytesToRead = std::min(bytes, dataSize);
// Read in a single step
if (bytesToRead <= dataCapacity - begIndex)
{
if (bytesToRead <= dataCapacity - begIndex) {
memcpy(data, buffer.data() + begIndex, bytesToRead);
begIndex += bytesToRead;
if (begIndex == dataCapacity)
begIndex = 0;
}
// Read in two steps
else
{
else {
size_t firstChunkSize = dataCapacity - begIndex;
memcpy(data, buffer.data() + begIndex, firstChunkSize);
size_t secondChunkSize = bytesToRead - firstChunkSize;

13
components/spotify/cspot/bell/main/io/EncodedAudioStream.cpp
View File

@@ -1,6 +1,14 @@
#include "EncodedAudioStream.h"
#include <iostream>
#include <string.h> // for memcpy, memmove
#include <stdexcept> // for runtime_error
#include <type_traits> // for remove_extent_t
#include <utility> // for move
#include "BellLogger.h" // for AbstractLogger, BELL_LOG, bell
#include "ByteStream.h" // for ByteStream
#include "DecoderGlobals.h" // for DecodersInstance, decodersInstance, AAC_...
using namespace bell;
EncodedAudioStream::EncodedAudioStream() {
@@ -171,5 +179,4 @@ void EncodedAudioStream::guessDataFormat() {
}
}
void EncodedAudioStream::readFully(uint8_t* dst, size_t nbytes) {
}
void EncodedAudioStream::readFully(uint8_t* dst, size_t nbytes) {}

43
components/spotify/cspot/bell/main/io/FileStream.cpp
View File

@@ -1,55 +1,48 @@
#include "FileStream.h"
#include <stdexcept> // for runtime_error
#include "BellLogger.h" // for bell
using namespace bell;
FileStream::FileStream(const std::string& path, std::string read)
{
FileStream::FileStream(const std::string& path, std::string read) {
file = fopen(path.c_str(), "rb");
if (file == NULL)
{
if (file == NULL) {
throw std::runtime_error("Could not open file: " + path);
}
}
FileStream::~FileStream()
{
FileStream::~FileStream() {
close();
}
size_t FileStream::read(uint8_t *buf, size_t nbytes)
{
if (file == NULL)
{
size_t FileStream::read(uint8_t* buf, size_t nbytes) {
if (file == NULL) {
throw std::runtime_error("Stream is closed");
}
return fread(buf, 1, nbytes, file);
}
size_t FileStream::skip(size_t nbytes)
{
if (file == NULL)
{
size_t FileStream::skip(size_t nbytes) {
if (file == NULL) {
throw std::runtime_error("Stream is closed");
}
return fseek(file, nbytes, SEEK_CUR);
}
size_t FileStream::position()
{
if (file == NULL)
{
size_t FileStream::position() {
if (file == NULL) {
throw std::runtime_error("Stream is closed");
}
return ftell(file);
}
size_t FileStream::size()
{
if (file == NULL)
{
size_t FileStream::size() {
if (file == NULL) {
throw std::runtime_error("Stream is closed");
}
@@ -60,10 +53,8 @@ size_t FileStream::size()
return size;
}
void FileStream::close()
{
if (file != NULL)
{
void FileStream::close() {
if (file != NULL) {
fclose(file);
file = NULL;
}

9
components/spotify/cspot/bell/main/io/HTTPClient.cpp
View File

@@ -1,5 +1,14 @@
#include "HTTPClient.h"
#include <string.h> // for memcpy
#include <algorithm> // for transform
#include <cassert> // for assert
#include <cctype> // for tolower
#include <ostream> // for operator<<, basic_ostream
#include <stdexcept> // for runtime_error
#include "BellSocket.h" // for bell
using namespace bell;
void HTTPClient::Response::connect(const std::string& url) {

10
components/spotify/cspot/bell/main/io/SocketStream.cpp
View File

@@ -1,9 +1,17 @@
#include "SocketStream.h"
#include <stdint.h> // for uint8_t
#include <cstdio> // for NULL, ssize_t
#include "TCPSocket.h" // for TCPSocket
#include "TLSSocket.h" // for TLSSocket
using namespace bell;
int SocketBuffer::open(const std::string& hostname, int port, bool isSSL) {
if (internalSocket != nullptr) { close(); }
if (internalSocket != nullptr) {
close();
}
if (isSSL) {
internalSocket = std::make_unique<bell::TLSSocket>();
} else {

11
components/spotify/cspot/bell/main/io/TLSSocket.cpp
View File

@@ -1,5 +1,14 @@
#include "TLSSocket.h"
#include "X509Bundle.h"
#include <mbedtls/ctr_drbg.h> // for mbedtls_ctr_drbg_free, mbedtls_ctr_...
#include <mbedtls/entropy.h> // for mbedtls_entropy_free, mbedtls_entro...
#include <mbedtls/net_sockets.h> // for mbedtls_net_connect, mbedtls_net_free
#include <mbedtls/ssl.h> // for mbedtls_ssl_conf_authmode, mbedtls_...
#include <cstring> // for strlen, NULL
#include <stdexcept> // for runtime_error
#include "BellLogger.h" // for AbstractLogger, BELL_LOG
#include "X509Bundle.h" // for shouldVerify, attach
/**
* Platform TLSSocket implementation for the mbedtls

32
components/spotify/cspot/bell/main/io/URLParser.cpp
View File

@@ -11,33 +11,43 @@ void URLParser::parse(const char* url, std::vector<std::string>& match) {
* below. This needs to be changed if you update that regex */
// get the schema
if (sscanf(url, "%[^:]:/", scratch) > 0) match[1] = scratch;
if (sscanf(url, "%[^:]:/", scratch) > 0)
match[1] = scratch;
// get the host
if (sscanf(url, "htt%*[^:]://%512[^/#?]", scratch) > 0) match[2] = scratch;
if (sscanf(url, "htt%*[^:]://%512[^/#?]", scratch) > 0)
match[2] = scratch;
// get the path
url = strstr(url, match[2].c_str()) + match[2].size();
if (sscanf(url, "/%512[^?]", scratch) > 0) match[3] = scratch;
else if (*url && *url != '?' && *url != '#') url++;
if (sscanf(url, "/%512[^?]", scratch) > 0)
match[3] = scratch;
else if (*url && *url != '?' && *url != '#')
url++;
// get the query
if (match[3].size()) url += match[3].size() + 1;
if (sscanf(url, "?%512[^#]", scratch) > 0) match[4] = scratch;
if (match[3].size())
url += match[3].size() + 1;
if (sscanf(url, "?%512[^#]", scratch) > 0)
match[4] = scratch;
// get the hash
if (match[4].size()) url += match[4].size() + 1;
if (sscanf(url, "#%512s", scratch) > 0) match[5] = scratch;
if (match[4].size())
url += match[4].size() + 1;
if (sscanf(url, "#%512s", scratch) > 0)
match[5] = scratch;
// fix the acquired items
match[3] = "/" + match[3];
if (match[4].size()) match[4] = "?" + match[4];
if (match[4].size())
match[4] = "?" + match[4];
// need at least schema and host
if (match[1].size() == 0 || match[2].size() == 0) match.clear();
if (match[1].size() == 0 || match[2].size() == 0)
match.clear();
}
#else
const std::regex URLParser::urlParseRegex = std::regex(
"^(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(\\?(?:[^#]*))?(#(?:.*))?");
#endif
}
} // namespace bell

22
components/spotify/cspot/bell/main/io/X509Bundle.cpp
View File

@@ -1,5 +1,15 @@
#include "X509Bundle.h"
#include <mbedtls/md.h> // for mbedtls_md, mbedtls_md_get_size
#include <mbedtls/pk.h> // for mbedtls_pk_can_do, mbedtls_pk_pa...
#include <mbedtls/ssl.h> // for mbedtls_ssl_conf_ca_chain, mbedt...
#include <mbedtls/x509.h> // for mbedtls_x509_buf, MBEDTLS_ERR_X5...
#include <stdlib.h> // for free, calloc
#include <string.h> // for memcmp, memcpy
#include <stdexcept> // for runtime_error
#include "BellLogger.h" // for AbstractLogger, BELL_LOG
using namespace bell::X509Bundle;
static mbedtls_x509_crt s_dummy_crt;
@@ -21,7 +31,8 @@ int bell::X509Bundle::crtCheckCertificate(mbedtls_x509_crt* child,
if ((ret = mbedtls_pk_parse_public_key(&parent.pk, pub_key_buf,
pub_key_len)) != 0) {
BELL_LOG(error, TAG, "PK parse failed with error %X", ret);
BELL_LOG(error, TAG, "PK parse failed with error 0x%04x, key len = %d", ret,
pub_key_len);
goto cleanup;
}
@@ -110,6 +121,8 @@ int bell::X509Bundle::crtVerifyCallback(void* buf, mbedtls_x509_crt* crt,
ret = crtCheckCertificate(
child, s_crt_bundle.crts[middle] + CRT_HEADER_OFFSET + name_len,
key_len);
} else {
BELL_LOG(error, TAG, "Certificate not found in bundle");
}
if (ret == 0) {
@@ -138,10 +151,13 @@ void bell::X509Bundle::init(const uint8_t* x509_bundle, size_t bundle_size) {
throw std::runtime_error("Unable to allocate memory for bundle");
}
bundleBytes.resize(bundle_size);
memcpy(bundleBytes.data(), x509_bundle, bundle_size);
const uint8_t* cur_crt;
/* This is the maximum region that is allowed to access */
const uint8_t* bundle_end = x509_bundle + bundle_size;
cur_crt = x509_bundle + BUNDLE_HEADER_OFFSET;
const uint8_t* bundle_end = bundleBytes.data() + bundle_size;
cur_crt = bundleBytes.data() + BUNDLE_HEADER_OFFSET;
for (int i = 0; i < num_certs; i++) {
crts[i] = cur_crt;

40
components/spotify/cspot/bell/main/io/include/BellHTTPServer.h
View File

@@ -1,22 +1,18 @@
#pragma once
#include <BellLogger.h>
#include <stdlib.h>
#include <sys/types.h>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <utility>
#include <optional>
#include <regex>
#include <sstream>
#include <string>
#include <mutex>
#include <unordered_map>
#include "CivetServer.h"
#include "civetweb.h"
#include <BellLogger.h> // for bell
#include <stdint.h> // for uint8_t
#include <stdlib.h> // for free, size_t
#include <functional> // for function
#include <map> // for map
#include <memory> // for unique_ptr
#include <mutex> // for mutex
#include <string> // for string, hash, operator==, operator<
#include <unordered_map> // for unordered_map
#include <utility> // for pair
#include <vector> // for vector
#include "CivetServer.h" // for CivetServer, CivetHandler
using namespace bell;
namespace bell {
@@ -46,7 +42,9 @@ class BellHTTPServer : public CivetHandler {
}
}
};
typedef std::function<std::unique_ptr<HTTPResponse>(struct mg_connection* conn)> HTTPHandler;
typedef std::function<std::unique_ptr<HTTPResponse>(
struct mg_connection* conn)>
HTTPHandler;
typedef std::function<void(struct mg_connection* conn, WSState)>
WSStateHandler;
typedef std::function<void(struct mg_connection* conn, char*, size_t)>
@@ -79,7 +77,8 @@ class BellHTTPServer : public CivetHandler {
std::vector<int> getListeningPorts() { return server->getListeningPorts(); };
void close() { server->close(); }
std::unique_ptr<HTTPResponse> makeJsonResponse(const std::string& json, int status = 200);
std::unique_ptr<HTTPResponse> makeJsonResponse(const std::string& json,
int status = 200);
std::unique_ptr<HTTPResponse> makeEmptyResponse();
void registerNotFound(HTTPHandler handler);
@@ -88,7 +87,8 @@ class BellHTTPServer : public CivetHandler {
void registerWS(const std::string&, WSDataHandler dataHandler,
WSStateHandler stateHandler);
static std::unordered_map<std::string, std::string> extractParams(struct mg_connection* conn);
static std::unordered_map<std::string, std::string> extractParams(
struct mg_connection* conn);
private:
std::unique_ptr<CivetServer> server;

2
components/spotify/cspot/bell/main/io/include/BellSocket.h
View File

@@ -14,6 +14,6 @@ class Socket {
virtual size_t read(uint8_t* buf, size_t len) = 0;
virtual bool isOpen() = 0;
virtual void close() = 0;
virtual int getFd() = 0;
};
} // namespace bell

5
components/spotify/cspot/bell/main/io/include/BellTar.h
View File

@@ -1,8 +1,7 @@
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <iostream> // for istream, ostream
#include <string> // for string
namespace bell::BellTar {
typedef long long unsigned file_size_t;

21
components/spotify/cspot/bell/main/io/include/BinaryReader.h
View File

@@ -1,17 +1,14 @@
#pragma once
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <memory>
#include "ByteStream.h"
#include <stdint.h> // for uint8_t, int16_t, int32_t, uint32_t
#include <stdlib.h> // for size_t
#include <memory> // for shared_ptr
#include <vector> // for vector
namespace bell
{
class BinaryReader
{
namespace bell {
class ByteStream;
class BinaryReader {
std::shared_ptr<ByteStream> stream;
size_t currentPos = 0;
@@ -28,4 +25,4 @@ namespace bell
std::vector<uint8_t> readBytes(size_t);
void skip(size_t);
};
}
} // namespace bell

7
components/spotify/cspot/bell/main/io/include/BinaryStream.h
View File

@@ -1,10 +1,11 @@
#pragma once
#ifndef ESP_PLATFORM
#include <bit>
#include <bit> // for endian
#endif
#include <iostream>
#include <vector>
#include <stdint.h> // for int16_t, int32_t, int64_t, uint16_t, uint32_t
#include <cstddef> // for byte
#include <iostream> // for istream, ostream
namespace bell {
class BinaryStream {

34
components/spotify/cspot/bell/main/io/include/BufferedStream.h
View File

@@ -1,12 +1,16 @@
#pragma once
#include "ByteStream.h"
#include "BellTask.h"
#include "WrappedSemaphore.h"
#include <atomic>
#include <functional>
#include <memory>
#include <mutex>
#include <stddef.h> // for size_t
#include <stdint.h> // for uint32_t, uint8_t
#include <atomic> // for atomic
#include <functional> // for function
#include <memory> // for shared_ptr
#include <mutex> // for mutex
#include <string> // for string
#include "BellTask.h" // for Task
#include "ByteStream.h" // for ByteStream
#include "WrappedSemaphore.h" // for WrappedSemaphore
/**
* This class implements a wrapper around an arbitrary bell::ByteStream,
@@ -41,13 +45,9 @@ class BufferedStream : public bell::ByteStream, bell::Task {
* @param waitForReady whether to wait for the buffer to be ready during reading
* @param endWithSource whether to end the streaming as soon as source returns 0 from read()
*/
BufferedStream(
const std::string &taskName,
uint32_t bufferSize,
uint32_t readThreshold,
uint32_t readSize,
uint32_t readyThreshold,
uint32_t notReadyThreshold,
BufferedStream(const std::string& taskName, uint32_t bufferSize,
uint32_t readThreshold, uint32_t readSize,
uint32_t readyThreshold, uint32_t notReadyThreshold,
bool waitForReady = false);
~BufferedStream() override;
bool open(const StreamPtr& stream);
@@ -105,8 +105,10 @@ class BufferedStream : public bell::ByteStream, bell::Task {
std::mutex runningMutex;
bool running = false;
bool terminate = false;
bell::WrappedSemaphore readSem; // signal to start writing to buffer after reading from it
std::mutex readMutex; // mutex for locking read operations during writing, and vice versa
bell::WrappedSemaphore
readSem; // signal to start writing to buffer after reading from it
std::mutex
readMutex; // mutex for locking read operations during writing, and vice versa
uint32_t bufferSize;
uint32_t readAt;
uint32_t readSize;

10
components/spotify/cspot/bell/main/io/include/ByteStream.h
View File

@@ -1,16 +1,14 @@
#ifndef BELL_BYTE_READER_H
#define BELL_BYTE_READER_H
#include <stdlib.h>
#include <stdint.h>
#include <stdlib.h>
/**
* A class for reading bytes from a stream. Further implemented in HTTPStream.h
*/
namespace bell
{
class ByteStream
{
namespace bell {
class ByteStream {
public:
ByteStream(){};
virtual ~ByteStream() = default;
@@ -22,6 +20,6 @@ namespace bell
virtual size_t size() = 0;
virtual void close() = 0;
};
}
} // namespace bell
#endif

20
components/spotify/cspot/bell/main/io/include/CircularBuffer.h
View File

@@ -1,12 +1,12 @@
#pragma once
#include <algorithm>
#include <memory>
#include <cstring>
#include <mutex>
#include <vector>
#include "WrappedSemaphore.h"
#include <cstdint> // for uint8_t
#include <cstring> // for size_t
#include <memory> // for unique_ptr
#include <mutex> // for mutex
#include <vector> // for vector
#include "WrappedSemaphore.h" // for WrappedSemaphore
namespace bell {
class CircularBuffer {
@@ -15,13 +15,9 @@ class CircularBuffer {
std::unique_ptr<bell::WrappedSemaphore> dataSemaphore;
size_t size() const {
return dataSize;
}
size_t size() const { return dataSize; }
size_t capacity() const {
return dataCapacity;
}
size_t capacity() const { return dataCapacity; }
size_t write(const uint8_t* data, size_t bytes);
size_t read(uint8_t* data, size_t bytes);

16
components/spotify/cspot/bell/main/io/include/EncodedAudioStream.h
View File

@@ -1,15 +1,17 @@
#pragma once
#include <string>
#include <vector>
#include <stddef.h> // for size_t
#include <cstdint> // for uint8_t
#include <memory> // for shared_ptr, unique_ptr
#include <string> // for basic_string, string
#include <vector> // for vector
#include "BellLogger.h"
#include "ByteStream.h"
#include "DecoderGlobals.h"
#include "aacdec.h"
#include "mp3dec.h"
#include "aacdec.h" // for AACFrameInfo
#include "mp3dec.h" // for MP3FrameInfo
namespace bell {
class ByteStream;
class EncodedAudioStream {
public:
EncodedAudioStream();

17
components/spotify/cspot/bell/main/io/include/FileStream.h
View File

@@ -1,10 +1,9 @@
#pragma once
#include <string>
#include <stdexcept>
#include <BellLogger.h>
#include <ByteStream.h>
#include <stdio.h>
#include <ByteStream.h> // for ByteStream
#include <stdint.h> // for uint8_t
#include <stdio.h> // for size_t, FILE
#include <string> // for string
/*
* FileStream
@@ -12,10 +11,8 @@
* A class for reading and writing to files implementing the ByteStream interface.
*
*/
namespace bell
{
class FileStream : public ByteStream
{
namespace bell {
class FileStream : public ByteStream {
public:
FileStream(const std::string& path, std::string mode);
~FileStream();
@@ -44,4 +41,4 @@ namespace bell
// Closes the connection
void close();
};
}
} // namespace bell

29
components/spotify/cspot/bell/main/io/include/HTTPClient.h
View File

@@ -1,24 +1,20 @@
#pragma once
#include <memory>
#include <stddef.h> // for size_t
#include <cstdint> // for uint8_t, int32_t
#include <memory> // for make_unique, unique_ptr
#include <string> // for string
#include <string_view> // for string_view
#include <utility> // for pair
#include <vector> // for vector
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
#include <variant>
#include <vector>
#include <cassert>
#include "BellSocket.h"
#include "ByteStream.h"
#include "SocketStream.h"
#include "URLParser.h"
#include "SocketStream.h" // for SocketStream
#include "URLParser.h" // for URLParser
#ifndef BELL_DISABLE_FMT
#include "fmt/core.h"
#include "fmt/core.h" // for format
#endif
#include "picohttpparser.h"
#include "picohttpparser.h" // for phr_header
namespace bell {
class HTTPClient {
@@ -34,7 +30,8 @@ class HTTPClient {
#ifndef BELL_DISABLE_FMT
return ValueHeader{"Range", fmt::format("bytes={}-{}", from, to)};
#else
return ValueHeader{"Range", "bytes=" + std::to_string(from) + "-" + std::to_string(to)};
return ValueHeader{
"Range", "bytes=" + std::to_string(from) + "-" + std::to_string(to)};
#endif
}

8
components/spotify/cspot/bell/main/io/include/SocketStream.h
View File

@@ -1,8 +1,10 @@
#pragma once
#include <iostream>
#include "TCPSocket.h"
#include "TLSSocket.h"
#include <iostream> // for streamsize, basic_streambuf<>::int_type, ios...
#include <memory> // for unique_ptr, operator!=
#include <string> // for char_traits, string
#include "BellSocket.h" // for Socket
namespace bell {
class SocketBuffer : public std::streambuf {

6
components/spotify/cspot/bell/main/io/include/TCPSocket.h
View File

@@ -39,6 +39,8 @@ class TCPSocket : public bell::Socket {
TCPSocket(){};
~TCPSocket() { close(); };
int getFd() { return sockFd; }
void open(const std::string& host, uint16_t port) {
int err;
int domain = AF_INET;
@@ -101,7 +103,9 @@ class TCPSocket : public bell::Socket {
#endif
return value;
}
bool isOpen() { return !isClosed; }
bool isOpen() {
return !isClosed;
}
void close() {
if (!isClosed) {

Some files were not shown because too many files have changed in this diff Show More