[pulseaudio-discuss] SBC XQ for PA 13.0

Andrey Semashev andrey.semashev at gmail.com
Mon Dec 9 11:32:52 UTC 2019 

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. Users might 
actually 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 at yandex.com>:
>>> 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 at yandex.com>:
>>>>   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 at gmail.com>:
>>>>>    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 at gmail.com>
>>>>>>
>>>>>>        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 at yandex.com>:
>>>>>>>     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 at yandex.com>:
>>>>>>>>       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 at lists.freedesktop.org
>>>>>>>>       https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss 
>>>>>>>>
>>>>>>     _______________________________________________
>>>>>>     pulseaudio-discuss mailing list
>>>>>>     pulseaudio-discuss at lists.freedesktop.org
>>>>>>     https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
>>>>>
>>>>>    _______________________________________________
>>>>>    pulseaudio-discuss mailing list
>>>>>    pulseaudio-discuss at lists.freedesktop.org
>>>>>    https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
>>>>
>>>>   _______________________________________________
>>>>   pulseaudio-discuss mailing list
>>>>   pulseaudio-discuss at lists.freedesktop.org
>>>>   https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
>>>
>>> _______________________________________________
>>> pulseaudio-discuss mailing list
>>> pulseaudio-discuss at lists.freedesktop.org
>>> https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
>> _______________________________________________
>> pulseaudio-discuss mailing list
>> pulseaudio-discuss at lists.freedesktop.org
>> https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss
>>
>

More information about the pulseaudio-discuss mailing list