11 #include "AudioCodecs/AudioEncoded.h"
12 #include "AudioTools/Buffers.h"
13 #include "AudioBasic/Net.h"
16 #ifndef FLAC_READ_TIMEOUT_MS
17 #define FLAC_READ_TIMEOUT_MS 10000
20 #ifndef FLAC_BUFFER_SIZE
21 #define FLAC_BUFFER_SIZE (8 * 1024)
44 void setTimeout(uint64_t readTimeout=FLAC_READ_TIMEOUT_MS) {
45 read_timeout_ms = readTimeout;
47 void setOgg(
bool isOgg) {
53 info.
sample_rate = FLAC__stream_decoder_get_sample_rate(decoder);
54 info.
channels = FLAC__stream_decoder_get_channels(decoder);
63 if (decoder ==
nullptr) {
64 if ((decoder = FLAC__stream_decoder_new()) == NULL) {
65 LOGE(
"ERROR: allocating decoder");
70 LOGI(
"FLAC__stream_decoder_new");
72 FLAC__stream_decoder_set_md5_checking(decoder,
false);
80 if (init_status != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
81 LOGE(
"ERROR: initializing decoder: %s", FLAC__StreamDecoderInitStatusString[init_status]);
92 FLAC__stream_decoder_delete(decoder);
98 while(FLAC__stream_decoder_process_single(decoder));
102 operator bool() {
return is_active; }
112 if (p_input ==
nullptr) {
113 LOGE(
"setInput was not called");
116 if (!FLAC__stream_decoder_process_single(decoder)) {
117 LOGE(
"FLAC__stream_decoder_process_single");
124 bool is_active =
false;
127 FLAC__StreamDecoder *decoder =
nullptr;
128 FLAC__StreamDecoderInitStatus init_status;
129 uint64_t time_last_read = 0;
130 uint64_t read_timeout_ms = FLAC_READ_TIMEOUT_MS;
138 FLAC__StreamDecoderErrorStatus status,
140 LOGE(FLAC__StreamDecoderErrorStatusString[status]);
143 size_t readBytes(uint8_t *buffer,
size_t len)
override {
144 return p_input->readBytes(buffer, len);
148 static FLAC__StreamDecoderReadStatus
read_callback(
const FLAC__StreamDecoder *decoder, FLAC__byte result_buffer[],
size_t *bytes,
void *client_data) {
149 FLAC__StreamDecoderReadStatus result = FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
150 LOGD(
"read_callback: %d", (
int) *bytes);
152 if (
self ==
nullptr || !self->is_active) {
153 return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
157 *bytes =
self->readBytes(result_buffer, *bytes);
158 LOGD(
"-> %d", (
int) *bytes);
159 if (self->isEof(*bytes)){
160 result = FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
161 self->is_active =
false;
174 if (
millis() - time_last_read >= read_timeout_ms){
181 static FLAC__StreamDecoderWriteStatus
write_callback(
const FLAC__StreamDecoder *decoder,
const FLAC__Frame *frame,
const FLAC__int32 *
const buffer[],
void *client_data) {
182 LOGD(
"write_callback: %u", (
unsigned)frame->header.blocksize);
185 AudioInfo actual_info =
self->audioInfo();
186 if (self->info != actual_info){
187 self->info = actual_info;
188 self->info.logInfo();
189 int bps = FLAC__stream_decoder_get_bits_per_sample(decoder);
191 LOGI(
"Converting from %d bits", bps);
193 self->info = actual_info;
194 self->notifyAudioChange(self->info);
198 int bps = FLAC__stream_decoder_get_bits_per_sample(decoder);
199 int16_t result_frame[actual_info.
channels];
203 for (
int j = 0; j < frame->header.blocksize; j++) {
204 for (
int i = 0; i < actual_info.
channels; i++) {
206 result_frame[i] = buffer[i][j]<<8;
208 self->p_print->write((uint8_t *)result_frame,
sizeof(result_frame));
212 for (
int j = 0; j < frame->header.blocksize; j++) {
213 for (
int i = 0; i < actual_info.
channels; i++) {
214 result_frame[i] = buffer[i][j];
216 self->p_print->write((uint8_t *)result_frame,
sizeof(result_frame));
220 for (
int j = 0; j < frame->header.blocksize; j++) {
221 for (
int i = 0; i < actual_info.
channels; i++) {
222 result_frame[i] = buffer[i][j] >> 8;
224 self->p_print->write((uint8_t *)result_frame,
sizeof(result_frame));
228 for (
int j = 0; j < frame->header.blocksize; j++) {
229 for (
int i = 0; i < actual_info.
channels; i++) {
230 result_frame[i] = buffer[i][j] >> 16;
232 self->p_print->write((uint8_t *)result_frame,
sizeof(result_frame));
236 LOGE(
"Unsupported bps: %d", bps);
239 return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
256 void setOgg(
bool isOgg) {
260 bool isOgg() {
return is_ogg;}
262 void setBlockSize(
int size){
263 flac_block_size = size;
266 int blockSize() {
return flac_block_size; }
268 void setCompressionLevel(
int level){
269 flac_compression_level = level;
272 int compressionLevel() {
return flac_compression_level;}
278 const char *
mime()
override {
return "audio/flac"; }
290 if (p_encoder==
nullptr){
291 p_encoder = FLAC__stream_encoder_new();
292 if (p_encoder==
nullptr){
293 LOGE(
"FLAC__stream_encoder_new");
298 FLAC__stream_encoder_set_channels(p_encoder, cfg.
channels);
299 FLAC__stream_encoder_set_bits_per_sample(p_encoder, cfg.
bits_per_sample);
300 FLAC__stream_encoder_set_sample_rate(p_encoder, cfg.
sample_rate);
301 FLAC__stream_encoder_set_blocksize(p_encoder, flac_block_size);
302 FLAC__stream_encoder_set_compression_level(p_encoder, flac_compression_level);
305 FLAC__StreamEncoderInitStatus status;
307 status = FLAC__stream_encoder_init_ogg_stream(p_encoder,
nullptr, write_callback,
nullptr,
nullptr,
nullptr,
this);
309 status = FLAC__stream_encoder_init_stream(p_encoder, write_callback,
nullptr,
nullptr,
nullptr,
this);
311 if (status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
312 LOGE(
"ERROR: initializing decoder: %s", FLAC__StreamEncoderInitStatusString[status]);
313 if (status==FLAC__STREAM_ENCODER_INIT_STATUS_ENCODER_ERROR){
314 LOGE(
" -> %s", FLAC__StreamEncoderStateString[FLAC__stream_encoder_get_state(p_encoder)]);
331 FLAC__stream_encoder_delete(p_encoder);
337 virtual size_t write(
const void *in_ptr,
size_t in_size)
override {
338 if (!is_open || p_print ==
nullptr)
return 0;
339 LOGD(
"write: %zu", in_size);
343 int32_t *data=
nullptr;
346 samples = in_size /
sizeof(int16_t);
348 writeBuffer((int16_t*)in_ptr, samples);
349 data = buffer.data();
354 samples = in_size /
sizeof(int32_t);
356 data = (int32_t*) in_ptr;
365 if (FLAC__stream_encoder_process_interleaved(p_encoder, data, frames)){
368 LOGE(
"FLAC__stream_encoder_process_interleaved");
375 operator bool()
override {
return is_open; }
377 bool isOpen() {
return is_open; }
381 Vector<FLAC__int32> buffer;
382 Print *p_print =
nullptr;
383 FLAC__StreamEncoder *p_encoder=
nullptr;
386 int flac_block_size = 512;
387 int flac_compression_level = 8;
389 static FLAC__StreamEncoderWriteStatus write_callback(
const FLAC__StreamEncoder *encoder,
const FLAC__byte buffer[],
size_t bytes, uint32_t samples, uint32_t current_frame,
void *client_data){
390 FLACEncoder *
self = (FLACEncoder *)client_data;
391 if (self->p_print!=
nullptr){
392 size_t written =
self->p_print->write((uint8_t*)buffer, bytes);
394 LOGE(
"write_callback %zu -> %zu", bytes, written);
395 return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
398 return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
401 void writeBuffer(int16_t * data,
size_t samples) {
402 buffer.resize(samples);
403 for (
int j=0;j<samples;j++){