2#include "AudioTools/CoreAudio/AudioEffects/SoundGenerator.h"
3#include "AudioTools/CoreAudio/AudioLogger.h"
4#include "AudioTools/CoreAudio/AudioOutput.h"
5#include "AudioTools/CoreAudio/AudioTimer/AudioTimer.h"
6#include "AudioTools/CoreAudio/AudioTypes.h"
7#include "AudioTools/CoreAudio/BaseConverter.h"
8#include "AudioTools/CoreAudio/BaseStream.h"
9#include "AudioTools/CoreAudio/Buffers.h"
10#include "AudioToolsConfig.h"
28 p_stream->setTimeout(clientTimeout);
31 virtual bool begin() {
return true; }
34 virtual size_t readBytes(uint8_t *data,
size_t len) {
37 return p_stream->readBytes(data, len);
40 int read() {
return p_stream->read(); }
42 int peek() {
return p_stream->peek(); }
44 int available() {
return p_stream->available(); }
46 virtual size_t write(uint8_t c) {
return p_stream->write(c); }
48 virtual size_t write(
const uint8_t *data,
size_t len) {
49 return p_stream->write(data, len);
52 virtual int availableForWrite() {
return p_stream->availableForWrite(); }
54 virtual void flush() { p_stream->flush(); }
58 int32_t clientTimeout = URL_CLIENT_TIMEOUT;
89 LOGD(
"MemoryStream: %d", buffer_size);
90 this->buffer_size = buffer_size;
91 this->memory_type = memoryType;
98 MemoryStream(
const uint8_t *buffer,
int buffer_size,
bool isActive =
true,
100 LOGD(
"MemoryStream: %d", buffer_size);
101 setValue(buffer, buffer_size, memoryType);
102 is_active = isActive;
98 MemoryStream(
const uint8_t *buffer,
int buffer_size,
bool isActive =
true, {
…}
111 setValue(source.buffer, source.buffer_size, source.memory_type);
113 source.setValue(
nullptr, 0, source.memory_type);
118 if (memoryCanChange() && buffer !=
nullptr) free(buffer);
128 operator bool()
override {
return available() > 0; }
139 write_pos = memoryCanChange() ? 0 : buffer_size;
140 if (this->buffer ==
nullptr && memoryCanChange()) {
148 virtual size_t write(uint8_t
byte)
override {
149 if (!is_active)
return 0;
150 if (memory_type == FLASH_RAM)
return 0;
151 if (buffer ==
nullptr)
return 0;
153 if (write_pos < buffer_size) {
155 buffer[write_pos] = byte;
161 virtual size_t write(
const uint8_t *
data,
size_t len)
override {
162 if (!is_active)
return 0;
163 if (memory_type == FLASH_RAM)
return 0;
165 for (
size_t j = 0; j < len; j++) {
166 if (!write(
data[j])) {
174 virtual int available()
override {
175 if (!is_active)
return 0;
176 if (buffer ==
nullptr)
return 0;
177 int result = write_pos - read_pos;
178 if (result <= 0 && is_loop) {
180 read_pos = rewind_pos;
181 result = write_pos - read_pos;
183 if (rewind !=
nullptr) rewind();
185 return is_loop ? DEFAULT_BUFFER_SIZE : result;
188 virtual int availableForWrite()
override {
189 if (!is_active)
return 0;
190 if (memory_type == FLASH_RAM)
return 0;
191 return buffer_size - write_pos;
194 virtual int read()
override {
202 virtual size_t readBytes(uint8_t *
data,
size_t len)
override {
203 if (!is_active)
return 0;
205 while (count < len) {
214 virtual int peek()
override {
215 if (!is_active)
return -1;
217 if (available() > 0) {
218 result = buffer[read_pos];
223 virtual void flush()
override {}
225 virtual void end()
override {
231 virtual void clear(
bool reset =
false) {
232 if (memoryCanChange()) {
235 if (buffer ==
nullptr) {
240 memset(buffer, 0, buffer_size);
244 LOGW(
"data is read only");
231 virtual void clear(
bool reset =
false) {
…}
253 if (buffer !=
nullptr && buffer_size > 12) {
254 if (memcmp(
"WAVE", buffer + 8, 4) == 0) {
261 virtual void setLoop(
bool loop,
int rewindPos) {
263 rewind_pos = rewindPos;
269 if (!memoryCanChange())
return false;
272 switch (memory_type) {
273#if defined(ESP32) && defined(ARDUINO)
275 buffer = (buffer ==
nullptr) ? (uint8_t *)ps_calloc(size, 1)
276 : (uint8_t *)ps_realloc(buffer, size);
280 buffer = (buffer ==
nullptr) ? (uint8_t *)calloc(size, 1)
281 : (uint8_t *)realloc(buffer, size);
284 return buffer !=
nullptr;
288 virtual uint8_t *
data() {
return buffer; }
297 void setValue(
const uint8_t *buffer,
int buffer_size,
299 this->buffer_size = buffer_size;
301 this->write_pos = buffer_size;
302 this->buffer = (uint8_t *)buffer;
303 this->memory_type = memoryType;
297 void setValue(
const uint8_t *buffer,
int buffer_size, {
…}
311 uint8_t *buffer =
nullptr;
313 bool is_loop =
false;
314 void (*rewind)() =
nullptr;
315 bool is_active =
false;
317 bool memoryCanChange() {
return memory_type != FLASH_RAM; }
319 void copy(MemoryStream &source) {
320 if (
this == &source)
return;
321 if (source.memory_type == FLASH_RAM) {
322 setValue(source.buffer, source.buffer_size, source.memory_type);
324 setValue(
nullptr, source.buffer_size, source.memory_type);
326 memcpy(buffer, source.buffer, buffer_size);
342 virtual int available()
override {
344 return buffer.available();
347 virtual int availableForWrite()
override {
348 return buffer.availableForWrite();
351 virtual void flush()
override {}
352 virtual int peek()
override {
354 if (!buffer.peek(data))
return -1;
357 virtual int read()
override {
359 if (!buffer.read(data))
return -1;
363 virtual size_t readBytes(uint8_t *data,
size_t len)
override {
364 return buffer.readArray(data, len);
367 virtual size_t write(
const uint8_t *data,
size_t len)
override {
369 return buffer.writeArray(data, len);
372 virtual size_t write(uint8_t c)
override {
return buffer.write(c); }
374 void resize(
int size) { buffer.resize(size); }
376 size_t size() {
return buffer.size(); }
404 this->generator_ptr = &generator;
407 AudioInfo defaultConfig() {
return this->generator_ptr->defaultConfig(); }
419 if (generator_ptr ==
nullptr) {
420 LOGE(
"%s", source_not_defined_error);
423 generator_ptr->begin();
424 notifyAudioChange(generator_ptr->audioInfo());
432 if (generator_ptr ==
nullptr) {
433 LOGE(
"%s", source_not_defined_error);
436 generator_ptr->begin(cfg);
437 notifyAudioChange(generator_ptr->audioInfo());
445 generator_ptr->end();
453 return active ? DEFAULT_BUFFER_SIZE * 2 : 0;
458 if (!active)
return 0;
459 LOGD(
"GeneratedSoundStream::readBytes: %u", (
unsigned int)len);
460 return generator_ptr->readBytes(data, len);
463 bool isActive() {
return active && generator_ptr->isActive(); }
465 operator bool() {
return isActive(); }
467 void flush()
override {}
471 SoundGenerator<T> *generator_ptr;
472 const char *source_not_defined_error =
"Source not defined";
487 buffer.resize(buffer_size);
493 buffer.resize(buffer_size);
499 buffer.resize(buffer_size);
505 buffer.resize(buffer_size);
511 buffer.resize(buffer_size);
523 if (buffer.isFull()) {
526 return buffer.write(c);
530 size_t write(
const uint8_t *data,
size_t len)
override {
531 LOGD(
"%s: %zu", LOG_METHOD, len);
533 for (
int j = 0; j < len; j++) {
534 result +=
write(data[j]);
530 size_t write(
const uint8_t *data,
size_t len)
override {
…}
542 if (buffer.available() > 0) {
543 writeExt(buffer.address(), buffer.available());
550 if (buffer.isEmpty()) {
554 if (!buffer.read(result))
return -1;
560 if (buffer.isEmpty()) {
564 if (!buffer.peek(result))
return -1;
570 if (buffer.isEmpty()) {
571 return readExt(data, len);
574 return buffer.readArray(data, len);
580 if (buffer.isEmpty()) {
583 return buffer.available();
591 Print *p_out =
nullptr;
596 size_t result = readExt(buffer.
address(), buffer.size());
600 virtual size_t writeExt(
const uint8_t *data,
size_t len) {
601 return p_out ==
nullptr ? 0 : p_out->write(data, len);
603 virtual size_t readExt(uint8_t *data,
size_t len) {
604 return p_in ==
nullptr ? 0 : p_in->readBytes(data, len);
624 setConverter(converter);
629 setConverter(converter);
644 void setConverter(
BaseConverter &cnv) { p_converter = &cnv; }
646 virtual int availableForWrite() {
return p_out->availableForWrite(); }
648 virtual size_t write(
const uint8_t *data,
size_t len) {
649 size_t result = p_converter->convert((uint8_t *)data, len);
651 size_t result_written = p_out->write(data, result);
652 return len * result_written / result;
657 size_t readBytes(uint8_t *data,
size_t len)
override {
658 if (p_stream ==
nullptr)
return 0;
659 size_t result = p_stream->readBytes(data, len);
660 return p_converter->convert(data, result);
665 if (p_stream ==
nullptr)
return 0;
666 return p_stream->available();
670 Stream *p_stream =
nullptr;
671 Print *p_out =
nullptr;
685 this->max_count = count;
694 this->max_count = count;
702 this->max_count = count;
722 total_bytes_since_begin += len;
723 return measure(p_stream->readBytes(data, len));
726 int available()
override {
return p_stream->available(); }
729 virtual size_t write(
const uint8_t *data,
size_t len)
override {
730 total_bytes_since_begin += len;
731 return measure(p_print->write(data, len));
729 virtual size_t write(
const uint8_t *data,
size_t len)
override {
…}
736 return p_print->availableForWrite();
744 if (frame_size == 0)
return 0;
745 return bytes_per_second / frame_size;
752 AudioStream::info = info;
757 total_bytes_since_begin = 0;
759 return AudioStream::begin();
762 bool begin(AudioInfo info) {
773 void setName(
const char *name) { this->name = name; }
797 bool is_regular_update =
true;
798 if (pos < total_bytes_since_begin) {
800 is_regular_update =
false;
802 total_bytes_since_begin = pos;
803 return is_regular_update;
809 Stream *p_stream =
nullptr;
810 Print *p_print =
nullptr;
813 int bytes_per_second = 0;
816 Print *p_logout =
nullptr;
817 bool report_bytes =
false;
818 const char *name =
"";
819 uint32_t ms_at_begin = 0;
820 uint32_t total_bytes_since_begin = 0;
822 size_t measure(
size_t len) {
827 uint32_t end_time =
millis();
828 int time_diff = end_time - start_time;
830 bytes_per_second = total_bytes / time_diff * 1000;
834 start_time = end_time;
842 if (report_bytes || frame_size == 0) {
843 snprintf(msg, 70,
"%s ==> Bytes per second: %d", name, bytes_per_second);
845 snprintf(msg, 70,
"%s ==> Samples per second: %d", name,
846 bytes_per_second / frame_size);
848 if (p_logout !=
nullptr) {
849 p_logout->println(msg);
864 size_t total_size = 0;
883 p_info_from = &stream;
900 void setPrint(Print &print) { p_print = &print; }
902 bool begin()
override {
903 if (p_info_from !=
nullptr) {
906 return AudioStream::begin();
917 progress_info = info;
925 progress_info.total_size = len;
929 size_t size() {
return progress_info.total_size; }
945 if (progress_info.total_size == 0)
return 0;
946 return 100.0 * total_processed / progress_info.total_size;
951 if (p_stream ==
nullptr)
return 0;
952 return measure(p_stream->readBytes(data, len));
955 int available()
override {
956 if (p_stream ==
nullptr)
return 0;
957 return p_stream->available();
961 virtual size_t write(
const uint8_t *data,
size_t len)
override {
962 if (p_print ==
nullptr)
return 0;
963 return measure(p_print->write(data, len));
961 virtual size_t write(
const uint8_t *data,
size_t len)
override {
…}
968 if (p_print ==
nullptr)
return 0;
969 return p_print->availableForWrite();
974 Stream *p_stream =
nullptr;
975 Print *p_print =
nullptr;
977 size_t total_processed = 0;
979 size_t measure(
size_t len) {
980 total_processed += len;
986 int byte_rate = info.sample_rate * info.bits_per_sample * info.channels / 8;
987 if (byte_rate == 0) {
988 LOGE(
"Audio Info not defined");
1006 int correction_us = 0;
1035 bool begin(ThrottleConfig cfg) {
1036 LOGI(
"begin sample_rate: %d, channels: %d, bits: %d", (
int)info.
sample_rate,
1043 bool begin(AudioInfo info) {
1044 LOGI(
"begin sample_rate: %d, channels: %d, bits: %d", (
int)info.sample_rate,
1045 (
int)info.channels, (
int)info.bits_per_sample);
1047 this->cfg.copyFrom(info);
1052 frame_size = cfg.bits_per_sample / 8 * cfg.channels;
1059 start_time = micros();
1063 int availableForWrite() {
1065 return p_out->availableForWrite();
1067 return DEFAULT_BUFFER_SIZE;
1070 size_t write(
const uint8_t *data,
size_t len) {
1071 size_t result = p_out->write(data, len);
1077 if (p_in ==
nullptr)
return 0;
1078 return p_in->available();
1081 size_t readBytes(uint8_t *data,
size_t len)
override {
1082 if (p_in ==
nullptr) {
1086 size_t result = p_in->readBytes(data, len);
1092 void delayBytes(
size_t bytes) { delayFrames(bytes / frame_size); }
1095 void delayFrames(
size_t frames) {
1096 sum_frames += frames;
1097 uint64_t durationUsEff = micros() - start_time;
1098 uint64_t durationUsToBe = getDelayUs(sum_frames);
1099 int64_t waitUs = durationUsToBe - durationUsEff + cfg.correction_us;
1100 LOGD(
"wait us: %ld",
static_cast<long>(waitUs));
1102 int64_t waitMs = waitUs / 1000;
1103 if (waitMs > 0) delay(waitMs);
1104 delayMicroseconds(waitUs - (waitMs * 1000));
1106 LOGD(
"negative delay!")
1110 inline int64_t getDelayUs(uint64_t frames) {
1111 return (frames * 1000000) / cfg.sample_rate;
1114 inline int64_t getDelayMs(uint64_t frames) {
1115 return getDelayUs(frames) / 1000;
1118 inline int64_t getDelaySec(uint64_t frames) {
1119 return getDelayUs(frames) / 1000000l;
1123 uint32_t start_time = 0;
1124 uint32_t sum_frames = 0;
1127 Print *p_out =
nullptr;
1128 Stream *p_in =
nullptr;
1140template <
typename T>
1147 streams.push_back(&in);
1148 weights.push_back(weight);
1149 total_weights += weight;
1154 if (channel <
size()) {
1155 streams[channel] = ∈
1157 LOGE(
"Invalid channel %d - max is %d", channel,
size() - 1);
1164 LOGI(
"frame_size: %d", frame_size);
1165 return frame_size > 0;
1172 if (channel <
size()) {
1173 weights[channel] = weight;
1175 for (
int j = 0; j < weights.size(); j++) {
1176 total += weights[j];
1178 total_weights = total;
1180 LOGE(
"Invalid channel %d - max is %d", channel,
size() - 1);
1188 result_vect.clear();
1189 current_vect.clear();
1190 total_weights = 0.0;
1194 int size() {
return streams.size(); }
1198 if (total_weights == 0 || frame_size == 0 || len == 0) {
1199 LOGW(
"readBytes: %d", (
int)len);
1203 if (limit_available_data) {
1211 result_len = len * frame_size / frame_size;
1229 Vector<int> weights{0};
1230 int total_weights = 0;
1232 bool limit_available_data =
false;
1233 int retry_count = 5;
1234 Vector<int> result_vect;
1235 Vector<T> current_vect;
1239 int samples = byteCount /
sizeof(T);
1240 result_vect.resize(samples);
1241 current_vect.resize(samples);
1242 int stream_count =
size();
1244 int samples_eff_max = 0;
1245 for (
int j = 0; j < stream_count; j++) {
1246 if (weights[j] > 0) {
1248 readSamples(streams[j], current_vect.data(), samples, retry_count);
1249 if (samples_eff > samples_eff_max) samples_eff_max = samples_eff;
1251 float factor = total_weights == 0.0f
1253 :
static_cast<float>(weights[j]) / total_weights;
1258 for (
int j = 0; j < samples; j++) {
1259 p_data[j] = result_vect[j];
1261 return samples_eff_max *
sizeof(T);
1266 int result = DEFAULT_BUFFER_SIZE;
1267 for (
int j = 0; j <
size(); j++) {
1268 result = min(result, streams[j]->available());
1273 void resultAdd(
float fact) {
1274 for (
int j = 0; j < current_vect.size(); j++) {
1275 current_vect[j] *= fact;
1276 result_vect[j] += current_vect[j];
1280 void resultClear() {
1281 memset(result_vect.data(), 0,
sizeof(
int) * result_vect.size());
1294template <
typename T>
1311 info.
channels = total_channel_count;
1320 virtual bool begin() {
1323 return AudioStream::begin();
1328 LOGD(
"readBytes: %d", (
int)len);
1329 T *p_data = (T *)data;
1331 int frames = result_len / (
sizeof(T) * total_channel_count);
1333 for (
int j = 0; j < frames; j++) {
1334 for (
int i = 0; i < records.size(); i++) {
1335 for (
int ch = 0; ch < records[i].channels; ch++) {
1336 p_data[result_idx++] =
1337 records[i].weight * readSample<T>(records[i].stream);
1341 return result_idx *
sizeof(T);
1347 records.push_back(rec);
1355 records[channel].weight = weight;
1357 LOGE(
"Invalid channel %d - max is %d", channel,
channelCount() - 1);
1362 void end()
override { records.clear(); }
1369 int result = records[0].stream->available();
1371 int tmp = records[j].stream->available();
1381 Stream *stream =
nullptr;
1392 int total_channel_count = 0;
1413 setUpdateCallback(cb_update);
1419 setUpdateCallback(cb_update);
1423 size_t (*cb_write)(
const uint8_t *data,
size_t len)) {
1424 setWriteCallback(cb_write);
1425 setReadCallback(cb_read);
1428 void setWriteCallback(
size_t (*cb_write)(
const uint8_t *data,
size_t len)) {
1429 this->cb_write = cb_write;
1432 void setReadCallback(
size_t (*cb_read)(uint8_t *data,
size_t len)) {
1433 this->cb_read = cb_read;
1436 void setUpdateCallback(
size_t (*cb_update)(uint8_t *data,
size_t len)) {
1437 this->cb_update = cb_update;
1442 void setAvailableCallback(
int (*cb)()) { this->cb_available = cb; }
1446 this->cb_audio_info = cb;
1452 if (cb_audio_info !=
nullptr) {
1453 cb_audio_info(info);
1461 virtual bool begin()
override {
1466 void end()
override { active =
false; }
1468 int available()
override {
1469 int result = AudioStream::available();
1471 if (available_bytes >= 0)
return available_bytes;
1473 if (cb_available ==
nullptr)
return result;
1475 int tmp_available = cb_available();
1476 if (tmp_available < 0)
return result;
1478 return tmp_available;
1481 size_t readBytes(uint8_t *data,
size_t len)
override {
1482 if (!active)
return 0;
1485 return cb_read(data, len);
1490 result = p_stream->readBytes(data, len);
1493 result = cb_update(data, result);
1498 size_t write(
const uint8_t *data,
size_t len)
override {
1499 if (!active)
return 0;
1502 return cb_write(data, len);
1506 size_t result = len;
1508 result = cb_update((uint8_t *)data, len);
1510 return p_out->write(data, result);
1539 size_t (*cb_write)(
const uint8_t *data,
size_t len) =
nullptr;
1540 size_t (*cb_read)(uint8_t *data,
size_t len) =
nullptr;
1541 size_t (*cb_update)(uint8_t *data,
size_t len) =
nullptr;
1542 void (*cb_audio_info)(
AudioInfo info) =
nullptr;
1543 int (*cb_available)() =
nullptr;
1544 Stream *p_stream =
nullptr;
1545 Print *p_out =
nullptr;
1546 int available_bytes = -1;
1556template <
typename T,
class TF>
1562 this->channels = channels;
1568 this->channels = channels;
1585 if (p_converter !=
nullptr && p_converter->getChannels() != channels) {
1586 LOGE(
"Inconsistent number of channels");
1592 bool begin()
override {
1593 if (channels == 0) {
1594 LOGE(
"channels must not be 0");
1597 if (p_converter ==
nullptr) {
1598 p_converter =
new ConverterNChannels<T, TF>(channels);
1600 return AudioStream::begin();
1603 void end()
override {
1604 ModifyingStream::end();
1605 if (p_converter !=
nullptr) {
1607 p_converter =
nullptr;
1611 virtual size_t write(
const uint8_t *data,
size_t len)
override {
1612 if (p_converter ==
nullptr)
return 0;
1613 size_t result = p_converter->convert((uint8_t *)data, len);
1614 return p_print->write(data, result);
1617 size_t readBytes(uint8_t *data,
size_t len)
override {
1618 if (p_converter ==
nullptr)
return 0;
1619 if (p_stream ==
nullptr)
return 0;
1620 size_t result = p_stream->readBytes(data, len);
1621 result = p_converter->convert(data, result);
1625 virtual int available()
override {
1626 if (p_stream ==
nullptr)
return 0;
1627 return p_stream->available();
1630 virtual int availableForWrite()
override {
1631 return p_print->availableForWrite();
1638 if (p_converter !=
nullptr) {
1639 p_converter->
setFilter(channel, filter);
1641 LOGE(
"p_converter is null");
1654 Stream *p_stream =
nullptr;
1655 Print *p_print =
nullptr;
1686 bool begin()
override {
return true; }
1696 size_t write(
const uint8_t *data,
size_t len) {
1697 updateVolumes(data, len);
1698 size_t result = len;
1699 if (p_out !=
nullptr) {
1700 result = p_out->write(data, len);
1705 size_t readBytes(uint8_t *data,
size_t len) {
1706 if (p_stream ==
nullptr)
return 0;
1707 size_t result = p_stream->readBytes(data, len);
1708 updateVolumes((
const uint8_t *)data, len);
1719 if (volumes.size() == 0) {
1720 LOGE(
"begin not called!");
1723 if (channel >= volumes.size()) {
1724 LOGE(
"invalid channel %d", channel);
1727 return volumes[channel];
1764 for (
int j = 0; j < info.
channels; j++) {
1766 count += sample_count_per_channel;
1768 return total / count;
1773 return sum[channel] / sample_count_per_channel;
1779 for (
int j = 0; j < info.
channels; j++) {
1792 float f_volume_tmp = 0;
1795 Vector<float> volumes_tmp{0};
1796 Vector<float> sum{0};
1797 Vector<float> sum_tmp{0};
1798 Print *p_out =
nullptr;
1799 Stream *p_stream =
nullptr;
1800 size_t sample_count_per_channel = 0;
1802 void updateVolumes(
const uint8_t *data,
size_t len) {
1806 updateVolumesT<int8_t>(data, len);
1809 updateVolumesT<int16_t>(data, len);
1812 updateVolumesT<int24_t>(data, len);
1815 updateVolumesT<int32_t>(data, len);
1823 template <
typename T>
1824 void updateVolumesT(
const uint8_t *buffer,
size_t size) {
1825 T *bufferT = (T *)buffer;
1826 int samplesCount = size /
sizeof(T);
1827 sample_count_per_channel = samplesCount / info.
channels;
1828 for (
int j = 0; j < samplesCount; j++) {
1829 float tmp = abs(
static_cast<float>(bufferT[j]));
1830 updateVolume(tmp, j);
1835 void updateVolume(
float tmp,
int j) {
1836 if (tmp > f_volume_tmp) {
1839 if (volumes_tmp.size() > 0 && info.
channels > 0) {
1841 if (tmp > volumes_tmp[ch]) {
1842 volumes_tmp[ch] = tmp;
1849 f_volume = f_volume_tmp;
1850 for (
int j = 0; j < info.
channels; j++) {
1851 volumes[j] = volumes_tmp[j];
1852 sum[j] = sum_tmp[j];
1858using VolumePrint = VolumeMeter;
1859using VolumeOutput = VolumeMeter;
1869 uint16_t buffer_size = DEFAULT_BUFFER_SIZE;
1870 bool use_timer =
true;
1872 TimerFunction timer_function = DirectTimerCallback;
1873 bool adapt_sample_rate =
false;
1874 uint16_t (*callback)(uint8_t *data, uint16_t len) =
nullptr;
1878static void timerCallback(
void *obj);
1889 friend void timerCallback(
void *obj);
1896 if (timer !=
nullptr)
delete timer;
1897 if (buffer !=
nullptr)
delete buffer;
1898 if (frame !=
nullptr)
delete[] frame;
1912 bool do_restart = active;
1913 if (do_restart)
end();
1917 if (do_restart)
begin(cfg);
1926 LOGD(
"%s: %s", LOG_METHOD,
1927 config.rx_tx_mode == RX_MODE ?
"RX_MODE" :
"TX_MODE");
1929 this->frameCallback = config.callback;
1930 if (cfg.use_timer) {
1931 frameSize = cfg.bits_per_sample * cfg.channels / 8;
1932 frame =
new uint8_t[frameSize];
1935 timer->setTimerFunction(cfg.timer_function);
1936 if (cfg.timer_id >= 0) {
1937 timer->setTimer(cfg.timer_id);
1940 LOGI(
"sample_rate: %u -> time: %u milliseconds",
1941 (
unsigned int)cfg.sample_rate, (
unsigned int)time);
1942 timer->setCallbackParameter(
this);
1943 timer->begin(timerCallback, time, TimeUnit::US);
1946 notifyAudioChange(cfg);
1953 if (this->frameCallback !=
nullptr) {
1954 if (cfg.use_timer) {
1955 timer->begin(timerCallback, time, TimeUnit::US);
1965 if (cfg.use_timer) {
1976 bool active =
false;
1977 uint16_t (*frameCallback)(uint8_t *data, uint16_t len);
1981 uint8_t *frame =
nullptr;
1982 uint16_t frameSize = 0;
1984 unsigned long lastTimestamp = 0u;
1985 uint32_t currentRateValue = 0;
1986 uint32_t printCount = 0;
1989 virtual size_t writeExt(
const uint8_t *data,
size_t len)
override {
1990 if (!active)
return 0;
1993 if (!cfg.use_timer) {
1994 result = frameCallback((uint8_t *)data, len);
1996 result = buffer->
writeArray((uint8_t *)data, len);
2003 virtual size_t readExt(uint8_t *data,
size_t len)
override {
2004 if (!active)
return 0;
2008 if (!cfg.use_timer) {
2009 result = frameCallback(data, len);
2019 unsigned long ms =
millis();
2020 if (lastTimestamp > 0u) {
2021 uint32_t diff = ms - lastTimestamp;
2023 uint16_t rate = 1 * 1000 / diff;
2025 if (currentRateValue == 0) {
2026 currentRateValue = rate;
2028 currentRateValue = (currentRateValue + rate) / 2;
2037 LOGI(
"effective sample rate: %u", (
unsigned int)currentRateValue);
2038 if (cfg.adapt_sample_rate &&
2039 abs((
int)currentRateValue - (
int)cfg.
sample_rate) > 200) {
2041 notifyAudioChange(cfg);
2047void IRAM_ATTR timerCallback(
void *obj) {
2048 TimerCallbackAudioStream *src = (TimerCallbackAudioStream *)obj;
2049 if (src !=
nullptr) {
2052 if (src->cfg.rx_tx_mode == RX_MODE) {
2054 uint16_t available_bytes = src->frameCallback(src->frame, src->frameSize);
2055 uint16_t buffer_available = src->buffer->availableForWrite();
2056 if (buffer_available < available_bytes) {
2058 uint16_t to_clear = available_bytes - buffer_available;
2059 uint8_t tmp[to_clear];
2060 src->buffer->readArray(tmp, to_clear);
2062 if (src->buffer->writeArray(src->frame, available_bytes) !=
2068 if (src->buffer !=
nullptr && src->frame !=
nullptr &&
2069 src->frameSize > 0) {
2070 uint16_t available_bytes =
2071 src->buffer->readArray(src->frame, src->frameSize);
2072 if (available_bytes !=
2073 src->frameCallback(src->frame, available_bytes)) {
2074 LOGE(
"data underflow");
2078 src->measureSampleRate();
MemoryType
Memory types.
Definition AudioTypes.h:35
RxTxMode
The Microcontroller is the Audio Source (TX_MODE) or Audio Sink (RX_MODE). RXTX_MODE is Source and Si...
Definition AudioTypes.h:28