[PATCH v2 2/2] Bluetooth A2DP aptX codec support

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Sat, 2018-07-28 at 17:34 +0200, Pali Rohár wrote:
> This patch provides support for aptX codec in bluetooth A2DP profile. In
> pulseaudio it is implemented as a new profile a2dp_aptx_sink. For aptX
> encoding it uses open source LGPLv2.1+ licensed libopenaptx library which
> can be found at https://github.com/pali/libopenaptx.
> 
> Limitations:
> 
> Codec selection (either SBC or aptX) is done by bluez itself and it does
> not provide API for switching codec. Therefore pulseaudio is not able to
> change codec and it is up to bluez if it decide to use aptX or not.
> 
> Only standard aptX codec is supported for now. Support for other variants
> like aptX HD, aptX Low Latency, FastStream may come up later.
> ---
>  configure.ac                                 |  19 ++
>  src/Makefile.am                              |   5 +
>  src/modules/bluetooth/a2dp-codecs.h          | 118 ++++++++++-
>  src/modules/bluetooth/bluez5-util.c          |  48 ++++-
>  src/modules/bluetooth/bluez5-util.h          |   2 +
>  src/modules/bluetooth/module-bluez5-device.c |  65 +++++-
>  src/modules/bluetooth/pa-a2dp-codec-aptx.c   | 297 +++++++++++++++++++++++++++
>  src/modules/bluetooth/pa-a2dp-codec.h        |   1 +
>  8 files changed, 548 insertions(+), 7 deletions(-)
>  create mode 100644 src/modules/bluetooth/pa-a2dp-codec-aptx.c
> 
> diff --git a/configure.ac b/configure.ac
> index d2bfab23b..c2d13fa53 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -1094,6 +1094,23 @@ AC_SUBST(HAVE_BLUEZ_5_NATIVE_HEADSET)
>  AM_CONDITIONAL([HAVE_BLUEZ_5_NATIVE_HEADSET], [test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = x1])
>  AS_IF([test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = "x1"], AC_DEFINE([HAVE_BLUEZ_5_NATIVE_HEADSET], 1, [Bluez 5 native headset backend enabled]))
>  
> +#### Bluetooth A2DP aptX codec (optional) ###
> +
> +AC_ARG_ENABLE([aptx],
> +    AS_HELP_STRING([--disable-aptx],[Disable optional bluetooth A2DP aptX codec support (via libopenaptx)]))
> +
> +AS_IF([test "x$HAVE_BLUEZ_5" = "x1" && test "x$enable_aptx" != "xno"],
> +    [AC_CHECK_HEADER([openaptx.h],
> +        [AC_CHECK_LIB([openaptx], [aptx_init], [HAVE_OPENAPTX=1], [HAVE_OPENAPTX=0])],
> +        [HAVE_OPENAPTX=0])])

Have you considered providing a .pc file? Now we have to hardcode the
openaptx specific CFLAGS and LIBADD for libbluez5-util. If you ever
need to add new flags, all openaptx users need to update their build
systems. Also, if the library is installed to a non-standard location,
the .pc file can set the -L and -I flags to point to the right place.

> +
> +AS_IF([test "x$HAVE_BLUEZ_5" = "x1" && test "x$enable_aptx" = "xyes" && test "x$HAVE_OPENAPTX" = "x0"],
> +    [AC_MSG_ERROR([*** libopenaptx from https://github.com/pali/libopenaptx not found])])
> +
> +AC_SUBST(HAVE_OPENAPTX)
> +AM_CONDITIONAL([HAVE_OPENAPTX], [test "x$HAVE_OPENAPTX" = "x1"])
> +AS_IF([test "x$HAVE_OPENAPTX" = "x1"], AC_DEFINE([HAVE_OPENAPTX], 1, [Have openaptx codec library]))
> +
>  #### UDEV support (optional) ####
>  
>  AC_ARG_ENABLE([udev],
> @@ -1579,6 +1596,7 @@ AS_IF([test "x$HAVE_SYSTEMD_JOURNAL" = "x1"], ENABLE_SYSTEMD_JOURNAL=yes, ENABLE
>  AS_IF([test "x$HAVE_BLUEZ_5" = "x1"], ENABLE_BLUEZ_5=yes, ENABLE_BLUEZ_5=no)
>  AS_IF([test "x$HAVE_BLUEZ_5_OFONO_HEADSET" = "x1"], ENABLE_BLUEZ_5_OFONO_HEADSET=yes, ENABLE_BLUEZ_5_OFONO_HEADSET=no)
>  AS_IF([test "x$HAVE_BLUEZ_5_NATIVE_HEADSET" = "x1"], ENABLE_BLUEZ_5_NATIVE_HEADSET=yes, ENABLE_BLUEZ_5_NATIVE_HEADSET=no)
> +AS_IF([test "x$HAVE_OPENAPTX" = "x1"], ENABLE_APTX=yes, ENABLE_APTX=no)
>  AS_IF([test "x$HAVE_HAL_COMPAT" = "x1"], ENABLE_HAL_COMPAT=yes, ENABLE_HAL_COMPAT=no)
>  AS_IF([test "x$HAVE_TCPWRAP" = "x1"], ENABLE_TCPWRAP=yes, ENABLE_TCPWRAP=no)
>  AS_IF([test "x$HAVE_LIBSAMPLERATE" = "x1"], ENABLE_LIBSAMPLERATE="yes (DEPRECATED)", ENABLE_LIBSAMPLERATE=no)
> @@ -1637,6 +1655,7 @@ echo "
>        Enable BlueZ 5:              ${ENABLE_BLUEZ_5}
>          Enable ofono headsets:     ${ENABLE_BLUEZ_5_OFONO_HEADSET}
>          Enable native headsets:    ${ENABLE_BLUEZ_5_NATIVE_HEADSET}
> +        Enable aptX codec:         ${ENABLE_APTX}
>      Enable udev:                   ${ENABLE_UDEV}
>        Enable HAL->udev compat:     ${ENABLE_HAL_COMPAT}
>      Enable systemd
> diff --git a/src/Makefile.am b/src/Makefile.am
> index 411b9e5e5..bbd797589 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -2136,6 +2136,11 @@ libbluez5_util_la_SOURCES += modules/bluetooth/pa-a2dp-codec-sbc.c
>  libbluez5_util_la_LIBADD += $(SBC_LIBS)
>  libbluez5_util_la_CFLAGS += $(SBC_CFLAGS)
>  
> +if HAVE_OPENAPTX
> +libbluez5_util_la_SOURCES += modules/bluetooth/pa-a2dp-codec-aptx.c
> +libbluez5_util_la_LIBADD += -lopenaptx
> +endif
> +
>  module_bluez5_discover_la_SOURCES = modules/bluetooth/module-bluez5-discover.c
>  module_bluez5_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
>  module_bluez5_discover_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) libbluez5-util.la
> diff --git a/src/modules/bluetooth/a2dp-codecs.h b/src/modules/bluetooth/a2dp-codecs.h
> index 004975586..0c3583434 100644
> --- a/src/modules/bluetooth/a2dp-codecs.h
> +++ b/src/modules/bluetooth/a2dp-codecs.h
> @@ -4,6 +4,7 @@
>   *
>   *  Copyright (C) 2006-2010  Nokia Corporation
>   *  Copyright (C) 2004-2010  Marcel Holtmann <marcel at holtmann.org>
> + *  Copyright (C) 2018       Pali Rohár <pali.rohar at gmail.com>
>   *
>   *
>   *  This library is free software; you can redistribute it and/or
> @@ -24,7 +25,18 @@
>  #define A2DP_CODEC_SBC			0x00
>  #define A2DP_CODEC_MPEG12		0x01
>  #define A2DP_CODEC_MPEG24		0x02
> -#define A2DP_CODEC_ATRAC		0x03
> +#define A2DP_CODEC_ATRAC		0x04
> +#define A2DP_CODEC_VENDOR		0xFF
> +
> +#define A2DP_VENDOR_APT_LIC_LTD		0x0000004f
> +#define APT_LIC_LTD_CODEC_APTX		0x0001
> +
> +#define A2DP_VENDOR_QTIL		0x0000000a
> +#define QTIL_CODEC_FASTSTREAM		0x0001
> +#define QTIL_CODEC_APTX_LL		0x0002
> +
> +#define A2DP_VENDOR_QUALCOMM_TECH_INC	0x000000d7
> +#define QUALCOMM_TECH_INC_CODEC_APTX_HD	0x0024
>  
>  #define SBC_SAMPLING_FREQ_16000		(1 << 3)
>  #define SBC_SAMPLING_FREQ_32000		(1 << 2)
> @@ -66,6 +78,26 @@
>  #define MPEG_SAMPLING_FREQ_44100	(1 << 1)
>  #define MPEG_SAMPLING_FREQ_48000	1
>  
> +#define APTX_CHANNEL_MODE_MONO		0x1
> +#define APTX_CHANNEL_MODE_STEREO	0x2
> +
> +#define APTX_SAMPLING_FREQ_16000	0x8
> +#define APTX_SAMPLING_FREQ_32000	0x4
> +#define APTX_SAMPLING_FREQ_44100	0x2
> +#define APTX_SAMPLING_FREQ_48000	0x1
> +
> +#define FASTSTREAM_DIRECTION_SINK	0x1
> +#define FASTSTREAM_DIRECTION_SOURCE	0x2
> +
> +#define FASTSTREAM_SINK_SAMPLING_FREQ_44100	0x2
> +#define FASTSTREAM_SINK_SAMPLING_FREQ_48000	0x1
> +
> +#define FASTSTREAM_SOURCE_SAMPLING_FREQ_16000	0x2
> +
> +typedef struct {
> +	uint32_t vendor_id;
> +	uint16_t codec_id;
> +} __attribute__ ((packed)) a2dp_vendor_codec_t;
>  
>  #if __BYTE_ORDER == __LITTLE_ENDIAN
>  
> @@ -89,6 +121,48 @@ typedef struct {
>  	uint16_t bitrate;
>  } __attribute__ ((packed)) a2dp_mpeg_t;
>  
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t channel_mode:4;
> +	uint8_t frequency:4;
> +} __attribute__ ((packed)) a2dp_aptx_t;
> +
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t direction;
> +	uint8_t sink_frequency:4;
> +	uint8_t source_frequency:4;
> +} __attribute__ ((packed)) a2dp_faststream_t;
> +
> +typedef struct {
> +	uint8_t reserved;
> +	uint16_t target_codec_level;
> +	uint16_t initial_codec_level;
> +	uint8_t sra_max_rate;
> +	uint8_t sra_avg_time;
> +	uint16_t good_working_level;
> +} __attribute__ ((packed)) a2dp_aptx_ll_new_caps_t;
> +
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t channel_mode:4;
> +	uint8_t frequency:4;
> +	uint8_t bidirect_link:1;
> +	uint8_t has_new_caps:1;
> +	uint8_t reserved:6;
> +	a2dp_aptx_ll_new_caps_t new_caps[0];
> +} __attribute__ ((packed)) a2dp_aptx_ll_t;
> +
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t channel_mode:4;
> +	uint8_t frequency:4;
> +	uint8_t reserved0;
> +	uint8_t reserved1;
> +	uint8_t reserved2;
> +	uint8_t reserved3;
> +} __attribute__ ((packed)) a2dp_aptx_hd_t;
> +
>  #elif __BYTE_ORDER == __BIG_ENDIAN
>  
>  typedef struct {
> @@ -111,6 +185,48 @@ typedef struct {
>  	uint16_t bitrate;
>  } __attribute__ ((packed)) a2dp_mpeg_t;
>  
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t frequency:4;
> +	uint8_t channel_mode:4;
> +} __attribute__ ((packed)) a2dp_aptx_t;
> +
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t direction;
> +	uint8_t source_frequency:4;
> +	uint8_t sink_frequency:4;
> +} __attribute__ ((packed)) a2dp_faststream_t;
> +
> +typedef struct {
> +	uint8_t reserved;
> +	uint16_t target_codec_level;
> +	uint16_t initial_codec_level;
> +	uint8_t sra_max_rate;
> +	uint8_t sra_avg_time;
> +	uint16_t good_working_level;
> +} __attribute__ ((packed)) a2dp_aptx_ll_new_caps_t;
> +
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t frequency:4;
> +	uint8_t channel_mode:4;
> +	uint8_t reserved:6;
> +	uint8_t has_new_caps:1;
> +	uint8_t bidirect_link:1;
> +	a2dp_aptx_ll_new_caps_t new_caps[0];
> +} __attribute__ ((packed)) a2dp_aptx_ll_t;
> +
> +typedef struct {
> +	a2dp_vendor_codec_t info;
> +	uint8_t frequency:4;
> +	uint8_t channel_mode:4;
> +	uint8_t reserved0;
> +	uint8_t reserved1;
> +	uint8_t reserved2;
> +	uint8_t reserved3;
> +} __attribute__ ((packed)) a2dp_aptx_hd_t;
> +
>  #else
>  #error "Unknown byte order"
>  #endif
> diff --git a/src/modules/bluetooth/bluez5-util.c b/src/modules/bluetooth/bluez5-util.c
> index 9c4e3367b..c139f7fc3 100644
> --- a/src/modules/bluetooth/bluez5-util.c
> +++ b/src/modules/bluetooth/bluez5-util.c
> @@ -50,7 +50,9 @@
>  #define BLUEZ_ERROR_NOT_SUPPORTED "org.bluez.Error.NotSupported"
>  
>  #define A2DP_SOURCE_SBC_ENDPOINT "/MediaEndpoint/A2DPSourceSBC"
> +#define A2DP_SOURCE_APTX_ENDPOINT "/MediaEndpoint/A2DPSourceAPTX"
>  #define A2DP_SINK_SBC_ENDPOINT "/MediaEndpoint/A2DPSinkSBC"
> +#define A2DP_SINK_APTX_ENDPOINT "/MediaEndpoint/A2DPSinkAPTX"
>  
>  #define ENDPOINT_INTROSPECT_XML                                         \
>      DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE                           \
> @@ -173,8 +175,22 @@ static bool device_supports_profile(pa_bluetooth_device *device, pa_bluetooth_pr
>      switch (profile) {
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK:
>              return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SINK);
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
> +#ifdef HAVE_OPENAPTX
> +            /* TODO: Implement once bluez provides API to check if codec is supported */
> +            return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SINK);

Is someone working on that API?

> +#else
> +            return false;
> +#endif
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
>              return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SOURCE);
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
> +#ifdef HAVE_OPENAPTX
> +            /* TODO: Implement once bluez provides API to check if codec is supported */
> +            return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_A2DP_SOURCE);
> +#else
> +            return false;
> +#endif
>          case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT:
>              return !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_HS)
>                  || !!pa_hashmap_get(device->uuids, PA_BLUETOOTH_UUID_HSP_HS_ALT)
> @@ -961,7 +977,9 @@ static void parse_interfaces_and_properties(pa_bluetooth_discovery *y, DBusMessa
>              if (!a->valid)
>                  return;
>  
> +            register_endpoint(y, path, A2DP_SOURCE_APTX_ENDPOINT, PA_BLUETOOTH_UUID_A2DP_SOURCE);
>              register_endpoint(y, path, A2DP_SOURCE_SBC_ENDPOINT, PA_BLUETOOTH_UUID_A2DP_SOURCE);
> +            register_endpoint(y, path, A2DP_SINK_APTX_ENDPOINT, PA_BLUETOOTH_UUID_A2DP_SINK);
>              register_endpoint(y, path, A2DP_SINK_SBC_ENDPOINT, PA_BLUETOOTH_UUID_A2DP_SINK);

We shouldn't register aptX endpoints if aptX support is not enabled.

Does the registration order matter? I have some vague recollection from
the earlier discussion that BlueZ chooses the codec based on the
endpoint registration order - is that true? If the order is important,
we should document that here.

>  
>          } else if (pa_streq(interface, BLUEZ_DEVICE_INTERFACE)) {
> @@ -1258,8 +1276,12 @@ const char *pa_bluetooth_profile_to_string(pa_bluetooth_profile_t profile) {
>      switch(profile) {
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK:
>              return "a2dp_sink";
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
> +            return "a2dp_aptx_sink";
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
>              return "a2dp_source";
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
> +            return "a2dp_aptx_source";
>          case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT:
>              return "headset_head_unit";
>          case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY:
> @@ -1275,8 +1297,12 @@ const char *pa_bluetooth_profile_to_a2dp_endpoint(pa_bluetooth_profile_t profile
>      switch (profile) {
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK:
>              return A2DP_SOURCE_SBC_ENDPOINT;
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
> +            return A2DP_SOURCE_APTX_ENDPOINT;
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
>              return A2DP_SINK_SBC_ENDPOINT;
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
> +            return A2DP_SINK_APTX_ENDPOINT;
>          default:
>              return NULL;
>      }
> @@ -1289,6 +1315,11 @@ const pa_a2dp_codec_t *pa_bluetooth_profile_to_a2dp_codec(pa_bluetooth_profile_t
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK:
>          case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
>              return &pa_a2dp_codec_sbc;
> +#ifdef HAVE_OPENAPTX
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
> +        case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
> +            return &pa_a2dp_codec_aptx;
> +#endif
>          default:
>              return NULL;
>      }
> @@ -1299,6 +1330,10 @@ const pa_a2dp_codec_t *pa_bluetooth_profile_to_a2dp_codec(pa_bluetooth_profile_t
>  const pa_a2dp_codec_t *pa_a2dp_endpoint_to_a2dp_codec(const char *endpoint) {
>      if (pa_streq(endpoint, A2DP_SOURCE_SBC_ENDPOINT) || pa_streq(endpoint, A2DP_SINK_SBC_ENDPOINT))
>          return &pa_a2dp_codec_sbc;
> +#ifdef HAVE_OPENAPTX
> +    else if (pa_streq(endpoint, A2DP_SOURCE_APTX_ENDPOINT) || pa_streq(endpoint, A2DP_SINK_APTX_ENDPOINT))
> +        return &pa_a2dp_codec_aptx;
> +#endif
>      else
>          return NULL;
>  }
> @@ -1359,9 +1394,15 @@ static DBusMessage *endpoint_set_configuration(DBusConnection *conn, DBusMessage
>              if (pa_streq(endpoint_path, A2DP_SOURCE_SBC_ENDPOINT)) {
>                  if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE))
>                      p = PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK;
> +            } else if (pa_streq(endpoint_path, A2DP_SOURCE_APTX_ENDPOINT)) {
> +                if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE))
> +                    p = PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK;
>              } else if (pa_streq(endpoint_path, A2DP_SINK_SBC_ENDPOINT)) {
>                  if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SINK))
>                      p = PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE;
> +            } else if (pa_streq(endpoint_path, A2DP_SINK_APTX_ENDPOINT)) {
> +                if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SINK))
> +                    p = PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE;
>              }
>  
>              if (p == PA_BLUETOOTH_PROFILE_OFF) {
> @@ -1546,7 +1587,8 @@ static DBusHandlerResult endpoint_handler(DBusConnection *c, DBusMessage *m, voi
>  
>      pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member);
>  
> -    if (!pa_streq(path, A2DP_SOURCE_SBC_ENDPOINT) && !pa_streq(path, A2DP_SINK_SBC_ENDPOINT))
> +    if (!pa_streq(path, A2DP_SOURCE_SBC_ENDPOINT) && !pa_streq(path, A2DP_SINK_SBC_ENDPOINT) &&
> +        !pa_streq(path, A2DP_SOURCE_APTX_ENDPOINT) && !pa_streq(path, A2DP_SINK_APTX_ENDPOINT))
>          return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
>  
>      if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) {
> @@ -1652,7 +1694,9 @@ pa_bluetooth_discovery* pa_bluetooth_discovery_get(pa_core *c, int headset_backe
>      }
>      y->matches_added = true;
>  
> +    endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK);
>      endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK);
> +    endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE);
>      endpoint_init(y, PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE);

We shouldn't set up endpoints for aptX if the aptX support is not
enabled.

>  
>      get_managed_objects(y);
> @@ -1721,7 +1765,9 @@ void pa_bluetooth_discovery_unref(pa_bluetooth_discovery *y) {
>          if (y->filter_added)
>              dbus_connection_remove_filter(pa_dbus_connection_get(y->connection), filter_cb, y);
>  
> +        endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK);
>          endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK);
> +        endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE);
>          endpoint_done(y, PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE);

If endpoint_init() is made conditional, these need to be made
conditional too (according to the dbus docs, unregistering an object
path that hasn't been registered first is considered an application
bug).

>  
>          pa_dbus_connection_unref(y->connection);
> diff --git a/src/modules/bluetooth/bluez5-util.h b/src/modules/bluetooth/bluez5-util.h
> index 365b9ef6f..29d862fe1 100644
> --- a/src/modules/bluetooth/bluez5-util.h
> +++ b/src/modules/bluetooth/bluez5-util.h
> @@ -55,7 +55,9 @@ typedef enum pa_bluetooth_hook {
>  
>  typedef enum profile {
>      PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK,
> +    PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK,
>      PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE,
> +    PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE,
>      PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT,
>      PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY,
>      PA_BLUETOOTH_PROFILE_OFF
> diff --git a/src/modules/bluetooth/module-bluez5-device.c b/src/modules/bluetooth/module-bluez5-device.c
> index e626e80e9..e8a07d067 100644
> --- a/src/modules/bluetooth/module-bluez5-device.c
> +++ b/src/modules/bluetooth/module-bluez5-device.c
> @@ -706,7 +706,8 @@ static void transport_config_mtu(struct userdata *u) {
>      if (u->sink) {
>          pa_sink_set_max_request_within_thread(u->sink, u->write_block_size);
>          pa_sink_set_fixed_latency_within_thread(u->sink,
> -                                                (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK ?
> +                                                ((u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK ||
> +                                                  u->profile == PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK) ?
>                                                   FIXED_LATENCY_PLAYBACK_A2DP : FIXED_LATENCY_PLAYBACK_SCO) +
>                                                  pa_bytes_to_usec(u->write_block_size, &u->sample_spec));
>  
> @@ -752,7 +753,7 @@ static void setup_stream(struct userdata *u) {
>      if (setsockopt(u->stream_fd, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)) < 0)
>          pa_log_warn("Failed to enable SO_TIMESTAMP: %s", pa_cstrerror(errno));
>  
> -    if (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK)
> +    if (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK || u->profile == PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK)
>          update_buffer_size(u);
>  
>      pa_log_debug("Stream properly set up, we're ready to roll!");
> @@ -925,6 +926,7 @@ static int add_source(struct userdata *u) {
>      if (!u->transport_acquired)
>          switch (u->profile) {
>              case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
> +            case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
>              case PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY:
>                  data.suspend_cause = PA_SUSPEND_USER;
>                  break;
> @@ -937,6 +939,7 @@ static int add_source(struct userdata *u) {
>                      pa_assert_not_reached();
>                  break;
>              case PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK:
> +            case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
>              case PA_BLUETOOTH_PROFILE_OFF:
>              default:
>                  pa_assert_not_reached();
> @@ -1111,8 +1114,10 @@ static int add_sink(struct userdata *u) {
>                      pa_assert_not_reached();
>                  break;
>              case PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK:
> +            case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
>                  /* Profile switch should have failed */
>              case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
> +            case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
>              case PA_BLUETOOTH_PROFILE_OFF:
>              default:
>                  pa_assert_not_reached();
> @@ -1145,7 +1150,7 @@ static void transport_config(struct userdata *u) {
>          u->sample_spec.rate = 8000;
>      } else {
>          const pa_a2dp_codec_t *codec = pa_bluetooth_profile_to_a2dp_codec(u->profile);
> -        bool is_sink = (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK);
> +        bool is_sink = (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK || u->profile == PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK);
>          pa_assert(codec);
>          pa_assert(u->transport);
>          codec->init(is_sink ? &u->encoder_info : &u->decoder_info, &u->sample_spec, is_sink, u->transport->config, u->transport->config_size);
> @@ -1169,7 +1174,7 @@ static int setup_transport(struct userdata *u) {
>  
>      u->transport = t;
>  
> -    if (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY)
> +    if (u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE || u->profile == PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY)
>          transport_acquire(u, true); /* In case of error, the sink/sources will be created suspended */
>      else {
>          int transport_error;
> @@ -1188,7 +1193,9 @@ static int setup_transport(struct userdata *u) {
>  static pa_direction_t get_profile_direction(pa_bluetooth_profile_t p) {
>      static const pa_direction_t profile_direction[] = {
>          [PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK] = PA_DIRECTION_OUTPUT,
> +        [PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK] = PA_DIRECTION_OUTPUT,
>          [PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE] = PA_DIRECTION_INPUT,
> +        [PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE] = PA_DIRECTION_INPUT,
>          [PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT,
>          [PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY] = PA_DIRECTION_INPUT | PA_DIRECTION_OUTPUT,
>          [PA_BLUETOOTH_PROFILE_OFF] = 0
> @@ -1520,7 +1527,7 @@ static int start_thread(struct userdata *u) {
>          /* If we are in the headset role or the device is an a2dp source,
>           * the source should not become default unless there is no other
>           * sound device available. */
> -        if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY || u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE)
> +        if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY || u->profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE || u->profile == PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE)
>              u->source->priority = 1500;
>  
>          pa_source_put(u->source);
> @@ -1745,6 +1752,18 @@ static pa_card_profile *create_card_profile(struct userdata *u, pa_bluetooth_pro
>          p = PA_CARD_PROFILE_DATA(cp);
>          break;
>  
> +    case PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK:
> +        cp = pa_card_profile_new(name, _("High Fidelity aptX Playback (A2DP Sink)"), sizeof(pa_bluetooth_profile_t));
> +        cp->priority = 50;
> +        cp->n_sinks = 1;
> +        cp->n_sources = 0;
> +        cp->max_sink_channels = 2;
> +        cp->max_source_channels = 0;
> +        pa_hashmap_put(output_port->profiles, cp->name, cp);
> +
> +        p = PA_CARD_PROFILE_DATA(cp);
> +        break;
> +
>      case PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE:
>          cp = pa_card_profile_new(name, _("High Fidelity SBC Capture (A2DP Source)"), sizeof(pa_bluetooth_profile_t));
>          cp->priority = 20;
> @@ -1757,6 +1776,18 @@ static pa_card_profile *create_card_profile(struct userdata *u, pa_bluetooth_pro
>          p = PA_CARD_PROFILE_DATA(cp);
>          break;
>  
> +    case PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE:
> +        cp = pa_card_profile_new(name, _("High Fidelity aptX Capture (A2DP Source)"), sizeof(pa_bluetooth_profile_t));
> +        cp->priority = 25;
> +        cp->n_sinks = 0;
> +        cp->n_sources = 1;
> +        cp->max_sink_channels = 0;
> +        cp->max_source_channels = 2;
> +        pa_hashmap_put(input_port->profiles, cp->name, cp);
> +
> +        p = PA_CARD_PROFILE_DATA(cp);
> +        break;
> +

My compiler started to be unsure whether p is always initialized:

  CC       modules/bluetooth/module_bluez5_device_la-module-bluez5-device.lo
modules/bluetooth/module-bluez5-device.c: In function â??create_card_profileâ??:
modules/bluetooth/module-bluez5-device.c:1821:8: warning: â??pâ?? may be used uninitialized in this function [-Wmaybe-uninitialized]
     *p = profile;
     ~~~^~~~~~~~~

This is a false positive, but we should do something to make the
compiler shut up.

>      case PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT:
>          cp = pa_card_profile_new(name, _("Headset Head Unit (HSP/HFP)"), sizeof(pa_bluetooth_profile_t));
>          cp->priority = 30;
> @@ -1840,8 +1871,10 @@ off:
>  }
>  
>  static int uuid_to_profile(const char *uuid, pa_bluetooth_profile_t *_r) {
> +    /* FIXME: PA_BLUETOOTH_UUID_A2DP_SINK maps to both SBC and APTX */
>      if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SINK))
>          *_r = PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK;
> +    /* FIXME: PA_BLUETOOTH_UUID_A2DP_SOURCE maps to both SBC and APTX */
>      else if (pa_streq(uuid, PA_BLUETOOTH_UUID_A2DP_SOURCE))
>          *_r = PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE;
>      else if (pa_bluetooth_uuid_is_hsp_hs(uuid) || pa_streq(uuid, PA_BLUETOOTH_UUID_HFP_HF))
> @@ -1907,6 +1940,28 @@ static int add_card(struct userdata *u) {
>          pa_hashmap_put(data.profiles, cp->name, cp);
>      }
>  
> +    PA_HASHMAP_FOREACH(uuid, d->uuids, state) {
> +        pa_bluetooth_profile_t profile;
> +
> +        /* FIXME: PA_BLUETOOTH_UUID_A2DP_SINK maps to both SBC and APTX */
> +        /* FIXME: PA_BLUETOOTH_UUID_A2DP_SOURCE maps to both SBC and APTX */
> +        if (uuid_to_profile(uuid, &profile) < 0)
> +            continue;
> +
> +        /* Handle APTX */
> +        if (profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SINK)
> +            profile = PA_BLUETOOTH_PROFILE_A2DP_APTX_SINK;
> +        else if (profile == PA_BLUETOOTH_PROFILE_A2DP_SBC_SOURCE)
> +            profile = PA_BLUETOOTH_PROFILE_A2DP_APTX_SOURCE;
> +        else
> +            continue;
> +
> +        if (!pa_hashmap_get(data.profiles, pa_bluetooth_profile_to_string(profile))) {
> +            cp = create_card_profile(u, profile, data.ports);
> +            pa_hashmap_put(data.profiles, cp->name, cp);
> +        }
> +    }
> +

We shouldn't create the card profile if aptX support is disabled.

>      pa_assert(!pa_hashmap_isempty(data.profiles));
>  
>      cp = pa_card_profile_new("off", _("Off"), sizeof(pa_bluetooth_profile_t));
> diff --git a/src/modules/bluetooth/pa-a2dp-codec-aptx.c b/src/modules/bluetooth/pa-a2dp-codec-aptx.c
> new file mode 100644
> index 000000000..8ce1fc67c
> --- /dev/null
> +++ b/src/modules/bluetooth/pa-a2dp-codec-aptx.c
> @@ -0,0 +1,297 @@
> +/***
> +  This file is part of PulseAudio.
> +
> +  Copyright 2018 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/log.h>
> +#include <pulsecore/macro.h>
> +#include <pulsecore/once.h>
> +#include <pulse/sample.h>
> +
> +#include <openaptx.h>
> +
> +#include "a2dp-codecs.h"
> +#include "pa-a2dp-codec.h"
> +
> +static size_t pa_aptx_fill_capabilities(uint8_t *capabilities_buffer, size_t capabilities_size) {
> +    a2dp_aptx_t *capabilities = (a2dp_aptx_t *) capabilities_buffer;
> +
> +    if (capabilities_size < sizeof(*capabilities)) {
> +        pa_log_error("Invalid size of capabilities buffer");
> +        return 0;
> +    }
> +
> +    pa_zero(*capabilities);
> +
> +    capabilities->info.vendor_id = A2DP_VENDOR_APT_LIC_LTD;
> +    capabilities->info.codec_id = APT_LIC_LTD_CODEC_APTX;
> +    capabilities->channel_mode = APTX_CHANNEL_MODE_STEREO;
> +    capabilities->frequency = APTX_SAMPLING_FREQ_16000 | APTX_SAMPLING_FREQ_32000 | APTX_SAMPLING_FREQ_44100 |
> +                             APTX_SAMPLING_FREQ_48000;
> +
> +    return sizeof(*capabilities);
> +}
> +
> +static bool pa_aptx_validate_configuration(const uint8_t *config_buffer, size_t config_size) {
> +    a2dp_aptx_t *config = (a2dp_aptx_t *) config_buffer;
> +
> +    if (config_size != sizeof(*config)) {
> +        pa_log_error("Invalid size of config buffer");
> +        return false;
> +    }
> +
> +    if (config->info.vendor_id != A2DP_VENDOR_APT_LIC_LTD || config->info.codec_id != APT_LIC_LTD_CODEC_APTX) {
> +        pa_log_error("Invalid vendor codec information in configuration");
> +        return false;
> +    }
> +
> +    if (config->frequency != APTX_SAMPLING_FREQ_16000 && config->frequency != APTX_SAMPLING_FREQ_32000 &&
> +        config->frequency != APTX_SAMPLING_FREQ_44100 && config->frequency != APTX_SAMPLING_FREQ_48000) {
> +        pa_log_error("Invalid sampling frequency in configuration");
> +        return false;
> +    }
> +
> +    if (config->channel_mode != APTX_CHANNEL_MODE_STEREO) {
> +        pa_log_error("Invalid channel mode in configuration");
> +        return false;
> +    }
> +
> +    return true;
> +}
> +
> +static size_t pa_aptx_select_configuration(const pa_sample_spec *sample_spec, const uint8_t *capabilities_buffer, size_t capabilities_size, uint8_t *config_buffer, size_t config_size) {
> +    a2dp_aptx_t *config = (a2dp_aptx_t *) config_buffer;
> +    a2dp_aptx_t *capabilities = (a2dp_aptx_t *) capabilities_buffer;
> +    int i;
> +
> +    static const struct {
> +        uint32_t rate;
> +        uint8_t cap;
> +    } freq_table[] = {
> +        { 16000U, APTX_SAMPLING_FREQ_16000 },
> +        { 32000U, APTX_SAMPLING_FREQ_32000 },
> +        { 44100U, APTX_SAMPLING_FREQ_44100 },
> +        { 48000U, APTX_SAMPLING_FREQ_48000 }
> +    };
> +
> +    if (capabilities_size != sizeof(*capabilities)) {
> +        pa_log_error("Invalid size of capabilities buffer");
> +        return 0;
> +    }
> +
> +    if (config_size < sizeof(*config)) {
> +        pa_log_error("Invalid size of config buffer");
> +        return 0;
> +    }
> +
> +    pa_zero(*config);
> +
> +    if (capabilities->info.vendor_id != A2DP_VENDOR_APT_LIC_LTD || capabilities->info.codec_id != APT_LIC_LTD_CODEC_APTX) {
> +        pa_log_error("No supported vendor codec information");
> +        return 0;
> +    }
> +
> +    config->info.vendor_id = A2DP_VENDOR_APT_LIC_LTD;
> +    config->info.codec_id = APT_LIC_LTD_CODEC_APTX;
> +
> +    if (sample_spec->channels != 2 || !(capabilities->channel_mode & APTX_CHANNEL_MODE_STEREO)) {
> +        pa_log_error("No supported channel modes");
> +        return 0;
> +    }

sample_spec->channels is the global default channel count, and it's
used only as a hint for choosing the preferable channel mode. Since we
support only one channel mode, we can ignore sample_spec->channels
altogether.

> +
> +    config->channel_mode = APTX_CHANNEL_MODE_STEREO;
> +
> +    /* 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 >= 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;
> +        }
> +    }
> +
> +    return sizeof(*config);
> +}
> +
> +static void pa_aptx_init(void **info_ptr, pa_sample_spec *sample_spec, bool is_a2dp_sink, const uint8_t *config_buffer, size_t config_size) {
> +    a2dp_aptx_t *config = (a2dp_aptx_t *) config_buffer;
> +
> +    pa_assert(config_size == sizeof(*config));
> +
> +    sample_spec->format = PA_SAMPLE_S24LE;
> +
> +    if (*info_ptr)
> +        aptx_reset((struct aptx_context *) *info_ptr);
> +    else
> +        *info_ptr = (void *)aptx_init(0);
> +
> +    switch (config->frequency) {
> +        case APTX_SAMPLING_FREQ_16000:
> +            sample_spec->rate = 16000U;
> +            break;
> +        case APTX_SAMPLING_FREQ_32000:
> +            sample_spec->rate = 32000U;
> +            break;
> +        case APTX_SAMPLING_FREQ_44100:
> +            sample_spec->rate = 44100U;
> +            break;
> +        case APTX_SAMPLING_FREQ_48000:
> +            sample_spec->rate = 48000U;
> +            break;
> +        default:
> +            pa_assert_not_reached();
> +    }
> +
> +    switch (config->channel_mode) {
> +        case APTX_CHANNEL_MODE_STEREO:
> +            sample_spec->channels = 2;
> +            break;
> +        default:
> +            pa_assert_not_reached();
> +    }
> +}
> +
> +static void pa_aptx_finish(void **info_ptr) {
> +    struct aptx_context *aptx_c = (struct aptx_context *) *info_ptr;
> +
> +    if (aptx_c) {
> +        aptx_finish(aptx_c);
> +        *info_ptr = NULL;
> +    }
> +}
> +
> +static void pa_aptx_setup(void **info_ptr) {
> +}
> +
> +static void pa_aptx_fill_blocksize(void **info_ptr, size_t read_link_mtu, size_t write_link_mtu, size_t *read_block_size, size_t *write_block_size) {
> +    *write_block_size = (write_link_mtu/(8*4)) * 8*4*6;
> +    *read_block_size = (read_link_mtu/(8*4)) * 8*4*6;

Please add comments that explain the math here.

> +}
> +
> +static bool pa_aptx_fix_latency(void **info_ptr) {
> +    return false;
> +}
> +
> +static size_t pa_aptx_encode(void **info_ptr, uint32_t timestamp, const uint8_t *input_buffer, size_t input_size, uint8_t *output_buffer, size_t output_size) {
> +    struct aptx_context *aptx_c = (struct aptx_context *) *info_ptr;
> +    uint8_t *d;
> +    const uint8_t *p;
> +    size_t to_write, to_encode;
> +
> +    p = input_buffer;
> +    to_encode = input_size;
> +
> +    d = output_buffer;
> +    to_write = output_size;
> +
> +    while (PA_LIKELY(to_encode > 0 && to_write > 0)) {
> +        size_t written;
> +        size_t encoded;
> +        encoded = aptx_encode(aptx_c, p, to_encode, d, to_write, &written);
> +
> +        if (PA_UNLIKELY(encoded == 0)) {
> +            pa_log_error("aptX encoding error");
> +            return 0;
> +        }
> +
> +        pa_assert_fp((size_t) encoded <= to_encode);
> +        pa_assert_fp((size_t) written <= to_write);
> +
> +        p += encoded;
> +        to_encode -= encoded;
> +
> +        d += written;
> +        to_write -= written;
> +    }
> +
> +    pa_assert(to_encode == 0);
> +
> +    PA_ONCE_BEGIN {
> +        pa_log_debug("Using aptX encoder implementation: libopenaptx from https://github.com/pali/libopenaptx";);
> +    } PA_ONCE_END;
> +
> +    return d - output_buffer;
> +}
> +
> +static size_t pa_aptx_decode(void **info_ptr, const uint8_t *input_buffer, size_t input_size, uint8_t *output_buffer, size_t output_size, size_t *processed) {
> +    struct aptx_context *aptx_c = (struct aptx_context *) *info_ptr;
> +
> +    const uint8_t *p;
> +    uint8_t *d;
> +    size_t to_write, to_decode;
> +
> +    p = input_buffer;
> +    to_decode = input_size;
> +
> +    d = output_buffer;
> +    to_write = output_size;
> +
> +    while (PA_LIKELY(to_decode > 0)) {
> +        size_t written;
> +        size_t decoded;
> +
> +        decoded = aptx_decode(aptx_c, p, to_decode, d, to_write, &written);
> +
> +        if (PA_UNLIKELY(decoded == 0)) {
> +            pa_log_error("aptX decoding error");
> +            *processed = p - input_buffer;
> +            return 0;
> +        }
> +
> +        pa_assert_fp((size_t) decoded <= to_decode);
> +
> +        p += decoded;
> +        to_decode -= decoded;
> +
> +        d += written;
> +        to_write -= written;
> +    }
> +
> +    *processed = p - input_buffer;
> +    return d - output_buffer;
> +}
> +
> +const pa_a2dp_codec_t pa_a2dp_codec_aptx = {
> +    .codec_id = A2DP_CODEC_VENDOR,
> +    .fill_capabilities = pa_aptx_fill_capabilities,
> +    .validate_configuration = pa_aptx_validate_configuration,
> +    .select_configuration = pa_aptx_select_configuration,
> +    .init = pa_aptx_init,
> +    .finish = pa_aptx_finish,
> +    .setup = pa_aptx_setup,
> +    .fill_blocksize = pa_aptx_fill_blocksize,
> +    .fix_latency = pa_aptx_fix_latency,
> +    .encode = pa_aptx_encode,
> +    .decode = pa_aptx_decode,
> +};
> diff --git a/src/modules/bluetooth/pa-a2dp-codec.h b/src/modules/bluetooth/pa-a2dp-codec.h
> index 68b1619c2..26e7653a6 100644
> --- a/src/modules/bluetooth/pa-a2dp-codec.h
> +++ b/src/modules/bluetooth/pa-a2dp-codec.h
> @@ -36,5 +36,6 @@ typedef struct pa_a2dp_codec {
>  } pa_a2dp_codec_t;
>  
>  extern const pa_a2dp_codec_t pa_a2dp_codec_sbc;
> +extern const pa_a2dp_codec_t pa_a2dp_codec_aptx;
>  
>  #endif

-- 
Tanu

https://www.patreon.com/tanuk
https://liberapay.com/tanuk


[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux