Meanwhile thousands users are using my SBC XQ patch and nobody reported any problem : for a good reason: it's simple enough to be reliable.
I hope you will manage to merge Pali's patch set before 2030.
I have to remind you about reality: Bluetooth and DLNA are the way 90% of the people are listening to music in 2020. Everything else can be delayed.
Oups : sorry, there's no DLNA support at all in Pulseaudio. .. so it's maybe time to start implememting it before PA version 0.1 ? Oups we passed version 0.1 without wireless audio support .... worth a Black Mirror episode ?
Jp
13:57, 9 décembre 2019, Hyperion <h1p8r10n@xxxxxxxxxx>:
09.12.2019, 12:33, "Andrey Semashev" <andrey.semashev@xxxxxxxxx>:I have another piece of feedback to provide. Sometimes I experience
audio dropouts. Sometimes in both left and right headphones, sometimes
just one. In particular, I noticed this happen when I have a
Bluetooth-connected DualShock 4 gamepad connected and playing games, but
it also happens without it, although less often.
I assume this is caused by Bluetooth bandwidth limitation. Note that EOZ
Air are "truly wireless" (i.e. the two headphones connect wirelessly),
and I have multiple WiFi networks available (one access point in the
same room as the Bluetooth transmitter, a few others behind walls). I
expect 2.4 GHz radio to be rather crowded. The gamepad and the
headphones are in the same room as the Bluetooth transmitter, in clear
direct visibility, so it can't get better than that.
I can see Pali's patches offer reduce_encoder_bitrate API that is
supposed to mitigate this problem, but both SBC XQ profiles don't allow
bitrate reduction. I think, SBC XQ desperately needs to support bitrate
reduction, as the codec with the highest bitrate out of all.
Yes, and my patch was providing 100% adaptative SBC XQ, with native bitpool
reduction, as you suggest. But something more complex and yet more "static"' has
been preferred.
Users mightactually have reduced experience due to audio dropouts compared to the
previously supported SBC HQ.
On 2019-12-07 21:09, Andrey Semashev wrote:FWIW, I tested the patch[1] from your github repository with PulseAudio
13.0 on Ubuntu 19.10 with my EOZ Air. It works, and the sound quality is
subjectively better compared to the stock PA 13.0. The noise level that
can be heard on silent audio sections seems to be lower.
However, I can still hear compression artefacts on quiet or nearly
silent audio sections, which sound like high-pitch squeaking sounds. It
can often be heard on various music fade out sections. I don't know if
this is inherrent from SBC codec itself or is a deficiency of libsbc
implementation, or the headphones. These artefacts are my main complaint
about SBC.
My EOZ Air also supports AAC, and the audio quality is better still with
it (I tested with pulseaudio-modules-bt[2] and my Android phone). There
are no squeaky artefacts with AAC.
Which brings me to my question to PA developers. Would an addition of
support for AAC be possible?
pulseaudio-modules-bt uses libfdk-aac to implement AAC, and if possible,
I would prefer that library as it provides the best quality available on
Linux. However, if licensing is an issue, there is also a built-in
implementation in ffmpeg.
[1]: Patch obtained with `git diff
200618b32f0964a479d69c9b6e5073e6931c370a..0853d7465729c1fb6c25745c05dc749a1b9a8d6f`
[2]: https://github.com/EHfive/pulseaudio-modules-bt
On 2019-09-20 12:45, Hyperion wrote:HI,
I have reworked my mod so that it can safely achieve bitpool 94 in
both dual channel and joint stereo, as long as the device supports it
(only my high end Harman Kardon support 94 in joint stereo).
Devices supporting only bitpool 53 are kept safe (bitpool is always
negociated, never forced : this doesn't use fixed caps).
Anyway most devices support at least bitpool 47 in dual channel mode,
and BT (version 3 and up) bandwidth is much higher : so this patch
deprecates both APTX and LDAC.
The Git is up to date : https://github.com/JPGuillemin/pulseaudio
This patch is likely safe to be applied on the official master cause
it doesn't need Bluez multi-codec API, and doesn't introduce any
patent issue (mainly from CSR, openaptx being underground reverse
ingeniering).
All the best
JP
19.09.2019, 13:07, "Hyperion" <h1p8r10n@xxxxxxxxxx>:The Git branch with my mods :_______________________________________________
https://github.com/JPGuillemin/pulseaudio/tree/SBC-XQ
I'm sure it needs improvement, but I need testers ;) for now it works
as expected on all my devices...
JP
19.09.2019, 11:21, "Hyperion" <h1p8r10n@xxxxxxxxxx>:Yes, thanks, you're right, I'm going to do it as soon as I get
enough testing feedback.
Talking about tests : I'm going to switch back to Pali's default
values for announced bitpool capabilities, cause some (rare) devices
produces a few distorsion with dual channel 47 bitpool.
So back to dual 38 / 76 , which should be ok on any device.
New patch :
http://download.zenwalk.org/x86_64/testing/pulseaudio-13.0-SBC-XQ_V3.patch
Thanks for testing :)
jp
19.09.2019, 10:27, "Andrey Semashev" <andrey.semashev@xxxxxxxxx>:I'm not the maintainer, but it might be better to create a merge
request
in GitLab project:
https://gitlab.freedesktop.org/pulseaudio/pulseaudio
and post any additional information there so it doesn't get lost.
On 2019-09-18 14:02, Hyperion wrote:Patch V2 with added DUAL_CHANNEL as preferred mode.
Works without any issue on more than 10 stereo and mono
devices that I have here.
http://download.zenwalk.org/x86_64/testing/pulseaudio-13.0-SBC-XQ_V2.patch
/***
This file is part of PulseAudio.
Copyright 2018-2019 Pali Rohár <pali.rohar@xxxxxxxxx>
PulseAudio is free software; you can redistribute it and/or
modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation; either version
2.1 of the
License, or (at your option) any later version.
PulseAudio is distributed in the hope that it will be
useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
the GNU
General Public License for more details.
You should have received a copy of the GNU Lesser General
Public
License along with PulseAudio; if not, see
<http://www.gnu.org/licenses/>.
***/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <pulsecore/core-util.h>
#include <pulsecore/log.h>
#include <pulsecore/macro.h>
#include <pulsecore/once.h>
#include <pulse/sample.h>
#include <pulse/xmalloc.h>
#include <arpa/inet.h>
#include <sbc/sbc.h>
#include "a2dp-codecs.h"
#include "a2dp-codec-api.h"
#include "rtp.h"
#define SBC_BITPOOL_DEC_LIMIT 32
#define SBC_BITPOOL_DEC_STEP 5
struct sbc_info {
sbc_t sbc; /* Codec data */
size_t codesize, frame_length; /* SBC Codesize,
frame_length. We simply cache those values here */
uint16_t seq_num; /* Cumulative packet sequence */
uint8_t frequency;
uint8_t blocks;
uint8_t subbands;
uint8_t mode;
uint8_t allocation;
uint8_t initial_bitpool;
uint8_t min_bitpool;
uint8_t max_bitpool;
};
static bool can_accept_capabilities(const uint8_t
*capabilities_buffer, uint8_t capabilities_size, bool for_encoding) {
const a2dp_sbc_t *capabilities = (const a2dp_sbc_t *)
capabilities_buffer;
if (capabilities_size != sizeof(*capabilities))
return false;
if (!(capabilities->frequency & (SBC_SAMPLING_FREQ_16000
| SBC_SAMPLING_FREQ_32000 | SBC_SAMPLING_FREQ_44100 |
SBC_SAMPLING_FREQ_48000)))
return false;
if (!(capabilities->channel_mode & (SBC_CHANNEL_MODE_MONO
| SBC_CHANNEL_MODE_DUAL_CHANNEL | SBC_CHANNEL_MODE_STEREO |
SBC_CHANNEL_MODE_JOINT_STEREO)))
return false;
if (!(capabilities->allocation_method &
(SBC_ALLOCATION_SNR | SBC_ALLOCATION_LOUDNESS)))
return false;
if (!(capabilities->subbands & (SBC_SUBBANDS_4 |
SBC_SUBBANDS_8)))
return false;
if (!(capabilities->block_length & (SBC_BLOCK_LENGTH_4 |
SBC_BLOCK_LENGTH_8 | SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16)))
return false;
return true;
}
static const char *choose_remote_endpoint(const pa_hashmap
*capabilities_hashmap, const pa_sample_spec *default_sample_spec,
bool for_encoding) {
const pa_a2dp_codec_capabilities *a2dp_capabilities;
const char *key;
void *state;
/* There is no preference, just choose random valid entry */
PA_HASHMAP_FOREACH_KV(key, a2dp_capabilities,
capabilities_hashmap, state) {
if
(can_accept_capabilities(a2dp_capabilities->buffer,
a2dp_capabilities->size, for_encoding))
return key;
}
return NULL;
}
static uint8_t fill_capabilities(uint8_t
capabilities_buffer[MAX_A2DP_CAPS_SIZE]) {
a2dp_sbc_t *capabilities = (a2dp_sbc_t *)
capabilities_buffer;
pa_zero(*capabilities);
capabilities->channel_mode = SBC_CHANNEL_MODE_MONO |
SBC_CHANNEL_MODE_DUAL_CHANNEL | SBC_CHANNEL_MODE_STEREO |
SBC_CHANNEL_MODE_JOINT_STEREO;
capabilities->frequency = SBC_SAMPLING_FREQ_16000 |
SBC_SAMPLING_FREQ_32000 | SBC_SAMPLING_FREQ_44100 |
SBC_SAMPLING_FREQ_48000;
capabilities->allocation_method = SBC_ALLOCATION_SNR |
SBC_ALLOCATION_LOUDNESS;
capabilities->subbands = SBC_SUBBANDS_4 | SBC_SUBBANDS_8;
capabilities->block_length = SBC_BLOCK_LENGTH_4 |
SBC_BLOCK_LENGTH_8 | SBC_BLOCK_LENGTH_12 | SBC_BLOCK_LENGTH_16;
capabilities->min_bitpool = SBC_MIN_BITPOOL;
capabilities->max_bitpool =
SBC_BITPOOL_HQ_JOINT_STEREO_44100;
return sizeof(*capabilities);
}
static bool is_configuration_valid(const uint8_t
*config_buffer, uint8_t config_size) {
const a2dp_sbc_t *config = (const a2dp_sbc_t *)
config_buffer;
if (config_size != sizeof(*config)) {
pa_log_error("Invalid size of config buffer");
return false;
}
if (config->frequency != SBC_SAMPLING_FREQ_16000 &&
config->frequency != SBC_SAMPLING_FREQ_32000 &&
config->frequency != SBC_SAMPLING_FREQ_44100 &&
config->frequency != SBC_SAMPLING_FREQ_48000) {
pa_log_error("Invalid sampling frequency in
configuration");
return false;
}
if (config->channel_mode != SBC_CHANNEL_MODE_MONO &&
config->channel_mode != SBC_CHANNEL_MODE_DUAL_CHANNEL &&
config->channel_mode != SBC_CHANNEL_MODE_STEREO &&
config->channel_mode != SBC_CHANNEL_MODE_JOINT_STEREO) {
pa_log_error("Invalid channel mode in configuration");
return false;
}
if (config->allocation_method != SBC_ALLOCATION_SNR &&
config->allocation_method != SBC_ALLOCATION_LOUDNESS) {
pa_log_error("Invalid allocation method in
configuration");
return false;
}
if (config->subbands != SBC_SUBBANDS_4 &&
config->subbands != SBC_SUBBANDS_8) {
pa_log_error("Invalid SBC subbands in configuration");
return false;
}
if (config->block_length != SBC_BLOCK_LENGTH_4 &&
config->block_length != SBC_BLOCK_LENGTH_8 &&
config->block_length != SBC_BLOCK_LENGTH_12 &&
config->block_length != SBC_BLOCK_LENGTH_16) {
pa_log_error("Invalid block length in configuration");
return false;
}
if (config->min_bitpool > config->max_bitpool) {
pa_log_error("Invalid bitpool in configuration");
return false;
}
return true;
}
static uint8_t default_bitpool(uint8_t freq, uint8_t mode) {
/* These bitpool values were chosen based on the A2DP
spec recommendation */
switch (freq) {
case SBC_SAMPLING_FREQ_48000:
switch (mode) {
case SBC_CHANNEL_MODE_MONO:
case SBC_CHANNEL_MODE_DUAL_CHANNEL:
return SBC_BITPOOL_HQ_MONO_48000;
case SBC_CHANNEL_MODE_STEREO:
case SBC_CHANNEL_MODE_JOINT_STEREO:
return SBC_BITPOOL_HQ_JOINT_STEREO_48000;
}
break;
case SBC_SAMPLING_FREQ_44100:
switch (mode) {
case SBC_CHANNEL_MODE_MONO:
case SBC_CHANNEL_MODE_DUAL_CHANNEL:
return SBC_BITPOOL_HQ_MONO_44100;
case SBC_CHANNEL_MODE_STEREO:
case SBC_CHANNEL_MODE_JOINT_STEREO:
return SBC_BITPOOL_HQ_JOINT_STEREO_44100;
}
break;
case SBC_SAMPLING_FREQ_16000:
case SBC_SAMPLING_FREQ_32000:
switch (mode) {
case SBC_CHANNEL_MODE_MONO:
case SBC_CHANNEL_MODE_DUAL_CHANNEL:
case SBC_CHANNEL_MODE_STEREO:
case SBC_CHANNEL_MODE_JOINT_STEREO:
return SBC_BITPOOL_HQ_JOINT_STEREO_44100;
}
break;
}
pa_assert_not_reached();
}
static uint8_t fill_preferred_configuration(const
pa_sample_spec *default_sample_spec, const uint8_t
*capabilities_buffer, uint8_t capabilities_size, uint8_t
config_buffer[MAX_A2DP_CAPS_SIZE]) {
a2dp_sbc_t *config = (a2dp_sbc_t *) config_buffer;
const a2dp_sbc_t *capabilities = (const a2dp_sbc_t *)
capabilities_buffer;
int i;
static const struct {
uint32_t rate;
uint8_t cap;
} freq_table[] = {
{ 16000U, SBC_SAMPLING_FREQ_16000 },
{ 32000U, SBC_SAMPLING_FREQ_32000 },
{ 44100U, SBC_SAMPLING_FREQ_44100 },
{ 48000U, SBC_SAMPLING_FREQ_48000 }
};
if (capabilities_size != sizeof(*capabilities)) {
pa_log_error("Invalid size of capabilities buffer");
return 0;
}
pa_zero(*config);
/* Find the lowest freq that is at least as high as the
requested sampling rate */
for (i = 0; (unsigned) i < PA_ELEMENTSOF(freq_table); i++)
if (freq_table[i].rate >= default_sample_spec->rate
&& (capabilities->frequency & freq_table[i].cap)) {
config->frequency = freq_table[i].cap;
break;
}
if ((unsigned) i == PA_ELEMENTSOF(freq_table)) {
for (--i; i >= 0; i--) {
if (capabilities->frequency & freq_table[i].cap) {
config->frequency = freq_table[i].cap;
break;
}
}
if (i < 0) {
pa_log_error("Not suitable sample rate");
return 0;
}
}
pa_assert((unsigned) i < PA_ELEMENTSOF(freq_table));
if (default_sample_spec->channels <= 1) {
if (capabilities->channel_mode & SBC_CHANNEL_MODE_MONO)
config->channel_mode = SBC_CHANNEL_MODE_MONO;
else if (capabilities->channel_mode &
SBC_CHANNEL_MODE_JOINT_STEREO)
config->channel_mode =
SBC_CHANNEL_MODE_JOINT_STEREO;
else if (capabilities->channel_mode &
SBC_CHANNEL_MODE_STEREO)
config->channel_mode = SBC_CHANNEL_MODE_STEREO;
else if (capabilities->channel_mode &
SBC_CHANNEL_MODE_DUAL_CHANNEL)
config->channel_mode =
SBC_CHANNEL_MODE_DUAL_CHANNEL;
else {
pa_log_error("No supported channel modes");
return 0;
}
} else {
if (capabilities->channel_mode &
SBC_CHANNEL_MODE_DUAL_CHANNEL)
config->channel_mode =
SBC_CHANNEL_MODE_DUAL_CHANNEL;
else if (capabilities->channel_mode &
SBC_CHANNEL_MODE_STEREO)
config->channel_mode = SBC_CHANNEL_MODE_STEREO;
else if (capabilities->channel_mode &
SBC_CHANNEL_MODE_JOINT_STEREO)
config->channel_mode =
SBC_CHANNEL_MODE_JOINT_STEREO;
else if (capabilities->channel_mode &
SBC_CHANNEL_MODE_MONO)
config->channel_mode = SBC_CHANNEL_MODE_MONO;
else {
pa_log_error("No supported channel modes");
return 0;
}
}
if (capabilities->block_length & SBC_BLOCK_LENGTH_16)
config->block_length = SBC_BLOCK_LENGTH_16;
else if (capabilities->block_length & SBC_BLOCK_LENGTH_12)
config->block_length = SBC_BLOCK_LENGTH_12;
else if (capabilities->block_length & SBC_BLOCK_LENGTH_8)
config->block_length = SBC_BLOCK_LENGTH_8;
else if (capabilities->block_length & SBC_BLOCK_LENGTH_4)
config->block_length = SBC_BLOCK_LENGTH_4;
else {
pa_log_error("No supported block lengths");
return 0;
}
if (capabilities->subbands & SBC_SUBBANDS_8)
config->subbands = SBC_SUBBANDS_8;
else if (capabilities->subbands & SBC_SUBBANDS_4)
config->subbands = SBC_SUBBANDS_4;
else {
pa_log_error("No supported subbands");
return 0;
}
if (capabilities->allocation_method &
SBC_ALLOCATION_LOUDNESS)
config->allocation_method = SBC_ALLOCATION_LOUDNESS;
else if (capabilities->allocation_method &
SBC_ALLOCATION_SNR)
config->allocation_method = SBC_ALLOCATION_SNR;
else {
pa_log_error("No supported allocation method");
return 0;
}
config->min_bitpool = (uint8_t) PA_MAX(SBC_MIN_BITPOOL,
capabilities->min_bitpool);
config->max_bitpool = (uint8_t)
PA_MIN(default_bitpool(config->frequency, config->channel_mode),
capabilities->max_bitpool);
if (config->min_bitpool > config->max_bitpool) {
pa_log_error("No supported bitpool");
return 0;
}
return sizeof(*config);
}
static void set_params(struct sbc_info *sbc_info) {
sbc_info->sbc.frequency = sbc_info->frequency;
sbc_info->sbc.blocks = sbc_info->blocks;
sbc_info->sbc.subbands = sbc_info->subbands;
sbc_info->sbc.mode = sbc_info->mode;
sbc_info->sbc.allocation = sbc_info->allocation;
sbc_info->sbc.bitpool = sbc_info->initial_bitpool;
sbc_info->sbc.endian = SBC_LE;
sbc_info->codesize = sbc_get_codesize(&sbc_info->sbc);
sbc_info->frame_length =
sbc_get_frame_length(&sbc_info->sbc);
}
static void *init(bool for_encoding, bool for_backchannel,
const uint8_t *config_buffer, uint8_t config_size, pa_sample_spec
*sample_spec) {
struct sbc_info *sbc_info;
const a2dp_sbc_t *config = (const a2dp_sbc_t *)
config_buffer;
int ret;
pa_assert(config_size == sizeof(*config));
pa_assert(!for_backchannel);
sbc_info = pa_xnew0(struct sbc_info, 1);
ret = sbc_init(&sbc_info->sbc, 0);
if (ret != 0) {
pa_xfree(sbc_info);
pa_log_error("SBC initialization failed: %d", ret);
return NULL;
}
sample_spec->format = PA_SAMPLE_S16LE;
switch (config->frequency) {
case SBC_SAMPLING_FREQ_48000:
sbc_info->frequency = SBC_FREQ_48000;
sample_spec->rate = 48000U;
break;
case SBC_SAMPLING_FREQ_44100:
sbc_info->frequency = SBC_FREQ_44100;
sample_spec->rate = 44100U;
break;
case SBC_SAMPLING_FREQ_32000:
sbc_info->frequency = SBC_FREQ_32000;
sample_spec->rate = 32000U;
break;
case SBC_SAMPLING_FREQ_16000:
sbc_info->frequency = SBC_FREQ_16000;
sample_spec->rate = 16000U;
break;
default:
pa_assert_not_reached();
}
switch (config->channel_mode) {
case SBC_CHANNEL_MODE_DUAL_CHANNEL:
sbc_info->mode = SBC_MODE_DUAL_CHANNEL;
sample_spec->channels = 2;
break;
case SBC_CHANNEL_MODE_STEREO:
sbc_info->mode = SBC_MODE_STEREO;
sample_spec->channels = 2;
break;
case SBC_CHANNEL_MODE_JOINT_STEREO:
sbc_info->mode = SBC_MODE_JOINT_STEREO;
sample_spec->channels = 2;
break;
case SBC_CHANNEL_MODE_MONO:
sbc_info->mode = SBC_MODE_MONO;
sample_spec->channels = 1;
break;
default:
pa_assert_not_reached();
}
switch (config->allocation_method) {
case SBC_ALLOCATION_LOUDNESS:
sbc_info->allocation = SBC_AM_LOUDNESS;
break;
case SBC_ALLOCATION_SNR:
sbc_info->allocation = SBC_AM_SNR;
break;
default:
pa_assert_not_reached();
}
switch (config->subbands) {
case SBC_SUBBANDS_4:
sbc_info->subbands = SBC_SB_4;
break;
case SBC_SUBBANDS_8:
sbc_info->subbands = SBC_SB_8;
break;
default:
pa_assert_not_reached();
}
switch (config->block_length) {
case SBC_BLOCK_LENGTH_4:
sbc_info->blocks = SBC_BLK_4;
break;
case SBC_BLOCK_LENGTH_8:
sbc_info->blocks = SBC_BLK_8;
break;
case SBC_BLOCK_LENGTH_12:
sbc_info->blocks = SBC_BLK_12;
break;
case SBC_BLOCK_LENGTH_16:
sbc_info->blocks = SBC_BLK_16;
break;
default:
pa_assert_not_reached();
}
sbc_info->min_bitpool = config->min_bitpool;
sbc_info->max_bitpool = config->max_bitpool;
/* Set minimum bitpool for source to get the maximum
possible block_size
* in get_block_size() function. This block_size is
length of buffer used
* for decoded audio data and so is inversely
proportional to frame length
* which depends on bitpool value. Bitpool is controlled
by other side from
* range [min_bitpool, max_bitpool]. */
sbc_info->initial_bitpool = for_encoding ?
sbc_info->max_bitpool : sbc_info->min_bitpool;
set_params(sbc_info);
pa_log_info("SBC parameters: allocation=%s, subbands=%u,
blocks=%u, mode=%s bitpool=%u codesize=%u frame_length=%u",
sbc_info->sbc.allocation ? "SNR" :
"Loudness", sbc_info->sbc.subbands ? 8 : 4,
(sbc_info->sbc.blocks+1)*4,
sbc_info->sbc.mode == SBC_MODE_MONO ? "Mono" :
sbc_info->sbc.mode == SBC_MODE_DUAL_CHANNEL ?
"DualChannel" :
sbc_info->sbc.mode == SBC_MODE_STEREO ?
"Stereo" : "JointStereo",
sbc_info->sbc.bitpool,
(unsigned)sbc_info->codesize, (unsigned)sbc_info->frame_length);
return sbc_info;
}
static void deinit(void *codec_info) {
struct sbc_info *sbc_info = (struct sbc_info *) codec_info;
sbc_finish(&sbc_info->sbc);
pa_xfree(sbc_info);
}
static void set_bitpool(struct sbc_info *sbc_info, uint8_t
bitpool) {
if (bitpool > sbc_info->max_bitpool)
bitpool = sbc_info->max_bitpool;
else if (bitpool < sbc_info->min_bitpool)
bitpool = sbc_info->min_bitpool;
sbc_info->sbc.bitpool = bitpool;
sbc_info->codesize = sbc_get_codesize(&sbc_info->sbc);
sbc_info->frame_length =
sbc_get_frame_length(&sbc_info->sbc);
pa_log_debug("Bitpool has changed to %u",
sbc_info->sbc.bitpool);
}
static int reset(void *codec_info) {
struct sbc_info *sbc_info = (struct sbc_info *) codec_info;
int ret;
ret = sbc_reinit(&sbc_info->sbc, 0);
if (ret != 0) {
pa_log_error("SBC reinitialization failed: %d", ret);
return -1;
}
/* sbc_reinit() sets also default parameters, so reset
them back */
set_params(sbc_info);
sbc_info->seq_num = 0;
return 0;
}
static size_t get_block_size(void *codec_info, size_t link_mtu) {
struct sbc_info *sbc_info = (struct sbc_info *) codec_info;
size_t rtp_size = sizeof(struct rtp_header) +
sizeof(struct rtp_sbc_payload);
size_t frame_count = (link_mtu - rtp_size) /
sbc_info->frame_length;
/* frame_count is only 4 bit number */
if (frame_count > 15)
frame_count = 15;
return frame_count * sbc_info->codesize;
}
static size_t reduce_encoder_bitrate(void *codec_info, size_t
write_link_mtu) {
struct sbc_info *sbc_info = (struct sbc_info *) codec_info;
uint8_t bitpool;
/* Check if bitpool is already at its limit */
if (sbc_info->sbc.bitpool <= SBC_BITPOOL_DEC_LIMIT)
return 0;
bitpool = sbc_info->sbc.bitpool - SBC_BITPOOL_DEC_STEP;
if (bitpool < SBC_BITPOOL_DEC_LIMIT)
bitpool = SBC_BITPOOL_DEC_LIMIT;
if (sbc_info->sbc.bitpool == bitpool)
return 0;
set_bitpool(sbc_info, bitpool);
return get_block_size(codec_info, write_link_mtu);
}
static size_t encode_buffer(void *codec_info, uint32_t
timestamp, const uint8_t *input_buffer, size_t input_size, uint8_t
*output_buffer, size_t output_size, size_t *processed) {
struct sbc_info *sbc_info = (struct sbc_info *) codec_info;
struct rtp_header *header;
struct rtp_sbc_payload *payload;
uint8_t *d;
const uint8_t *p;
size_t to_write, to_encode;
uint8_t frame_count;
header = (struct rtp_header*) output_buffer;
payload = (struct rtp_sbc_payload*) (output_buffer +
sizeof(*header));
frame_count = 0;
p = input_buffer;
to_encode = input_size;
d = output_buffer + sizeof(*header) + sizeof(*payload);
to_write = output_size - sizeof(*header) - sizeof(*payload);
/* frame_count is only 4 bit number */
while (PA_LIKELY(to_encode > 0 && to_write > 0 &&
frame_count < 15)) {
ssize_t written;
ssize_t encoded;
encoded = sbc_encode(&sbc_info->sbc,
p, to_encode,
d, to_write,
&written);
if (PA_UNLIKELY(encoded <= 0)) {
pa_log_error("SBC encoding error (%li)", (long)
encoded);
break;
}
if (PA_UNLIKELY(written < 0)) {
pa_log_error("SBC encoding error (%li)", (long)
written);
break;
}
pa_assert_fp((size_t) encoded <= to_encode);
pa_assert_fp((size_t) encoded == sbc_info->codesize);
pa_assert_fp((size_t) written <= to_write);
pa_assert_fp((size_t) written ==
sbc_info->frame_length);
p += encoded;
to_encode -= encoded;
d += written;
to_write -= written;
frame_count++;
}
PA_ONCE_BEGIN {
pa_log_debug("Using SBC codec implementation: %s",
pa_strnull(sbc_get_implementation_info(&sbc_info->sbc)));
} PA_ONCE_END;
if (PA_UNLIKELY(frame_count == 0)) {
*processed = 0;
return 0;
}
/* write it to the fifo */
pa_memzero(output_buffer, sizeof(*header) +
sizeof(*payload));
header->v = 2;
/* A2DP spec: "A payload type in the RTP dynamic range
shall be chosen".
* RFC3551 defines the dynamic range to span from 96 to
127, and 96 appears
* to be the most common choice in A2DP implementations. */
header->pt = 96;
header->sequence_number = htons(sbc_info->seq_num++);
header->timestamp = htonl(timestamp);
header->ssrc = htonl(1);
payload->frame_count = frame_count;
*processed = p - input_buffer;
return d - output_buffer;
}
static size_t decode_buffer(void *codec_info, const uint8_t
*input_buffer, size_t input_size, uint8_t *output_buffer, size_t
output_size, size_t *processed) {
struct sbc_info *sbc_info = (struct sbc_info *) codec_info;
struct rtp_header *header;
struct rtp_sbc_payload *payload;
const uint8_t *p;
uint8_t *d;
size_t to_write, to_decode;
uint8_t frame_count;
header = (struct rtp_header *) input_buffer;
payload = (struct rtp_sbc_payload*) (input_buffer +
sizeof(*header));
frame_count = payload->frame_count;
/* TODO: Add support for decoding fragmented SBC frames */
if (payload->is_fragmented) {
pa_log_error("Unsupported fragmented SBC frame");
*processed = 0;
return 0;
}
p = input_buffer + sizeof(*header) + sizeof(*payload);
to_decode = input_size - sizeof(*header) - sizeof(*payload);
d = output_buffer;
to_write = output_size;
while (PA_LIKELY(to_decode > 0 && to_write > 0 &&
frame_count > 0)) {
size_t written;
ssize_t decoded;
decoded = sbc_decode(&sbc_info->sbc,
p, to_decode,
d, to_write,
&written);
if (PA_UNLIKELY(decoded <= 0)) {
pa_log_error("SBC decoding error (%li)", (long)
decoded);
break;
}
/* Reset frame length, it can be changed due to
bitpool change */
sbc_info->frame_length =
sbc_get_frame_length(&sbc_info->sbc);
pa_assert_fp((size_t) decoded <= to_decode);
pa_assert_fp((size_t) decoded ==
sbc_info->frame_length);
pa_assert_fp((size_t) written <= to_write);
pa_assert_fp((size_t) written == sbc_info->codesize);
p += decoded;
to_decode -= decoded;
d += written;
to_write -= written;
frame_count--;
}
*processed = p - input_buffer;
return d - output_buffer;
}
const pa_a2dp_codec pa_a2dp_codec_sbc = {
.name = "sbc",
.description = "SBC",
.id = { A2DP_CODEC_SBC, 0, 0 },
.support_backchannel = false,
.can_accept_capabilities = can_accept_capabilities,
.choose_remote_endpoint = choose_remote_endpoint,
.fill_capabilities = fill_capabilities,
.is_configuration_valid = is_configuration_valid,
.fill_preferred_configuration =
fill_preferred_configuration,
.init = init,
.deinit = deinit,
.reset = reset,
.get_read_block_size = get_block_size,
.get_write_block_size = get_block_size,
.reduce_encoder_bitrate = reduce_encoder_bitrate,
.encode_buffer = encode_buffer,
.decode_buffer = decode_buffer,
};
17.09.2019, 09:34, "Hyperion" <h1p8r10n@xxxxxxxxxx>:btw here's the updated V12-12 patch in Pali's latest rel95_______________________________________________
patchset that applies to PA 13.0.
http://download.zenwalk.org/x86_64/testing/v12-12-13-zen-bluetooth-Implement-A2DP-codec-switching-and-backchannel-support-.patch
JP
16.09.2019, 09:32, "Hyperion" <h1p8r10n@xxxxxxxxxx>:Hi,
Following what has already be done in some Android
derivatives, here's a simple patch that extend SBP bitpool
negociation to XQ quality.
According to :
-->
http://soundexpert.org/articles/-/blogs/audio-quality-of-sbc-xq-bluetooth-audio-codec
--> https://lineageos.org/engineering/Bluetooth-SBC-XQ/ ,
--> and confirmed by my own experimentation on more than
10 different devices,
here are the features of the (very simple and non
intrusive) patch :
- allow to use bitpool 76 on devices that support it, aka
SBC XQ
- harmless for devices limited to bitpool 53
- deprecates the need for APTX & APTX HD support, which
are not better than SBC XQ, are not Open Source, and less
supported by devices
This patch will be superseded by multi-profiles Pali Rohar
A2DP stack implementation, when it's ready for production.
Thanks to Pali for the help testing many codec parameters.
Let me know if I have to clone the git to push my patch,
or if a regular PA dev could do it.
All the best
JP
diff -rNaud
pulseaudio-13.0/src/modules/bluetooth/a2dp-codec-sbc.c
pulseaudio-13.0-new/src/modules/bluetooth/a2dp-codec-sbc.c
--- pulseaudio-13.0/src/modules/bluetooth/a2dp-codec-sbc.c
2019-09-13 15:20:03.000000000 +0200
+++
pulseaudio-13.0-new/src/modules/bluetooth/a2dp-codec-sbc.c
2019-09-16 08:57:50.363122019 +0200
@@ -290,10 +290,10 @@
return 0;
}
- if (capabilities->allocation_method &
SBC_ALLOCATION_LOUDNESS)
- config->allocation_method = SBC_ALLOCATION_LOUDNESS;
- else if (capabilities->allocation_method &
SBC_ALLOCATION_SNR)
+ if (capabilities->allocation_method & SBC_ALLOCATION_SNR)
config->allocation_method = SBC_ALLOCATION_SNR;
+ else if (capabilities->allocation_method &
SBC_ALLOCATION_LOUDNESS)
+ config->allocation_method = SBC_ALLOCATION_LOUDNESS;
else {
pa_log_error("No supported allocation method");
return 0;
diff -rNaud
pulseaudio-13.0/src/modules/bluetooth/a2dp-codecs.h
pulseaudio-13.0-new/src/modules/bluetooth/a2dp-codecs.h
--- pulseaudio-13.0/src/modules/bluetooth/a2dp-codecs.h
2019-09-13 15:20:03.000000000 +0200
+++
pulseaudio-13.0-new/src/modules/bluetooth/a2dp-codecs.h
2019-09-16 08:44:20.382086305 +0200
@@ -61,14 +61,11 @@
* Allocation method = Loudness
* Subbands = 8
*/
-#define SBC_BITPOOL_MQ_MONO_44100 19
-#define SBC_BITPOOL_MQ_MONO_48000 18
-#define SBC_BITPOOL_MQ_JOINT_STEREO_44100 35
-#define SBC_BITPOOL_MQ_JOINT_STEREO_48000 33
-#define SBC_BITPOOL_HQ_MONO_44100 31
-#define SBC_BITPOOL_HQ_MONO_48000 29
-#define SBC_BITPOOL_HQ_JOINT_STEREO_44100 53
-#define SBC_BITPOOL_HQ_JOINT_STEREO_48000 51
+
+#define SBC_BITPOOL_HQ_MONO_44100 38
+#define SBC_BITPOOL_HQ_MONO_48000 38
+#define SBC_BITPOOL_HQ_JOINT_STEREO_44100 76
+#define SBC_BITPOOL_HQ_JOINT_STEREO_48000 76
#define MPEG_CHANNEL_MODE_MONO (1 << 3)
#define MPEG_CHANNEL_MODE_DUAL_CHANNEL (1 << 2)
_______________________________________________
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
_______________________________________________
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
_______________________________________________
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
_______________________________________________
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
_______________________________________________
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
--
Sent from Yandex.Mail for mobile
_______________________________________________ pulseaudio-discuss mailing list pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
