const int32_t *
pcm_resample_lsr_32(struct pcm_resample_state *state,
uint8_t channels,
unsigned src_rate,
const int32_t *src_buffer, size_t src_size,
unsigned dest_rate, size_t *dest_size_r,
GError **error_r)
{
bool success;
SRC_DATA *data = &state->data;
size_t data_in_size;
size_t data_out_size;
int error;
int32_t *dest_buffer;
assert((src_size % (sizeof(*src_buffer) * channels)) == 0);
success = pcm_resample_set(state, channels, src_rate, dest_rate,
error_r);
if (!success)
return NULL;
/* there was an error previously, and nothing has changed */
if (state->error) {
g_set_error(error_r, libsamplerate_quark(), state->error,
"libsamplerate has failed: %s",
src_strerror(state->error));
return NULL;
}
data->input_frames = src_size / sizeof(*src_buffer) / channels;
data_in_size = data->input_frames * sizeof(float) * channels;
data->data_in = pcm_buffer_get(&state->in, data_in_size);
data->output_frames = (src_size * dest_rate + src_rate - 1) / src_rate;
data_out_size = data->output_frames * sizeof(float) * channels;
data->data_out = pcm_buffer_get(&state->out, data_out_size);
src_int_to_float_array(src_buffer, data->data_in,
data->input_frames * channels);
error = src_process(state->state, data);
if (error) {
g_set_error(error_r, libsamplerate_quark(), error,
"libsamplerate has failed: %s",
src_strerror(error));
state->error = error;
return NULL;
}
*dest_size_r = data->output_frames_gen *
sizeof(*dest_buffer) * channels;
dest_buffer = pcm_buffer_get(&state->buffer, *dest_size_r);
src_float_to_int_array(data->data_out, dest_buffer,
data->output_frames_gen * channels);
return dest_buffer;
}
const int32_t *
pcm_resample_lsr_32(struct pcm_resample_state *state,
unsigned channels,
unsigned src_rate,
const int32_t *src_buffer, size_t src_size,
unsigned dest_rate, size_t *dest_size_r,
GError **error_r)
{
bool success;
SRC_DATA *data = &state->data;
size_t data_in_size;
size_t data_out_size;
int32_t *dest_buffer;
assert((src_size % (sizeof(*src_buffer) * channels)) == 0);
success = pcm_resample_set(state, channels, src_rate, dest_rate,
error_r);
if (!success)
return NULL;
data->input_frames = src_size / sizeof(*src_buffer) / channels;
data_in_size = data->input_frames * sizeof(float) * channels;
data->data_in = pcm_buffer_get(&state->in, data_in_size);
data->output_frames = (src_size * dest_rate + src_rate - 1) / src_rate;
data_out_size = data->output_frames * sizeof(float) * channels;
data->data_out = pcm_buffer_get(&state->out, data_out_size);
src_int_to_float_array(src_buffer, data->data_in,
data->input_frames * channels);
if (!lsr_process(state, error_r))
return NULL;
*dest_size_r = data->output_frames_gen *
sizeof(*dest_buffer) * channels;
dest_buffer = pcm_buffer_get(&state->buffer, *dest_size_r);
src_float_to_int_array(data->data_out, dest_buffer,
data->output_frames_gen * channels);
return dest_buffer;
}
/* All and mighty connection handler. */
static void* rsd_thread(void *thread_data)
{
connection_t conn;
void *data = NULL;
wav_header_t w;
wav_header_t w_orig;
int resample = 0;
int rc, written;
void *buffer = NULL;
#ifdef HAVE_SAMPLERATE
SRC_STATE *resample_state = NULL;
#else
resampler_t *resample_state = NULL;
#endif
float *resample_buffer = NULL;
resample_cb_state_t cb_data;
connection_t *temp_conn = thread_data;
conn.socket = temp_conn->socket;
conn.ctl_socket = temp_conn->ctl_socket;
conn.serv_ptr = 0;
conn.rate_ratio = 1.0;
conn.identity[0] = '\0';
free(temp_conn);
if ( debug )
log_printf("Connection accepted, awaiting WAV header data ...\n");
/* Firstly, get the wave header with stream settings. */
rc = get_wav_header(conn, &w);
if ( rc == -1 )
{
close(conn.socket);
close(conn.ctl_socket);
log_printf("Couldn't read WAV header... Disconnecting.\n");
pthread_exit(NULL);
}
memcpy(&w_orig, &w, sizeof(wav_header_t));
if ( resample_freq > 0 && resample_freq != (int)w.sampleRate )
{
w.sampleRate = resample_freq;
w.bitsPerSample = w_orig.bitsPerSample == 32 ? 32 : 16;
if (w_orig.bitsPerSample == 32)
w.rsd_format = (is_little_endian()) ? RSD_S32_LE : RSD_S32_BE;
else
w.rsd_format = (is_little_endian()) ? RSD_S16_LE : RSD_S16_BE;
resample = 1;
conn.rate_ratio = (float)w.sampleRate * w.bitsPerSample / ((float)w_orig.sampleRate * w_orig.bitsPerSample);
}
if ( debug )
{
log_printf("Successfully got WAV header ...\n");
pheader(&w_orig);
if ( resample )
{
log_printf("Resamples to:\n");
pheader(&w);
}
}
if ( debug )
log_printf("Initializing %s ...\n", backend->backend);
/* Sets up backend */
if ( backend->init(&data) < 0 )
{
log_printf("Failed to initialize %s ...\n", backend->backend);
goto rsd_exit;
}
/* Opens device with settings. */
if ( backend->open(data, &w) < 0 )
{
log_printf("Failed to open audio driver ...\n");
goto rsd_exit;
}
backend_info_t backend_info;
memset(&backend_info, 0, sizeof(backend_info));
backend->get_backend_info(data, &backend_info);
if ( backend_info.chunk_size == 0 )
{
log_printf("Couldn't get backend info ...\n");
goto rsd_exit;
}
if ( backend_info.resample )
{
resample = 1;
w.sampleRate = w.sampleRate * backend_info.ratio;
conn.rate_ratio = backend_info.ratio;
w.bitsPerSample = w_orig.bitsPerSample == 32 ? 32 : 16;
if (w_orig.bitsPerSample == 32)
w.rsd_format = (is_little_endian()) ? RSD_S32_LE : RSD_S32_BE;
else
w.rsd_format = (is_little_endian()) ? RSD_S16_LE : RSD_S16_BE;
}
size_t size = backend_info.chunk_size;
size_t read_size = size;
size_t buffer_size = (read_size > size) ? read_size : size;
buffer = malloc(buffer_size);
if ( buffer == NULL )
{
log_printf("Could not allocate memory for buffer.");
goto rsd_exit;
}
if ( resample )
{
resample_buffer = malloc(BYTES_TO_SAMPLES(buffer_size, w.rsd_format) * sizeof(float));
if ( resample_buffer == NULL )
{
log_printf("Could not allocate memory for buffer.");
goto rsd_exit;
}
cb_data.format = w_orig.rsd_format;
cb_data.data = data;
cb_data.conn = &conn;
cb_data.framesize = w_orig.numChannels * rsnd_format_to_bytes(w_orig.rsd_format);
#ifdef HAVE_SAMPLERATE
int err;
resample_state = src_callback_new(resample_callback, src_converter, w.numChannels, &err, &cb_data);
#else
resample_state = resampler_new(resample_callback, (float)w.sampleRate/w_orig.sampleRate, w.numChannels, &cb_data);
#endif
if ( resample_state == NULL )
{
log_printf("Could not initialize resampler.");
goto rsd_exit;
}
}
#define MAX_TCP_BUFSIZ (1 << 14)
// We only bother with setting buffer size if we're doing TCP.
if ( rsd_conn_type == RSD_CONN_TCP )
{
int flag = 1;
int bufsiz = backend_info.chunk_size * 32;
if (bufsiz > MAX_TCP_BUFSIZ)
bufsiz = MAX_TCP_BUFSIZ;
setsockopt(conn.socket, SOL_SOCKET, SO_RCVBUF, CONST_CAST &bufsiz, sizeof(int));
if ( conn.ctl_socket )
{
setsockopt(conn.ctl_socket, SOL_SOCKET, SO_RCVBUF, CONST_CAST &bufsiz, sizeof(int));
setsockopt(conn.ctl_socket, SOL_SOCKET, SO_SNDBUF, CONST_CAST &bufsiz, sizeof(int));
setsockopt(conn.ctl_socket, IPPROTO_TCP, TCP_NODELAY, CONST_CAST &flag, sizeof(int));
}
setsockopt(conn.socket, IPPROTO_TCP, TCP_NODELAY, CONST_CAST &flag, sizeof(int));
}
/* Now we can send backend info to client. */
if ( send_backend_info(conn, &backend_info) < 0 )
{
log_printf("Failed to send backend info ...\n");
goto rsd_exit;
}
if ( debug )
log_printf("Initializing of %s successful ...\n", backend->backend);
if ( debug )
{
if ( resample )
{
log_printf("Resampling active. %d Hz --> %d Hz ", (int)w_orig.sampleRate, (int)w.sampleRate);
#ifdef HAVE_SAMPLERATE
log_printf("(libsamplerate)\n");
#else
log_printf("(internal quadratic resampler)\n");
#endif
}
}
/* Recieve data, write to sound card. Rinse, repeat :') */
for(;;)
{
if ( strlen(conn.identity) > 0 && verbose )
{
log_printf(" :: %s\n", conn.identity);
conn.identity[0] = '\0';
}
if ( resample )
{
#ifdef HAVE_SAMPLERATE
rc = src_callback_read(resample_state, (double)w.sampleRate/(double)w_orig.sampleRate, BYTES_TO_SAMPLES(size, w.rsd_format)/w.numChannels, resample_buffer);
if (rsnd_format_to_bytes(w.rsd_format) == 4)
src_float_to_int_array(resample_buffer, buffer, BYTES_TO_SAMPLES(size, w.rsd_format));
else
src_float_to_short_array(resample_buffer, buffer, BYTES_TO_SAMPLES(size, w.rsd_format));
#else
rc = resampler_cb_read(resample_state, BYTES_TO_SAMPLES(size, w.rsd_format)/w.numChannels, resample_buffer);
if (rsnd_format_to_bytes(w.rsd_format) == 4)
resampler_float_to_s32(buffer, resample_buffer, BYTES_TO_SAMPLES(size, w.rsd_format));
else
resampler_float_to_s16(buffer, resample_buffer, BYTES_TO_SAMPLES(size, w.rsd_format));
#endif
}
else
rc = receive_data(data, &conn, buffer, read_size);
if ( rc <= 0 )
{
if ( debug )
log_printf("Client closed connection.\n");
goto rsd_exit;
}
for ( written = 0; written < (int)size; )
{
rc = backend->write(data, (const char*)buffer + written, size - written);
if ( rc == 0 )
goto rsd_exit;
written += rc;
}
}
/* Cleanup */
rsd_exit:
if ( debug )
log_printf("Closed connection.\n\n");
#ifdef _WIN32
#undef close
#endif
backend->close(data);
#ifdef _WIN32
#define close(x) closesocket(x)
#endif
free(buffer);
close(conn.socket);
if (conn.ctl_socket)
close(conn.ctl_socket);
if (resample_state)
{
#ifdef HAVE_SAMPLERATE
src_delete(resample_state);
#else
resampler_free(resample_state);
#endif
}
free(resample_buffer);
pthread_exit(NULL);
}
