Mirror/squeezelite-esp32
1
0
Fork 0
mirror of https://github.com/sle118/squeezelite-esp32.git synced 2025-12-12 06:27:12 +03:00
Code Issues Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
philippe44
2019-05-26 22:58:38 -07:00
parent 66b2f74ebe
commit b53c14a2b5
4 changed files with 76 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
main/output.c
View File

@@ -48,7 +48,7 @@ frames_t _output_frames(frames_t avail) {
frames_t frames, size;
bool silence;
s32_t cross_gain_in = 0, cross_gain_out = 0; s32_t *cross_ptr = NULL;
s32_t cross_gain_in = 0, cross_gain_out = 0; ISAMPLE_T *cross_ptr = NULL;
s32_t gainL = output.current_replay_gain ? gain(output.gainL, output.current_replay_gain) : output.gainL;
s32_t gainR = output.current_replay_gain ? gain(output.gainR, output.current_replay_gain) : output.gainR;
@@ -242,7 +242,7 @@ frames_t _output_frames(frames_t avail) {
gainL = output.gainL;
gainR = output.gainR;
if (output.invert) { gainL = -gainL; gainR = -gainR; }
cross_ptr = (s32_t *)(output.fade_end + cur_f * BYTES_PER_FRAME);
cross_ptr = (ISAMPLE_T *)(output.fade_end + cur_f * BYTES_PER_FRAME);
} else {
LOG_INFO("unable to continue crossfade - too few samples");
output.fade = FADE_INACTIVE;

80
main/output_dac.c
View File

@@ -10,6 +10,10 @@ static bool running = true;
extern struct outputstate output;
extern struct buffer *outputbuf;
#if REPACK && BYTES_PER_FRAMES == 4
#error "REPACK is not compatible with BYTES_PER_FRAME=4"
#endif
#define LOCK mutex_lock(outputbuf->mutex)
#define UNLOCK mutex_unlock(outputbuf->mutex)
@@ -17,33 +21,34 @@ extern struct buffer *outputbuf;
extern u8_t *silencebuf;
// buffer to hold output data so we can block on writing outside of output lock, allocated on init
static u8_t *buf;
static unsigned buffill;
static u8_t *optr;
static int bytes_per_frame;
static thread_type thread;
static int _dac_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR,
s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr);
s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr);
static void *output_thread();
void set_volume(unsigned left, unsigned right) {}
void set_volume(unsigned left, unsigned right) {
LOG_DEBUG("setting internal gain left: %u right: %u", left, right);
LOCK;
output.gainL = left;
output.gainR = right;
UNLOCK;
}
void output_init_dac(log_level level, unsigned output_buf_size, char *params, unsigned rates[], unsigned rate_delay, unsigned idle) {
loglevel = level;
LOG_INFO("init output DAC");
buf = malloc(FRAME_BLOCK * BYTES_PER_FRAME);
if (!buf) {
LOG_ERROR("unable to malloc buf");
return;
}
buffill = 0;
memset(&output, 0, sizeof(output));
#if BYTES_PER_FRAME == 4
output.format = S16_LE;
#else
output.format = S32_LE;
#endif
output.start_frames = FRAME_BLOCK * 2;
output.write_cb = &_dac_write_frames;
output.rate_delay = rate_delay;
@@ -82,13 +87,11 @@ void output_close_dac(void) {
running = false;
UNLOCK;
free(buf);
output_close_common();
}
static int _dac_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32_t gainR,
s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr) {
s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr) {
u8_t *obuf;
@@ -98,22 +101,51 @@ static int _dac_write_frames(frames_t out_frames, bool silence, s32_t gainL, s32
_apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out, cross_ptr);
}
#if !REPACK
if (gainL != FIXED_ONE || gainR!= FIXED_ONE) {
_apply_gain(outputbuf, out_frames, gainL, gainR);
}
IF_DSD(
if (output.outfmt == DOP) {
update_dop((u32_t *) outputbuf->readp, out_frames, output.invert);
} else if (output.outfmt != PCM && output.invert)
dsd_invert((u32_t *) outputbuf->readp, out_frames);
)
memcpy(optr, outputbuf->readp, out_frames * BYTES_PER_FRAME);
#else
obuf = outputbuf->readp;
#endif
} else {
obuf = silencebuf;
#if !REPACK
IF_DSD(
if (output.outfmt != PCM) {
obuf = silencebuf_dsd;
update_dop((u32_t *) obuf, out_frames, false); // don't invert silence
}
)
memcpy(optr, obuf, out_frames * BYTES_PER_FRAME);
#endif
}
_scale_and_pack_frames(buf + buffill * bytes_per_frame, (s32_t *)(void *)obuf, out_frames, gainL, gainR, output.format);
buffill += out_frames;
#if REPACK
_scale_and_pack_frames(optr, (s32_t *)(void *)obuf, out_frames, gainL, gainR, output.format);
#endif
return (int)out_frames;
}
static void *output_thread() {
// buffer to hold output data so we can block on writing outside of output lock, allocated on init
u8_t *obuf = malloc(FRAME_BLOCK * BYTES_PER_FRAME);
unsigned frames = 0;
#if REPACK
LOCK;
switch (output.format) {
@@ -129,6 +161,7 @@ static void *output_thread() {
}
UNLOCK;
#endif
while (running) {
@@ -144,14 +177,15 @@ static void *output_thread() {
output.updated = gettime_ms();
output.frames_played_dmp = output.frames_played;
_output_frames(FRAME_BLOCK);
optr = obuf + frames * bytes_per_frame;
frames += _output_frames(FRAME_BLOCK);
UNLOCK;
if (buffill) {
// do something ...
usleep((buffill * 1000 * 1000) / output.current_sample_rate);
buffill = 0;
if (frames) {
// do something with some of these frames...
usleep((frames * 1000 * 1000) / output.current_sample_rate);
frames = 0;
} else {
usleep((FRAME_BLOCK * 1000 * 1000) / output.current_sample_rate);
}

17
main/output_pack.c
View File

@@ -23,8 +23,14 @@
#include "squeezelite.h"
#if BYTES_PER_FRAM == 4
#define MAX_VAL16 0x7fffffffLL
#define MAX_SCALESAMPLE 0x7fffffffffffLL
#define MIN_SCALESAMPLE -MAX_SCALESAMPLE
#else
#define MAX_SCALESAMPLE 0x7fffffffffffLL
#define MIN_SCALESAMPLE -MAX_SCALESAMPLE
#endif
// inlining these on windows prevents them being linkable...
#if !WIN
@@ -338,11 +344,11 @@ void _scale_and_pack_frames(void *outputptr, s32_t *inputptr, frames_t cnt, s32_
#if !WIN
inline
#endif
void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr) {
s32_t *ptr = (s32_t *)(void *)outputbuf->readp;
void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr) {
ISAMPLE_T *ptr = (ISAMPLE_T *)(void *)outputbuf->readp;
frames_t count = out_frames * 2;
while (count--) {
if (*cross_ptr > (s32_t *)outputbuf->wrap) {
if (*cross_ptr > (ISAMPLE_T *)outputbuf->wrap) {
*cross_ptr -= outputbuf->size / BYTES_PER_FRAME * 2;
}
*ptr = gain(cross_gain_out, *ptr) + gain(cross_gain_in, **cross_ptr);
@@ -354,8 +360,8 @@ void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gai
inline
#endif
void _apply_gain(struct buffer *outputbuf, frames_t count, s32_t gainL, s32_t gainR) {
s32_t *ptrL = (s32_t *)(void *)outputbuf->readp;
s32_t *ptrR = (s32_t *)(void *)outputbuf->readp + 1;
ISAMPLE_T *ptrL = (ISAMPLE_T *)(void *)outputbuf->readp;
ISAMPLE_T *ptrR = (ISAMPLE_T *)(void *)outputbuf->readp + 1;
while (count--) {
*ptrL = gain(gainL, *ptrL);
*ptrR = gain(gainR, *ptrR);
@@ -363,3 +369,4 @@ void _apply_gain(struct buffer *outputbuf, frames_t count, s32_t gainL, s32_t ga
ptrR += 2;
}
}

2
main/squeezelite.h
View File

@@ -733,7 +733,7 @@ void output_close_stdout(void);
// output_pack.c
void _scale_and_pack_frames(void *outputptr, s32_t *inputptr, frames_t cnt, s32_t gainL, s32_t gainR, output_format format);
void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gain_in, s32_t cross_gain_out, s32_t **cross_ptr);
void _apply_cross(struct buffer *outputbuf, frames_t out_frames, s32_t cross_gain_in, s32_t cross_gain_out, ISAMPLE_T **cross_ptr);
void _apply_gain(struct buffer *outputbuf, frames_t count, s32_t gainL, s32_t gainR);
s32_t gain(s32_t gain, s32_t sample);
s32_t to_gain(float f);