3 #include "AudioConfig.h"
4 #include "AudioTools/AudioIO.h"
5 #include "AudioTools/AudioOutput.h"
6 #include "AudioTools/AudioStreams.h"
7 #include "AudioTools/AudioTypes.h"
24 virtual AudioInfo audioInfo() {
return info; };
30 if (p_notify !=
nullptr) {
31 p_notify->setAudioInfo(from);
38 Print *p_print = &out_stream;
45 Print *p_print = &out_stream;
52 p_print = &out_stream;
63 Print *p_print =
nullptr;
81 virtual const char *
mime() = 0;
88 virtual void setBlockSize(
int blockSize) = 0;
93 virtual int blockSize() =0;
112 virtual void begin() {}
113 virtual void end() {}
122 virtual operator bool() {
return false; }
123 virtual int readStream(Stream &in) {
return 0; };
126 virtual size_t write(
const void *in_ptr,
size_t in_size) {
127 memset((
void *)in_ptr, 0, in_size);
131 virtual const char *
mime() {
return nullptr; }
157 Print *p_print = &out_stream;
164 Print *p_print = &out_stream;
176 virtual operator bool() = 0;
182 virtual size_t readBytes(uint8_t *buffer,
size_t len) = 0;
204 writer_ptr = decoder_ptr;
210 ptr_out = outputStream;
214 writer_ptr = decoder_ptr;
220 ptr_out = outputStream;
224 writer_ptr = decoder_ptr;
230 ptr_out = outputStream;
233 writer_ptr = decoder_ptr;
239 ptr_out = outputStream;
241 encoder_ptr->setOutput(*outputStream);
242 writer_ptr = encoder_ptr;
248 ptr_out = outputStream;
250 encoder_ptr->setOutput(*outputStream);
252 writer_ptr = encoder_ptr;
258 ptr_out = outputStream;
260 encoder_ptr->setOutput(*outputStream);
262 writer_ptr = encoder_ptr;
276 cfg.sample_rate = 44100;
277 cfg.bits_per_sample = 16;
281 virtual void setAudioInfo(AudioInfo info)
override {
283 if (this->info != info && info.channels!=0 && info.sample_rate!=0) {
285 AudioStream::setAudioInfo(info);
293 ptr_out = outputStream;
294 if (decoder_ptr !=
nullptr) {
297 if (encoder_ptr !=
nullptr) {
298 encoder_ptr->setOutput(*ptr_out);
307 encoder = CodecNOP::instance();
311 if (ptr_out !=
nullptr) {
312 encoder_ptr->setOutput(*ptr_out);
316 void setDecoder(AudioDecoder *
decoder) {
318 decoder = CodecNOP::instance();
322 if (ptr_out !=
nullptr) {
329 custom_log_level.set();
333 const CodecNOP *nop = CodecNOP::instance();
334 if (decoder_ptr != nop || encoder_ptr != nop) {
336 decoder_ptr->begin();
337 encoder_ptr->begin();
339 LOGW(
"no decoder or encoder defined");
342 custom_log_level.reset();
354 custom_log_level.set();
359 custom_log_level.reset();
363 virtual size_t write(
const uint8_t *data,
size_t len)
override {
364 custom_log_level.set();
365 LOGD(
"EncodedAudioOutput::write: %d", (
int)len);
367 LOGI(
"write: %d", 0);
371 if (writer_ptr ==
nullptr || data ==
nullptr) {
376 size_t result = writer_ptr->write(data, len);
377 LOGD(
"EncodedAudioOutput::write: %d -> %d", (
int)len, (
int)result);
378 custom_log_level.reset();
383 int availableForWrite()
override {
return min(ptr_out->availableForWrite(), DEFAULT_BUFFER_SIZE); }
386 operator bool() {
return active; }
396 custom_log_level.set(level);
404 Print *ptr_out =
nullptr;
406 CustomLogLevel custom_log_level;
410 using EncodedAudioPrint = EncodedAudioOutput;
438 writer_ptr = decoder_ptr;
464 EncodedAudioOutput::setEncoder(
encoder);
468 void setDecoder(AudioDecoder *
decoder) {
469 EncodedAudioOutput::setDecoder(
decoder);
474 void resize(
int size) { decoded_buffer.resize(size); }
479 int available()
override {
480 if (p_stream ==
nullptr)
return 0;
481 decode(reqested_bytes);
485 size_t readBytes(uint8_t *buffer,
size_t length)
override {
486 custom_log_level.set();
487 LOGD(
"EncodedAudioStream::readBytes: %d", (
int)length);
488 if (p_stream ==
nullptr) {
492 decode(reqested_bytes);
493 size_t result = decoded_buffer.
readArray(buffer, length);
494 custom_log_level.reset();
499 RingBuffer<uint8_t> decoded_buffer{0};
500 QueueStream<uint8_t> queue_stream{decoded_buffer};
501 Vector<uint8_t> copy_buffer{DEFAULT_BUFFER_SIZE};
502 Stream *p_stream =
nullptr;
503 AudioWriter *p_write =
nullptr;
504 int reqested_bytes = DEFAULT_BUFFER_SIZE;
505 bool is_setup =
false;
506 int max_read_count = 5;
509 void decode(
int requestedBytes) {
515 if (p_stream->available() > 0 &&
516 decoded_buffer.
available() < reqested_bytes) {
517 for (
int j = 0; j < max_read_count; j++) {
519 p_stream->readBytes(copy_buffer.data(), DEFAULT_BUFFER_SIZE);
520 LOGD(
"bytes_read: %d", bytes_read);
521 int result = writer_ptr->write(copy_buffer.data(), bytes_read);
522 if (p_stream->available() == 0 ||
523 decoded_buffer.
available() >= reqested_bytes) {
528 LOGD(
"available decoded data %d", decoded_buffer.
available());
534 LOGI(
"Setup reading support");
537 writer_ptr->setOutput(queue_stream);
538 queue_stream.
begin();
552 void setWriter(
AudioWriter *writer) { p_writer = writer; }
553 size_t write(
const uint8_t *in_ptr,
size_t in_size) {
554 return p_writer->write(in_ptr, in_size);
570 virtual bool begin() = 0;
571 virtual void end() = 0;
572 virtual void setAudioInfo(
AudioInfo info) {
573 if (this->info != info && info.channels!=0 && info.sample_rate!=0) {
575 if (p_writer1 !=
nullptr) p_writer1->setAudioInfo(info);
576 if (p_writer2 !=
nullptr) p_writer2->setAudioInfo(info);
579 virtual size_t write(uint8_t *data,
size_t size) = 0;
595 print2.setWriter(p_writer2);
603 virtual bool begin() {
606 if (p_writer2 !=
nullptr) {
607 p_writer1->setOutput(print2);
608 p_writer2->setOutput(*p_print);
612 p_writer1->setOutput(*p_print);
620 if (p_writer1 !=
nullptr) p_writer1->end();
621 if (p_writer2 !=
nullptr) p_writer2->end();
625 virtual size_t write(uint8_t *data,
size_t size) {
627 return p_writer1->write(data, size);
631 Print *p_print =
nullptr;