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
