Re: [PATCH v3 2/4] Add A2DP AAC codec support

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

 



Hi,

On Sat, Dec 29, 2018 at 12:49 PM Huang-Huang Bao <eh5@xxxxxxxx> wrote:
>
> Optional (build with --disable-bluez5-aac-codec)
>
> AAC User Configurations:
>    KEY                 VALUE    DESC                                      DEFAULT
>    aac_bitrate_mode    [1, 5]   Variable Bitrate (VBR) (encoder)          5
>                        0        Constant Bitrate (CBR) (encoder)
>
>    aac_fmt             s16      16-bit signed LE (encoder)                auto
>                        s32      32-bit signed LE (encoder)
>                        auto
>
>    aac_afterburner     <on/off> FDK-AAC afterburner feature (encoder)     off
> ---
>  configure.ac                           |  14 +-
>  src/Makefile.am                        |   8 +
>  src/modules/bluetooth/a2dp/a2dp-api.h  |  10 +-
>  src/modules/bluetooth/a2dp/a2dp_aac.c  | 762 +++++++++++++++++++++++++
>  src/modules/bluetooth/a2dp/a2dp_util.c |  33 ++
>  5 files changed, 825 insertions(+), 2 deletions(-)
>  create mode 100644 src/modules/bluetooth/a2dp/a2dp_aac.c
>
> diff --git a/configure.ac b/configure.ac
> index 2512d3c95..0f9d7fb6c 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -1061,7 +1061,7 @@ PA_MACHINE_ID_FALLBACK="${localstatedir}/lib/dbus/machine-id"
>  AX_DEFINE_DIR(PA_MACHINE_ID_FALLBACK, PA_MACHINE_ID_FALLBACK,
>               [Fallback machine-id file])
>
> -#### BlueZ support (optional, dependent on D-Bus and SBC) ####
> +#### BlueZ support (optional, dependent on D-Bus and SBC and FDK-AAC) ####
>
>  AC_ARG_ENABLE([bluez5],
>      AS_HELP_STRING([--disable-bluez5],[Disable optional BlueZ 5 support]))
> @@ -1083,6 +1083,16 @@ AS_IF([test "x$HAVE_BLUEZ_5" = "x1"], HAVE_BLUEZ=1, HAVE_BLUEZ=0)
>  AC_SUBST(HAVE_BLUEZ)
>  AM_CONDITIONAL([HAVE_BLUEZ], [test "x$HAVE_BLUEZ" = x1])
>
> +## FDK-AAC ##
> +AC_ARG_ENABLE([bluez5-aac-codec],
> +    AS_HELP_STRING([--disable-bluez5-aac-codec],[Disable optional A2DP AAC codec support (Bluez 5)]))
> +AS_IF([test "x$HAVE_BLUEZ_5" = "x1" && test "x$enable_bluez5_aac_codec" != "xno"],
> +    [PKG_CHECK_MODULES(FDK_AAC, [ fdk-aac >= 0.1.5 ], HAVE_FDK_AAC=1, HAVE_FDK_AAC=0)],
> +    HAVE_FDK_AAC=0)
> +AC_SUBST(HAVE_FDK_AAC)
> +AM_CONDITIONAL([HAVE_FDK_AAC], [test "x$HAVE_FDK_AAC" = x1])
> +AS_IF([test "x$HAVE_FDK_AAC" = "x1"], AC_DEFINE([HAVE_FDK_AAC], 1, [Bluez 5 A2DP AAC codec enabled]))
> +
>  ## Bluetooth Headset profiles backend ##
>
>  AC_ARG_ENABLE([bluez5-ofono-headset],
> @@ -1587,6 +1597,7 @@ AS_IF([test "x$HAVE_SYSTEMD_DAEMON" = "x1"], ENABLE_SYSTEMD_DAEMON=yes, ENABLE_S
>  AS_IF([test "x$HAVE_SYSTEMD_LOGIN" = "x1"], ENABLE_SYSTEMD_LOGIN=yes, ENABLE_SYSTEMD_LOGIN=no)
>  AS_IF([test "x$HAVE_SYSTEMD_JOURNAL" = "x1"], ENABLE_SYSTEMD_JOURNAL=yes, ENABLE_SYSTEMD_JOURNAL=no)
>  AS_IF([test "x$HAVE_BLUEZ_5" = "x1"], ENABLE_BLUEZ_5=yes, ENABLE_BLUEZ_5=no)
> +AS_IF([test "x$HAVE_FDK_AAC" = "x1"], ENABLE_BLUEZ_5_AAC_CODEC=yes, ENABLE_BLUEZ_5_AAC_CODEC=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_HAL_COMPAT" = "x1"], ENABLE_HAL_COMPAT=yes, ENABLE_HAL_COMPAT=no)
> @@ -1645,6 +1656,7 @@ echo "
>      Enable LIRC:                   ${ENABLE_LIRC}
>      Enable D-Bus:                  ${ENABLE_DBUS}
>        Enable BlueZ 5:              ${ENABLE_BLUEZ_5}
> +        Enable A2DP AAC codec:     ${ENABLE_BLUEZ_5_AAC_CODEC}
>          Enable ofono headsets:     ${ENABLE_BLUEZ_5_OFONO_HEADSET}
>          Enable native headsets:    ${ENABLE_BLUEZ_5_NATIVE_HEADSET}
>      Enable udev:                   ${ENABLE_UDEV}
> diff --git a/src/Makefile.am b/src/Makefile.am
> index 521b9b684..c44a65f05 100644
> --- a/src/Makefile.am
> +++ b/src/Makefile.am
> @@ -2128,6 +2128,10 @@ libbluez5_util_la_SOURCES = \
>                 modules/bluetooth/a2dp/a2dp-api.h \
>                 modules/bluetooth/a2dp/a2dp-codecs.h \
>                 modules/bluetooth/a2dp/rtp.h
> +if HAVE_FDK_AAC
> +libbluez5_util_la_SOURCES += \
> +               modules/bluetooth/a2dp/a2dp_aac.c
> +endif
>  if HAVE_BLUEZ_5_OFONO_HEADSET
>  libbluez5_util_la_SOURCES += \
>                 modules/bluetooth/backend-ofono.c
> @@ -2140,6 +2144,10 @@ endif
>  libbluez5_util_la_LDFLAGS = -avoid-version
>  libbluez5_util_la_LIBADD = $(MODULE_LIBADD) $(DBUS_LIBS) $(SBC_LIBS)
>  libbluez5_util_la_CFLAGS = $(AM_CFLAGS) $(DBUS_CFLAGS) $(SBC_CFLAGS)
> +if HAVE_FDK_AAC
> +libbluez5_util_la_LIBADD += $(FDK_AAC_LIBS)
> +libbluez5_util_la_CFLAGS += $(FDK_AAC_CFLAGS)
> +endif
>
>  module_bluez5_discover_la_SOURCES = modules/bluetooth/module-bluez5-discover.c
>  module_bluez5_discover_la_LDFLAGS = $(MODULE_LDFLAGS)
> diff --git a/src/modules/bluetooth/a2dp/a2dp-api.h b/src/modules/bluetooth/a2dp/a2dp-api.h
> index 1492d29fd..1e601a9c5 100644
> --- a/src/modules/bluetooth/a2dp/a2dp-api.h
> +++ b/src/modules/bluetooth/a2dp/a2dp-api.h
> @@ -37,7 +37,9 @@ typedef struct pa_a2dp_codec pa_a2dp_codec_t;
>  typedef struct pa_a2dp_config pa_a2dp_config_t;
>
>  extern const pa_a2dp_codec_t pa_a2dp_sbc;
> -
> +#ifdef HAVE_FDK_AAC
> +extern const pa_a2dp_codec_t pa_a2dp_aac;
> +#endif
>
>  /* Run from <pa_a2dp_sink_t>.encode */
>
> @@ -50,9 +52,15 @@ typedef void (*pa_a2dp_source_read_buf_free_cb_t)(const void **read_buf, void *d
>  typedef enum pa_a2dp_codec_index {
>      PA_A2DP_SINK_MIN,
>      PA_A2DP_SINK_SBC,
> +#ifdef HAVE_FDK_AAC
> +    PA_A2DP_SINK_AAC,
> +#endif
>      PA_A2DP_SINK_MAX,
>      PA_A2DP_SOURCE_MIN = PA_A2DP_SINK_MAX,
>      PA_A2DP_SOURCE_SBC,
> +#ifdef HAVE_FDK_AAC
> +    PA_A2DP_SOURCE_AAC,
> +#endif
>      PA_A2DP_SOURCE_MAX,
>      PA_A2DP_CODEC_INDEX_UNAVAILABLE
>  } pa_a2dp_codec_index_t;
> diff --git a/src/modules/bluetooth/a2dp/a2dp_aac.c b/src/modules/bluetooth/a2dp/a2dp_aac.c
> new file mode 100644
> index 000000000..a1d7bf1d2
> --- /dev/null
> +++ b/src/modules/bluetooth/a2dp/a2dp_aac.c
> @@ -0,0 +1,762 @@
> +/***
> +  This file is part of PulseAudio.
> +
> +  Copyright 2018 Huang-Huang Bao
> +
> +  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/>.
> +***/
> +
> +#include <arpa/inet.h>
> +#include <string.h>
> +
> +#include <fdk-aac/aacenc_lib.h>
> +#include <fdk-aac/aacdecoder_lib.h>
> +
> +#include <pulse/xmalloc.h>
> +
> +#include "a2dp-api.h"
> +
> +#define streq(a, b) (!strcmp((a),(b)))
> +
> +#define AAC_DEFAULT_BITRATE 320000u
> +
> +typedef struct aac_info {
> +    pa_a2dp_source_read_cb_t read_pcm;
> +    pa_a2dp_source_read_buf_free_cb_t read_buf_free;
> +
> +    bool is_a2dp_sink;
> +
> +    uint16_t seq_num;
> +
> +    HANDLE_AACDECODER aacdecoder_handle;
> +    bool aacdecoder_handle_opened;
> +
> +    HANDLE_AACENCODER aacenc_handle;
> +    bool aacenc_handle_opened;
> +    AACENC_InfoStruct aacenc_info;
> +
> +    uint32_t bitrate;
> +    size_t mtu;
> +
> +    /* Constant Bitrate: 0
> +     * Variable Bitrate: 1-5 (Only effects when both bluetooth devices have vbr support ) */
> +    int aac_enc_bitrate_mode;
> +    uint32_t aac_afterburner;
> +    pa_sample_format_t force_pa_fmt;
> +
> +    pa_sample_spec sample_spec;
> +
> +    size_t read_block_size;
> +    size_t write_block_size;
> +
> +} aac_info_t;
> +
> +static bool pa_aac_decoder_load() {
> +    /* AAC libs dynamically linked */
> +    return true;
> +}
> +
> +static bool pa_aac_encoder_load() {
> +    /* AAC libs dynamically linked */
> +    return true;
> +}
> +
> +static bool
> +pa_aac_decoder_init(void **codec_data) {
> +    aac_info_t *info = pa_xmalloc0(sizeof(aac_info_t));
> +    *codec_data = info;
> +    info->is_a2dp_sink = true;
> +    return true;
> +}
> +
> +static bool
> +pa_aac_encoder_init(pa_a2dp_source_read_cb_t read_cb, pa_a2dp_source_read_buf_free_cb_t free_cb, void **codec_data) {
> +    aac_info_t *info = pa_xmalloc0(sizeof(aac_info_t));
> +    *codec_data = info;
> +    info->is_a2dp_sink = false;
> +    info->read_pcm = read_cb;
> +    info->read_buf_free = free_cb;
> +    info->aacenc_handle_opened = false;
> +    info->aac_enc_bitrate_mode = 5;
> +    info->aac_afterburner = false;
> +    info->force_pa_fmt = PA_SAMPLE_INVALID;
> +    return true;
> +}
> +
> +/* KEY                 VALUE    DESC                                      DEFAULT
> + * aac_bitrate_mode    [1, 5]   Variable Bitrate (VBR) (encoder)          5
> + *                     0        Constant Bitrate (CBR) (encoder)
> + *
> + * aac_fmt             s16      16-bit signed LE (encoder)                auto
> + *                     s32      32-bit signed LE (encoder)
> + *                     auto
> + *
> + * aac_afterburner     <on/off> FDK-AAC afterburner feature (encoder)     off
> + */
> +static int pa_aac_update_user_config(pa_proplist *user_config, void **codec_data) {
> +    aac_info_t *i = *codec_data;
> +    const char *aac_bitrate_mode_str, *aac_fmt_str, *aac_afterburner_str;
> +    int aac_bitrate_mode = 0, ret = 0;
> +    pa_assert(i);
> +
> +    aac_bitrate_mode_str = pa_proplist_gets(user_config, "aac_bitrate_mode");
> +    aac_fmt_str = pa_proplist_gets(user_config, "aac_fmt");
> +    aac_afterburner_str = pa_proplist_gets(user_config, "aac_afterburner");
> +
> +    if (aac_bitrate_mode_str) {
> +        aac_bitrate_mode = atoi(aac_bitrate_mode_str);
> +
> +        if (aac_bitrate_mode >= 0 && aac_bitrate_mode <= 5) {
> +            i->aac_enc_bitrate_mode = aac_bitrate_mode;
> +            ret++;
> +        } else
> +            pa_log ("aac_bitrate_mode parameter must in range [0, 5] (found %s)", aac_bitrate_mode_str);
> +    }
> +
> +    if (aac_fmt_str) {
> +        if (streq(aac_fmt_str, "s16")) {
> +            i->force_pa_fmt = PA_SAMPLE_S16LE;
> +            ret++;
> +        } else if (streq(aac_fmt_str, "s32")) {
> +            i->force_pa_fmt = PA_SAMPLE_S32LE;
> +            ret++;
> +        } else if (streq(aac_fmt_str, "auto")) {
> +            i->force_pa_fmt = PA_SAMPLE_INVALID;
> +            ret++;
> +        } else
> +            pa_log ("aac_fmt parameter must be either s16, s32 or auto (found %s)", aac_fmt_str);
> +    }
> +
> +    if (aac_afterburner_str) {
> +        if (streq("on", aac_afterburner_str)) {
> +            i->aac_afterburner = 1;
> +            ret++;
> +        } else if (streq("off", aac_afterburner_str)) {
> +            i->aac_afterburner = 0;
> +            ret++;
> +        } else
> +            pa_log ("aac_afterburner parameter must be either on or off (found %s)", aac_afterburner_str);
> +    }
> +
> +    return ret;
> +}
> +
> +static size_t
> +pa_aac_decode(const void *read_buf, size_t read_buf_size, void *write_buf, size_t write_buf_size, size_t *_decoded,
> +              uint32_t *timestamp, void **codec_data) {
> +    const struct rtp_header *header;
> +    const UCHAR *p;
> +    INT_PCM *d;
> +    UINT to_decode, pkt_size;
> +    UINT total_written = 0;
> +    aac_info_t *aac_info = *codec_data;
> +    pa_assert(aac_info);
> +
> +    header = read_buf;
> +    *timestamp = ntohl(header->timestamp);
> +
> +    p = (UCHAR *) read_buf + sizeof(*header);
> +    pkt_size = to_decode = (UINT) (read_buf_size - sizeof(*header));
> +
> +    d = write_buf;
> +
> +    *_decoded = 0;
> +    while (PA_LIKELY(to_decode > 0)) {
> +        CStreamInfo* info;
> +
> +        AAC_DECODER_ERROR aac_err = aacDecoder_Fill(aac_info->aacdecoder_handle,
> +                                                    (UCHAR **) &p, &pkt_size, &to_decode);
> +
> +        if (PA_UNLIKELY(aac_err != AAC_DEC_OK)) {
> +            pa_log_error("aacDecoder_Fill() error 0x%x", aac_err);
> +            *_decoded = 0;
> +            return 0;
> +        }
> +
> +        while (true) {
> +            INT written;
> +            aac_err = aacDecoder_DecodeFrame(aac_info->aacdecoder_handle, d, (INT) write_buf_size, 0);
> +            if (PA_UNLIKELY(aac_err == AAC_DEC_NOT_ENOUGH_BITS))
> +                break;
> +            if (PA_UNLIKELY(aac_err != AAC_DEC_OK)){
> +                pa_log_error("aacDecoder_DecodeFrame() error 0x%x", aac_err);
> +                break;
> +            }
> +
> +            info = aacDecoder_GetStreamInfo(aac_info->aacdecoder_handle);
> +            if(PA_UNLIKELY(!info || info->sampleRate <= 0)) {
> +                pa_log_error("Invalid stream info");
> +                break;
> +            }
> +
> +            written = info->frameSize * info->numChannels * 2;
> +            d += written;
> +            total_written += (UINT) written;
> +        }
> +    }
> +
> +    *_decoded = pkt_size;
> +
> +    return total_written;
> +}
> +
> +static size_t
> +pa_aac_encode(uint32_t timestamp, void *write_buf, size_t write_buf_size, size_t *_encoded, void *read_cb_data,
> +              void **codec_data) {
> +    struct rtp_header *header;
> +    size_t nbytes;
> +    uint8_t *d;
> +    const uint8_t *p;
> +    int to_write;
> +    unsigned frame_count;
> +    aac_info_t *aac_info = *codec_data;
> +    const size_t sample_size = pa_sample_size(&aac_info->sample_spec),
> +            frame_size = pa_frame_size(&aac_info->sample_spec);
> +    void *in_bufs[1] = {NULL};
> +    void *out_bufs[1] = {NULL};
> +    int in_bufferIdentifiers[1] = {IN_AUDIO_DATA};
> +    int out_bufferIdentifiers[1] = {OUT_BITSTREAM_DATA};
> +    int in_bufSizes[1] = {(int) (aac_info->aacenc_info.frameLength * frame_size)};
> +    int out_bufSizes[1];
> +    int bufElSizes[1] = {(int) sample_size};
> +    AACENC_BufDesc in_bufDesc = {
> +            .numBufs = 1,
> +            .bufs = in_bufs,
> +            .bufferIdentifiers = in_bufferIdentifiers,
> +            .bufSizes = in_bufSizes,
> +            .bufElSizes = bufElSizes
> +    };
> +    AACENC_BufDesc out_bufDesc = {
> +            .numBufs = 1,
> +            .bufs = out_bufs,
> +            .bufferIdentifiers = out_bufferIdentifiers,
> +            .bufSizes = out_bufSizes,
> +            .bufElSizes = bufElSizes
> +    };
> +    AACENC_InArgs in_args = {
> +            .numAncBytes = 0,
> +            .numInSamples = aac_info->aacenc_info.frameLength * aac_info->aacenc_info.inputChannels
> +    };
> +    AACENC_OutArgs out_args;
> +
> +    pa_assert(aac_info);
> +
> +    header = write_buf;
> +
> +    frame_count = 0;
> +
> +    aac_info->read_pcm((const void **) &p, (size_t) in_bufSizes[0], read_cb_data);
> +
> +    in_bufDesc.bufs[0] = (void *) p;
> +
> +    d = (uint8_t *) write_buf + sizeof(*header);
> +    to_write = (int) (write_buf_size - sizeof(*header));
> +    out_bufDesc.bufs[0] = d;
> +    out_bufSizes[0] = to_write;
> +
> +
> +    *_encoded = 0;
> +
> +    while (PA_UNLIKELY(in_args.numInSamples && to_write > 0)) {
> +        size_t encoded;
> +
> +        AACENC_ERROR aac_err = aacEncEncode(aac_info->aacenc_handle, &in_bufDesc, &out_bufDesc, &in_args, &out_args);
> +
> +        if (PA_UNLIKELY(aac_err != AACENC_OK)) {
> +            pa_log_error("AAC encoding error, 0x%x", aac_err);
> +            aac_info->read_buf_free((const void **) &p, read_cb_data);
> +            *_encoded = 0;
> +            return 0;
> +        }
> +
> +        encoded = out_args.numInSamples * sample_size;
> +
> +        in_args.numInSamples -= out_args.numInSamples;
> +        p += encoded;
> +        *_encoded += encoded;
> +
> +        to_write -= out_args.numOutBytes;
> +        d += out_args.numOutBytes;
> +
> +        frame_count++;
> +    }
> +
> +    aac_info->read_buf_free((const void **) &p, read_cb_data);
> +
> +    memset(write_buf, 0, sizeof(*header));
> +    header->v = 2;
> +    header->pt = 1;
> +    header->sequence_number = htons(aac_info->seq_num++);
> +    header->timestamp = htonl(timestamp);
> +    header->ssrc = htonl(1);
> +
> +    nbytes = d - (uint8_t *) write_buf;
> +
> +    return nbytes;
> +}
> +
> +static void
> +pa_aac_config_transport(pa_sample_spec default_sample_spec, const void *configuration, size_t configuration_size,
> +                        pa_sample_spec *sample_spec, void **codec_data) {
> +    AACENC_ERROR aac_err;
> +    aac_info_t *aac_info = *codec_data;
> +    a2dp_aac_t *config = (a2dp_aac_t *) configuration;
> +    UINT aot, sample_rate, channels;
> +    pa_sample_format_t fmt;
> +
> +    pa_assert(aac_info);
> +    pa_assert_se(configuration_size == sizeof(*config));
> +
> +    aac_info->bitrate = PA_MIN(AAC_DEFAULT_BITRATE, ((uint32_t) AAC_GET_BITRATE(*config)));
> +
> +
> +    if(aac_info->is_a2dp_sink)
> +        sample_spec->format = PA_SAMPLE_S16LE;
> +    else{
> +        if (aac_info->force_pa_fmt == PA_SAMPLE_INVALID)
> +            fmt = default_sample_spec.format;
> +        else
> +            fmt = aac_info->force_pa_fmt;
> +
> +        switch (fmt) {
> +            case PA_SAMPLE_S24LE:
> +            case PA_SAMPLE_S24BE:
> +            case PA_SAMPLE_S24_32LE:
> +            case PA_SAMPLE_S24_32BE:
> +            case PA_SAMPLE_S32LE:
> +            case PA_SAMPLE_S32BE:
> +            case PA_SAMPLE_FLOAT32LE:
> +            case PA_SAMPLE_FLOAT32BE:
> +                sample_spec->format = PA_SAMPLE_S32LE;
> +                break;
> +            default:
> +                sample_spec->format = PA_SAMPLE_S16LE;
> +        }
> +    }
> +
> +    switch (config->object_type) {
> +        case AAC_OBJECT_TYPE_MPEG2_AAC_LC:
> +            aot = AOT_AAC_LC;
> +            break;
> +        case AAC_OBJECT_TYPE_MPEG4_AAC_LC:
> +            aot = AOT_AAC_LC;
> +            break;
> +        case AAC_OBJECT_TYPE_MPEG4_AAC_LTP:
> +            aot = AOT_AAC_LTP;
> +            break;
> +        case AAC_OBJECT_TYPE_MPEG4_AAC_SCA:
> +            aot = AOT_AAC_SCAL;
> +            break;
> +        default:
> +            pa_log_error("Invalid AAC object type");
> +            pa_assert_not_reached();
> +    }
> +
> +    switch (AAC_GET_FREQUENCY(*config)) {
> +        case AAC_SAMPLING_FREQ_8000:
> +            sample_rate = 8000;
> +            sample_spec->rate = 8000;
> +            break;
> +        case AAC_SAMPLING_FREQ_11025:
> +            sample_rate = 11025;
> +            sample_spec->rate = 11025;
> +            break;
> +        case AAC_SAMPLING_FREQ_12000:
> +            sample_rate = 12000;
> +            sample_spec->rate = 12000;
> +            break;
> +        case AAC_SAMPLING_FREQ_16000:
> +            sample_rate = 16000;
> +            sample_spec->rate = 16000;
> +            break;
> +        case AAC_SAMPLING_FREQ_22050:
> +            sample_rate = 22050;
> +            sample_spec->rate = 22050;
> +            break;
> +        case AAC_SAMPLING_FREQ_24000:
> +            sample_rate = 24000;
> +            sample_spec->rate = 24000;
> +            break;
> +        case AAC_SAMPLING_FREQ_32000:
> +            sample_rate = 32000;
> +            sample_spec->rate = 32000;
> +            break;
> +        case AAC_SAMPLING_FREQ_44100:
> +            sample_rate = 44100;
> +            sample_spec->rate = 44100;
> +            break;
> +        case AAC_SAMPLING_FREQ_48000:
> +            sample_rate = 48000;
> +            sample_spec->rate = 48000;
> +            break;
> +        case AAC_SAMPLING_FREQ_64000:
> +            sample_rate = 64000;
> +            sample_spec->rate = 64000;
> +            break;
> +        case AAC_SAMPLING_FREQ_88200:
> +            sample_rate = 88200;
> +            sample_spec->rate = 88200;
> +            break;
> +        case AAC_SAMPLING_FREQ_96000:
> +            sample_rate = 96000;
> +            sample_spec->rate = 96000;
> +            break;
> +        default:
> +            pa_log_error("Invalid AAC frequency");
> +            pa_assert_not_reached();
> +    }
> +
> +    switch (config->channels) {
> +        case AAC_CHANNELS_1:
> +            channels = MODE_1;
> +            sample_spec->channels = 1;
> +            break;
> +        case AAC_CHANNELS_2:
> +            channels = MODE_2;
> +            sample_spec->channels = 2;
> +            break;
> +        default:
> +            pa_log_error("Invalid AAC channel mode");
> +            pa_assert_not_reached();
> +    }
> +
> +    aac_info->sample_spec = *sample_spec;
> +
> +    /* AAC SINK */
> +    if (aac_info->is_a2dp_sink) {
> +        if (!aac_info->aacdecoder_handle_opened) {
> +            aac_info->aacdecoder_handle = aacDecoder_Open(TT_MP4_LATM_MCP1, 1);
> +            aac_info->aacdecoder_handle_opened = true;
> +        }
> +
> +        pa_assert_se(AAC_DEC_OK == aacDecoder_SetParam(aac_info->aacdecoder_handle, AAC_PCM_MIN_OUTPUT_CHANNELS,
> +                                                       sample_spec->channels));
> +        pa_assert_se(AAC_DEC_OK == aacDecoder_SetParam(aac_info->aacdecoder_handle, AAC_PCM_MAX_OUTPUT_CHANNELS,
> +                                                       sample_spec->channels));
> +
> +        return;
> +    }
> +
> +
> +    /* AAC SOURCE */
> +
> +    if (!aac_info->aacenc_handle_opened) {
> +        aac_err = aacEncOpen(&aac_info->aacenc_handle, 0, 2);
> +
> +        if (aac_err != AACENC_OK) {
> +            pa_log_error("Cannot open AAC encoder handle: AAC error 0x%x", aac_err);
> +            pa_assert_not_reached();
> +        }
> +        aac_info->aacenc_handle_opened = true;
> +    }
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_AOT, aot);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_SAMPLERATE, sample_rate);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_CHANNELMODE, channels);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    if (config->vbr) {
> +        aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_BITRATEMODE,
> +                                      (UINT) aac_info->aac_enc_bitrate_mode);
> +        if (aac_err != AACENC_OK)
> +            pa_assert_not_reached();
> +    }
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_AUDIOMUXVER, 2);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_SIGNALING_MODE, 1);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_BITRATE, aac_info->bitrate);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_TRANSMUX, TT_MP4_LATM_MCP1);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_HEADER_PERIOD, 1);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_AFTERBURNER, aac_info->aac_afterburner);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncEncode(aac_info->aacenc_handle, NULL, NULL, NULL, NULL);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    pa_assert_se(AACENC_OK == aacEncInfo(aac_info->aacenc_handle, &aac_info->aacenc_info));
> +
> +    pa_assert(aac_info->aacenc_info.inputChannels == aac_info->sample_spec.channels);
> +
> +};
> +
> +static void pa_aac_get_read_block_size(size_t read_link_mtu, size_t *read_block_size, void **codec_data) {
> +    aac_info_t *aac_info = *codec_data;
> +    pa_assert(aac_info);
> +
> +    aac_info->mtu = read_link_mtu;
> +
> +    /* aacEncoder.pdf Section 3.2.1
> +     * AAC-LC audio frame contains 1024 PCM samples per channel */
> +    *read_block_size = 1024 * pa_frame_size(&aac_info->sample_spec);
> +    aac_info->read_block_size = *read_block_size;
> +};
> +
> +static void pa_aac_get_write_block_size(size_t write_link_mtu, size_t *write_block_size, void **codec_data) {
> +    aac_info_t *aac_info = *codec_data;
> +    pa_assert(aac_info);
> +
> +    aac_info->mtu = write_link_mtu;
> +
> +    /* aacEncoder.pdf section 3.2.1
> +     * AAC-LC audio frame contains 1024 PCM samples per channel */
> +    *write_block_size = 1024 * pa_frame_size(&aac_info->sample_spec);
> +    aac_info->write_block_size = *write_block_size;
> +};
> +
> +static void pa_aac_setup_stream(void **codec_data) {
> +    AACENC_ERROR aac_err;
> +    aac_info_t *aac_info = *codec_data;
> +    uint32_t max_bitrate;
> +    pa_assert(aac_info);
> +
> +    max_bitrate = (uint32_t) ((8 * (aac_info->mtu - sizeof(struct rtp_header)) * aac_info->sample_spec.rate) / 1024);
> +
> +    aac_info->bitrate = PA_MIN(max_bitrate, aac_info->bitrate);
> +
> +    pa_log_debug("Maximum AAC transmission bitrate: %d bps; Bitrate in use: %d bps", max_bitrate, aac_info->bitrate);
> +
> +    /* AAC SINK */
> +    if (aac_info->is_a2dp_sink) {
> +        return;
> +    }
> +
> +
> +    /* AAC SOURCE */
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_BITRATE, aac_info->bitrate);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +    aac_err = aacEncoder_SetParam(aac_info->aacenc_handle, AACENC_PEAK_BITRATE, (UINT) max_bitrate);
> +    if (aac_err != AACENC_OK)
> +        pa_assert_not_reached();
> +
> +};
> +
> +static void pa_aac_free(void **codec_data) {
> +    aac_info_t *aac_info = *codec_data;
> +    if (!aac_info)
> +        return;
> +
> +    if (aac_info->aacenc_handle_opened)
> +        aacEncClose(&aac_info->aacenc_handle);
> +
> +    if (aac_info->aacdecoder_handle_opened)
> +        aacDecoder_Close(aac_info->aacdecoder_handle);
> +
> +    pa_xfree(aac_info);
> +    *codec_data = NULL;
> +
> +};
> +
> +static size_t pa_aac_get_capabilities(void **_capabilities) {
> +    a2dp_aac_t *capabilities = pa_xmalloc0(sizeof(a2dp_aac_t));
> +
> +    capabilities->object_type = AAC_OBJECT_TYPE_MPEG2_AAC_LC | AAC_OBJECT_TYPE_MPEG4_AAC_LC;
> +    capabilities->channels = AAC_CHANNELS_1 | AAC_CHANNELS_2;
> +    AAC_SET_BITRATE(*capabilities, AAC_DEFAULT_BITRATE);
> +    AAC_SET_FREQUENCY(*capabilities, (AAC_SAMPLING_FREQ_8000 | AAC_SAMPLING_FREQ_11025 | AAC_SAMPLING_FREQ_12000 |
> +                                      AAC_SAMPLING_FREQ_16000 | AAC_SAMPLING_FREQ_22050 | AAC_SAMPLING_FREQ_24000 |
> +                                      AAC_SAMPLING_FREQ_32000 | AAC_SAMPLING_FREQ_44100 | AAC_SAMPLING_FREQ_48000 |
> +                                      AAC_SAMPLING_FREQ_64000 | AAC_SAMPLING_FREQ_88200 | AAC_SAMPLING_FREQ_96000));
> +    capabilities->vbr = 1;
> +    *_capabilities = capabilities;
> +
> +    return sizeof(*capabilities);
> +};
> +
> +static size_t
> +pa_aac_select_configuration(const pa_sample_spec default_sample_spec, const uint8_t *supported_capabilities,
> +                            const size_t capabilities_size, void **configuration) {
> +    a2dp_aac_t *cap = (a2dp_aac_t *) supported_capabilities;
> +    a2dp_aac_t *config = pa_xmalloc0(sizeof(a2dp_aac_t));
> +    pa_a2dp_freq_cap_t aac_freq_cap, aac_freq_table[] = {
> +            {8000U,  AAC_SAMPLING_FREQ_8000},
> +            {11025U, AAC_SAMPLING_FREQ_11025},
> +            {12000U, AAC_SAMPLING_FREQ_12000},
> +            {16000U, AAC_SAMPLING_FREQ_16000},
> +            {22050U, AAC_SAMPLING_FREQ_22050},
> +            {24000U, AAC_SAMPLING_FREQ_24000},
> +            {32000U, AAC_SAMPLING_FREQ_32000},
> +            {44100U, AAC_SAMPLING_FREQ_44100},
> +            {48000U, AAC_SAMPLING_FREQ_48000},
> +            {64000U, AAC_SAMPLING_FREQ_64000},
> +            {88200U, AAC_SAMPLING_FREQ_88200},
> +            {96000U, AAC_SAMPLING_FREQ_96000}
> +    };
> +
> +    if (capabilities_size != sizeof(a2dp_aac_t))
> +        return 0;
> +
> +    if (!pa_a2dp_select_cap_frequency(AAC_GET_FREQUENCY(*cap), default_sample_spec, aac_freq_table,
> +                                      PA_ELEMENTSOF(aac_freq_table), &aac_freq_cap))
> +        return 0;
> +
> +    AAC_SET_FREQUENCY(*config, aac_freq_cap.cap);
> +
> +    AAC_SET_BITRATE(*config, AAC_GET_BITRATE(*cap));
> +
> +    if (default_sample_spec.channels <= 1) {
> +        if (cap->channels & AAC_CHANNELS_1)
> +            config->channels = AAC_CHANNELS_1;
> +        else if (cap->channels & AAC_CHANNELS_2)
> +            config->channels = AAC_CHANNELS_2;
> +        else {
> +            pa_log_error("No supported channel modes");
> +            return 0;
> +        }
> +    }
> +
> +    if (default_sample_spec.channels >= 2) {
> +        if (cap->channels & AAC_CHANNELS_2)
> +            config->channels = AAC_CHANNELS_2;
> +        else if (cap->channels & AAC_CHANNELS_1)
> +            config->channels = AAC_CHANNELS_1;
> +        else {
> +            pa_log_error("No supported channel modes");
> +            return 0;
> +        }
> +    }
> +
> +    if (cap->object_type & AAC_OBJECT_TYPE_MPEG4_AAC_LC)
> +        config->object_type = AAC_OBJECT_TYPE_MPEG4_AAC_LC;
> +    else if (cap->object_type & AAC_OBJECT_TYPE_MPEG2_AAC_LC)
> +        config->object_type = AAC_OBJECT_TYPE_MPEG2_AAC_LC;
> +    else {
> +        pa_log_error("No supported aac object type");
> +        return 0;
> +    }
> +
> +    config->vbr = cap->vbr;
> +
> +    *configuration = config;
> +    return sizeof(*config);
> +};
> +
> +static void pa_aac_free_capabilities(void **capabilities) {
> +    if (!capabilities || !*capabilities)
> +        return;
> +    pa_xfree(*capabilities);
> +    *capabilities = NULL;
> +}
> +
> +static bool pa_aac_validate_configuration(const uint8_t *selected_configuration, const size_t configuration_size) {
> +    a2dp_aac_t *c = (a2dp_aac_t *) selected_configuration;
> +
> +    if (configuration_size != sizeof(a2dp_aac_t)) {
> +        pa_log_error("AAC configuration array of invalid size");
> +        return false;
> +    }
> +
> +    switch (c->object_type) {
> +        case AAC_OBJECT_TYPE_MPEG2_AAC_LC:
> +        case AAC_OBJECT_TYPE_MPEG4_AAC_LC:
> +            break;
> +        default:
> +            pa_log_error("Invalid object type in AAC configuration");
> +            return false;
> +    }
> +
> +    switch (AAC_GET_FREQUENCY(*c)) {
> +        case AAC_SAMPLING_FREQ_8000:
> +        case AAC_SAMPLING_FREQ_11025:
> +        case AAC_SAMPLING_FREQ_12000:
> +        case AAC_SAMPLING_FREQ_16000:
> +        case AAC_SAMPLING_FREQ_22050:
> +        case AAC_SAMPLING_FREQ_24000:
> +        case AAC_SAMPLING_FREQ_32000:
> +        case AAC_SAMPLING_FREQ_44100:
> +        case AAC_SAMPLING_FREQ_48000:
> +        case AAC_SAMPLING_FREQ_64000:
> +        case AAC_SAMPLING_FREQ_88200:
> +        case AAC_SAMPLING_FREQ_96000:
> +            break;
> +        default:
> +            pa_log_error("Invalid sampling frequency in AAC configuration");
> +            return false;
> +    }
> +
> +    switch (c->channels) {
> +        case AAC_CHANNELS_1:
> +        case AAC_CHANNELS_2:
> +            break;
> +        default:
> +            pa_log_error("Invalid channel mode in AAC Configuration");
> +            return false;
> +    }
> +
> +    return true;
> +};
> +
> +
> +static pa_a2dp_source_t pa_aac_source = {
> +        .encoder_load = pa_aac_encoder_load,
> +        .init = pa_aac_encoder_init,
> +        .update_user_config = pa_aac_update_user_config,
> +        .encode = pa_aac_encode,
> +        .config_transport=pa_aac_config_transport,
> +        .get_block_size=pa_aac_get_write_block_size,
> +        .setup_stream = pa_aac_setup_stream,
> +        .set_tx_length = NULL,
> +        .decrease_quality = NULL,
> +        .free = pa_aac_free
> +};
> +
> +static pa_a2dp_sink_t pa_aac_sink = {
> +        .decoder_load = pa_aac_decoder_load,
> +        .init = pa_aac_decoder_init,
> +        .update_user_config = NULL,
> +        .config_transport=pa_aac_config_transport,
> +        .get_block_size=pa_aac_get_read_block_size,
> +        .setup_stream = pa_aac_setup_stream,
> +        .decode = pa_aac_decode,
> +        .free = pa_aac_free
> +};
> +
> +const pa_a2dp_codec_t pa_a2dp_aac = {
> +        .name = "AAC",
> +        .codec = A2DP_CODEC_MPEG24,
> +        .vendor_codec = NULL,
> +        .a2dp_sink = &pa_aac_sink,
> +        .a2dp_source = &pa_aac_source,
> +        .get_capabilities = pa_aac_get_capabilities,
> +        .select_configuration = pa_aac_select_configuration,
> +        .free_capabilities = pa_aac_free_capabilities,
> +        .free_configuration = pa_aac_free_capabilities,
> +        .validate_configuration = pa_aac_validate_configuration
> +};
> diff --git a/src/modules/bluetooth/a2dp/a2dp_util.c b/src/modules/bluetooth/a2dp/a2dp_util.c
> index cc9382f2e..edd28b5cc 100644
> --- a/src/modules/bluetooth/a2dp/a2dp_util.c
> +++ b/src/modules/bluetooth/a2dp/a2dp_util.c
> @@ -30,6 +30,9 @@
>  #define A2DP_SBC_SRC_ENDPOINT A2DP_SOURCE_ENDPOINT "/SBC"
>  #define A2DP_SBC_SNK_ENDPOINT A2DP_SINK_ENDPOINT "/SBC"
>
> +#define A2DP_AAC_SRC_ENDPOINT A2DP_SOURCE_ENDPOINT "/AAC"
> +#define A2DP_AAC_SNK_ENDPOINT A2DP_SINK_ENDPOINT "/AAC"
> +
>  #define A2DP_VENDOR_SRC_ENDPOINT A2DP_SOURCE_ENDPOINT "/VENDOR"
>  #define A2DP_VENDOR_SNK_ENDPOINT A2DP_SINK_ENDPOINT "/VENDOR"
>
> @@ -209,6 +212,14 @@ void pa_a2dp_codec_index_to_endpoint(pa_a2dp_codec_index_t codec_index, const ch
>          case PA_A2DP_SOURCE_SBC:
>              *endpoint = A2DP_SBC_SRC_ENDPOINT;
>              break;
> +#ifdef HAVE_FDK_AAC
> +        case PA_A2DP_SINK_AAC:
> +            *endpoint = A2DP_AAC_SNK_ENDPOINT;
> +            break;
> +        case PA_A2DP_SOURCE_AAC:
> +            *endpoint = A2DP_AAC_SRC_ENDPOINT;
> +            break;
> +#endif
>          default:
>              *endpoint = NULL;
>      }
> @@ -219,6 +230,12 @@ void pa_a2dp_endpoint_to_codec_index(const char *endpoint, pa_a2dp_codec_index_t
>          *codec_index = PA_A2DP_SINK_SBC;
>      else if (streq(endpoint, A2DP_SBC_SRC_ENDPOINT))
>          *codec_index = PA_A2DP_SOURCE_SBC;
> +#ifdef HAVE_FDK_AAC
> +    else if (streq(endpoint, A2DP_AAC_SNK_ENDPOINT))
> +        *codec_index = PA_A2DP_SINK_AAC;
> +    else if (streq(endpoint, A2DP_AAC_SRC_ENDPOINT))
> +        *codec_index = PA_A2DP_SOURCE_AAC;
> +#endif
>      else
>          *codec_index = PA_A2DP_CODEC_INDEX_UNAVAILABLE;
>  };
> @@ -229,6 +246,12 @@ void pa_a2dp_codec_index_to_a2dp_codec(pa_a2dp_codec_index_t codec_index, const
>          case PA_A2DP_SOURCE_SBC:
>              *a2dp_codec = &pa_a2dp_sbc;
>              break;
> +#ifdef HAVE_FDK_AAC
> +        case PA_A2DP_SINK_AAC:
> +        case PA_A2DP_SOURCE_AAC:
> +            *a2dp_codec = &pa_a2dp_aac;
> +            break;
> +#endif
>          default:
>              *a2dp_codec = NULL;
>      }
> @@ -244,6 +267,11 @@ void pa_a2dp_a2dp_codec_to_codec_index(const pa_a2dp_codec_t *a2dp_codec, bool i
>          case A2DP_CODEC_SBC:
>              *codec_index = is_a2dp_sink ? PA_A2DP_SINK_SBC : PA_A2DP_SOURCE_SBC;
>              return;
> +#ifdef HAVE_FDK_AAC
> +        case A2DP_CODEC_MPEG24:
> +            *codec_index = is_a2dp_sink ? PA_A2DP_SINK_AAC : PA_A2DP_SOURCE_AAC;
> +            return;
> +#endif
>          case A2DP_CODEC_VENDOR:
>              if (!a2dp_codec->vendor_codec) {
>                  *codec_index = PA_A2DP_CODEC_INDEX_UNAVAILABLE;
> @@ -262,6 +290,11 @@ pa_a2dp_get_a2dp_codec(uint8_t codec, const a2dp_vendor_codec_t *vendor_codec, c
>          case A2DP_CODEC_SBC:
>              *a2dp_codec = &pa_a2dp_sbc;
>              return;
> +#ifdef HAVE_FDK_AAC
> +        case A2DP_CODEC_MPEG24:
> +            *a2dp_codec = &pa_a2dp_aac;
> +            return;
> +#endif
>          case A2DP_CODEC_VENDOR:
>              if (!vendor_codec) {
>                  *a2dp_codec = NULL;
> --

Im little worried about the maintainance of a2dp_util.c if we keedp
the practice of #ifsef every codec, imo it would be much cleaner if we
just have a mechanism to register the codecs, maybe we load them as
separate plugins which then call a2dp_util.c to register their
'drivers', the plugin can check if the bluetooth plugin is loaded in
order to register itself, doing that way we can also pass the
parameter via default.pa.

-- 
Luiz Augusto von Dentz
_______________________________________________
pulseaudio-discuss mailing list
pulseaudio-discuss@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss




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

  Powered by Linux