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;
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");
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;
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(); }
393template <
class T =
int16_t>
404 this->generator_ptr = &generator;
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()
override {
return isActive(); }
467 void flush()
override {}
471 SoundGenerator<T> *generator_ptr;
472 const char *source_not_defined_error =
"Source not defined";
487 if (buffer_size > 0)
resize(buffer_size);
493 if (buffer_size > 0)
resize(buffer_size);
499 if (buffer_size > 0)
resize(buffer_size);
505 if (buffer_size > 0)
resize(buffer_size);
511 if (buffer_size > 0)
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]);
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() && len >= minReadBufferSize) {
571 return readExt(data, len);
574 return buffer.readArray(data, len);
580 if (buffer.isEmpty()) {
583 return buffer.peekArray(data, len);
588 if (p_in ==
nullptr)
return 0;
589 return buffer.available() + p_in->available();
596 void resize(
int size) { buffer.resize(size); }
600 minReadBufferSize = size;
605 Print *p_out =
nullptr;
606 Stream *p_in =
nullptr;
607 size_t minReadBufferSize = 1024;
613 size_t already_available = buffer.available();
614 size_t free_space = buffer.availableForWrite();
615 if (free_space == 0) {
620 size_t added = readExt(buffer.address() + already_available, free_space);
621 buffer.setAvailable(already_available + added);
626 if (buffer.available() >= len)
return;
630 virtual size_t writeExt(
const uint8_t *data,
size_t len) {
631 return p_out ==
nullptr ? 0 : p_out->write(data, len);
633 virtual size_t readExt(uint8_t *data,
size_t len) {
634 return p_in ==
nullptr ? 0 : p_in->readBytes(data, len);
654 setConverter(converter);
659 setConverter(converter);
674 void setConverter(
BaseConverter &cnv) { p_converter = &cnv; }
676 virtual int availableForWrite() {
return p_out->availableForWrite(); }
678 virtual size_t write(
const uint8_t *data,
size_t len) {
679 size_t result = p_converter->convert((uint8_t *)data, len);
681 size_t result_written = p_out->write(data, result);
682 return len * result_written / result;
687 size_t readBytes(uint8_t *data,
size_t len)
override {
688 if (p_stream ==
nullptr)
return 0;
689 size_t result = p_stream->readBytes(data, len);
690 return p_converter->convert(data, result);
695 if (p_stream ==
nullptr)
return 0;
696 return p_stream->available();
700 Stream *p_stream =
nullptr;
701 Print *p_out =
nullptr;
715 this->max_count = count;
724 this->max_count = count;
732 this->max_count = count;
752 total_bytes_since_begin += len;
753 return measure(p_stream->readBytes(data, len));
756 int available()
override {
return p_stream->available(); }
759 virtual size_t write(
const uint8_t *data,
size_t len)
override {
760 total_bytes_since_begin += len;
761 return measure(p_print->write(data, len));
766 return p_print->availableForWrite();
774 if (frame_size == 0)
return 0;
775 return bytes_per_second / frame_size;
782 AudioStream::info = info;
786 bool begin()
override {
787 total_bytes_since_begin = 0;
789 return AudioStream::begin();
792 bool begin(AudioInfo info) {
803 void setName(
const char *name) { this->name = name; }
827 bool is_regular_update =
true;
828 if (pos < total_bytes_since_begin) {
830 is_regular_update =
false;
832 total_bytes_since_begin = pos;
833 return is_regular_update;
839 Stream *p_stream =
nullptr;
840 Print *p_print =
nullptr;
843 int bytes_per_second = 0;
846 Print *p_logout =
nullptr;
847 bool report_bytes =
false;
848 const char *name =
"";
849 uint32_t ms_at_begin = 0;
850 uint32_t total_bytes_since_begin = 0;
852 size_t measure(
size_t len) {
857 uint32_t end_time =
millis();
858 int time_diff = end_time - start_time;
860 bytes_per_second = total_bytes / time_diff * 1000;
864 start_time = end_time;
872 if (report_bytes || frame_size == 0) {
873 snprintf(msg, 70,
"%s ==> Bytes per second: %d", name, bytes_per_second);
875 snprintf(msg, 70,
"%s ==> Samples per second: %d", name,
876 bytes_per_second / frame_size);
878 if (p_logout !=
nullptr) {
879 p_logout->println(msg);
894 size_t total_size = 0;
913 p_info_from = &stream;
930 void setPrint(Print &print) { p_print = &print; }
932 bool begin()
override {
933 if (p_info_from !=
nullptr) {
936 return AudioStream::begin();
947 progress_info = info;
955 progress_info.total_size = len;
959 size_t size() {
return progress_info.total_size; }
975 if (progress_info.total_size == 0)
return 0;
976 return 100.0 * total_processed / progress_info.total_size;
981 if (p_stream ==
nullptr)
return 0;
982 return measure(p_stream->readBytes(data, len));
985 int available()
override {
986 if (p_stream ==
nullptr)
return 0;
987 return p_stream->available();
991 virtual size_t write(
const uint8_t *data,
size_t len)
override {
992 if (p_print ==
nullptr)
return 0;
993 return measure(p_print->write(data, len));
998 if (p_print ==
nullptr)
return 0;
999 return p_print->availableForWrite();
1004 Stream *p_stream =
nullptr;
1005 Print *p_print =
nullptr;
1007 size_t total_processed = 0;
1009 size_t measure(
size_t len) {
1010 total_processed += len;
1016 int byte_rate = info.sample_rate * info.bits_per_sample * info.channels / 8;
1017 if (byte_rate == 0) {
1018 LOGE(
"Audio Info not defined");
1036 int correction_us = 0;
1065 bool begin(ThrottleConfig cfg) {
1066 LOGI(
"begin sample_rate: %d, channels: %d, bits: %d", (
int)info.
sample_rate,
1073 bool begin(AudioInfo info) {
1074 LOGI(
"begin sample_rate: %d, channels: %d, bits: %d", (
int)info.sample_rate,
1075 (
int)info.channels, (
int)info.bits_per_sample);
1077 this->cfg.copyFrom(info);
1081 bool begin()
override {
1082 frame_size = cfg.bits_per_sample / 8 * cfg.channels;
1089 start_time = micros();
1093 int availableForWrite()
override {
1095 return p_out->availableForWrite();
1097 return DEFAULT_BUFFER_SIZE;
1100 size_t write(
const uint8_t *data,
size_t len)
override {
1101 size_t result = p_out->write(data, len);
1106 int available()
override {
1107 if (p_in ==
nullptr)
return 0;
1108 return p_in->available();
1111 size_t readBytes(uint8_t *data,
size_t len)
override {
1112 if (p_in ==
nullptr) {
1116 size_t result = p_in->readBytes(data, len);
1122 void delayBytes(
size_t bytes) { delayFrames(bytes / frame_size); }
1125 void delayFrames(
size_t frames) {
1126 sum_frames += frames;
1127 uint64_t durationUsEff = micros() - start_time;
1128 uint64_t durationUsToBe = getDelayUs(sum_frames);
1129 int64_t waitUs = durationUsToBe - durationUsEff + cfg.correction_us;
1130 LOGD(
"wait us: %ld",
static_cast<long>(waitUs));
1132 int64_t waitMs = waitUs / 1000;
1133 if (waitMs > 0) delay(waitMs);
1134 delayMicroseconds(waitUs - (waitMs * 1000));
1136 LOGD(
"negative delay!")
1140 inline int64_t getDelayUs(uint64_t frames) {
1141 return (frames * 1000000) / cfg.sample_rate;
1144 inline int64_t getDelayMs(uint64_t frames) {
1145 return getDelayUs(frames) / 1000;
1148 inline int64_t getDelaySec(uint64_t frames) {
1149 return getDelayUs(frames) / 1000000l;
1153 uint32_t start_time = 0;
1154 uint32_t sum_frames = 0;
1157 Print *p_out =
nullptr;
1158 Stream *p_in =
nullptr;
1170template <
typename T>
1177 streams.push_back(&in);
1178 weights.push_back(weight);
1179 total_weights += weight;
1180 return streams.indexOf(&in);
1185 if (index <
size()) {
1186 streams[index] = ∈
1189 LOGE(
"Invalid index %d - max is %d", index,
size() - 1);
1197 LOGI(
"frame_size: %d", frame_size);
1198 return frame_size > 0;
1205 if (index < streams.size()) {
1206 weights[index] = weight;
1209 LOGE(
"Invalid index %d - max is %d", index,
size() - 1);
1217 result_vect.clear();
1218 current_vect.clear();
1219 total_weights = 0.0;
1223 int size() {
return streams.size(); }
1227 if (total_weights == 0 || frame_size == 0 || len == 0) {
1228 LOGW(
"readBytes: %d", (
int)len);
1232 if (limit_available_data) {
1240 result_len = len * frame_size / frame_size;
1258 if (idx < 0 || idx >=
size()) {
1286 if (idx < 0 || idx >=
size())
return nullptr;
1287 return streams[idx];
1292 for (
int i = 0; i < streams.size(); i++) {
1293 if (streams[i]->available() == 0) {
1302 Vector<int> weights{0};
1303 int total_weights = 0;
1305 bool limit_available_data =
false;
1306 int retry_count = 5;
1307 Vector<int> result_vect;
1308 Vector<T> current_vect;
1313 for (
int j = 0; j < weights.size(); j++) {
1314 total += weights[j];
1316 total_weights = total;
1321 int samples = byteCount /
sizeof(T);
1322 result_vect.resize(samples);
1323 current_vect.resize(samples);
1324 int stream_count =
size();
1326 int samples_eff_max = 0;
1327 for (
int j = 0; j < stream_count; j++) {
1328 if (weights[j] > 0) {
1330 readSamples(streams[j], current_vect.data(), samples, retry_count);
1331 if (samples_eff > samples_eff_max) samples_eff_max = samples_eff;
1333 float factor = total_weights == 0.0f
1335 :
static_cast<float>(weights[j]) / total_weights;
1340 for (
int j = 0; j < samples; j++) {
1341 p_data[j] = result_vect[j];
1343 return samples_eff_max *
sizeof(T);
1348 int result = DEFAULT_BUFFER_SIZE;
1349 for (
int j = 0; j <
size(); j++) {
1350 result = min(result, streams[j]->available());
1355 void resultAdd(
float fact) {
1356 for (
int j = 0; j < current_vect.size(); j++) {
1357 current_vect[j] *= fact;
1358 result_vect[j] += current_vect[j];
1362 void resultClear() {
1363 memset(result_vect.data(), 0,
sizeof(
int) * result_vect.size());
1376template <
typename T>
1393 info.
channels = total_channel_count;
1402 virtual bool begin()
override {
1405 return AudioStream::begin();
1410 LOGD(
"readBytes: %d", (
int)len);
1411 T *p_data = (T *)data;
1413 int frames = result_len / (
sizeof(T) * total_channel_count);
1415 for (
int j = 0; j < frames; j++) {
1416 for (
int i = 0; i < records.size(); i++) {
1417 for (
int ch = 0; ch < records[i].channels; ch++) {
1418 p_data[result_idx++] =
1419 records[i].weight * readSample<T>(records[i].stream);
1423 return result_idx *
sizeof(T);
1429 records.push_back(rec);
1437 records[channel].weight = weight;
1439 LOGE(
"Invalid channel %d - max is %d", channel,
channelCount() - 1);
1444 void end()
override { records.clear(); }
1451 int result = records[0].stream->available();
1453 int tmp = records[j].stream->available();
1463 Stream *stream =
nullptr;
1474 int total_channel_count = 0;
1495 setUpdateCallback(cb_update);
1501 setUpdateCallback(cb_update);
1505 size_t (*cb_write)(
const uint8_t *data,
size_t len)) {
1506 setWriteCallback(cb_write);
1507 setReadCallback(cb_read);
1510 void setWriteCallback(
size_t (*cb_write)(
const uint8_t *data,
size_t len)) {
1511 this->cb_write = cb_write;
1514 void setReadCallback(
size_t (*cb_read)(uint8_t *data,
size_t len)) {
1515 this->cb_read = cb_read;
1518 void setUpdateCallback(
size_t (*cb_update)(uint8_t *data,
size_t len)) {
1519 this->cb_update = cb_update;
1524 void setAvailableCallback(
int (*cb)()) { this->cb_available = cb; }
1528 this->cb_audio_info = cb;
1534 if (cb_audio_info !=
nullptr) {
1535 cb_audio_info(info);
1543 virtual bool begin()
override {
1548 void end()
override { active =
false; }
1550 int available()
override {
1551 int result = AudioStream::available();
1553 if (available_bytes >= 0)
return available_bytes;
1555 if (cb_available ==
nullptr)
return result;
1557 int tmp_available = cb_available();
1558 if (tmp_available < 0)
return result;
1560 return tmp_available;
1563 size_t readBytes(uint8_t *data,
size_t len)
override {
1564 if (!active)
return 0;
1567 return cb_read(data, len);
1572 result = p_stream->readBytes(data, len);
1575 result = cb_update(data, result);
1580 size_t write(
const uint8_t *data,
size_t len)
override {
1581 if (!active)
return 0;
1584 return cb_write(data, len);
1588 size_t result = len;
1590 result = cb_update((uint8_t *)data, len);
1592 return p_out->write(data, result);
1621 size_t (*cb_write)(
const uint8_t *data,
size_t len) =
nullptr;
1622 size_t (*cb_read)(uint8_t *data,
size_t len) =
nullptr;
1623 size_t (*cb_update)(uint8_t *data,
size_t len) =
nullptr;
1624 void (*cb_audio_info)(
AudioInfo info) =
nullptr;
1625 int (*cb_available)() =
nullptr;
1626 Stream *p_stream =
nullptr;
1627 Print *p_out =
nullptr;
1628 int available_bytes = -1;
1638template <
typename T,
class TF>
1644 this->channels = channels;
1650 this->channels = channels;
1667 if (p_converter !=
nullptr && p_converter->getChannels() != channels) {
1668 LOGE(
"Inconsistent number of channels");
1674 bool begin()
override {
1675 if (channels == 0) {
1676 LOGE(
"channels must not be 0");
1679 if (p_converter ==
nullptr) {
1680 p_converter =
new ConverterNChannels<T, TF>(channels);
1682 return AudioStream::begin();
1685 void end()
override {
1686 ModifyingStream::end();
1687 if (p_converter !=
nullptr) {
1689 p_converter =
nullptr;
1693 virtual size_t write(
const uint8_t *data,
size_t len)
override {
1694 if (p_converter ==
nullptr)
return 0;
1695 size_t result = p_converter->convert((uint8_t *)data, len);
1696 return p_print->write(data, result);
1699 size_t readBytes(uint8_t *data,
size_t len)
override {
1700 if (p_converter ==
nullptr)
return 0;
1701 if (p_stream ==
nullptr)
return 0;
1702 size_t result = p_stream->readBytes(data, len);
1703 result = p_converter->convert(data, result);
1707 virtual int available()
override {
1708 if (p_stream ==
nullptr)
return 0;
1709 return p_stream->available();
1712 virtual int availableForWrite()
override {
1713 return p_print->availableForWrite();
1720 if (p_converter !=
nullptr) {
1721 p_converter->
setFilter(channel, filter);
1723 LOGE(
"p_converter is null");
1736 Stream *p_stream =
nullptr;
1737 Print *p_print =
nullptr;
1768 bool begin()
override {
1775 LOGI(
"VolumeMeter::setAudioInfo: channels %d", channels);
1778 volumes.resize(channels);
1779 volumes_tmp.resize(channels);
1780 sum.resize(channels);
1781 sum_tmp.resize(channels);
1785 size_t write(
const uint8_t *data,
size_t len)
override {
1786 updateVolumes(data, len);
1787 size_t result = len;
1788 if (p_out !=
nullptr) {
1789 result = p_out->write(data, len);
1794 size_t readBytes(uint8_t *data,
size_t len)
override {
1795 if (p_stream ==
nullptr)
return 0;
1796 size_t result = p_stream->readBytes(data, len);
1797 updateVolumes((
const uint8_t *)data, len);
1808 if (volumes.size() == 0) {
1809 LOGE(
"begin not called!");
1812 if (channel >= volumes.size()) {
1813 LOGE(
"invalid channel %d", channel);
1816 return volumes[channel];
1853 for (
int j = 0; j < info.
channels; j++) {
1855 count += sample_count_per_channel;
1857 return total / count;
1862 return sum[channel] / sample_count_per_channel;
1868 for (
int j = 0; j < info.
channels; j++) {
1881 float f_volume_tmp = 0;
1884 Vector<float> volumes_tmp{0};
1885 Vector<float> sum{0};
1886 Vector<float> sum_tmp{0};
1887 Print *p_out =
nullptr;
1888 Stream *p_stream =
nullptr;
1889 size_t sample_count_per_channel = 0;
1891 void updateVolumes(
const uint8_t *data,
size_t len) {
1892 if (data ==
nullptr || len == 0)
return;
1896 updateVolumesT<int8_t>(data, len);
1899 updateVolumesT<int16_t>(data, len);
1902 updateVolumesT<int24_t>(data, len);
1905 updateVolumesT<int32_t>(data, len);
1913 template <
typename T>
1914 void updateVolumesT(
const uint8_t *buffer,
size_t size) {
1915 T *bufferT = (T *)buffer;
1916 int samplesCount = size /
sizeof(T);
1917 sample_count_per_channel = samplesCount / info.
channels;
1918 for (
int j = 0; j < samplesCount; j++) {
1919 float tmp = abs(
static_cast<float>(bufferT[j]));
1920 updateVolume(tmp, j);
1925 void updateVolume(
float tmp,
int j) {
1926 if (tmp > f_volume_tmp) {
1929 if (volumes_tmp.size() > 0 && info.
channels > 0) {
1931 if (tmp > volumes_tmp[ch]) {
1932 volumes_tmp[ch] = tmp;
1939 f_volume = f_volume_tmp;
1940 for (
int j = 0; j < info.
channels; j++) {
1941 volumes[j] = volumes_tmp[j];
1942 sum[j] = sum_tmp[j];
1948using VolumePrint = VolumeMeter;
1949using VolumeOutput = VolumeMeter;
1959 uint16_t buffer_size = DEFAULT_BUFFER_SIZE;
1960 bool use_timer =
true;
1962 TimerFunction timer_function = DirectTimerCallback;
1963 bool adapt_sample_rate =
false;
1964 uint16_t (*callback)(uint8_t *data, uint16_t len) =
nullptr;
1968static void timerCallback(
void *obj);
1979 friend void timerCallback(
void *obj);
1986 if (timer !=
nullptr)
delete timer;
1987 if (buffer !=
nullptr)
delete buffer;
1988 if (frame !=
nullptr)
delete[] frame;
2002 bool do_restart = active;
2003 if (do_restart)
end();
2007 if (do_restart)
begin(cfg);
2016 LOGD(
"%s: %s", LOG_METHOD,
2017 config.rx_tx_mode == RX_MODE ?
"RX_MODE" :
"TX_MODE");
2019 this->frameCallback = config.callback;
2020 if (cfg.use_timer) {
2021 frameSize = cfg.bits_per_sample * cfg.channels / 8;
2022 frame =
new uint8_t[frameSize];
2025 timer->setTimerFunction(cfg.timer_function);
2026 if (cfg.timer_id >= 0) {
2027 timer->setTimer(cfg.timer_id);
2030 LOGI(
"sample_rate: %u -> time: %u milliseconds",
2031 (
unsigned int)cfg.sample_rate, (
unsigned int)time);
2032 timer->setCallbackParameter(
this);
2033 timer->begin(timerCallback, time, TimeUnit::US);
2036 notifyAudioChange(cfg);
2043 if (this->frameCallback !=
nullptr) {
2044 if (cfg.use_timer) {
2045 timer->begin(timerCallback, time, TimeUnit::US);
2055 if (cfg.use_timer) {
2066 bool active =
false;
2067 uint16_t (*frameCallback)(uint8_t *data, uint16_t len);
2071 uint8_t *frame =
nullptr;
2072 uint16_t frameSize = 0;
2074 unsigned long lastTimestamp = 0u;
2075 uint32_t currentRateValue = 0;
2076 uint32_t printCount = 0;
2079 virtual size_t writeExt(
const uint8_t *data,
size_t len)
override {
2080 if (!active)
return 0;
2083 if (!cfg.use_timer) {
2084 result = frameCallback((uint8_t *)data, len);
2086 result = buffer->
writeArray((uint8_t *)data, len);
2093 virtual size_t readExt(uint8_t *data,
size_t len)
override {
2094 if (!active)
return 0;
2098 if (!cfg.use_timer) {
2099 result = frameCallback(data, len);
2109 unsigned long ms =
millis();
2110 if (lastTimestamp > 0u) {
2111 uint32_t diff = ms - lastTimestamp;
2113 uint16_t rate = 1 * 1000 / diff;
2115 if (currentRateValue == 0) {
2116 currentRateValue = rate;
2118 currentRateValue = (currentRateValue + rate) / 2;
2127 LOGI(
"effective sample rate: %u", (
unsigned int)currentRateValue);
2128 if (cfg.adapt_sample_rate &&
2129 abs((
int)currentRateValue - (
int)cfg.
sample_rate) > 200) {
2131 notifyAudioChange(cfg);
2137void IRAM_ATTR timerCallback(
void *obj) {
2138 TimerCallbackAudioStream *src = (TimerCallbackAudioStream *)obj;
2139 if (src !=
nullptr) {
2142 if (src->cfg.rx_tx_mode == RX_MODE) {
2144 uint16_t available_bytes = src->frameCallback(src->frame, src->frameSize);
2145 uint16_t buffer_available = src->buffer->availableForWrite();
2146 if (buffer_available < available_bytes) {
2148 uint16_t to_clear = available_bytes - buffer_available;
2149 uint8_t tmp[to_clear];
2150 src->buffer->readArray(tmp, to_clear);
2152 if (src->buffer->writeArray(src->frame, available_bytes) !=
2158 if (src->buffer !=
nullptr && src->frame !=
nullptr &&
2159 src->frameSize > 0) {
2160 uint16_t available_bytes =
2161 src->buffer->readArray(src->frame, src->frameSize);
2162 if (available_bytes !=
2163 src->frameCallback(src->frame, available_bytes)) {
2164 LOGE(
"data underflow");
2168 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