3#include "AudioToolsConfig.h"
9#include "AudioTools/CoreAudio/AudioBasic/Collections/Vector.h"
10#include "AudioTools/CoreAudio/AudioLogger.h"
17#define MIN(A, B) ((A) < (B) ? (A) : (B))
21using sample_rate_t = uint32_t;
28enum RxTxMode { UNDEFINED_MODE = 0, TX_MODE = 1, RX_MODE = 2, RXTX_MODE = 3 };
40static const char*
RxTxModeNames[4] = {
"UNDEFINED_MODE",
"TX_MODE",
"RX_MODE",
40static const char*
RxTxModeNames[4] = {
"UNDEFINED_MODE",
"TX_MODE",
"RX_MODE", {
…};
47static const char* TimeUnitStr[3]{
"MS",
"US",
"HZ"};
65 AudioInfo(sample_rate_t sampleRate, uint16_t channelCount,
66 uint8_t bitsPerSample) {
65 AudioInfo(sample_rate_t sampleRate, uint16_t channelCount, {
…}
117 virtual void clear() {
123 virtual void logInfo(
const char* source =
"") {
124 LOGI(
"%s sample_rate: %d / channels: %d / bits_per_sample: %d", source,
152 if (!notify_vector.contains(&bi)) notify_vector.push_back(&bi);
157 int pos = notify_vector.indexOf(&bi);
158 if (pos < 0)
return false;
159 notify_vector.erase(pos);
174 bool is_notify_active =
true;
178 for (
auto n : notify_vector) {
179 n->setAudioInfo(info);
192 virtual float volume() {
return volume_value; }
200 float volume_value = 1.0f;
209 virtual size_t write(
const uint8_t* data,
size_t len) = 0;
211 virtual void setOutput(
Print& out_stream) = 0;
212 virtual operator bool() = 0;
213 virtual bool begin() = 0;
218 virtual void end() = 0;
221 void writeBlocking(
Print* out, uint8_t* data,
size_t len) {
226 int result = out->write(data + written, open);
240 static uint32_t
toTimeUs(uint32_t samplingRate, uint8_t limit = 10) {
241 uint32_t result = 1000000l / samplingRate;
242 if (1000000l % samplingRate != 0) {
245 if (result <= limit) {
246 LOGW(
"Time for samplingRate %u -> %u is < %u μs - we rounded up",
247 (
unsigned int)samplingRate, (
unsigned int)result,
248 (
unsigned int)limit);
240 static uint32_t
toTimeUs(uint32_t samplingRate, uint8_t limit = 10) {
…}
261 static uint32_t toTimeMs(uint32_t samplingRate, uint8_t limit = 1) {
262 uint32_t result = 1000l / samplingRate;
263 if (1000000l % samplingRate != 0) {
266 if (result <= limit) {
267 LOGW(
"Time for samplingRate %u -> %u is < %u μs - we rounded up",
268 (
unsigned int)samplingRate, (
unsigned int)result,
269 (
unsigned int)limit);
275 static float toRateUs(uint32_t time_us) {
return 1000000.0 / time_us; }
277 static float toRateMs(uint32_t time_ms) {
return 1000.0 / time_ms; }
288inline T
mapT(T x, T in_min, T in_max, T out_min, T out_max) {
289 return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
288inline T
mapT(T x, T in_min, T in_max, T out_min, T out_max) {
…}
299 static int64_t
maxValue(
int value_bits_per_sample) {
300 switch (value_bits_per_sample) {
314 template <
typename T>
320 return std::numeric_limits<T>::max();
326 template <
typename T>
327 static float minValueT() {
332 return std::numeric_limits<T>::min();
339 template <
typename T>
341 float mv = maxValueT<T>();
344 }
else if (value < -mv) {
351 inline static int32_t
clip(
float value,
int bits) {
355 }
else if (value < -mv) {
351 inline static int32_t
clip(
float value,
int bits) {
…}
362 template <
typename T>
364 return static_cast<float>(value) / maxValueT<T>();
368 template <
typename T>
370 return value * maxValueT<T>();
374 inline static float toFloat(int32_t value,
int bits) {
375 return static_cast<float>(value) /
maxValue(bits);
374 inline static float toFloat(int32_t value,
int bits) {
…}
379 inline static int32_t
fromFloat(
float value,
int bits) {
384 template <
typename FromT,
typename ToT>
386 float value1 = value;
387 float minTo = minValueT<ToT>();
388 float maxTo = maxValueT<ToT>();
389 float maxFrom = maxValueT<FromT>();
390 float minFrom = minValueT<FromT>();
392 if (maxTo - minTo > 1.0f || maxFrom - minFrom > 1.0f) {
393 return mapT<float>(value1, minFrom, maxFrom, minTo, maxTo);
396 return value1 * maxValueT<ToT>() / maxValueT<FromT>();
400 template <
typename FromT,
typename ToT>
403 float factor =
static_cast<float>(maxValueT<ToT>()) / maxValueT<FromT>();
404 float vol_factor = factor * vol;
405 for (
int j = 0; j < samples; j++) {
406 to[j] = clipT<ToT>(vol * convert<FromT, ToT>(from[j]));
421 I2S_RIGHT_JUSTIFIED_FORMAT,
422 I2S_LEFT_JUSTIFIED_FORMAT,
426static const char* i2s_formats[] = {
"I2S_STD_FORMAT",
429 "I2S_PHILIPS_FORMAT",
430 "I2S_RIGHT_JUSTIFIED_FORMAT",
431 "I2S_LEFT_JUSTIFIED_FORMAT",
444static const char* i2s_signal_types[] = {
"Digital",
"Analog",
"PDM",
"TDM"};
452 uint8_t* p_result = (uint8_t*)&result;
453 int open =
sizeof(T);
457 int read = p_stream->readBytes(p_result + total, open);
467 int retryCount = -1) {
468 uint8_t* p_result = (uint8_t*)data;
469 int open = samples *
sizeof(T);
474 int read = p_stream->readBytes(p_result + total, open);
484 if (retryCount >= 0 && count0 > retryCount)
break;
487 return total /
sizeof(T);
491template <
typename T,
class P>
492size_t writeDataT(P* p_out, T* data,
int samples,
int maxSamples = 512) {
493 uint8_t* p_result = (uint8_t*)data;
494 int open = samples *
sizeof(T);
498 int to_write = min(open,
static_cast<int>(maxSamples *
sizeof(T)));
499 int written = p_out->write(p_result + total, to_write);
504 return total /
sizeof(T);
492size_t writeDataT(P* p_out, T* data,
int samples,
int maxSamples = 512) {
…}
508size_t writeData(Print* p_out, T* data,
int samples,
int maxSamples = 512) {
509 return writeDataT<T, Print>(p_out, data, samples, maxSamples);
521inline void waitFor(
bool& flag) {
while (!flag); }
MemoryType
Memory types.
Definition AudioTypes.h:35
void waitFor(bool &flag)
wait for flag to be active
Definition AudioTypes.h:521
RxTxMode
The Microcontroller is the Audio Source (TX_MODE) or Audio Sink (RX_MODE). RXTX_MODE is Source and Si...
Definition AudioTypes.h:28
TimeUnit
Time Units.
Definition AudioTypes.h:46