nils/shairport-sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
abede0a4f7bd6686c06d1ee8946ba02e7643cf4c
shairport-sync/audio.c
T
Mike Brady b405c0b896 Version 5.0 Major Release. 
New Features:
Multi-Channel and High-Resolution Audio Support
48,000 frames per second ("48k") operation.
48k lossless stereo support.
5.1 and 7.1 surround sound support.
Multi-channel and multi-rate operation on ALSA, PipeWire, PulseAudio, FreeBSD, stdout and Unix pipe output backends.
Automatic Audio Format Selection
Flexible and controllable output format selection.
Automatic rate, sample format, and channel count selection.
Full FFmpeg Integration
Support for transcoding.
Advanced resampling capabilities.
New audio format support.
Enhanced Resampling
New vernier resampling and interpolation method optimized for low-power CPUs.
Better performance on resource-constrained devices.

Convolution and Loudness Enhancements:
Convolution system is now multithreaded and works on stereo and multichannel audio at 48k and 44.1k.
Multiple impulse response (IR) files can now be provided via convolution_ir_files setting.
New convolution_thread_pool_size setting for multithreaded processing (defaults to 1).
Loudness processing now works with stereo and multichannel audio at 48k and 44.1k.
Updated to the most recent HiFi-LoFi FFT convolver.

MQTT Enhancements:
Added new publish_retain boolean option. When enabled, published MQTT messages have the retain flag set, so the MQTT broker stores the last message per topic and new subscribers receive the most recent value immediately. Thanks to lululombard for PR #2142.

D-Bus Enhancements:
Added new dbus_default_message_bus command-line argument (can be system or session) to set the default message bus for both D-Bus native service and MPRIS service.

Performance Improvements:
Enhanced compatibility with AirPlay 2 AutoMix and Smart Tracklists resulting in less unexplained track skipping.
Better operation on low-power devices down to Raspberry Pi B.
Improved efficiency on embedded systems.
Enhanced timestamp handling for better synchronization.
Improved sync error calculation.
Rebuilt buffered audio processor for cleaner handling of immediate and deferred flush requests.

Docker Enhancements:
Reduced Docker image sizes with slimmed-down FFmpeg library.
Removed dhclient from Docker images for smaller footprint.

Bug Fixes:
Fixed MQTT warning on service startup: "Could not establish a mqtt connection". The startup script now correctly states that the mosquitto service is required. Thanks to Hugo Villeneuve for PR #2137.
Fixed compatibility with mbedtls library version 3.4+ (present on recent Linux versions). Thanks to Christian Beier for finding and fixing the bug.
Fixed PulseAudio backend so that PA_ERR_NODATA returns "No latency data yet". Thanks to Vladimir Shakov for the report and fix.
Ensured old flush requests are deleted when a new play session starts. Thanks to saujanyashah for the report.
Fixed format warnings on 64-bit and 32-bit systems
Removed compilation warnings on 32-bit builds
Improved argument checking for debug(), inform(), warn() and die() functions
Fixed "daemon" typos throughout codebase. Thanks to Chris Boot for PR #1981.
Added warning if a convolution impulse response file cannot be read due to bad path or permissions

Build System Improvements:
Unified service file with variable substitution for Avahi support, making it easier to add future service dependencies. Thanks to Hugo Villeneuve.
Network interface selection now only considers interfaces that are up, running and not loopback interfaces. Thanks to Carl Johnson for the suggestion.
Configuration File Changes and Deprecations

New settings: convolution_ir_files (replaces convolution_ir_file), convolution_enabled (replaces convolution), convolution_max_length_in_seconds (replaces convolution_max_length), loudness_enabled (replaces loudness).
New convolution_thread_pool_size setting (defaults to 1).
Deprecated settings: convolution_ir_file, convolution, convolution_max_length, loudness.
Corresponding D-Bus methods and properties have been updated.

Deprecation Notice:
The Jack Audio and soundio backends are deprecated and will be removed in a future release. Consider using the updated PipeWire backend instead.

Documentation Updates
Updated BUILD.md with latest build instructions.
Updated AIRPLAY2.md with feature information.
Enhanced convolution and loudness documentation.

Maintenance:
Fixed FFmpeg deprecation warnings.
Bumped actions/checkout from 6.0.1 to 6.0.2.
Bumped docker/login-action from 3.6.0 to 3.7.0.
Bumped docker/build-push-action from 6.13.0 to 6.15.0.
Bumped docker/setup-qemu-action from 3.4.0 to 3.6.0.
Bumped docker/setup-buildx-action from 3.9.0 to 3.10.0.
2026-02-13 15:17:40 +00:00

1049 lines
45 KiB
C
Raw Blame History

/*
* Audio driver handler. This file is part of Shairport.
* Copyright (c) James Laird 2013
* Modifications (c) Mike Brady 2014--2025
* All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
#include "audio.h"
#include "common.h"
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef CONFIG_JACK
extern audio_output audio_jack;
#endif
#ifdef CONFIG_SNDIO
extern audio_output audio_sndio;
#endif
#ifdef CONFIG_AO
extern audio_output audio_ao;
#endif
#ifdef CONFIG_SOUNDIO
extern audio_output audio_soundio;
#endif
#ifdef CONFIG_PIPEWIRE
extern audio_output audio_pw;
#endif
#ifdef CONFIG_PULSEAUDIO
extern audio_output audio_pa;
#endif
#ifdef CONFIG_ALSA
extern audio_output audio_alsa;
#endif
#ifdef CONFIG_DUMMY
extern audio_output audio_dummy;
#endif
#ifdef CONFIG_PIPE
extern audio_output audio_pipe;
#endif
#ifdef CONFIG_STDOUT
extern audio_output audio_stdout;
#endif
static audio_output *outputs[] = {
#ifdef CONFIG_ALSA
&audio_alsa,
#endif
#ifdef CONFIG_SNDIO
&audio_sndio,
#endif
#ifdef CONFIG_PIPEWIRE
&audio_pw,
#endif
#ifdef CONFIG_PULSEAUDIO
&audio_pa,
#endif
#ifdef CONFIG_JACK
&audio_jack,
#endif
#ifdef CONFIG_AO
&audio_ao,
#endif
#ifdef CONFIG_SOUNDIO
&audio_soundio,
#endif
#ifdef CONFIG_PIPE
&audio_pipe,
#endif
#ifdef CONFIG_STDOUT
&audio_stdout,
#endif
#ifdef CONFIG_DUMMY
&audio_dummy,
#endif
NULL};
audio_output *audio_get_output(const char *name) {
audio_output **out;
// default to the first
if (!name)
return outputs[0];
for (out = outputs; *out; out++)
if (!strcasecmp(name, (*out)->name))
return *out;
return NULL;
}
void audio_ls_outputs(void) {
audio_output **out;
printf("Available audio backends:\n");
for (out = outputs; *out; out++)
printf(" %s%s\n", (*out)->name, out == outputs ? " (default)" : "");
for (out = outputs; *out; out++) {
printf("\n");
if ((*out)->help) {
printf("Settings and options for the audio backend \"%s\":\n", (*out)->name);
(*out)->help();
} else {
printf("There are no settings or options for the audio backend \"%s\".\n", (*out)->name);
}
}
}
void parse_audio_options(const char *named_stanza, uint32_t default_format_set,
uint32_t default_rate_set, uint32_t default_channel_set) {
/* this must be called after the output device has been initialised, so that the default values
* are set before any options are chosen */
int value;
double dvalue;
const char *str = 0;
if (config.cfg != NULL) {
/* Get the desired buffer size setting (deprecated). */
if (config_lookup_int(config.cfg, "general.audio_backend_buffer_desired_length", &value)) {
inform("The setting general.audio_backend_buffer_desired_length is no longer supported. "
"Please use general.audio_backend_buffer_desired_length_in_seconds instead.");
}
/* Get the desired backend buffer size setting in seconds. */
/* This is the size of the buffer in the output system, e.g. in the DAC itself in ALSA */
if (config_lookup_float(config.cfg, "general.audio_backend_buffer_desired_length_in_seconds",
&dvalue)) {
if (dvalue < 0) {
die("Invalid audio_backend_buffer_desired_length_in_seconds value: \"%f\". It "
"should be 0.0 or greater."
" The default is %.3f seconds",
dvalue, config.audio_backend_buffer_desired_length);
} else {
config.audio_backend_buffer_desired_length = dvalue;
}
}
/* Get the desired decoded buffer size setting in seconds. */
/* This is the size of the buffer of decoded and deciphered audio held in the player's output
* queue prior to sending it to the output system */
if (config_lookup_float(config.cfg, "general.audio_decoded_buffer_desired_length_in_seconds",
&dvalue)) {
if (dvalue < 0) {
die("Invalid audio_decoded_buffer_desired_length_in_seconds value: \"%f\". It "
"should be 0.0 or greater."
" The default is %.3f seconds",
dvalue, config.audio_decoded_buffer_desired_length);
} else {
config.audio_decoded_buffer_desired_length = dvalue;
}
}
/* Get the minimum buffer size for fancy interpolation setting in seconds. */
if (config_lookup_float(config.cfg,
"general.audio_backend_buffer_interpolation_threshold_in_seconds",
&dvalue)) {
if ((dvalue < 0) || (dvalue > config.audio_backend_buffer_desired_length)) {
die("Invalid audio_backend_buffer_interpolation_threshold_in_seconds value: \"%f\". It "
"should be between 0 and "
"audio_backend_buffer_desired_length_in_seconds of %.3f, default is %.3f seconds",
dvalue, config.audio_backend_buffer_desired_length,
config.audio_backend_buffer_interpolation_threshold_in_seconds);
} else {
config.audio_backend_buffer_interpolation_threshold_in_seconds = dvalue;
}
}
/* Get the latency offset (deprecated). */
if (config_lookup_int(config.cfg, "general.audio_backend_latency_offset", &value)) {
inform("The setting general.audio_backend_latency_offset is no longer supported. "
"Please use general.audio_backend_latency_offset_in_seconds instead.");
}
/* Get the latency offset in seconds. */
if (config_lookup_float(config.cfg, "general.audio_backend_latency_offset_in_seconds",
&dvalue)) {
config.audio_backend_latency_offset = dvalue;
}
/* Check if the length of the silent lead-in ia set to \"auto\". */
if (config_lookup_string(config.cfg, "general.audio_backend_silent_lead_in_time", &str)) {
if (strcasecmp(str, "auto") == 0) {
config.audio_backend_silent_lead_in_time_auto = 1;
} else {
if (config.audio_backend_silent_lead_in_time_auto == 1)
warn("Invalid audio_backend_silent_lead_in_time \"%s\". It should be \"auto\" or the "
"lead-in time in seconds. "
"It remains set to \"auto\". Note: numbers should not be placed in quotes.",
str);
else
warn("Invalid output rate \"%s\". It should be \"auto\" or the lead-in time in seconds. "
"It remains set to %f. Note: numbers should not be placed in quotes.",
str, config.audio_backend_silent_lead_in_time);
}
}
/* Get the desired length of the silent lead-in. */
if (config_lookup_float(config.cfg, "general.audio_backend_silent_lead_in_time", &dvalue)) {
if ((dvalue < 0.0) || (dvalue > 4)) {
if (config.audio_backend_silent_lead_in_time_auto == 1)
warn("Invalid audio_backend_silent_lead_in_time \"%f\". It "
"must be between 0.0 and 4.0 seconds. Omit the setting to use the automatic value. "
"The setting remains at \"auto\".",
dvalue);
else
warn("Invalid audio_backend_silent_lead_in_time \"%f\". It "
"must be between 0.0 and 4.0 seconds. Omit the setting to use the automatic value. "
"It remains set to %f.",
dvalue, config.audio_backend_silent_lead_in_time);
} else {
config.audio_backend_silent_lead_in_time = dvalue;
config.audio_backend_silent_lead_in_time_auto = 0;
}
}
}
if (named_stanza != NULL) {
config.format_set = get_format_settings(named_stanza, "output_format");
config.rate_set = get_rate_settings(named_stanza, "output_rate");
config.channel_set = get_channel_settings(named_stanza, "output_channels");
}
// use the supplied defaults if no settings were given
if (config.format_set == 0)
config.format_set = default_format_set;
if (config.rate_set == 0)
config.rate_set = default_rate_set;
if (config.channel_set == 0)
config.channel_set = default_channel_set;
}
uint32_t get_format_settings(const char *stanza_name, const char *setting_name) {
uint32_t format_set = 0;
if (config.cfg != NULL) {
char setting_path[256];
snprintf(setting_path, sizeof(setting_path) - 1, "%s.%s", stanza_name, setting_name);
// get any format settings -- can be "auto", a single format e.g. "S16" or a list of formats
config_setting_t *format_setting = config_lookup(config.cfg, setting_path);
if (format_setting != NULL) {
const char **format_settings;
int format_settings_count =
config_get_string_settings_as_string_array(format_setting, &format_settings);
if (format_settings_count > 0) {
int i;
for (i = 0; i < format_settings_count; i++) {
debug(3, "format setting %u: \"%s\".", i, format_settings[i]);
if (strcmp(format_settings[i], "auto") == 0) {
if (format_settings_count != 1)
warn("in the \"%s\" setting in the \"%s\" section of the configuration file, "
"multiple formats, including \"auto\", "
"are specified, but \"auto\" includes all "
"formats anyway...",
setting_name, stanza_name);
format_set = SPS_FORMAT_SET; // all valid formats
} else if (strcmp(format_settings[i], "S16") == 0) {
format_set |= (1 << SPS_FORMAT_S16_LE) | (1 << SPS_FORMAT_S16_BE);
} else if (strcmp(format_settings[i], "S24") == 0) {
format_set |= (1 << SPS_FORMAT_S24_LE) | (1 << SPS_FORMAT_S24_BE) |
(1 << SPS_FORMAT_S24_3LE) | (1 << SPS_FORMAT_S24_3BE);
} else if (strcmp(format_settings[i], "S32") == 0) {
format_set |= (1 << SPS_FORMAT_S32_LE) | (1 << SPS_FORMAT_S32_BE);
} else {
sps_format_t f;
int valid = 0;
for (f = SPS_FORMAT_LOWEST; f <= SPS_FORMAT_HIGHEST_NATIVE; f++) {
if (strcmp(format_settings[i], sps_format_description_string(f)) == 0) {
format_set |= (1 << f);
valid = 1;
}
}
if (valid == 0) {
warn("in the \"%s\" setting in the \"%s\" section of the configuration file, an "
"invalid format: \"%s\" has been detected.",
setting_name, stanza_name, format_settings[i]);
}
}
}
free(format_settings);
} else {
debug(1,
"in the \"%s\" setting in the \"%s\" section of the configuration file, an error has "
"been detected at argument %d.",
setting_name, stanza_name, -format_settings_count);
}
}
}
sps_format_t f;
uint32_t t_format_set = format_set;
char buf[256];
char *p = buf;
for (f = SPS_FORMAT_UNKNOWN; f <= SPS_FORMAT_S32_BE; f++) {
if ((t_format_set & (1 << f)) != 0) {
snprintf(p, sizeof(buf) - (p - buf) - 1, "%s", sps_format_description_string(f));
p = p + strlen(sps_format_description_string(f));
t_format_set -= (1 << f);
if (t_format_set != 0) {
snprintf(p, sizeof(buf) - (p - buf) - 1, ", ");
p = p + strlen(", ");
}
}
}
if (p != buf) {
*p = '.';
p++;
}
*p = '\0';
if (strlen(buf) == 0)
debug(3, "No \"%s\" output format settings.", stanza_name);
else
debug(3, "The \"%s\" output format settings are: \"%s\".", stanza_name, buf);
return format_set;
}
uint32_t get_rate_settings(const char *stanza_name, const char *setting_name) {
uint32_t rate_set = 0;
if (config.cfg != NULL) {
char setting_path[256];
snprintf(setting_path, sizeof(setting_path) - 1, "%s.%s", stanza_name, setting_name);
config_setting_t *rate_setting = config_lookup(config.cfg, setting_path);
if (rate_setting != NULL) {
if (config_setting_type(rate_setting) == CONFIG_TYPE_STRING) {
// see if it is "auto"
if (strcmp(config_setting_get_string(rate_setting), "auto") == 0) {
#ifdef CONFIG_FFMPEG
rate_set = SPS_RATE_SET; // all valid rates
#else
rate_set = SPS_RATE_NON_FFMPEG_SET;
#endif
} else {
warn("In the \"%s\" setting in the \"%s\" section of the configuration file, an invalid "
"character string -- \"%s\" -- has been detected. (Note that numbers must not be "
"enclosed in quotes.)",
setting_name, stanza_name, config_setting_get_string(rate_setting));
}
} else {
int *rates;
int rate_settings_count = config_get_int_settings_as_int_array(rate_setting, &rates);
if (rate_settings_count > 0) {
debug(3, "%d rate settings found.", rate_settings_count);
int i;
for (i = 0; i < rate_settings_count; i++) {
debug(3, "rate setting %d: %d.", i, rates[i]);
sps_rate_t r;
int valid = 0;
for (r = SPS_RATE_5512; r <= SPS_RATE_384000; r++) {
if ((unsigned int)rates[i] == sps_rate_actual_rate(r)) {
valid = 1;
#ifdef CONFIG_FFMPEG
rate_set |= (1 << r);
#else
if (((1 << r) & SPS_RATE_NON_FFMPEG_SET) != 0) {
rate_set |= (1 << r);
} else {
warn("In the \"%s\" setting in the \"%s\" section of the configuration file, "
"the rate selected -- %d -- can not be used because Shairport Sync has been "
"built without FFmpeg support.",
setting_name, stanza_name, rates[i]);
}
#endif
}
}
if (valid == 0) {
warn("In the \"%s\" setting in the \"%s\" section of the configuration file, an "
"invalid rate: %d has been detected.",
setting_name, stanza_name, rates[i]);
}
}
free(rates);
} else {
warn("in the \"%s\" setting in the \"%s\" section of the configuration file, an error "
"has been detected at argument %d. (Note that numbers must not be enclosed in "
"quotes.)",
setting_name, stanza_name, -rate_settings_count);
}
}
}
}
sps_rate_t r;
char buf[256];
char *p = buf;
uint32_t t_rate_set = rate_set;
char numbuf[32];
for (r = SPS_RATE_UNKNOWN; r <= SPS_RATE_384000; r++) {
if ((t_rate_set & (1 << r)) != 0) {
snprintf(numbuf, sizeof(numbuf) - 1, "%u", sps_rate_actual_rate(r));
snprintf(p, sizeof(buf) - (p - buf) - 1, "%s", numbuf);
p = p + strlen(numbuf);
t_rate_set -= (1 << r);
if (t_rate_set != 0) {
snprintf(p, sizeof(buf) - (p - buf) - 1, ", ");
p = p + strlen(", ");
}
}
}
if (p != buf) {
*p = '.';
p++;
}
*p = '\0';
if (strlen(buf) == 0)
debug(3, "No \"%s\" output rate settings.", stanza_name);
else
debug(3, "The \"%s\" output rate settings are: \"%s\".", stanza_name, buf);
return rate_set;
}
uint32_t get_channel_settings(const char *stanza_name, const char *setting_name) {
uint32_t channel_set = 0;
if (config.cfg != NULL) {
char setting_path[256];
snprintf(setting_path, sizeof(setting_path) - 1, "%s.%s", stanza_name, setting_name);
// now get the channels count set
config_setting_t *channels_setting = config_lookup(config.cfg, setting_path);
if (channels_setting != NULL) {
if (config_setting_type(channels_setting) == CONFIG_TYPE_STRING) {
// see if it is "auto"
if (strcmp(config_setting_get_string(channels_setting), "auto") == 0) {
#ifdef CONFIG_FFMPEG
channel_set = SPS_CHANNEL_SET; // all valid channels
#else
channel_set = SPS_CHANNNEL_NON_FFMPEG_SET; // just two channels
#endif
} else {
warn("in the \"%s\" setting in the \"%s\" section of the configuration file, an invalid "
"setting: \"%s\" has been detected.",
setting_name, stanza_name, config_setting_get_string(channels_setting));
}
} else {
int *channel_counts;
int channel_counts_count =
config_get_int_settings_as_int_array(channels_setting, &channel_counts);
if (channel_counts_count > 0) {
debug(3, "%d channel count settings found.", channel_counts_count);
int i;
for (i = 0; i < channel_counts_count; i++) {
debug(3, "channel count setting %d: %d.", i, channel_counts[i]);
if ((channel_counts[i] >= 1) && (channel_counts[i] <= 8)) {
#ifdef CONFIG_FFMPEG
channel_set |= (1 << channel_counts[i]);
#else
if (((1 << channel_counts[i]) & SPS_CHANNNEL_NON_FFMPEG_SET) != 0) {
channel_set |= (1 << channel_counts[i]);
} else {
warn("in the \"%s\" setting in the \"%s\" section of the configuration file, "
"the channel count selected -- %d -- can not be used because Shairport Sync "
"has been built without FFmpeg support.",
setting_name, stanza_name, channel_counts[i]);
}
#endif
} else {
warn("in the \"%s\" setting in the \"%s\" section of the configuration file, an "
"invalid channel count: %d has been detected.",
setting_name, stanza_name, channel_counts[i]);
}
}
free(channel_counts);
} else {
debug(1,
"in the \"%s\" setting in the \"%s\" section of the configuration file, an error "
"has been detected at argument %d.",
setting_name, stanza_name, -channel_counts_count);
}
}
}
}
char buf[256];
char *p = buf;
char numbuf[32];
unsigned int c;
uint32_t t_channel_set = channel_set;
for (c = 0; c <= 8; c++) {
if ((t_channel_set & (1 << c)) != 0) {
snprintf(numbuf, sizeof(numbuf) - 1, "%u", c);
snprintf(p, sizeof(buf) - (p - buf) - 1, "%s", numbuf);
p = p + strlen(numbuf);
t_channel_set -= (1 << c);
if (t_channel_set != 0) {
snprintf(p, sizeof(buf) - (p - buf) - 1, ", ");
p = p + strlen(", ");
}
}
}
if (p != buf) {
*p = '.';
p++;
}
*p = '\0';
if (strlen(buf) == 0)
debug(3, "No \"%s\" output channel settings.", stanza_name);
else
debug(3, "The \"%s\" output channel settings are: \"%s\".", stanza_name, buf);
return channel_set;
}
sps_format_t check_configuration_with_formats(
unsigned int channels, unsigned int rate, sps_format_t format,
int (*check_configuration)(unsigned int channels, unsigned int rate, unsigned int format)) {
sps_format_t response = SPS_FORMAT_UNKNOWN; // this is encoded as zero
// first, check that the channels are permissible...
if ((config.channel_set & (1 << channels)) != 0) {
// now check the rate...
sps_rate_t r = SPS_RATE_LOWEST;
int rate_is_permissible = 0;
while ((rate_is_permissible == 0) && (r <= SPS_RATE_HIGHEST)) {
if (((config.rate_set & (1 << r)) != 0) && (rate == sps_rate_actual_rate(r)))
rate_is_permissible = 1;
else
r++;
}
if (rate_is_permissible != 0) {
// check the actual requested format first with the initial_search array
// and if it fails, then check in the subsequent_search array.
// the choice of subsequent search array is determined by the machine's endianness
// clang-format off
sps_format_t ordered_initial_search_U8[] = {SPS_FORMAT_U8, SPS_FORMAT_S8};
sps_format_t ordered_initial_search_S8[] = {SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_subsequent_search_8_LE[] = {SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S24_LE, SPS_FORMAT_S24_BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE};
sps_format_t ordered_subsequent_search_8_BE[] = {SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S24_BE, SPS_FORMAT_S24_LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE};
sps_format_t ordered_initial_search_S16_LE[] = {SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE};
sps_format_t ordered_initial_search_S16_BE[] = {SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE};
sps_format_t ordered_subsequent_search_S16_LE[] = {SPS_FORMAT_S24_LE, SPS_FORMAT_S24_BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_subsequent_search_S16_BE[] = {SPS_FORMAT_S24_BE, SPS_FORMAT_S24_LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_initial_search_S24_LE[] = {SPS_FORMAT_S24_LE, SPS_FORMAT_S24_BE};
sps_format_t ordered_initial_search_S24_BE[] = {SPS_FORMAT_S24_BE, SPS_FORMAT_S24_LE};
sps_format_t ordered_subsequent_search_S24_LE[] = {SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_subsequent_search_S24_BE[] = {SPS_FORMAT_S24_3BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_initial_search_S24_3le[] = {SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE};
sps_format_t ordered_initial_search_S24_3be[] = {SPS_FORMAT_S24_3BE, SPS_FORMAT_S24_3LE};
sps_format_t ordered_subsequent_search_S24_3le[] = {SPS_FORMAT_S24_LE, SPS_FORMAT_S24_BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_subsequent_search_S24_3be[] = {SPS_FORMAT_S24_BE, SPS_FORMAT_S24_LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_initial_search_S32_LE[] = {SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE};
sps_format_t ordered_initial_search_S32_BE[] = {SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE};
sps_format_t ordered_subsequent_search_S32_LE[] = {SPS_FORMAT_S24_LE, SPS_FORMAT_S24_BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S8, SPS_FORMAT_U8};
sps_format_t ordered_subsequent_search_S32_BE[] = {SPS_FORMAT_S24_BE, SPS_FORMAT_S24_LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE, SPS_FORMAT_S8, SPS_FORMAT_U8};
// clang-format on
// set up the initial_search pointer
sps_format_t *initial_formats_to_check = NULL;
unsigned int number_of_initial_formats_to_check = 0;
// set up the subsequent_search pointer
sps_format_t *subsequent_formats_to_check = NULL;
unsigned int number_of_subsequent_formats_to_check = 0;
// Set up the initial and subsequent search pointers.
// Searching is done with an initial search and, if necessary, a subsequent search.
// Searching stops when a suitable format is confirmed as being acceptable.
// The initial search checks the requested format first, followed by its equivalents of the
// same bit size. The subsequent search puts the formats to check in order of suitability but
// with the native-endian format first. SPS_FORMAT_S16, SPS_FORMAT_S24 and SPS_FORMAT_S24 are
// treated the same as their equivalent with native endianness. AUTO is treated as
// SPS_FORMAT_S24 with native endianness.
switch (format) {
case SPS_FORMAT_U8:
case SPS_FORMAT_S8:
if (config.endianness == SS_LITTLE_ENDIAN) {
subsequent_formats_to_check = ordered_subsequent_search_8_LE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_8_LE) / sizeof(sps_format_t);
} else {
subsequent_formats_to_check = ordered_subsequent_search_8_BE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_8_BE) / sizeof(sps_format_t);
}
if (format == SPS_FORMAT_S8) {
initial_formats_to_check = ordered_initial_search_S8;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S8) / sizeof(sps_format_t);
} else {
initial_formats_to_check = ordered_initial_search_U8;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_U8) / sizeof(sps_format_t);
}
break;
case SPS_FORMAT_S16:
case SPS_FORMAT_S16_LE:
case SPS_FORMAT_S16_BE:
if (config.endianness == SS_LITTLE_ENDIAN) {
subsequent_formats_to_check = ordered_subsequent_search_S16_LE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S16_LE) / sizeof(sps_format_t);
if (format == SPS_FORMAT_S16) {
initial_formats_to_check = ordered_initial_search_S16_LE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S16_LE) / sizeof(sps_format_t);
}
} else {
subsequent_formats_to_check = ordered_subsequent_search_S16_BE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S16_BE) / sizeof(sps_format_t);
if (format == SPS_FORMAT_S16) {
initial_formats_to_check = ordered_initial_search_S16_BE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S16_BE) / sizeof(sps_format_t);
}
}
if (format == SPS_FORMAT_S16_LE) {
initial_formats_to_check = ordered_initial_search_S16_LE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S16_LE) / sizeof(sps_format_t);
} else if (format == SPS_FORMAT_S16_BE) {
initial_formats_to_check = ordered_initial_search_S16_BE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S16_BE) / sizeof(sps_format_t);
}
break;
case SPS_FORMAT_S24:
case SPS_FORMAT_S24_LE:
case SPS_FORMAT_S24_BE:
if (config.endianness == SS_LITTLE_ENDIAN) {
subsequent_formats_to_check = ordered_subsequent_search_S24_LE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S24_LE) / sizeof(sps_format_t);
if (format == SPS_FORMAT_S24) {
initial_formats_to_check = ordered_initial_search_S24_LE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S24_LE) / sizeof(sps_format_t);
}
} else {
subsequent_formats_to_check = ordered_subsequent_search_S24_BE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S24_BE) / sizeof(sps_format_t);
if (format == SPS_FORMAT_S24) {
initial_formats_to_check = ordered_initial_search_S24_BE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S24_BE) / sizeof(sps_format_t);
}
}
if (format == SPS_FORMAT_S24_LE) {
initial_formats_to_check = ordered_initial_search_S24_LE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S24_LE) / sizeof(sps_format_t);
} else if (format == SPS_FORMAT_S24_BE) {
initial_formats_to_check = ordered_initial_search_S24_BE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S24_BE) / sizeof(sps_format_t);
}
break;
case SPS_FORMAT_S32:
case SPS_FORMAT_S32_LE:
case SPS_FORMAT_S32_BE:
// case SPS_FORMAT_AUTO:
if (config.endianness == SS_LITTLE_ENDIAN) {
subsequent_formats_to_check = ordered_subsequent_search_S32_LE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S32_LE) / sizeof(sps_format_t);
if ((format == SPS_FORMAT_S32) || (format == SPS_FORMAT_AUTO)) {
initial_formats_to_check = ordered_initial_search_S32_LE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S32_LE) / sizeof(sps_format_t);
}
} else {
subsequent_formats_to_check = ordered_subsequent_search_S32_BE;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S32_BE) / sizeof(sps_format_t);
if ((format == SPS_FORMAT_S32) || (format == SPS_FORMAT_AUTO)) {
initial_formats_to_check = ordered_initial_search_S32_BE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S32_BE) / sizeof(sps_format_t);
}
}
if (format == SPS_FORMAT_S32_LE) {
initial_formats_to_check = ordered_initial_search_S32_LE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S32_LE) / sizeof(sps_format_t);
} else if (format == SPS_FORMAT_S32_BE) {
initial_formats_to_check = ordered_initial_search_S32_BE;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S32_BE) / sizeof(sps_format_t);
}
break;
case SPS_FORMAT_S24_3LE:
case SPS_FORMAT_S24_3BE:
if (config.endianness == SS_LITTLE_ENDIAN) {
subsequent_formats_to_check = ordered_subsequent_search_S24_3le;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S24_3le) / sizeof(sps_format_t);
} else {
subsequent_formats_to_check = ordered_subsequent_search_S24_3be;
number_of_subsequent_formats_to_check =
sizeof(ordered_subsequent_search_S24_3be) / sizeof(sps_format_t);
}
if (format == SPS_FORMAT_S24_3LE) {
initial_formats_to_check = ordered_initial_search_S24_3le;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S24_3le) / sizeof(sps_format_t);
} else {
initial_formats_to_check = ordered_initial_search_S24_3be;
number_of_initial_formats_to_check =
sizeof(ordered_initial_search_S24_3be) / sizeof(sps_format_t);
}
break;
default:
debug(1, "unknown format %u to check.", format);
break;
}
if ((initial_formats_to_check == NULL) || (subsequent_formats_to_check == NULL)) {
debug(1, "error initialising for format %s.", sps_format_description_string(format));
}
// here, we know the channel and rate are permissible according to the settings,
// but we don't yet know about each of the formats
// do initial search
unsigned int i = 0;
while ((i < number_of_initial_formats_to_check) && (response == SPS_FORMAT_UNKNOWN)) {
// only call check_configuration() if the format is permissible
if ((((1 << initial_formats_to_check[i]) & config.format_set) != 0) &&
((check_configuration == NULL) ||
(check_configuration(channels, rate, initial_formats_to_check[i]) == 0)))
response = initial_formats_to_check[i];
else
i++;
}
// if no joy, do subsequent search
if (response == 0) {
i = 0;
while ((i < number_of_subsequent_formats_to_check) && (response == SPS_FORMAT_UNKNOWN)) {
// only call check_configuration() if the format is permissible
if ((((1 << subsequent_formats_to_check[i]) & config.format_set) != 0) &&
((check_configuration == NULL) ||
(check_configuration(channels, rate, subsequent_formats_to_check[i]) == 0)))
response = subsequent_formats_to_check[i];
else
i++;
}
}
}
}
return response;
}
/*
sps_format_t all_formats_to_check_le[] = {SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S24_LE,
SPS_FORMAT_S24_BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE,
SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE};
// look at little-endian formats first
sps_format_t all_formats_to_check_le[] = {SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE, SPS_FORMAT_S24_LE,
SPS_FORMAT_S24_BE, SPS_FORMAT_S24_3LE, SPS_FORMAT_S24_3BE,
SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE};
// look at big-endian formats first
sps_format_t all_formats_to_check_be[] = {SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE, SPS_FORMAT_S24_BE,
SPS_FORMAT_S24_LE, SPS_FORMAT_S24_3BE, SPS_FORMAT_S24_3LE,
SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE};
// look at little-endian formats first
sps_format_t s32_formats_to_check_le[] = {SPS_FORMAT_S32_LE, SPS_FORMAT_S32_BE};
// look at big-endian formats first
sps_format_t s32_formats_to_check_be[] = {SPS_FORMAT_S32_BE, SPS_FORMAT_S32_LE};
// look at little-endian formats first
sps_format_t s24_formats_to_check_le[] = {
SPS_FORMAT_S24_LE,
SPS_FORMAT_S24_BE,
SPS_FORMAT_S24_3LE,
SPS_FORMAT_S24_3BE,
};
// look at big-endian formats first
sps_format_t s24_formats_to_check_be[] = {
SPS_FORMAT_S24_BE,
SPS_FORMAT_S24_LE,
SPS_FORMAT_S24_3BE,
SPS_FORMAT_S24_3LE,
};
// look at little-endian formats first
sps_format_t s16_formats_to_check_le[] = {SPS_FORMAT_S16_LE, SPS_FORMAT_S16_BE};
// look at big-endian formats first
sps_format_t s16_formats_to_check_be[] = {SPS_FORMAT_S16_BE, SPS_FORMAT_S16_LE};
sps_format_t single_format_to_check[1];
sps_format_t check_configuration_with_formats(
unsigned int channels, unsigned int rate, sps_format_t format,
int (*check_configuration)(unsigned int channels, unsigned int rate, unsigned int format)) {
sps_format_t response = SPS_FORMAT_UNKNOWN; // this is encoded as zero
// assume there is one single format to check
unsigned int number_of_formats_to_check = 1;
sps_format_t single_format_to_check[] = {format};
sps_format_t *formats_to_check = single_format_to_check;
// now, check to see if there are multiple formats to check, e.g. if the format is given as AUTO
// or if it doesn't specify _LE or _BE. Try to favour the host endianness:
if (config.endianness == SS_LITTLE_ENDIAN) {
switch (format) {
case SPS_FORMAT_AUTO:
case SPS_FORMAT_S32:
case SPS_FORMAT_32_LE:
case SPS_FORMAT_32_BE:
formats_to_check = all_formats_to_check_le;
number_of_formats_to_check = sizeof(all_formats_to_check_le) / sizeof(sps_format_t);
break;
case SPS_FORMAT_S24:
case SPS_FORMAT_S24_LE:
case SPS_FORMAT_S24_BE:
formats_to_check = s32_formats_to_check_le;
number_of_formats_to_check = sizeof(s32_formats_to_check_le) / sizeof(sps_format_t);
break;
case SPS_FORMAT_S24:
formats_to_check = s24_formats_to_check_le;
number_of_formats_to_check = sizeof(s24_formats_to_check_le) / sizeof(sps_format_t);
break;
case SPS_FORMAT_S16:
formats_to_check = s16_formats_to_check_le;
number_of_formats_to_check = sizeof(s16_formats_to_check_le) / sizeof(sps_format_t);
break;
default:
break;
};
} else { // big-endian
switch (format) {
case SPS_FORMAT_AUTO:
formats_to_check = all_formats_to_check_be;
number_of_formats_to_check = sizeof(all_formats_to_check_be) / sizeof(sps_format_t);
break;
case SPS_FORMAT_S32:
formats_to_check = s32_formats_to_check_be;
number_of_formats_to_check = sizeof(s32_formats_to_check_be) / sizeof(sps_format_t);
break;
case SPS_FORMAT_S24:
formats_to_check = s24_formats_to_check_be;
number_of_formats_to_check = sizeof(s24_formats_to_check_be) / sizeof(sps_format_t);
break;
case SPS_FORMAT_S16:
formats_to_check = s16_formats_to_check_be;
number_of_formats_to_check = sizeof(s16_formats_to_check_be) / sizeof(sps_format_t);
break;
default:
break;
};
}
unsigned int i = 0;
while ((i < number_of_formats_to_check) && (response == SPS_FORMAT_UNKNOWN)) {
if (check_configuration(channels, rate, formats_to_check[i]) == 0)
response = formats_to_check[i];
else
i++;
}
return response;
}
*/
// This looks for a suitable configuration in the right order and checks possible
// configurations using the check_configuration method passed in.
// If it's the same as the most recent request, it sends back the cached reply.
// The cache is keyed to the address of the checker method in order to distinguish
// between requests from different backends. It's moot, as only one back end can be
// active, but anyway... ya never just know.
// but it does mean that it only remembers the last response, whichever backend it was for
typedef struct {
int32_t encoded_request; // this will have the channels and the rate requested but not the format
int32_t encoded_response; // this will have the channels, rate and format suggested
int (*check_configuration)(unsigned int channels, unsigned int rate, unsigned int format);
} configuration_request_and_response_t;
static configuration_request_and_response_t search_for_suitable_configuration_last_response = {
0, 0, NULL};
// First it looks for an exact match of channels, rate or with a rate that is an even multiple.
// If that fails it will look for an exact match of channels with the next highest rate
// If that fails it will look for an exact match of channels with the next lowest rate
// If that fails it increases the number channels, if available, and checks all over again
// Finally, if that fails it reduces the number channels, if possible, and checks all over again.
// Regarding the requested format: ask for the exact format only if no audio processing will be
// done in the software or (as far as can be known) in the hardware mixer.
// So, if ignore_volume_control is set and volume_max_db is
// not set, and the number of output channels is greater than or equal to those requested,
// and mixing to mono is not requested and the rate being checked is the rate requested,
// then look for the exact rate format.
// Otherwise ask for the deepest format, which could be useful
// for attenuation, mixing, transcoding or other audio processing.
// (Haven't included checking for convolution here.)
int32_t search_for_suitable_configuration(unsigned int channels, unsigned int rate,
unsigned int format,
int (*check_configuration)(unsigned int in_channels,
unsigned int in_rate,
unsigned int in_format)) {
int32_t reply = 0; // means nothing was found
if ((channels == 0) || (rate == 0))
debug(1, "invalid channel %u or rate %u parameters to search_for_suitable_configuration",
channels, rate);
int32_t encoded_request = CHANNELS_TO_ENCODED_FORMAT(channels) | RATE_TO_ENCODED_FORMAT(rate) |
FORMAT_TO_ENCODED_FORMAT(format);
if ((search_for_suitable_configuration_last_response.check_configuration ==
check_configuration) && // same method (implies same backend)
(search_for_suitable_configuration_last_response.encoded_request ==
encoded_request)) { // same request
reply = search_for_suitable_configuration_last_response
.encoded_response; // provide cached response...
}
if (reply == 0) { // no luck with the last response generated, if any...
// check for native number of channels or more... and then, if not successful, with fewer
// channels
#ifdef CONFIG_FFMPEG
unsigned int channel_count_check_sequence[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1};
unsigned int rates[] = {44100, 48000, 88200, 96000, 176400, 192000, 352800, 384000,
64000, 32000, 22050, 16000, 11025, 8000, 5512};
#else
unsigned int channel_count_check_sequence[] = {0, 1, 2};
// unsigned int rates[] = {44100};
#endif
unsigned int channel_count_index = channels;
// start looking with the required number of channels
unsigned int local_channels;
unsigned int local_rate;
sps_format_t local_format = SPS_FORMAT_UNKNOWN;
uint32_t channel_check_bit_field = 0; // set (1 << channel_count) when check done.
// Use it to stop checking the same channel count on the way down as well as on the way up...
while ((local_format == SPS_FORMAT_UNKNOWN) &&
(channel_count_index < (sizeof(channel_count_check_sequence) / sizeof(unsigned int)))) {
local_channels = channel_count_check_sequence[channel_count_index];
// if we haven't already checked....
if ((channel_check_bit_field & (1 << local_channels)) == 0) {
channel_check_bit_field |= (1 << local_channels); // flag that we have checked it
int rate_multiplier = 2;
local_rate = rate; // begin with the requested rate
debug(3, "check for an exact multiple of %u with %u channels.", rate, local_channels);
while ((local_rate <= 384000) && (local_format == SPS_FORMAT_UNKNOWN)) {
if (
// clang-format off
// check for the exact format only under these conditions, otherwise look for the best
(config.ignore_volume_control != 0) &&
(config.volume_max_db_set == 0) &&
(local_rate == rate) &&
(local_channels >= channels) &&
(config.playback_mode != ST_mono)
// clang-format on
) {
// debug(1, "check exact");
local_format = check_configuration_with_formats(
local_channels, local_rate, (sps_format_t)format, check_configuration);
} else {
// debug(1, "check best");
local_format = check_configuration_with_formats(local_channels, local_rate,
SPS_FORMAT_S32, check_configuration);
}
if (local_format == SPS_FORMAT_UNKNOWN) {
local_rate = rate * rate_multiplier;
rate_multiplier = rate_multiplier * 2;
}
}
#ifdef CONFIG_FFMPEG
if (local_format == SPS_FORMAT_UNKNOWN) {
debug(3, "check for an next highest rate above %u with %u channels.", rate,
local_channels);
unsigned int rate_pointer = 0;
while ((rate_pointer < sizeof(rates) / sizeof(unsigned int)) &&
(local_format == SPS_FORMAT_UNKNOWN)) {
local_rate = rates[rate_pointer];
if (local_rate > rate) {
local_format = check_configuration_with_formats(
local_channels, local_rate, (sps_format_t)format, check_configuration);
}
if (local_format == SPS_FORMAT_UNKNOWN) {
rate_pointer++;
}
}
}
if (local_format == SPS_FORMAT_UNKNOWN) {
int rate_pointer = (int)(sizeof(rates) / sizeof(unsigned int) - 1);
debug(3, "check for an next lowest rate below %u with %u channels.", rate,
local_channels);
while ((rate_pointer >= 0) && (local_format == SPS_FORMAT_UNKNOWN)) {
local_rate = rates[rate_pointer];
if (local_rate < rate) {
local_format = check_configuration_with_formats(
local_channels, local_rate, (sps_format_t)format, check_configuration);
}
if (local_format == SPS_FORMAT_UNKNOWN) {
rate_pointer--;
}
}
}
#endif
}
// if unsuccessful, try with, firstly, more channels, and then, later, with fewer channels
if (local_format == SPS_FORMAT_UNKNOWN)
channel_count_index++;
}
if (local_format != SPS_FORMAT_UNKNOWN) {
reply = CHANNELS_TO_ENCODED_FORMAT(local_channels) | RATE_TO_ENCODED_FORMAT(local_rate) |
FORMAT_TO_ENCODED_FORMAT(local_format);
// cache the response
search_for_suitable_configuration_last_response.check_configuration = check_configuration;
search_for_suitable_configuration_last_response.encoded_request = encoded_request;
search_for_suitable_configuration_last_response.encoded_response = reply;
debug(3,
"output configuration search for request: %s/%u/%u, succeeded with response: %u/%s/%u.",
sps_format_description_string(format), rate, channels,
RATE_FROM_ENCODED_FORMAT(reply), // rate
sps_format_description_string(FORMAT_FROM_ENCODED_FORMAT(reply)), // format
CHANNELS_FROM_ENCODED_FORMAT(reply) // channels
);
} else {
debug(1, "output configuration search for request: %s/%u/%u failed.",
sps_format_description_string(format), rate, channels);
}
}
return reply;
}
Reference in New Issue View Git Blame Copy Permalink