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
