Commit: 1944dc968f191d8233f71cf02f640bd57ba4cf8f - system-bt (git)

system/bt

Commit MetaInfo

• Revision: 1944dc968f191d8233f71cf02f640bd57ba4cf8f (tree)
• Zeit: 2016-09-28 19:20:11
• Autor: Linux Build Service Account <lnxbuild@loca...>
• Commiter: Linux Build Service Account

Log Message

Promotion of bt.lnx.2.1-00015.

CRs Change ID Subject

---

1050999 Idf8e2bebdc2ca7621aef06dd5f2075ef2c5fa08c Bluetooth: Set alarm's queue to NULL on alarm expired
1070444 Ie5b8b89b5d499e999167ad599fa587cea5dde2e7 GAP: Host sending two sdp req during legacy pairing
1063748 1069656 Iba694e2547abc8e6161997cd136064fe3a411abc aptXHD codec support
1069198 I4a2e429484378d23c996caffb6495407793548d2 SDP: Crash in sdp due to invalid length

Change-Id: I2d4755c678374e1233d3663262894780b25f3340
CRs-Fixed: 1069656, 1050999, 1070444, 1063748, 1069198

Ändern Zusammenfassung

• modified: audio_a2dp_hw/audio_a2dp_hw.c
• modified: audio_a2dp_hw/bthost_ipc.c
• modified: audio_a2dp_hw/bthost_ipc.h
• modified: bta/Android.mk
• modified: bta/av/bta_av_aact.c
• modified: bta/av/bta_av_int.h
• modified: bta/av/bta_av_main.c
• modified: bta/include/bta_av_api.h
• modified: bta/include/bta_av_co.h
• modified: btif/Android.mk
• modified: btif/co/bta_av_co.c
• modified: btif/include/btif_av.h
• modified: btif/include/btif_av_co.h
• modified: btif/include/btif_media.h
• modified: btif/src/btif_av.c
• modified: btif/src/btif_media_task.c
• modified: btif/src/btif_rc.c
• modified: embdrv/sbc/encoder/include/sbc_encoder.h
• modified: include/bt_target.h
• modified: main/Android.mk
• modified: osi/src/alarm.c
• modified: stack/Android.mk
• modified: stack/a2dp/a2d_aptx.c
• add: stack/a2dp/a2d_aptx_hd.c
• modified: stack/avdt/avdt_scb_act.c
• modified: stack/include/a2d_api.h
• modified: stack/include/a2d_aptx.h
• add: stack/include/a2d_aptx_hd.h
• modified: stack/l2cap/l2c_csm.c
• modified: stack/sdp/sdp_discovery.c

Diff

--- a/audio_a2dp_hw/audio_a2dp_hw.c
+++ b/audio_a2dp_hw/audio_a2dp_hw.c
@@ -172,11 +172,12 @@ static const char* dump_a2dp_ctrl_event(char event)
 static int calc_audiotime(struct a2dp_config cfg, int bytes)
 {
     int chan_count = popcount(cfg.channel_flags);
+    int bytes_per_sample = 4;
 
-    ASSERTC(cfg.format == AUDIO_FORMAT_PCM_16_BIT,
+    ASSERTC(cfg.format == AUDIO_FORMAT_PCM_8_24_BIT,
             "unsupported sample sz", cfg.format);
 
-    return bytes*(1000000/(chan_count*2))/cfg.rate;
+    return (int)(((int64_t)bytes * (1000000 / (chan_count * bytes_per_sample))) / cfg.rate);
 }
 
 static void ts_error_log(char *tag, int val, int buff_size, struct a2dp_config cfg)
@@ -1382,7 +1383,7 @@ static int adev_open_output_stream(struct audio_hw_device *dev,
     a2dp_stream_common_init(&out->common);
 #endif
     out->common.cfg.channel_flags = AUDIO_STREAM_DEFAULT_CHANNEL_FLAG;
-    out->common.cfg.format = AUDIO_STREAM_DEFAULT_FORMAT;
+    out->common.cfg.format = AUDIO_FORMAT_PCM_8_24_BIT;
     out->common.cfg.rate = AUDIO_STREAM_DEFAULT_RATE;
 
    /* set output config values */

--- a/audio_a2dp_hw/bthost_ipc.c
+++ b/audio_a2dp_hw/bthost_ipc.c
@@ -49,7 +49,9 @@
 #include "osi/include/osi.h"
 #include "osi/include/socket_utils/sockets.h"
 
-
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
 #define LOG_TAG "bthost_ipc"
 #include "osi/include/log.h"
 
@@ -720,7 +722,6 @@ int a2dp_read_codec_config(struct a2dp_stream_common *common,uint8_t idx)
 int a2dp_get_multicast_status(struct a2dp_stream_common *common, uint8_t *mcast_status,
                                uint8_t *num_dev)
 {
-    char cmd = A2DP_CTRL_GET_MULTICAST_STATUS;
     INFO("%s",__func__);
     if (a2dp_command(common,A2DP_CTRL_GET_MULTICAST_STATUS) < 0)
     {
@@ -977,7 +978,7 @@ int audio_start_stream()
             INFO("control path is disconnected");
             break;
         }
-        INFO("%s: a2dp stream not started,wait 100mse & retry");
+        INFO("%s: a2dp stream not started,wait 100mse & retry", __func__);
         usleep(100000);
     }
     if (audio_stream.state != AUDIO_A2DP_STATE_STARTED)
@@ -1067,9 +1068,6 @@ void clear_a2dpsuspend_flag()
 void * audio_get_codec_config(uint8_t *multicast_status, uint8_t *num_dev,
                               audio_format_t *codec_type)
 {
-    char *p_common_cfg = &audio_stream.codec_cfg[0];
-    int i;
-
     INFO("%s: state = %s",__func__,dump_a2dp_hal_state(audio_stream.state));
 
     a2dp_get_multicast_status(&audio_stream, multicast_status,num_dev);

--- a/audio_a2dp_hw/bthost_ipc.h
+++ b/audio_a2dp_hw/bthost_ipc.h
@@ -154,7 +154,7 @@ typedef struct {
     int (*a2dp_read_audio_config)(struct a2dp_stream_common *common);
     int (*skt_read)(int fd,void *buf, size_t bytes);
     int (*skt_write)(int fd,const void *buf, size_t bytes);
-    void (*skt_disconnect)(int fd);
+    int (*skt_disconnect)(int fd);
     int (*a2dp_command)(struct a2dp_stream_common *common,char cmd);
     int (*audio_stream_open)(void);
     int (*audio_stream_close)(void);

--- a/bta/Android.mk
+++ b/bta/Android.mk
@@ -96,7 +96,6 @@ LOCAL_C_INCLUDES+= . \
                    $(LOCAL_PATH)/../udrv/include \
                    $(LOCAL_PATH)/../vnd/include \
                    $(LOCAL_PATH)/../utils/include \
-                   $(TARGET_OUT_HEADERS)/bt/hci_qcomm_init/aptX \
                    $(bluetooth_C_INCLUDES)
 
 LOCAL_CFLAGS += $(bluetooth_CFLAGS) -DBUILDCFG

--- a/bta/av/bta_av_aact.c
+++ b/bta/av/bta_av_aact.c
@@ -38,6 +38,8 @@
 #include "avdt_api.h"
 #include "bta_av_int.h"
 #include "bt_utils.h"
+#include "a2d_aptx.h"
+#include "a2d_aptx_hd.h"
 #include "l2cdefs.h"
 #include "l2c_api.h"
 #include "osi/include/properties.h"
@@ -266,20 +268,31 @@ tAVDT_CTRL_CBACK * const bta_av_dt_cback[] =
 static UINT8 bta_av_get_scb_handle(tBTA_AV_SCB *p_scb, UINT8 local_sep)
 {
     UINT8 xx =0;
-    const int NON_A2DP = 0xFF;
     for (xx = 0; xx<BTA_AV_MAX_SEPS; xx++)
     {
         if ((p_scb->seps[xx].tsep == local_sep) &&
             (p_scb->seps[xx].codec_type == p_scb->codec_type))
         {
-            if (p_scb->seps[xx].codec_type != NON_A2DP)
+            if (p_scb->seps[xx].codec_type != A2D_NON_A2DP_MEDIA_CT)
                 return (p_scb->seps[xx].av_handle);
             else {
-                UINT8 vendorId = p_scb->cfg.codec_info[BTA_AV_VENDOR_ID_TYPE_IDX];
-                UINT8 codecId = p_scb->cfg.codec_info[BTA_AV_CODEC_ID_TYPE_IDX];
-
-                if (codecId == p_scb->seps[xx].codecId && vendorId == p_scb->seps[xx].vendorId)
-                   return (p_scb->seps[xx].av_handle);
+                UINT8 losc = p_scb->cfg.codec_info[0];
+                if (losc == A2D_APTX_CODEC_LEN)
+                {
+                    tA2D_APTX_CIE aptx_config;
+                    if (A2D_ParsAptxInfo(&aptx_config, p_scb->cfg.codec_info, FALSE) == A2D_SUCCESS)
+                        if ((aptx_config.codecId == p_scb->seps[xx].codecId) &&
+                            (aptx_config.vendorId == p_scb->seps[xx].vendorId))
+                           return (p_scb->seps[xx].av_handle);
+                } else if (losc == A2D_APTX_HD_CODEC_LEN)
+                {
+                    tA2D_APTX_HD_CIE aptx_config;
+                    if (A2D_ParsAptx_hdInfo(&aptx_config, p_scb->cfg.codec_info, FALSE) == A2D_SUCCESS)
+                        if ((aptx_config.codecId == p_scb->seps[xx].codecId) &&
+                            (aptx_config.vendorId == p_scb->seps[xx].vendorId))
+                           return (p_scb->seps[xx].av_handle);
+                } else
+                    APPL_TRACE_DEBUG("%s: Invalid aptX Losc", __func__)
             }
         }
     }
@@ -784,7 +797,6 @@ static void bta_av_a2d_sdp_cback(BOOLEAN found, tA2D_Service *p_service)
 static void bta_av_adjust_seps_idx(tBTA_AV_SCB *p_scb, UINT8 avdt_handle)
 {
     int xx;
-    const int NON_A2DP = 0xFF;
     APPL_TRACE_DEBUG("bta_av_adjust_seps_idx codec_type: %d", p_scb->codec_type);
     for(xx=0; xx<BTA_AV_MAX_SEPS; xx++)
     {
@@ -793,26 +805,46 @@ static void bta_av_adjust_seps_idx(tBTA_AV_SCB *p_scb, UINT8 avdt_handle)
         if((p_scb->seps[xx].av_handle && p_scb->codec_type == p_scb->seps[xx].codec_type)
             && (p_scb->seps[xx].av_handle == avdt_handle))
         {
-            if (p_scb->seps[xx].codec_type != NON_A2DP)
+            if (p_scb->seps[xx].codec_type != A2D_NON_A2DP_MEDIA_CT)
             {
                 p_scb->sep_idx      = xx;
                 p_scb->avdt_handle  = p_scb->seps[xx].av_handle;
                 break;
             }
             else {
-                UINT8 vendorId = p_scb->cfg.codec_info[BTA_AV_VENDOR_ID_TYPE_IDX];
-                UINT8 codecId = p_scb->cfg.codec_info[BTA_AV_CODEC_ID_TYPE_IDX];
-                APPL_TRACE_DEBUG("%s vendorId: %x codecId: %x", __func__, p_scb->seps[xx].vendorId, p_scb->seps[xx].codecId);
-                if (codecId == p_scb->seps[xx].codecId && vendorId == p_scb->seps[xx].vendorId)
+                UINT8 losc = p_scb->cfg.codec_info[0];
+                if (losc == A2D_APTX_CODEC_LEN)
                 {
-                    APPL_TRACE_DEBUG("%s p_scb->sep_idx: %d", __func__, p_scb->sep_idx);
-                    APPL_TRACE_DEBUG("%s vendorID: %x  codecID: %x", __func__, vendorId, codecId);
-                    p_scb->sep_idx = xx;
-                    p_scb->avdt_handle = p_scb->seps[xx].av_handle;
-                    APPL_TRACE_DEBUG("%s p_scb->sep_idx: %d", __func__, p_scb->sep_idx);
-                    APPL_TRACE_DEBUG("%s p_scb->avdt_handle: %d", __func__, p_scb->avdt_handle);
-                    break;
-                }
+                    tA2D_APTX_CIE aptx_config;
+                    if (A2D_ParsAptxInfo(&aptx_config, p_scb->cfg.codec_info, FALSE) == A2D_SUCCESS) {
+                        APPL_TRACE_DEBUG("%s vendorId: %x codecId: %x", __func__, p_scb->seps[xx].vendorId, p_scb->seps[xx].codecId);
+                        if ((aptx_config.codecId == p_scb->seps[xx].codecId) &&
+                            (aptx_config.vendorId == p_scb->seps[xx].vendorId)) {
+                            APPL_TRACE_DEBUG("%s p_scb->sep_idx: %d", __func__, p_scb->sep_idx);
+                            p_scb->sep_idx = xx;
+                            p_scb->avdt_handle = p_scb->seps[xx].av_handle;
+                            APPL_TRACE_DEBUG("%s p_scb->sep_idx: %d", __func__, p_scb->sep_idx);
+                            APPL_TRACE_DEBUG("%s p_scb->avdt_handle: %d", __func__, p_scb->avdt_handle);
+                            break;
+                        }
+                    }
+                } else if (losc == A2D_APTX_HD_CODEC_LEN)
+                {
+                    tA2D_APTX_HD_CIE aptx_config;
+                    if (A2D_ParsAptx_hdInfo(&aptx_config, p_scb->cfg.codec_info, FALSE) == A2D_SUCCESS) {
+                        APPL_TRACE_DEBUG("%s vendorId: %x codecId: %x", __func__, p_scb->seps[xx].vendorId, p_scb->seps[xx].codecId);
+                        if ((aptx_config.codecId == p_scb->seps[xx].codecId) &&
+                            (aptx_config.vendorId == p_scb->seps[xx].vendorId)) {
+                            APPL_TRACE_DEBUG("%s p_scb->sep_idx: %d", __func__, p_scb->sep_idx);
+                            p_scb->sep_idx = xx;
+                            p_scb->avdt_handle = p_scb->seps[xx].av_handle;
+                            APPL_TRACE_DEBUG("%s p_scb->sep_idx: %d", __func__, p_scb->sep_idx);
+                            APPL_TRACE_DEBUG("%s p_scb->avdt_handle: %d", __func__, p_scb->avdt_handle);
+                            break;
+                        }
+                    }
+                } else
+                    APPL_TRACE_DEBUG("%s: Invalid aptX Losc", __func__)
             }
         }
     }
@@ -1572,14 +1604,14 @@ void bta_av_str_opened (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data)
 }
 /*******************************************************************************
 **
-** Function         bta_av_co_audio_get_codec_type
+** Function         bta_av_get_codec_type
 **
-** Description      Gets the p_scb->codec_type
+** Description      Returns the codec_type from the most recently used scb
 **
 ** Returns          bta_av_cb.codec_type
 **
 *******************************************************************************/
-UINT8 bta_av_co_audio_get_codec_type()
+UINT8 bta_av_get_codec_type()
 {
     APPL_TRACE_DEBUG("%s [bta_av_cb.codec_type] %x", __func__, bta_av_cb.codec_type);
     return bta_av_cb.codec_type;

--- a/bta/av/bta_av_int.h
+++ b/bta/av/bta_av_int.h
@@ -422,8 +422,8 @@ typedef struct
     tBTA_AV_CODEC       codec_type;        /* codec type */
     UINT8               tsep;              /* SEP type of local SEP */
     tBTA_AV_DATA_CBACK  *p_app_data_cback; /* Application callback for media packets */
-    UINT8               vendorId;          /* vendorId type */
-    UINT8               codecId;           /* codecId type */
+    UINT32              vendorId;          /* vendorId type */
+    UINT16              codecId;           /* codecId type */
 } tBTA_AV_SEP;
 
 

--- a/bta/av/bta_av_main.c
+++ b/bta/av/bta_av_main.c
@@ -34,6 +34,7 @@
 
 #include "bt_target.h"
 #include "osi/include/log.h"
+#include <cutils/properties.h>
 
 #if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE)
 #include "bta_av_co.h"
@@ -48,6 +49,7 @@
 #endif
 
 #include "a2d_aptx.h"
+#include "a2d_aptx_hd.h"
 
 /*****************************************************************************
 ** Constants and types
@@ -693,16 +695,15 @@ static void bta_av_api_register(tBTA_AV_DATA *p_data)
                    (*bta_av_a2d_cos.init)(&codec_type, cs.cfg.codec_info,
                     &cs.cfg.num_protect, cs.cfg.protect_info, index) == TRUE)
             {
+                UINT8* ptr = cs.cfg.codec_info;
+                tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
+                UINT32 vendorId = codecInfo->vendorId;
+                UINT16 codecId = codecInfo->codecId;
+
                 if ((*bta_av_a2d_cos.offload)() ==  TRUE)
                 {
                     if(codec_type == A2D_NON_A2DP_MEDIA_CT)
                     {
-
-                       UINT8* ptr = cs.cfg.codec_info;
-                       tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[3];
-                       UINT8 vendorId = codecInfo->vendorId;
-                       UINT8 codecId = codecInfo->codecId;
-
                        if (vendorId == A2D_APTX_VENDOR_ID &&
                            codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
                        {
@@ -723,24 +724,36 @@ static void bta_av_api_register(tBTA_AV_DATA *p_data)
                             continue;
                         }
                     }
-                }
-                else if((codec_type == A2D_NON_A2DP_MEDIA_CT) && (A2D_check_and_init_aptX() == false))
-                {
-                   index++;
-                   continue;
+                } else if (codec_type == A2D_NON_A2DP_MEDIA_CT) {
+                    if ((codecId == A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID)
+                        && (A2D_check_and_init_aptX() == false)) {
+                        APPL_TRACE_WARNING("%s aptX not available ", __func__);
+                        index++;
+                        continue;
+
+                    } else {
+                        char value[PROPERTY_VALUE_MAX];
+                        bool enableAptXHD = false;
+                        if (property_get("persist.bt.enableAptXHD", value, "false") && strcmp(value, "true") == 0)
+                            enableAptXHD = true;
+                        else
+                            APPL_TRACE_WARNING("%s enableAptXHD property is not set", __func__);
+
+                        if ((codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_HD_VENDOR_ID) &&
+                            ((enableAptXHD == false) || (A2D_check_and_init_aptX_HD() == false))) {
+                             APPL_TRACE_WARNING("%s aptX-HD not available", __func__);
+                             index++;
+                             continue;
+                        }
+                    }
                 }
 
                 if(AVDT_CreateStream(&p_scb->seps[index - startIndex].av_handle, &cs) ==
                                                                             AVDT_SUCCESS)
                 {
                    if ((profile_initialized == UUID_SERVCLASS_AUDIO_SOURCE) &&
-                                        (index == BTIF_SV_AV_AA_APTX_INDEX))
+                       ((index == BTIF_SV_AV_AA_APTX_INDEX) || (index == BTIF_SV_AV_AA_APTX_HD_INDEX)))
                    {
-                       UINT8* ptr = cs.cfg.codec_info;
-                       tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[3];
-                       UINT8 vendorId = codecInfo->vendorId;
-                       UINT8 codecId = codecInfo->codecId;
-
                        p_scb->seps[index - startIndex].vendorId = vendorId;
                        p_scb->seps[index - startIndex].codecId = codecId;
                        APPL_TRACE_DEBUG("%s audio[%x] vendorId: %x codecId: %x", __func__,
@@ -854,8 +867,7 @@ void bta_av_api_deregister(tBTA_AV_DATA *p_data)
 {
     tBTA_AV_SCB *p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific);
 
-    // de-initialize aptX
-    A2D_deinit_aptX();
+    A2D_close_aptX();
 
     if(p_scb)
     {

--- a/bta/include/bta_av_api.h
+++ b/bta/include/bta_av_api.h
@@ -97,12 +97,6 @@ typedef UINT8 tBTA_AV_HNDL;
 /* offset of codec type in codec info byte array */
 #define BTA_AV_CODEC_TYPE_IDX       AVDT_CODEC_TYPE_INDEX   /* 2 */
 
-/* offset of vendorId type in vendorId info byte array */
-#define BTA_AV_VENDOR_ID_TYPE_IDX    AVDT_VENDOR_ID_TYPE_INDEX   /* 3 */
-
-/* offset of codecId type in codecId info byte array */
-#define BTA_AV_CODEC_ID_TYPE_IDX     AVDT_CODEC_ID_TYPE_INDEX   /* 7 */
-
 /* maximum number of streams created: 1 for audio, 1 for video */
 #ifndef BTA_AV_NUM_STRS
 #define BTA_AV_NUM_STRS         2
@@ -110,9 +104,9 @@ typedef UINT8 tBTA_AV_HNDL;
 
 #ifndef BTA_AV_MAX_SEPS
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
-#define BTA_AV_MAX_SEPS         3
+#define BTA_AV_MAX_SEPS         4
 #else
-#define BTA_AV_MAX_SEPS         2
+#define BTA_AV_MAX_SEPS         3
 #endif
 #endif
 
@@ -142,6 +136,9 @@ typedef UINT8 tBTA_AV_CODEC;
 /* Company ID in BT assigned numbers */
 #define BTA_AV_BT_VENDOR_ID     VDP_BT_VENDOR_ID        /* Broadcom Corporation */
 
+/* Offset for codec configuration in codec info */
+#define BTA_AV_CFG_START_IDX    3
+
 /* vendor specific codec ID */
 #define BTA_AV_CODEC_ID_H264    VDP_CODEC_ID_H264       /* Non-VDP codec ID - H.264 */
 #define BTA_AV_CODEC_ID_IMG     VDP_CODEC_ID_IMG        /* Non-VDP codec ID - images/slideshow */
@@ -896,6 +893,16 @@ void BTA_AvOffloadStart(tBTA_AV_HNDL hndl);
 *******************************************************************************/
 void BTA_AvOffloadStartRsp(tBTA_AV_HNDL hndl, tBTA_AV_STATUS status);
 
+/*******************************************************************************
+**
+** Function         bta_av_get_codec_type
+**
+** Description      Returns the codec_type from the most recently used scb
+**
+** Returns          A2D_NON_A2DP_MEDIA_CT or BTIF_AV_CODEC_SBC
+**
+*******************************************************************************/
+UINT8 bta_av_get_codec_type();
 
 #ifdef __cplusplus
 }

--- a/bta/include/bta_av_co.h
+++ b/bta/include/bta_av_co.h
@@ -63,6 +63,7 @@ enum
 {
     BTIF_SV_AV_AA_SBC_INDEX = 0,
     BTIF_SV_AV_AA_APTX_INDEX,
+    BTIF_SV_AV_AA_APTX_HD_INDEX,
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
     BTIF_SV_AV_AA_AAC_INDEX,
 #endif

--- a/btif/Android.mk
+++ b/btif/Android.mk
@@ -114,9 +114,9 @@ btifCommonIncludes := \
   $(LOCAL_PATH)/../audio_a2dp_hw \
   $(LOCAL_PATH)/../utils/include \
   $(bluetooth_C_INCLUDES) \
-  $(TARGET_OUT_HEADERS)/bt/hci_qcomm_init/aptX \
   external/tinyxml2 \
-  external/zlib
+  external/zlib \
+  $(call include-path-for, audio-utils)
 
 ifneq ($(TARGET_SUPPORTS_WEARABLES),true)
 btifCommonIncludes += \

--- a/btif/co/bta_av_co.c
+++ b/btif/co/bta_av_co.c
@@ -39,12 +39,14 @@
 
 #include "btif_media.h"
 #include "sbc_encoder.h"
+#include "btif_av.h"
 #include "btif_av_co.h"
 #include "btif_util.h"
 #include "osi/include/mutex.h"
 
 #include "bt_utils.h"
 #include "a2d_aptx.h"
+#include "a2d_aptx_hd.h"
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
 #include "a2d_aac.h"
 #include "bta_av_aac.h"
@@ -164,6 +166,31 @@ const tA2D_APTX_CIE btif_av_aptx_default_config =
     A2D_APTX_FUTURE_2
 };
 
+const tA2D_APTX_HD_CIE bta_av_co_aptx_hd_caps =
+{
+    A2D_APTX_HD_VENDOR_ID,
+    A2D_APTX_HD_CODEC_ID_BLUETOOTH,
+    A2D_APTX_HD_SAMPLERATE_44100,
+    A2D_APTX_HD_CHANNELS_STEREO,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED0,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED1,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED2,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED3
+};
+
+/* Default aptX_hd codec configuration */
+const tA2D_APTX_HD_CIE btif_av_aptx_hd_default_config =
+{
+    A2D_APTX_HD_VENDOR_ID,
+    A2D_APTX_HD_CODEC_ID_BLUETOOTH,
+    A2D_APTX_HD_SAMPLERATE_44100,
+    A2D_APTX_HD_CHANNELS_STEREO,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED0,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED1,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED2,
+    A2D_APTX_HD_ACL_SPRINT_RESERVED3
+};
+
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
 const tA2D_AAC_CIE bta_av_co_aac_caps =
 {
@@ -193,7 +220,6 @@ const tA2D_AAC_CIE btif_av_aac_default_config =
 };
 #endif
 
-
 /*****************************************************************************
 **  Local data
 *****************************************************************************/
@@ -250,6 +276,8 @@ typedef struct
     tBTIF_AV_CODEC_INFO codec_cfg_sbc_setconfig; /* remote peer setconfig preference (SBC) */
     tBTIF_AV_CODEC_INFO codec_cfg_aptx;
     tBTIF_AV_CODEC_INFO codec_cfg_aptx_setconfig; /* remote peer setconfig preference (aptX)*/
+    tBTIF_AV_CODEC_INFO codec_cfg_aptx_hd;
+    tBTIF_AV_CODEC_INFO codec_cfg_aptx_hd_setconfig; /* remote peer setconfig preference (aptX HD) */
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
     tBTIF_AV_CODEC_INFO codec_cfg_aac;
     tBTIF_AV_CODEC_INFO codec_cfg_aac_setconfig; /* remote peer setconfig preference (AAC)*/
@@ -268,7 +296,6 @@ static BOOLEAN bta_av_co_audio_peer_supports_codec(tBTA_AV_CO_PEER *p_peer, UINT
 static BOOLEAN bta_av_co_audio_media_supports_config(UINT8 codec_type, const UINT8 *p_codec_cfg);
 static BOOLEAN bta_av_co_audio_sink_supports_config(UINT8 codec_type, const UINT8 *p_codec_cfg);
 static BOOLEAN bta_av_co_audio_peer_src_supports_codec(tBTA_AV_CO_PEER *p_peer, UINT8 *p_src_index);
-extern UINT8 bta_av_co_audio_get_codec_type();
 #ifdef BTA_AV_SPLIT_A2DP_ENABLED
 extern BOOLEAN btif_av_is_codec_offload_supported(int codec);
 #else
@@ -418,6 +445,14 @@ BOOLEAN bta_av_co_audio_init(UINT8 *p_codec_type, UINT8 *p_codec_info, UINT8 *p_
         *p_codec_type = A2D_NON_A2DP_MEDIA_CT;
         A2D_BldAptxInfo(AVDT_MEDIA_AUDIO, (tA2D_APTX_CIE *) &bta_av_co_aptx_caps, p_codec_info);
         return TRUE;
+
+    case BTIF_SV_AV_AA_APTX_HD_INDEX:
+        APPL_TRACE_DEBUG("%s aptX HD", __func__);
+        /* Set up for aptX HD codec */
+        *p_codec_type = A2D_NON_A2DP_MEDIA_CT;
+        A2D_BldAptx_hdInfo(AVDT_MEDIA_AUDIO, (tA2D_APTX_HD_CIE *) &bta_av_co_aptx_hd_caps, p_codec_info);
+        return TRUE;
+
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
     case BTIF_SV_AV_AA_AAC_INDEX:
         APPL_TRACE_DEBUG("%s AAC", __func__);
@@ -739,15 +774,17 @@ UINT8 bta_av_co_audio_getconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
         break;
     case A2D_NON_A2DP_MEDIA_CT:
     {
-        UINT16 codecId = ((tA2D_APTX_CIE*)(&p_codec_info[3]))->codecId;
-        UINT32 vendorId = ((tA2D_APTX_CIE*)(&p_codec_info[3]))->vendorId;
+        UINT16 codecId = ((tA2D_APTX_CIE*)(&p_codec_info[BTA_AV_CFG_START_IDX]))->codecId;
+        UINT32 vendorId = ((tA2D_APTX_CIE*)(&p_codec_info[BTA_AV_CFG_START_IDX]))->vendorId;
         APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecId );
         APPL_TRACE_DEBUG("%s vendorId = %x", __func__, vendorId );
 
-        if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID)
-        {
+        if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID) {
             /* aptX */
             supported = TRUE;
+        } else if (codecId ==  A2D_APTX_HD_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_HD_VENDOR_ID) {
+            /*	aptX HD	*/
+            supported = TRUE;
         }
         break;
     }
@@ -777,7 +814,7 @@ UINT8 bta_av_co_audio_getconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
                 APPL_TRACE_DEBUG("%s p_codec_info[%d]: %x", __func__, i,  p_codec_info[i]);
 
             if (codec_type == A2D_NON_A2DP_MEDIA_CT)
-                memcpy(p_sink->codec_caps, &p_codec_info[3], AVDT_CODEC_SIZE);
+                memcpy(p_sink->codec_caps, &p_codec_info[BTA_AV_CFG_START_IDX], AVDT_CODEC_SIZE);
             else
                 memcpy(p_sink->codec_caps, p_codec_info, AVDT_CODEC_SIZE);
 
@@ -998,8 +1035,8 @@ void bta_av_co_audio_setconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
             {
                 UINT16 codecId;
                 UINT32 vendorId;
-                codecId = ((tA2D_APTX_CIE*)(&p_codec_info[3]))->codecId;
-                vendorId = ((tA2D_APTX_CIE*)(&p_codec_info[3]))->vendorId;
+                codecId = ((tA2D_APTX_CIE*)(&p_codec_info[BTA_AV_CFG_START_IDX]))->codecId;
+                vendorId = ((tA2D_APTX_CIE*)(&p_codec_info[BTA_AV_CFG_START_IDX]))->vendorId;
                 APPL_TRACE_DEBUG("%s codec_type = %x", __func__, codec_type);
                 APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecId);
                 APPL_TRACE_DEBUG("%s vendorId = %x", __func__, vendorId);
@@ -1018,12 +1055,16 @@ void bta_av_co_audio_setconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
                     recfg_needed = TRUE;
                 }
 
-                if ((codecId == A2D_APTX_CODEC_ID_BLUETOOTH) && (vendorId == A2D_APTX_VENDOR_ID))
-                {
+                if ((codecId == A2D_APTX_CODEC_ID_BLUETOOTH) && (vendorId == A2D_APTX_VENDOR_ID)) {
                     APPL_TRACE_DEBUG("%s aptX", __func__);
                     bta_av_co_cb.codec_cfg_aptx_setconfig.id = A2D_NON_A2DP_MEDIA_CT;
                     memcpy(bta_av_co_cb.codec_cfg_aptx_setconfig.info, p_codec_info, AVDT_CODEC_SIZE);
                     bta_av_co_cb.codec_cfg_setconfig = &bta_av_co_cb.codec_cfg_aptx_setconfig;
+                } else if ((codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH) && (vendorId == A2D_APTX_HD_VENDOR_ID)) {
+                    APPL_TRACE_DEBUG("%s aptX HD", __func__);
+                    bta_av_co_cb.codec_cfg_aptx_hd_setconfig.id = A2D_NON_A2DP_MEDIA_CT;
+                    memcpy(bta_av_co_cb.codec_cfg_aptx_hd_setconfig.info, p_codec_info, AVDT_CODEC_SIZE);
+                    bta_av_co_cb.codec_cfg_setconfig = &bta_av_co_cb.codec_cfg_aptx_hd_setconfig;
                 }
                 break;
              }
@@ -1160,14 +1201,21 @@ void bta_av_co_audio_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type,
                            UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr)
 {
     UNUSED(hndl);
-    UNUSED(codec_type);
-    UNUSED(p_codec_info);
-    UNUSED(p_no_rtp_hdr);
 
     FUNC_TRACE();
 
     APPL_TRACE_DEBUG("bta_av_co_audio_start");
 
+    if (codec_type == A2D_NON_A2DP_MEDIA_CT) {
+        UINT16 codecId = ((tA2D_APTX_CIE*)(&p_codec_info[BTA_AV_CFG_START_IDX]))->codecId;
+        UINT32 vendorId = ((tA2D_APTX_CIE*)(&p_codec_info[BTA_AV_CFG_START_IDX]))->vendorId;
+
+        // for aptX, we only add RTP hdr along with CP
+        if (codecId == A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID) {
+            if (!bta_av_co_cb.cp.active)
+                *p_no_rtp_hdr = TRUE;
+        }
+    }
 }
 
 /*******************************************************************************
@@ -1336,10 +1384,15 @@ static BOOLEAN bta_av_co_audio_codec_build_config(const UINT8 *p_codec_caps, UIN
         APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecId);
         APPL_TRACE_DEBUG("%s vendorId = %x", __func__, vendorId);
 
-        memcpy(p_codec_cfg, bta_av_co_cb.codec_cfg->info, A2D_APTX_CODEC_LEN+1);
-        APPL_TRACE_DEBUG("%s aptX",__func__);
+        if ((codecId == A2D_APTX_CODEC_ID_BLUETOOTH) && (vendorId == A2D_APTX_VENDOR_ID)) {
+            memcpy(p_codec_cfg, bta_av_co_cb.codec_cfg->info, A2D_APTX_CODEC_LEN+1);
+            APPL_TRACE_DEBUG("%s aptX",__func__);
+        } else if ((codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH) && (vendorId == A2D_APTX_HD_VENDOR_ID)) {
+            memcpy(p_codec_cfg, bta_av_co_cb.codec_cfg->info, A2D_APTX_HD_CODEC_LEN+1);
+            APPL_TRACE_DEBUG("%s aptX HD",__func__);
+        }
         break;
-     }
+    }
 
     default:
         APPL_TRACE_ERROR("bta_av_co_audio_codec_build_config: unsupported codec id %d", bta_av_co_cb.codec_cfg->id);
@@ -1495,19 +1548,23 @@ static BOOLEAN bta_av_co_audio_codec_match(const UINT8 *p_codec_caps, UINT8 code
             APPL_TRACE_DEBUG("%s codecId = %d ", __func__, codecId);
             APPL_TRACE_DEBUG("%s vendorId = %x ", __func__, vendorId);
 
-            if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID)
-            {
+            if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID) {
                 /* aptX Classic */
                 APPL_TRACE_DEBUG("%s aptX", __func__);
                 return bta_av_co_audio_codec_cfg_matches_caps(bta_av_co_cb.codec_cfg_aptx.id, p_codec_caps, bta_av_co_cb.codec_cfg_aptx.info);
                 break;
+            } else if (codecId ==  A2D_APTX_HD_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_HD_VENDOR_ID) {
+                /* aptX HD */
+                APPL_TRACE_DEBUG("%s aptX HD", __func__);
+                return bta_av_co_audio_codec_cfg_matches_caps(bta_av_co_cb.codec_cfg_aptx_hd.id, p_codec_caps, bta_av_co_cb.codec_cfg_aptx_hd.info);
+                break;
             } else {
-                APPL_TRACE_ERROR("%s incorrect aptX vendor and codec ID combination (codec ID: %d)", __func__, codecId);
-                APPL_TRACE_ERROR("%s incorrect aptX vendor (%x) and codec ID combination ", __func__, vendorId);
+                APPL_TRACE_ERROR("%s incorrect codecId (%d)", __func__, codecId);
+                APPL_TRACE_ERROR("%s incorrect vendorId (%x)", __func__, vendorId);
                 break;
             }
         }
-     default:
+    default:
         return bta_av_co_audio_codec_cfg_matches_caps(bta_av_co_cb.codec_cfg_sbc.id, p_codec_caps, bta_av_co_cb.codec_cfg_sbc.info);
         break;
     }
@@ -1636,51 +1693,89 @@ static BOOLEAN bta_av_co_audio_peer_supports_codec(tBTA_AV_CO_PEER *p_peer, UINT
     /* Configure the codec type to look for */
     codec_type = bta_av_co_cb.codec_cfg->id;
 
-/* Check for aptX as this is order of priority.
- * Check for aptX-HD, then aptX-LL before aptX Classic as
+/* Check for aptX HD before aptX Classic as
  * this is order of priority, if supported return true.
+ * multicast is not supported for aptX
  */
-    if ((!bt_split_a2dp_enabled && isA2dAptXEnabled && (btif_max_av_clients <= 1)) ||
+    if ((!bt_split_a2dp_enabled && isA2dAptXEnabled && (btif_av_is_multicast_supported() == FALSE)) ||
         (bt_split_a2dp_enabled && btif_av_is_codec_offload_supported(APTX)))
     {
-         UINT16 codecId;
-         UINT32 vendorId;
-         UINT8* aptx_capabilities;
-
-         for (index = 0; index < p_peer->num_sup_snks; index++)
-         {
-             if (p_peer->snks[index].codec_type == A2D_NON_A2DP_MEDIA_CT)
-             {
-                 aptx_capabilities = &(p_peer->snks[index].codec_caps[0]);
-                 codecId = ((tA2D_APTX_CIE*)aptx_capabilities)->codecId;
-                 vendorId = ((tA2D_APTX_CIE*)aptx_capabilities)->vendorId;
-                 int i = 0;
-                 for ( i = 0 ; i < AVDT_CODEC_SIZE; i++) {
-                     APPL_TRACE_DEBUG("%s codec_caps[%d]: %x", __func__, i, p_peer->snks[index].codec_caps[i]);
-                 }
-                 APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecId);
-                 APPL_TRACE_DEBUG("%s vendorId = %x", __func__, vendorId);
-                 APPL_TRACE_DEBUG("%s p_peer->snks[index].codec_type = %x", __func__, p_peer->snks[index].codec_type );
-
-                 if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID)
-                 {
-                     if (p_snk_index)
+        UINT16 codecId;
+        UINT32 vendorId;
+        UINT8* aptx_capabilities;
+
+        if (isA2dAptXHdEnabled) {
+            for (index = 0; index < p_peer->num_sup_snks; index++)
+            {
+                if (p_peer->snks[index].codec_type == A2D_NON_A2DP_MEDIA_CT)
+                {
+                    aptx_capabilities = &(p_peer->snks[index].codec_caps[0]);
+                    codecId = ((tA2D_APTX_HD_CIE*)aptx_capabilities)->codecId;
+                    vendorId = ((tA2D_APTX_HD_CIE*)aptx_capabilities)->vendorId;
+                    int i = 0;
+                    for ( i = 0 ; i < AVDT_CODEC_SIZE; i++) {
+                        APPL_TRACE_DEBUG("%s codec_caps[%d]: %x", __func__, i, p_peer->snks[index].codec_caps[i]);
+                    }
+                    APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecId);
+                    APPL_TRACE_DEBUG("%s vendorId = %x", __func__, vendorId);
+                    APPL_TRACE_DEBUG("%s p_peer->snks[index].codec_type = %x", __func__, p_peer->snks[index].codec_type );
+
+                    if (codecId ==  A2D_APTX_HD_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_HD_VENDOR_ID  )
+                    {
+                        if (p_snk_index)
+                            *p_snk_index = index;
+                        APPL_TRACE_DEBUG("%s aptX HD", __func__);
+
+                        if (bta_av_co_audio_codec_match(p_peer->snks[index].codec_caps, A2D_NON_A2DP_MEDIA_CT))
+                        {
+    #if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE)
+                            if (bta_av_co_audio_sink_has_scmst(&p_peer->snks[index]))
+    #endif
+                            {
+                                bta_av_co_cb.current_codec_id = bta_av_co_cb.codec_cfg_aptx_hd.id;
+                                bta_av_co_cb.codec_cfg = &bta_av_co_cb.codec_cfg_aptx_hd;
+                                return TRUE;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        for (index = 0; index < p_peer->num_sup_snks; index++)
+        {
+            if (p_peer->snks[index].codec_type == A2D_NON_A2DP_MEDIA_CT)
+            {
+                aptx_capabilities = &(p_peer->snks[index].codec_caps[0]);
+                codecId = ((tA2D_APTX_CIE*)aptx_capabilities)->codecId;
+                vendorId = ((tA2D_APTX_CIE*)aptx_capabilities)->vendorId;
+                int i = 0;
+                for ( i = 0 ; i < AVDT_CODEC_SIZE; i++) {
+                    APPL_TRACE_DEBUG("%s codec_caps[%d]: %x", __func__, i, p_peer->snks[index].codec_caps[i]);
+                }
+                APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecId);
+                APPL_TRACE_DEBUG("%s vendorId = %x", __func__, vendorId);
+                APPL_TRACE_DEBUG("%s p_peer->snks[index].codec_type = %x", __func__, p_peer->snks[index].codec_type );
+
+                if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID)
+                {
+                    if (p_snk_index)
                         *p_snk_index = index;
-                     APPL_TRACE_DEBUG("%s aptX", __func__);
+                    APPL_TRACE_DEBUG("%s aptX", __func__);
 
-                     if (bta_av_co_audio_codec_match(p_peer->snks[index].codec_caps, A2D_NON_A2DP_MEDIA_CT))
-                     {
+                    if (bta_av_co_audio_codec_match(p_peer->snks[index].codec_caps, A2D_NON_A2DP_MEDIA_CT))
+                    {
 #if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE)
-                         if (bta_av_co_audio_sink_has_scmst(&p_peer->snks[index]))
+                        if (bta_av_co_audio_sink_has_scmst(&p_peer->snks[index]))
 #endif
-                         {
-                             bta_av_co_cb.current_codec_id = bta_av_co_cb.codec_cfg_aptx.id;
-                             bta_av_co_cb.codec_cfg = &bta_av_co_cb.codec_cfg_aptx;
-                             return TRUE;
-                         }
-                     }
+                        {
+                            bta_av_co_cb.current_codec_id = bta_av_co_cb.codec_cfg_aptx.id;
+                            bta_av_co_cb.codec_cfg = &bta_av_co_cb.codec_cfg_aptx;
+                            return TRUE;
+                        }
+                    }
                 }
-           }
+            }
         }
     } else
         APPL_TRACE_DEBUG("%s aptX is disabled", __func__);
@@ -1879,11 +1974,16 @@ static BOOLEAN bta_av_co_audio_media_supports_config(UINT8 codec_type, const UIN
         APPL_TRACE_DEBUG("%s codecId = %d ", __func__, codecId);
         APPL_TRACE_DEBUG("%s vendorId = %x ", __func__, vendorId);
 
-        if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID)
-        {
+        if (codecId ==  A2D_APTX_HD_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_HD_VENDOR_ID) {
+            APPL_TRACE_DEBUG("%s tA2D_APTX_CIE aptX HD", __func__);
+            if (a2d_av_aptx_hd_cfg_in_cap((UINT8 *)p_codec_cfg, (tA2D_APTX_HD_CIE *)&bta_av_co_aptx_hd_caps)) {
+                APPL_TRACE_DEBUG("%s aptX HD", __func__);
+                return FALSE;
+            }
+            break;
+        } else if (codecId ==  A2D_APTX_CODEC_ID_BLUETOOTH && vendorId == A2D_APTX_VENDOR_ID) {
             APPL_TRACE_DEBUG("%s tA2D_APTX_CIE aptX", __func__);
-            if (a2d_av_aptx_cfg_in_cap((UINT8 *)p_codec_cfg, (tA2D_APTX_CIE *)&bta_av_co_aptx_caps))
-            {
+            if (a2d_av_aptx_cfg_in_cap((UINT8 *)p_codec_cfg, (tA2D_APTX_CIE *)&bta_av_co_aptx_caps)) {
                 APPL_TRACE_DEBUG("%s aptX", __func__);
                 return FALSE;
             }
@@ -1962,9 +2062,9 @@ BOOLEAN bta_av_co_audio_codec_supported(tBTIF_STATUS *p_status)
                     /* Check if this sink supports SCMS */
                     cp_active = bta_av_co_audio_sink_has_scmst(p_sink);
 #endif
-                    APPL_TRACE_DEBUG("%s %x", __func__, bta_av_co_cb.current_codec_id);
+                    APPL_TRACE_DEBUG("%s current_codec_id: %x", __func__, bta_av_co_cb.current_codec_id);
                     APPL_TRACE_DEBUG("%s p_scb_codec_type: %x", __func__, p_scb_codec_type);
-                    p_scb_codec_type = bta_av_co_audio_get_codec_type();
+                    p_scb_codec_type = bta_av_get_codec_type();
                     APPL_TRACE_DEBUG("%s p_scb_codec_type: %x", __func__, p_scb_codec_type);
                     /* Check if this is a new configuration (new sink or new config) */
                     if ((p_sink != p_peer->p_snk) ||
@@ -2042,6 +2142,11 @@ void bta_av_co_audio_codec_reset(void)
     if (A2D_BldAptxInfo(A2D_MEDIA_TYPE_AUDIO, (tA2D_APTX_CIE *)&btif_av_aptx_default_config, bta_av_co_cb.codec_cfg_aptx.info) != A2D_SUCCESS)
         APPL_TRACE_ERROR("%s A2D_BldAptxInfo failed", __func__);
 
+    /* Reset the Current configuration to aptX HD */
+    bta_av_co_cb.codec_cfg_aptx_hd.id = A2D_NON_A2DP_MEDIA_CT;
+    if (A2D_BldAptx_hdInfo(A2D_MEDIA_TYPE_AUDIO, (tA2D_APTX_HD_CIE *)&btif_av_aptx_hd_default_config, bta_av_co_cb.codec_cfg_aptx_hd.info) != A2D_SUCCESS)
+        APPL_TRACE_ERROR("%s A2D_BldAptx_hdInfo failed", __func__);
+
     mutex_global_unlock();
 }
 
@@ -2062,6 +2167,8 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
     tBTIF_AV_CODEC_INFO new_cfg_sbc;
     tA2D_APTX_CIE aptx_config;
     tBTIF_AV_CODEC_INFO new_cfg_aptx;
+    tA2D_APTX_HD_CIE aptx_hd_config;
+    tBTIF_AV_CODEC_INFO new_cfg_aptx_hd;
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
     tA2D_AAC_CIE aac_config;
     tBTIF_AV_CODEC_INFO new_cfg_aac;
@@ -2087,13 +2194,16 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
             return FALSE;
         }
         if ((p_feeding->cfg.pcm.bit_per_sample != 8) &&
-            (p_feeding->cfg.pcm.bit_per_sample != 16))
+            (p_feeding->cfg.pcm.bit_per_sample != 16) &&
+            (p_feeding->cfg.pcm.bit_per_sample != 32))
         {
             APPL_TRACE_ERROR("bta_av_co_audio_set_codec PCM sample size unsupported");
             return FALSE;
         }
         new_cfg_aptx.id = A2D_NON_A2DP_MEDIA_CT;
         aptx_config = btif_av_aptx_default_config;
+        new_cfg_aptx_hd.id = A2D_NON_A2DP_MEDIA_CT;
+        aptx_hd_config = btif_av_aptx_hd_default_config;
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
         new_cfg_aac.id = BTIF_AV_CODEC_M24;
         aac_config = btif_av_aac_default_config;
@@ -2108,6 +2218,7 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
         case 48000:
             sbc_config.samp_freq = A2D_SBC_IE_SAMP_FREQ_48;
             aptx_config.sampleRate = A2D_APTX_SAMPLERATE_48000;
+            aptx_hd_config.sampleRate = A2D_APTX_HD_SAMPLERATE_48000;
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
             aac_config.samp_freq = A2D_AAC_IE_SAMP_FREQ_48000;
 #endif
@@ -2118,6 +2229,7 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
         case 44100:
             sbc_config.samp_freq = A2D_SBC_IE_SAMP_FREQ_44;
             aptx_config.sampleRate = A2D_APTX_SAMPLERATE_44100;
+            aptx_hd_config.sampleRate = A2D_APTX_HD_SAMPLERATE_44100;
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
             aac_config.samp_freq = A2D_AAC_IE_SAMP_FREQ_44100;
 #endif
@@ -2138,6 +2250,11 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
             APPL_TRACE_ERROR("%s A2D_BldAptxInfo failed", __func__);
             return FALSE;
         }
+        if (A2D_BldAptx_hdInfo(A2D_MEDIA_TYPE_AUDIO, &aptx_hd_config, new_cfg_aptx_hd.info) != A2D_SUCCESS)
+        {
+            APPL_TRACE_ERROR("%s A2D_BldAptx_hdInfo failed", __func__);
+            return FALSE;
+        }
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
         if (A2D_BldAacInfo(A2D_MEDIA_TYPE_AUDIO, &aac_config, new_cfg_aac.info) != A2D_SUCCESS)
         {
@@ -2158,6 +2275,7 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
     bta_av_co_cb.codec_cfg_sbc = new_cfg_sbc;
     bta_av_co_cb.codec_cfg = &bta_av_co_cb.codec_cfg_sbc;
     bta_av_co_cb.codec_cfg_aptx= new_cfg_aptx;
+    bta_av_co_cb.codec_cfg_aptx_hd = new_cfg_aptx_hd;
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
     bta_av_co_cb.codec_cfg_aac = new_cfg_aac;
 #endif
@@ -2169,9 +2287,11 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
 
 UINT8 bta_av_select_codec(UINT8 hdl)
 {
-    // Some circumstances - bta_av_co functions are called before codec clock is initialised
     if (NULL == bta_av_co_cb.codec_cfg)
     {
+        // Some circumstances - bta_av_co functions are called before
+        // codec clock is initialised
+        APPL_TRACE_ERROR("%s hdl = %d, no codec configured", __func__, hdl);
         return BTIF_AV_CODEC_NONE;
     }
     else
@@ -2194,7 +2314,7 @@ UINT8 bta_av_select_codec(UINT8 hdl)
     }
 }
 
-UINT8 bta_av_get_current_codec()
+UINT8 bta_av_co_get_current_codec()
 {
     // Some circumstances - bta_av_co functions are called before codec clock is initialised
     if (NULL == bta_av_co_cb.codec_cfg)
@@ -2203,7 +2323,7 @@ UINT8 bta_av_get_current_codec()
         return bta_av_co_cb.codec_cfg->id;
 }
 
-UINT8* bta_av_get_current_codecInfo()
+UINT8* bta_av_co_get_current_codecInfo()
 {
     // We assume that the configuration block is always valid when this is called.
     return &bta_av_co_cb.codec_cfg->info[0];
@@ -2244,15 +2364,20 @@ BOOLEAN bta_av_co_audio_get_codec_config(UINT8 *p_config, UINT16 *p_minmtu, UINT
             result = TRUE;
         else
             memcpy((tA2D_SBC_CIE *) p_config, &btif_av_sbc_default_config, sizeof(tA2D_SBC_CIE));
-    }
-    if (type == A2D_NON_A2DP_MEDIA_CT && ((tA2D_APTX_CIE *)p_config)->vendorId == A2D_APTX_VENDOR_ID && ((tA2D_APTX_CIE *)p_config)->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
-    {
+    } else if (type == A2D_NON_A2DP_MEDIA_CT && ((tA2D_APTX_CIE *)p_config)->vendorId == A2D_APTX_VENDOR_ID && ((tA2D_APTX_CIE *)p_config)->codecId == A2D_APTX_CODEC_ID_BLUETOOTH) {
         APPL_TRACE_DEBUG("%s aptX", __func__);
         tA2D_APTX_CIE *aptx_config = (tA2D_APTX_CIE *)p_config;
         if (A2D_ParsAptxInfo(aptx_config, bta_av_co_cb.codec_cfg_aptx.info, FALSE) == A2D_SUCCESS)
             result = TRUE;
         else
             memcpy((tA2D_APTX_CIE *) p_config, &btif_av_aptx_default_config, sizeof(tA2D_APTX_CIE));
+    } else if (type == A2D_NON_A2DP_MEDIA_CT && ((tA2D_APTX_HD_CIE *)p_config)->vendorId == A2D_APTX_HD_VENDOR_ID && ((tA2D_APTX_HD_CIE *)p_config)->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH) {
+        APPL_TRACE_DEBUG("%s aptX HD", __func__);
+        tA2D_APTX_HD_CIE *aptx_hd_config = (tA2D_APTX_HD_CIE *)p_config;
+        if (A2D_ParsAptx_hdInfo(aptx_hd_config, bta_av_co_cb.codec_cfg_aptx_hd.info, FALSE) == A2D_SUCCESS)
+            result = TRUE;
+        else
+            memcpy((tA2D_APTX_HD_CIE *) p_config, &btif_av_aptx_hd_default_config, sizeof(tA2D_APTX_HD_CIE));
     } else {
         APPL_TRACE_DEBUG("%s vendorId: %d  codecId: %d\n", __func__, ((tA2D_APTX_CIE *)p_config)->vendorId, ((tA2D_APTX_CIE *)p_config)->codecId);
     }

--- a/btif/include/btif_av.h
+++ b/btif/include/btif_av.h
@@ -257,4 +257,26 @@ void btif_av_get_peer_addr(bt_bdaddr_t *peer_bda);
 #define btif_av_get_peer_addr(peer_bda) (0)
 #endif
 
+/*******************************************************************************
+**
+** Function         btif_av_get_multicast_state
+**
+** Description      Check if A2DP multicast is enabled
+**
+** Returns          TRUE if a2dp multicast is enabled
+**
+*******************************************************************************/
+BOOLEAN btif_av_get_multicast_state();
+
+/*******************************************************************************
+**
+** Function         btif_av_is_multicast_supported
+**
+** Description      Check if A2DP multicast is supported
+**
+** Returns          TRUE if a2dp multicast is supported
+**
+*******************************************************************************/
+BOOLEAN btif_av_is_multicast_supported();
+
 #endif /* BTIF_AV_H */

--- a/btif/include/btif_av_co.h
+++ b/btif/include/btif_av_co.h
@@ -111,25 +111,25 @@ BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTI
 
 /*******************************************************************************
  **
- ** Function         bta_av_get_current_codec
+ ** Function         bta_av_co_get_current_codec
  **
  ** Description      Get the current codec type.
  **
  ** Returns          Codec Type Value
  **
  *******************************************************************************/
-UINT8 bta_av_get_current_codec();
+UINT8 bta_av_co_get_current_codec();
 
 /*******************************************************************************
  **
- ** Function         bta_av_get_current_codecInfo
+ ** Function         bta_av_co_get_current_codecInfo
  **
  ** Description      Get the current codec Info.
  **
  ** Returns          Returns  pointer to Info
  **
  *******************************************************************************/
-UINT8* bta_av_get_current_codecInfo();
+UINT8* bta_av_co_get_current_codecInfo();
 
 /*******************************************************************************
  **
@@ -227,15 +227,4 @@ BOOLEAN bta_av_co_get_remote_bitpool_pref(UINT8 *min, UINT8 *max);
  *******************************************************************************/
 UINT8 bta_av_select_codec(tBTA_AV_HNDL hdl);
 
-/*******************************************************************************
- **
- ** Function         bta_av_get_current_codec
- **
- ** Description      Get current codec id selected for streaming.
- **
- ** Returns          Return current codec id
- **
- *******************************************************************************/
-UINT8 bta_av_get_current_codec(void);
-
 #endif

--- a/btif/include/btif_media.h
+++ b/btif/include/btif_media.h
@@ -62,8 +62,7 @@
 #define BTIF_MEDIA_TRSCD_OFF             0
 #define BTIF_MEDIA_TRSCD_PCM_2_SBC       1  /* Tx */
 #define BTIF_MEDIA_TRSCD_PCM_2_APTX      2
-
-extern int btif_max_av_clients;                      /* maximum number of AV clients supported */
+#define BTIF_MEDIA_TRSCD_PCM_2_APTX_HD   3
 
 /*******************************************************************************
  **  Data types
@@ -82,8 +81,8 @@ typedef struct
         UINT8 AllocationMethod; /* loudness or SNR*/
         UINT16 MtuSize; /* peer mtu size */
         UINT8 CodecType; /* SBC or Non-A2DP */
-        UINT8 BluetoothVendorID; /* Bluetooth Vendor ID */
-        UINT8 BluetoothCodecID; /* Bluetooth Codec ID */
+        UINT32 BluetoothVendorID; /* Bluetooth Vendor ID */
+        UINT16 BluetoothCodecID; /* Bluetooth Codec ID */
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
         UINT8 ObjectType;
         UINT32 bit_rate;
@@ -100,8 +99,8 @@ typedef struct
         UINT8 MaxBitPool; /* Maximum peer bitpool */
         UINT8 MinBitPool; /* Minimum peer bitpool */
         UINT8 CodecType; /* SBC or Non-A2DP */
-        UINT8 BluetoothVendorID; /* Bluetooth Vendor ID */
-        UINT8 BluetoothCodecID; /* Bluetooth Codec ID */
+        UINT32 BluetoothVendorID; /* Bluetooth Vendor ID */
+        UINT16 BluetoothCodecID; /* Bluetooth Codec ID */
 } tBTIF_MEDIA_UPDATE_AUDIO;
 
 /* tBTIF_MEDIA_INIT_AUDIO_FEEDING msg structure */

--- a/btif/src/btif_av.c
+++ b/btif/src/btif_av.c
@@ -3493,6 +3493,19 @@ BOOLEAN btif_av_get_ongoing_multicast()
 
 /******************************************************************************
 **
+** Function        btif_av_is_multicast_supported
+**
+** Description     Returns TRUE if multicast is supported
+**
+** Returns         BOOLEAN
+******************************************************************************/
+BOOLEAN btif_av_is_multicast_supported()
+{
+    return is_multicast_supported;
+}
+
+/******************************************************************************
+**
 ** Function        btif_av_is_offload_supported
 **
 ** Description     Returns split mode status

--- a/btif/src/btif_media_task.c
+++ b/btif/src/btif_media_task.c
@@ -42,11 +42,14 @@
 #include <pthread.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <dlfcn.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <audio_utils/primitives.h>
+#include <audio_utils/format.h>
 
 #include <hardware/bluetooth.h>
 
@@ -61,6 +64,7 @@
 #include "a2d_int.h"
 #include "a2d_sbc.h"
 #include "a2d_aptx.h"
+#include "a2d_aptx_hd.h"
 #include "a2d_aac.h"
 #include "audio_a2dp_hw.h"
 #include "bt_target.h"
@@ -193,8 +197,10 @@ enum {
 
 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
 #define BTIF_MEDIA_AA_APTX_OFFSET (AVDT_MEDIA_OFFSET + 1)
+#define BTIF_MEDIA_AA_APTX_HD_OFFSET (AVDT_MEDIA_OFFSET + 1)
 #else
 #define BTIF_MEDIA_AA_APTX_OFFSET (AVDT_MEDIA_OFFSET - AVDT_MEDIA_HDR_SIZE) //no RTP header for aptX classic
+#define BTIF_MEDIA_AA_APTX_HD_OFFSET (AVDT_MEDIA_OFFSET) //there is an RTP header for aptX HD, but no CP byte
 #endif
 /* Define the bitrate step when trying to match bitpool value */
 #ifndef BTIF_MEDIA_BITRATE_STEP
@@ -372,7 +378,9 @@ typedef struct
     SBC_ENC_PARAMS encoder;
     UINT16 offset;
     A2D_APTX_ENC_PARAMS aptxEncoderParams;
+    A2D_APTX_HD_ENC_PARAMS aptxhdEncoderParams;
     UINT16 as16PcmBuffer[1024];
+    UINT32 as32PcmBuffer[1024];
     UINT8 busy_level;
     void* av_sm_hdl;
     UINT8 a2dp_cmd_pending; /* we can have max one command pending */
@@ -446,7 +454,6 @@ static void btif_media_task_handle_inc_media(tBT_SBC_HDR*p_msg);
 #endif
 
 BOOLEAN bta_av_co_audio_get_codec_config(UINT8 *p_config, UINT16 *p_minmtu, UINT8 type);
-UINT8 bta_av_get_current_codec();
 static thread_t *aptx_thread = NULL;
 
 #if (BTA_AV_INCLUDED == TRUE)
@@ -518,7 +525,6 @@ static fixed_queue_t *btif_media_cmd_msg_queue;
 static thread_t *worker_thread;
 
 BOOLEAN bta_av_co_audio_get_codec_config(UINT8 *p_config, UINT16 *p_minmtu, UINT8 type);
-UINT8 bta_av_get_current_codec();
 
 extern BOOLEAN bt_split_a2dp_enabled;
 extern int btif_max_av_clients;
@@ -895,7 +901,7 @@ static void btif_recv_ctrl_data(void)
             }
             else //get playing device hdl
             {
-                codec_id =  bta_av_get_current_codec();
+                codec_id =  bta_av_co_get_current_codec();
             }
 
             a2dp_cmd_acknowledge(A2DP_CTRL_ACK_SUCCESS);
@@ -918,7 +924,7 @@ static void btif_recv_ctrl_data(void)
             else if (codec_id == A2D_NON_A2DP_MEDIA_CT) //this is changed to non-a2dp VS codec
             {
                //ADD APTX support
-                UINT8* ptr = bta_av_get_current_codecInfo();
+                UINT8* ptr = bta_av_co_get_current_codecInfo();
                 int j;
                 UINT8 *p_ptr = ptr;
                 for(j=0; j< (int)sizeof(tA2D_APTX_CIE);j++)
@@ -928,8 +934,8 @@ static void btif_recv_ctrl_data(void)
                 if (ptr)
                 {
                     tA2D_APTX_CIE* codecInfo = 0;
-                    codecInfo = (tA2D_APTX_CIE*) &ptr[3];
-                    if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID
+                    codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
+                    if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID 
                         && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
                     {
                         tA2D_APTX_CIE aptx_config;
@@ -1075,15 +1081,16 @@ static void btif_a2dp_data_cb(tUIPC_CH_ID ch_id, tUIPC_EVENT event)
 static BOOLEAN btif_media_task_is_aptx_configured()
 {
     BOOLEAN result = FALSE;
-    UINT8 codectype = bta_av_get_current_codec();
-
-    if (codectype == A2D_NON_A2DP_MEDIA_CT)
-    {
-        UINT8* ptr = bta_av_get_current_codecInfo();
-        if (ptr)
-        {
-            tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[3];
-            if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
+    UINT8 codectype = bta_av_co_get_current_codec();
+
+    if (codectype == A2D_NON_A2DP_MEDIA_CT) {
+        UINT8* ptr = bta_av_co_get_current_codecInfo();
+        if (ptr) {
+            tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
+            if ((codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
+                || (codecInfo && codecInfo->vendorId == A2D_APTX_HD_VENDOR_ID && codecInfo->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH))
+                APPL_TRACE_DEBUG("%s codecId %d", __func__, codecInfo->codecId);
+                APPL_TRACE_DEBUG("%s vendorId %x", __func__, codecInfo->vendorId);
                 result = TRUE;
         }
     }
@@ -1093,16 +1100,16 @@ static BOOLEAN btif_media_task_is_aptx_configured()
 A2D_AptXCodecType btif_media_task_get_aptX_codec_type()
 {
     A2D_AptXCodecType codec = APTX_CODEC_NONE;
-    UINT8 a2dp_codectype = bta_av_get_current_codec();
+    UINT8 a2dp_codectype = bta_av_co_get_current_codec();
 
-    if (a2dp_codectype == A2D_NON_A2DP_MEDIA_CT)
-    {
-        UINT8* ptr = bta_av_get_current_codecInfo();
-        if (ptr)
-        {
-            tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[3];
+    if (a2dp_codectype == A2D_NON_A2DP_MEDIA_CT) {
+        UINT8* ptr = bta_av_co_get_current_codecInfo();
+        if (ptr) {
+            tA2D_APTX_CIE* codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
             if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
                 codec = APTX_CODEC;
+            else if (codecInfo && codecInfo->vendorId == A2D_APTX_HD_VENDOR_ID && codecInfo->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH)
+                codec = APTX_HD_CODEC;
         }
     }
     return codec;
@@ -1156,13 +1163,11 @@ static void btif_a2dp_encoder_init(tBTA_AV_HNDL hdl)
 
     UINT8 codectype;
     codectype = bta_av_select_codec(hdl);
-    if (A2D_NON_A2DP_MEDIA_CT == codectype)
-    {
-        UINT8* ptr = bta_av_get_current_codecInfo();
-        if (ptr)
-        {
+    if (A2D_NON_A2DP_MEDIA_CT == codectype) {
+        UINT8* ptr = bta_av_co_get_current_codecInfo();
+        if (ptr) {
            //tA2D_APTX_CIE starts on 4th byte
-            codecInfo = (tA2D_APTX_CIE*) &ptr[3];
+            codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
             APPL_TRACE_DEBUG("%s codecId = %d", __func__, codecInfo->codecId);
             APPL_TRACE_DEBUG("%s vendorId = %x", __func__, codecInfo->vendorId);
 
@@ -1184,6 +1189,25 @@ static void btif_a2dp_encoder_init(tBTA_AV_HNDL hdl)
                 btif_media_task_enc_init_req(&msg);
                 return;
             }
+
+            if (codecInfo && codecInfo->vendorId == A2D_APTX_HD_VENDOR_ID
+                && codecInfo->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH)
+            {
+                btif_media_cb.offset = BTIF_MEDIA_AA_APTX_HD_OFFSET;
+                tA2D_APTX_HD_CIE aptx_hd_config;
+                ALOGI("%s Selected Codec aptX HD", __func__);
+                aptx_hd_config.vendorId = codecInfo->vendorId;
+                aptx_hd_config.codecId = codecInfo->codecId;
+                bta_av_co_audio_get_codec_config((UINT8*)&aptx_hd_config, &minmtu, A2D_NON_A2DP_MEDIA_CT);
+                msg.CodecType = A2D_NON_A2DP_MEDIA_CT;
+                msg.SamplingFreq = aptx_hd_config.sampleRate;
+                msg.MtuSize = minmtu;
+                msg.ChannelMode = aptx_hd_config.channelMode;
+                msg.BluetoothVendorID = aptx_hd_config.vendorId;
+                msg.BluetoothCodecID = aptx_hd_config.codecId;
+                btif_media_task_enc_init_req(&msg);
+                return;
+            }
         }
     }/* if ( A2D_NON_A2DP_MEDIA_CT == codectype) */
 
@@ -1236,13 +1260,13 @@ static void btif_a2dp_encoder_update(void)
     APPL_TRACE_DEBUG("btif_a2dp_encoder_update");
 
     UINT8 codectype = 0;
-    codectype = bta_av_get_current_codec();
+    codectype = bta_av_co_get_current_codec();
     if (codectype == A2D_NON_A2DP_MEDIA_CT)
     {
-        UINT8* ptr = bta_av_get_current_codecInfo();
+        UINT8* ptr = bta_av_co_get_current_codecInfo();
         if (ptr)
         {
-            codecInfo = (tA2D_APTX_CIE*) &ptr[3];
+            codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
             if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)
             {
                 APPL_TRACE_DEBUG("%s aptX", __func__);
@@ -1254,6 +1278,18 @@ static void btif_a2dp_encoder_update(void)
                 msg.BluetoothVendorID = aptx_config.vendorId;
                 msg.BluetoothCodecID = aptx_config.codecId;
             }
+
+            if (codecInfo && codecInfo->vendorId == A2D_APTX_HD_VENDOR_ID && codecInfo->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH)
+            {
+                APPL_TRACE_DEBUG("%s aptX HD", __func__);
+                tA2D_APTX_HD_CIE aptx_hd_config;
+                aptx_hd_config.vendorId = codecInfo->vendorId;
+                aptx_hd_config.codecId = codecInfo->codecId;
+                bta_av_co_audio_get_codec_config((UINT8*)&aptx_hd_config, &minmtu, A2D_NON_A2DP_MEDIA_CT );
+                msg.CodecType = A2D_NON_A2DP_MEDIA_CT;
+                msg.BluetoothVendorID = aptx_hd_config.vendorId;
+                msg.BluetoothCodecID = aptx_hd_config.codecId;
+            }
         } /* if (ptr) */
     }
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
@@ -1445,13 +1481,17 @@ tBTIF_STATUS btif_a2dp_setup_codec(tBTA_AV_HNDL hdl)
     /* for now hardcode 48 khz 16 bit stereo PCM format */
     media_feeding.cfg.pcm.sampling_freq = 48000;
 #else
-    /* for now hardcode 44.1 khz 16 bit stereo PCM format */
+    /* for now hardcode 44.1 khz 32 bit stereo PCM format */
     media_feeding.cfg.pcm.sampling_freq = BTIF_A2DP_SRC_SAMPLING_RATE;
 #endif
     media_feeding.cfg.pcm.bit_per_sample = BTIF_A2DP_SRC_BIT_DEPTH;
     media_feeding.cfg.pcm.num_channel = BTIF_A2DP_SRC_NUM_CHANNELS;
     media_feeding.format = BTIF_AV_CODEC_PCM;
 
+    /* 32 bits for AUDIO_FORMAT_PCM_8_24_BIT, all codecs affected. */
+    APPL_TRACE_EVENT("%s bit_per_sample %d", __func__, media_feeding.cfg.pcm.bit_per_sample);
+    APPL_TRACE_EVENT("%s sampling_freq %d", __func__, media_feeding.cfg.pcm.sampling_freq);
+
     if (bta_av_co_audio_set_codec(&media_feeding, &status))
     {
         tBTIF_MEDIA_INIT_AUDIO_FEEDING mfeed;
@@ -1559,7 +1599,7 @@ void btif_a2dp_on_open(void)
  *******************************************************************************/
 BOOLEAN btif_media_task_clear_track(void)
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = BTIF_MEDIA_AUDIO_SINK_CLEAR_TRACK;
     if (btif_media_cmd_msg_queue != NULL)
@@ -2006,7 +2046,7 @@ static void btif_media_thread_cleanup(UNUSED_ATTR void *context) {
  *******************************************************************************/
 BOOLEAN btif_media_task_send_cmd_evt(UINT16 Evt)
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = Evt;
 
@@ -2339,7 +2379,7 @@ BOOLEAN btif_media_task_audio_feeding_init_req(tBTIF_MEDIA_INIT_AUDIO_FEEDING *p
  *******************************************************************************/
 BOOLEAN btif_media_task_start_aa_req(void)
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = BTIF_MEDIA_START_AA_TX;
 
@@ -2359,7 +2399,7 @@ BOOLEAN btif_media_task_start_aa_req(void)
  *******************************************************************************/
 BOOLEAN btif_media_task_stop_aa_req(void)
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = BTIF_MEDIA_STOP_AA_TX;
 
@@ -2392,7 +2432,7 @@ BOOLEAN btif_media_task_aa_rx_flush_req(void)
     if (fixed_queue_is_empty(btif_media_cb.RxSbcQ)) /*  Que is already empty */
         return TRUE;
 
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
     p_buf->event = BTIF_MEDIA_FLUSH_AA_RX;
 
     if (btif_media_cmd_msg_queue != NULL)
@@ -2411,7 +2451,7 @@ BOOLEAN btif_media_task_aa_rx_flush_req(void)
  *******************************************************************************/
 BOOLEAN btif_media_task_aa_tx_flush_req(void)
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = BTIF_MEDIA_FLUSH_AA_TX;
 
@@ -2497,8 +2537,7 @@ static void btif_media_task_enc_init(BT_HDR *p_msg)
         APPL_TRACE_EVENT("%s BluetoothVendorID %x, BluetoothCodecID %d", __func__,
                      pInitAudio->BluetoothVendorID, pInitAudio->BluetoothCodecID);
         if ((pInitAudio->BluetoothVendorID == A2D_APTX_VENDOR_ID)
-                && (pInitAudio->BluetoothCodecID == A2D_APTX_CODEC_ID_BLUETOOTH))  /* aptX Classic */
-        {
+                && (pInitAudio->BluetoothCodecID == A2D_APTX_CODEC_ID_BLUETOOTH)) {
             btif_media_cb.aptxEncoderParams.s16SamplingFreq= pInitAudio->SamplingFreq;
             btif_media_cb.aptxEncoderParams.s16ChannelMode = pInitAudio->ChannelMode;
             btif_media_cb.aptxEncoderParams.u16PacketLength = 4;    // 32-bit word encoded by aptX encoder
@@ -2507,6 +2546,16 @@ static void btif_media_task_enc_init(BT_HDR *p_msg)
                                              < pInitAudio->MtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_OFFSET
                                                                        - sizeof(BT_HDR)) : pInitAudio->MtuSize;
             return;
+        } else if ((pInitAudio->BluetoothVendorID == A2D_APTX_HD_VENDOR_ID)
+                && (pInitAudio->BluetoothCodecID == A2D_APTX_HD_CODEC_ID_BLUETOOTH)) {
+            btif_media_cb.aptxhdEncoderParams.s16SamplingFreq= pInitAudio->SamplingFreq;
+            btif_media_cb.aptxhdEncoderParams.s16ChannelMode = pInitAudio->ChannelMode;
+            btif_media_cb.aptxhdEncoderParams.u16PacketLength = 6;    // 48-bit word encoded by aptX encoder
+            btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_APTX_HD;
+            btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_HD_OFFSET-sizeof(BT_HDR))
+                                             < pInitAudio->MtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_HD_OFFSET
+                                                                       - sizeof(BT_HDR)) : pInitAudio->MtuSize;
+            return;
         } else {
             /* do nothing, fall through to SBC */
         }
@@ -2586,13 +2635,18 @@ static void btif_media_task_enc_update(BT_HDR *p_msg)
                      pUpdateAudio->BluetoothVendorID, pUpdateAudio->BluetoothCodecID);
 
         if ((pUpdateAudio->BluetoothVendorID == A2D_APTX_VENDOR_ID)
-           && (pUpdateAudio->BluetoothCodecID == A2D_APTX_CODEC_ID_BLUETOOTH))  /* aptX Classic */
-        {
+           && (pUpdateAudio->BluetoothCodecID == A2D_APTX_CODEC_ID_BLUETOOTH)) {
             APPL_TRACE_DEBUG("%s aptX ", __func__);
             btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_OFFSET - sizeof(BT_HDR)) < pUpdateAudio->MinMtuSize) ?
                                                   (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_OFFSET - sizeof(BT_HDR)) : pUpdateAudio->MinMtuSize;
             APPL_TRACE_DEBUG("%s : aptX btif_media_cb.TxAaMtuSize %d", __func__, btif_media_cb.TxAaMtuSize);
             return;
+        } else if ((pUpdateAudio->BluetoothVendorID == A2D_APTX_HD_VENDOR_ID)
+            && (pUpdateAudio->BluetoothCodecID == A2D_APTX_HD_CODEC_ID_BLUETOOTH)) {
+            APPL_TRACE_DEBUG("%s aptX HD", __func__);
+            btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_HD_OFFSET - sizeof(BT_HDR)) < pUpdateAudio->MinMtuSize) ?
+                                                  (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_APTX_HD_OFFSET - sizeof(BT_HDR)) : pUpdateAudio->MinMtuSize;
+            return;
         } else {
             /* do nothing, fall through to SBC */
         }
@@ -2832,6 +2886,80 @@ static void btif_media_task_pcm2sbc_init(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_feed
 
 /*******************************************************************************
  **
+ ** Function         btif_media_task_pcm2aptx_hd_init
+ **
+ ** Description      Init encoding task for PCM to aptX according to feeding
+ **
+ ** Returns          void
+ **
+ *******************************************************************************/
+static void btif_media_task_pcm2aptx_hd_init(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_feeding)
+{
+    BOOLEAN reconfig_needed = FALSE;
+
+    APPL_TRACE_DEBUG("%s aptX HD", __func__);
+    APPL_TRACE_DEBUG("%s PCM feeding:", __func__);
+    APPL_TRACE_DEBUG("%s sampling_freq:%d", __func__, p_feeding->feeding.cfg.pcm.sampling_freq);
+    APPL_TRACE_DEBUG("%s num_channel:%d", __func__, p_feeding->feeding.cfg.pcm.num_channel);
+    APPL_TRACE_DEBUG("%s bit_per_sample:%d", __func__, p_feeding->feeding.cfg.pcm.bit_per_sample);
+
+    /* Check the PCM feeding sampling_freq */
+    switch (p_feeding->feeding.cfg.pcm.sampling_freq)
+    {
+        case  8000:
+        case 12000:
+        case 16000:
+        case 24000:
+        case 32000:
+        case 48000:
+            /* For these sampling_freq the AV connection must be 48000 */
+            if (btif_media_cb.aptxhdEncoderParams.s16SamplingFreq != A2D_APTX_HD_SAMPLERATE_48000)
+            {
+                /* Reconfiguration needed at 48000 */
+                APPL_TRACE_DEBUG("%s Reconfiguration needed at 48000", __func__);
+                btif_media_cb.aptxhdEncoderParams.s16SamplingFreq = A2D_APTX_HD_SAMPLERATE_48000;
+                reconfig_needed = TRUE;
+            }
+            break;
+
+        case 11025:
+        case 22050:
+        case 44100:
+            /* For these sampling_freq the AV connection must be 44100 */
+            if (btif_media_cb.aptxhdEncoderParams.s16SamplingFreq != A2D_APTX_HD_SAMPLERATE_44100)
+            {
+                /* Reconfiguration needed at 44100 */
+                APPL_TRACE_DEBUG("%s Reconfiguration needed at 44100", __func__);
+                btif_media_cb.aptxhdEncoderParams.s16SamplingFreq = A2D_APTX_HD_SAMPLERATE_44100;
+                reconfig_needed = TRUE;
+            }
+            break;
+        default:
+            APPL_TRACE_DEBUG("%s Feeding PCM sampling_freq unsupported", __func__);
+            break;
+    }
+
+    /* Some AV Headsets do not support Mono => always ask for Stereo */
+    if (btif_media_cb.aptxhdEncoderParams.s16ChannelMode ==  A2D_APTX_HD_CHANNELS_MONO)
+    {
+        APPL_TRACE_DEBUG("%s Reconfiguration needed in Stereo", __func__);
+        btif_media_cb.aptxhdEncoderParams.s16ChannelMode = A2D_APTX_HD_CHANNELS_STEREO;
+        reconfig_needed = TRUE;
+    }
+
+    if (reconfig_needed != FALSE)
+    {
+        APPL_TRACE_DEBUG("%s calls APTX_HD_Encoder_Init", __func__);
+        APPL_TRACE_DEBUG("%s mtu %d", __func__, btif_media_cb.TxAaMtuSize);
+        APPL_TRACE_DEBUG("%s ch mode %d, Smp freq %d", __func__,
+                          btif_media_cb.aptxhdEncoderParams.s16ChannelMode, btif_media_cb.aptxhdEncoderParams.s16SamplingFreq);
+    } else {
+        APPL_TRACE_DEBUG("%s No aptX HD reconfig needed", __func__);
+    }
+}
+
+/*******************************************************************************
+ **
  ** Function         btif_media_task_pcm2aptx_init
  **
  ** Description      Init encoding task for PCM to aptX according to feeding
@@ -2928,30 +3056,31 @@ static void btif_media_task_audio_feeding_init(BT_HDR *p_msg)
         case BTIF_AV_CODEC_PCM:
         {
             UINT8 codectype;
-            codectype = bta_av_get_current_codec();
+            codectype = bta_av_co_get_current_codec();
+
+            if (A2D_NON_A2DP_MEDIA_CT == codectype) {
+                UINT8* ptr = bta_av_co_get_current_codecInfo();
+                if (ptr) {
+                    // tA2D_APTX_CIE starts on 4th byte
+                    codecInfo = (tA2D_APTX_CIE*) &ptr[BTA_AV_CFG_START_IDX];
+                    if (codecInfo) {
+                        APPL_TRACE_DEBUG("%s codecId = %d ", __func__, codecInfo->codecId);
+                        APPL_TRACE_DEBUG("%s vendorId = %x ", __func__, codecInfo->vendorId);
+                    }
 
-            if (A2D_NON_A2DP_MEDIA_CT == codectype)
-            {
-                UINT8* ptr = bta_av_get_current_codecInfo();
-                if (ptr)
-                {
-                   // tA2D_APTX_CIE starts on 4th byte
-                   codecInfo = (tA2D_APTX_CIE*) &ptr[3];
-                   if (codecInfo)
-                   {
-                      APPL_TRACE_DEBUG("%s codecId = %d ", __func__, codecInfo->codecId);
-                      APPL_TRACE_DEBUG("%s vendorId = %x ", __func__, codecInfo->vendorId);
-                   }
-
-                   if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH)     /* aptX Classic */
-                   {
-                      APPL_TRACE_DEBUG("%s aptX", __func__);
-                      btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_APTX;
-                      btif_media_task_pcm2aptx_init(p_feeding);
-                      break;
-                   } else {
-                      /* do nothing, fall through to SBC */
-                   }
+                    if (codecInfo && codecInfo->vendorId == A2D_APTX_VENDOR_ID && codecInfo->codecId == A2D_APTX_CODEC_ID_BLUETOOTH) {
+                        APPL_TRACE_DEBUG("%s aptX", __func__);
+                        btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_APTX;
+                        btif_media_task_pcm2aptx_init(p_feeding);
+                        break;
+                    } else if (codecInfo && codecInfo->vendorId == A2D_APTX_HD_VENDOR_ID && codecInfo->codecId == A2D_APTX_HD_CODEC_ID_BLUETOOTH) {
+                        APPL_TRACE_DEBUG("%s aptX HD", __func__);
+                        btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_APTX_HD;
+                        btif_media_task_pcm2aptx_hd_init(p_feeding);
+                        break;
+                    } else {
+                        /* do nothing, fall through to SBC */
+                    }
                 }
             }
 
@@ -3249,6 +3378,12 @@ int btif_media_task_cb_packet_send(uint8_t* packet, int length, int pcm_bytes_en
 {
     int bytes_per_frame = 2;
     uint64_t timestamp_us = 0;
+    UINT8 codectype;
+    codectype = bta_av_co_get_current_codec();
+
+    if (btif_media_task_get_aptX_codec_type() == APTX_HD_CODEC) {
+        bytes_per_frame = 3;
+    }
 
     if (length > 0 ) {
 
@@ -3267,7 +3402,7 @@ int btif_media_task_cb_packet_send(uint8_t* packet, int length, int pcm_bytes_en
             osi_free(fixed_queue_try_dequeue(btif_media_cb.TxAaQ));
         }
 
-        BT_HDR *p_buf = osi_malloc(BTIF_MEDIA_AA_BUF_SIZE);
+        BT_HDR *p_buf = (BT_HDR *)osi_malloc(BTIF_MEDIA_AA_BUF_SIZE);
 
         int rtpTimestamp = (pcm_bytes_encoded / btif_media_cb.media_feeding.cfg.pcm.num_channel / bytes_per_frame);
 
@@ -3340,7 +3475,7 @@ static void btif_media_task_aa_start_tx(void)
           BOOLEAN use_SCMS_T = false;
 #endif
           A2D_AptXCodecType aptX_codec_type = btif_media_task_get_aptX_codec_type();
-          BOOLEAN is_24bit_audio = false;
+          BOOLEAN is_24bit_audio = true;
 
           BOOLEAN test = false;
           BOOLEAN trace = false;
@@ -3743,7 +3878,7 @@ UINT8 btif_media_sink_enque_buf(BT_HDR *p_pkt)
 BT_HDR *btif_media_aa_readbuf(void)
 {
     uint64_t now_us = time_now_us();
-    BT_HDR *p_buf = fixed_queue_try_dequeue(btif_media_cb.TxAaQ);
+    BT_HDR *p_buf = (BT_HDR *)fixed_queue_try_dequeue(btif_media_cb.TxAaQ);
 
     btif_media_cb.stats.tx_queue_total_readbuf_calls++;
     btif_media_cb.stats.tx_queue_last_readbuf_us = now_us;
@@ -3777,9 +3912,9 @@ BOOLEAN btif_media_aa_read_feeding(tUIPC_CH_ID channel_id)
     UINT16 bytes_needed = blocm_x_subband * btif_media_cb.encoder.s16NumOfChannels * \
                           btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8;
     static UINT16 up_sampled_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS
-            * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS * 2];
+            * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS * 4];
     static UINT16 read_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS
-            * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS];
+            * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS * 2];
     UINT32 src_size_used;
     UINT32 dst_size_used;
     BOOLEAN fract_needed;
@@ -3810,7 +3945,7 @@ BOOLEAN btif_media_aa_read_feeding(tUIPC_CH_ID channel_id)
     if (sbc_sampling == btif_media_cb.media_feeding.cfg.pcm.sampling_freq) {
         read_size = bytes_needed - btif_media_cb.media_feeding_state.pcm.aa_feed_residue;
         nb_byte_read = UIPC_Read(channel_id, &event,
-                  ((UINT8 *)btif_media_cb.encoder.as16PcmBuffer) +
+                  ((UINT8 *)btif_media_cb.encoder.as32PcmBuffer) +
                   btif_media_cb.media_feeding_state.pcm.aa_feed_residue,
                   read_size);
         if (nb_byte_read == read_size) {
@@ -3929,7 +4064,7 @@ BOOLEAN btif_media_aa_read_feeding(tUIPC_CH_ID channel_id)
     if(btif_media_cb.media_feeding_state.pcm.aa_feed_residue >= bytes_needed)
     {
         /* Copy the output pcm samples in SBC encoding buffer */
-        memcpy((UINT8 *)btif_media_cb.encoder.as16PcmBuffer,
+        memcpy((UINT8 *)btif_media_cb.encoder.as32PcmBuffer,
                 (UINT8 *)up_sampled_buffer,
                 bytes_needed);
         /* update the residue */
@@ -3964,7 +4099,7 @@ static void btif_media_aa_prep_sbc_2_send(UINT8 nb_frame,
                              btif_media_cb.encoder.s16NumOfBlocks;
 
     while (nb_frame) {
-        BT_HDR *p_buf = osi_malloc(BTIF_MEDIA_AA_BUF_SIZE);
+        BT_HDR *p_buf = (BT_HDR *)osi_malloc(BTIF_MEDIA_AA_BUF_SIZE);
 
         /* Init buffer */
         p_buf->offset = BTIF_MEDIA_AA_SBC_OFFSET;
@@ -3976,12 +4111,14 @@ static void btif_media_aa_prep_sbc_2_send(UINT8 nb_frame,
             /* Write @ of allocated buffer in encoder.pu8Packet */
             btif_media_cb.encoder.pu8Packet = (UINT8 *) (p_buf + 1) + p_buf->offset + p_buf->len;
             /* Fill allocated buffer with 0 */
-            memset(btif_media_cb.encoder.as16PcmBuffer, 0, blocm_x_subband
-                    * btif_media_cb.encoder.s16NumOfChannels);
+            memset(btif_media_cb.encoder.as32PcmBuffer, 0, blocm_x_subband
+                               * btif_media_cb.encoder.s16NumOfChannels * 2);
 
             /* Read PCM data and upsample them if needed */
             if (btif_media_aa_read_feeding(UIPC_CH_ID_AV_AUDIO))
             {
+                size_t frames  = blocm_x_subband * btif_media_cb.encoder.s16NumOfChannels;
+                memcpy_by_audio_format(btif_media_cb.encoder.as16PcmBuffer, AUDIO_FORMAT_PCM_16_BIT, btif_media_cb.encoder.as32PcmBuffer, AUDIO_FORMAT_PCM_8_24_BIT, frames);
                 SBC_Encoder(&(btif_media_cb.encoder));
 
                 /* Update SBC frame length */
@@ -4199,7 +4336,7 @@ void disconnect_a2dp_on_vendor_start_failure()
 
 void btif_media_send_reset_vendor_state()
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = BTIF_MEDIA_RESET_VS_STATE;
     if (btif_media_cmd_msg_queue != NULL)
@@ -4227,7 +4364,7 @@ void btif_media_start_vendor_command()
 
 void btif_media_on_start_vendor_command()
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     p_buf->event = BTIF_MEDIA_START_VS_CMD;
     if (btif_media_cmd_msg_queue != NULL)
@@ -4236,7 +4373,7 @@ void btif_media_on_start_vendor_command()
 
 void btif_media_on_stop_vendor_command()
 {
-    BT_HDR *p_buf = osi_malloc(sizeof(BT_HDR));
+    BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     APPL_TRACE_IMP("btif_media_on_stop_vendor_command");
     p_buf->event = BTIF_MEDIA_STOP_VS_CMD;
@@ -4255,7 +4392,7 @@ void btif_media_a2dp_start_cb(tBTM_VSC_CMPL *param)
     }
     APPL_TRACE_IMP("VS_QHCI_START_A2DP_MEDIA sent with error code: %u", status);
 
-    p_buf = osi_malloc(sizeof(BT_HDR));
+    p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     if (!status)
         p_buf->event = BTIF_MEDIA_VS_A2DP_START_SUCCESS;
@@ -4300,7 +4437,7 @@ void btif_media_a2dp_stop_cb(tBTM_VSC_CMPL *param)
     }
     APPL_TRACE_IMP("VS_QHCI_STOP_A2DP_MEDIA sent with error code: %u", status);
 
-    p_buf = osi_malloc(sizeof(BT_HDR));
+    p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 
     if (!status)
         p_buf->event = BTIF_MEDIA_VS_A2DP_STOP_SUCCESS;
@@ -4348,7 +4485,7 @@ void btif_media_selected_codec_cb(tBTM_VSC_CMPL *param)
 
     if (!status)
     {
-        p_buf = osi_malloc(sizeof(BT_HDR));
+        p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
         p_buf->event = BTIF_MEDIA_VS_A2DP_SELECTED_CODEC_SUCCESS;
         if (btif_media_cmd_msg_queue != NULL)
             fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
@@ -4365,11 +4502,11 @@ void btif_media_selected_codec_cb(tBTM_VSC_CMPL *param)
 
 BOOLEAN btif_media_send_vendor_selected_codec()
 {
-    UINT8 param[12], codec_type = A2DP_CODEC_SBC;//bta_av_get_current_code();
+    UINT8 param[12], codec_type = A2DP_CODEC_SBC;
     UINT16 index = 0;
 
-    codec_type = bta_av_get_current_codec();
-    if (codec_type == 0xFF)
+    codec_type = bta_av_co_get_current_codec();
+    if (codec_type == A2D_NON_A2DP_MEDIA_CT)
         codec_type = A2DP_CODEC_APTX;
 
     APPL_TRACE_IMP("btif_media_send_selected_codec: codec: %d", codec_type);
@@ -4408,7 +4545,7 @@ void btif_media_transport_cfg_cb(tBTM_VSC_CMPL *param)
 
     if (!status)
     {
-        p_buf = osi_malloc(sizeof(BT_HDR));
+        p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
         p_buf->event = BTIF_MEDIA_VS_A2DP_TRANSPORT_CFG_SUCCESS;
         if (btif_media_cmd_msg_queue != NULL)
             fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
@@ -4425,11 +4562,11 @@ void btif_media_transport_cfg_cb(tBTM_VSC_CMPL *param)
 BOOLEAN btif_media_send_vendor_transport_cfg()
 {
     UINT8 param[3];
-    UINT8 codec_type = bta_av_get_current_codec();
+    UINT8 codec_type = bta_av_co_get_current_codec();
     UINT8 stream_type;
     APPL_TRACE_IMP("btif_media_send_vendor_transport_cfg: codec: %d", codec_type);
     stream_type = codec_type;
-    if (codec_type == 0xFF)
+    if (codec_type == A2D_NON_A2DP_MEDIA_CT)
         stream_type = A2DP_TRANSPORT_STREAM_TYPE_APTX;
     param[0] = VS_QHCI_A2DP_TRANSPORT_CONFIGURATION;
     param[1] = A2DP_TRANSPORT_TYPE_SLIMBUS;
@@ -4453,7 +4590,7 @@ void btif_media_a2dp_media_chn_cfg_cb(tBTM_VSC_CMPL *param)
 
     if (!status)
     {
-        p_buf = osi_malloc(sizeof(BT_HDR));
+        p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
         p_buf->event = BTIF_MEDIA_VS_A2DP_MEDIA_CHNL_CFG_SUCCESS;
         if (btif_media_cmd_msg_queue != NULL)
             fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
@@ -4506,7 +4643,7 @@ void btif_media_a2dp_write_sbc_cfg_cb(tBTM_VSC_CMPL *param)
 
     if (!status)
     {
-        p_buf = osi_malloc(sizeof(BT_HDR));
+        p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
         p_buf->event = BTIF_MEDIA_VS_A2DP_WRITE_SBC_CFG_SUCCESS;
         if (btif_media_cmd_msg_queue != NULL)
             fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
@@ -4576,7 +4713,7 @@ void btif_media_pref_bit_rate_cb(tBTM_VSC_CMPL *param)
 
     if (!status)
     {
-        p_buf = osi_malloc(sizeof(BT_HDR));
+        p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
         p_buf->event = BTIF_MEDIA_VS_A2DP_PREF_BIT_RATE_SUCCESS;
         if (btif_media_cmd_msg_queue != NULL)
             fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);
@@ -4618,7 +4755,7 @@ void btif_media_scmst_cb(tBTM_VSC_CMPL *param)
 
     if (!status)
     {
-        p_buf = osi_malloc(sizeof(BT_HDR));
+        p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
         p_buf->event = BTIF_MEDIA_VS_A2DP_SET_SCMST_HDR_SUCCESS;
         if (btif_media_cmd_msg_queue != NULL)
             fixed_queue_enqueue(btif_media_cmd_msg_queue, p_buf);

--- a/btif/src/btif_rc.c
+++ b/btif/src/btif_rc.c
@@ -401,7 +401,6 @@ extern BOOLEAN btif_av_is_playing();
 extern BOOLEAN btif_av_is_device_connected(BD_ADDR address);
 extern void btif_av_trigger_dual_handoff(BOOLEAN handoff, BD_ADDR address);
 extern BOOLEAN btif_hf_is_call_idle();
-extern BOOLEAN btif_av_get_multicast_state();
 extern BOOLEAN btif_av_is_current_device(BD_ADDR address);
 extern UINT16 btif_av_get_num_connected_devices(void);
 extern UINT16 btif_av_get_num_playing_devices(void);

--- a/embdrv/sbc/encoder/include/sbc_encoder.h
+++ b/embdrv/sbc/encoder/include/sbc_encoder.h
@@ -175,6 +175,7 @@ typedef struct SBC_ENC_PARAMS_TAG
     SINT16 *ps16PcmBuffer;
 #else
     SINT16 as16PcmBuffer[SBC_MAX_NUM_FRAME*SBC_MAX_NUM_OF_BLOCKS * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS];
+    SINT32 as32PcmBuffer[SBC_MAX_NUM_FRAME*SBC_MAX_NUM_OF_BLOCKS * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS];
 #endif
 
     SINT16  s16ScartchMemForBitAlloc[16];

--- a/include/bt_target.h
+++ b/include/bt_target.h
@@ -1,4 +1,4 @@
-/******************************************************************************
+ /******************************************************************************
  *  Copyright (c) 2016, The Linux Foundation. All rights reserved.
  *
  *  Not a contribution.
@@ -138,7 +138,7 @@
 #endif
 
 #ifndef BTIF_A2DP_SRC_BIT_DEPTH
-#define BTIF_A2DP_SRC_BIT_DEPTH 16
+#define BTIF_A2DP_SRC_BIT_DEPTH 32
 #endif
 
 #ifndef BTIF_A2DP_SRC_NUM_CHANNELS
@@ -1210,9 +1210,9 @@
  */
 #ifndef AVDT_NUM_SEPS
 #if defined(AAC_ENCODER_INCLUDED) && (AAC_ENCODER_INCLUDED == TRUE)
-#define AVDT_NUM_SEPS               7
+#define AVDT_NUM_SEPS               9
 #else
-#define AVDT_NUM_SEPS               5
+#define AVDT_NUM_SEPS               7
 #endif
 #endif
 

--- a/main/Android.mk
+++ b/main/Android.mk
@@ -53,7 +53,8 @@ LOCAL_C_INCLUDES+= . \
 	$(LOCAL_PATH)/../utils/include \
 	$(bluetooth_C_INCLUDES) \
 	external/tinyxml2 \
-	external/zlib
+    external/zlib \
+    $(call include-path-for, audio-utils)
 
 LOCAL_SHARED_LIBRARIES := \
     libcutils \
@@ -64,7 +65,8 @@ LOCAL_SHARED_LIBRARIES := \
     libprotobuf-cpp-full \
     libmedia \
     libutils \
-    libchrome
+    libchrome \
+    libaudioutils
 
 LOCAL_STATIC_LIBRARIES := \
     libtinyxml2 \

--- a/osi/src/alarm.c
+++ b/osi/src/alarm.c
@@ -607,6 +607,7 @@ static void alarm_queue_ready(fixed_queue_t *queue,
     alarm->deadline = 0;
     alarm->callback = NULL;
     alarm->data = NULL;
+    alarm->queue = NULL;
   }
 
   pthread_mutex_lock(&alarm->callback_lock);

--- a/stack/Android.mk
+++ b/stack/Android.mk
@@ -39,6 +39,7 @@ LOCAL_SRC_FILES:= \
     ./a2dp/a2d_api.c \
     ./a2dp/a2d_sbc.c \
     ./a2dp/a2d_aptx.c \
+    ./a2dp/a2d_aptx_hd.c \
     ./a2dp/a2d_aac.c \
     ./avrc/avrc_api.c \
     ./avrc/avrc_sdp.c \

--- a/stack/a2dp/a2d_aptx.c
+++ b/stack/a2dp/a2d_aptx.c
@@ -44,6 +44,7 @@
 #include "a2d_api.h"
 #include "a2d_int.h"
 #include "a2d_aptx.h"
+#include "a2d_aptx_hd.h"
 #include <utils/Log.h>
 
 const char* A2D_APTX_SCHED_LIB_NAME = "libaptXScheduler.so";
@@ -277,19 +278,45 @@ void A2D_deinit_aptX(void)
 
     if (isA2dAptXEnabled && A2dAptXSchedLibHandle)
     {
-       // remove aptX thread
-       if (A2d_aptx_thread)
-       {
-           A2D_aptx_sched_stop();
-           thread_free(A2d_aptx_thread);
-           A2d_aptx_thread = NULL;
-       }
-
-       A2D_aptx_encoder_deinit();
-       dlclose(A2dAptXSchedLibHandle);
-       A2dAptXSchedLibHandle = NULL;
-       isA2dAptXEnabled = false;
+        A2D_aptx_encoder_deinit();
+        isA2dAptXEnabled = false;
+    }
+
+    return;
+}
+
+/*******************************************************************************
+**
+** Function         A2D_close_aptX
+**
+** Description      This function close aptX
+**
+** Returns          Nothing
+**
+*******************************************************************************/
+void A2D_close_aptX(void)
+{
+    A2D_TRACE_DEBUG("%s", __func__);
+
+    if (A2dAptXSchedLibHandle)
+    {
+        // remove aptX thread
+        if (A2d_aptx_thread)
+        {
+            A2D_aptx_sched_stop();
+            thread_free(A2d_aptx_thread);
+            A2d_aptx_thread = NULL;
+        }
     }
 
+    // de-initialize aptX HD
+    A2D_deinit_aptX_HD();
+
+    // de-initialize aptX
+    A2D_deinit_aptX();
+
+    dlclose(A2dAptXSchedLibHandle);
+    A2dAptXSchedLibHandle = NULL;
+
     return;
 }

--- /dev/null
+++ b/stack/a2dp/a2d_aptx_hd.c
@@ -0,0 +1,251 @@
+/******************************************************************************
+
+    Copyright (c) 2016, The Linux Foundation. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the name of The Linux Foundation nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+    WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+    ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+    BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+    OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+    IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ******************************************************************************/
+/******************************************************************************
+
+    Utility functions to help build and parse the aptX HD Codec Information
+    Element and Media Payload.
+
+******************************************************************************/
+
+#include "bt_target.h"
+
+#include <string.h>
+#include <dlfcn.h>
+#include "osi/include/thread.h"
+#include "bt_utils.h"
+#include "a2d_api.h"
+#include "a2d_int.h"
+#include "a2d_aptx.h"
+#include "a2d_aptx_hd.h"
+#include <utils/Log.h>
+
+
+BOOLEAN isA2dAptXHdEnabled = FALSE;
+
+int (*A2D_aptx_hd_encoder_init)(void);
+void (*A2D_aptx_hd_encoder_deinit)(void);
+
+/******************************************************************************
+**
+** Function         A2D_BldAptx_hdInfo
+**
+******************************************************************************/
+UINT8 A2D_BldAptx_hdInfo(UINT8 media_type, tA2D_APTX_HD_CIE *p_ie, UINT8 *p_result)
+{
+    A2D_TRACE_API("%s: - MediaType:%d", __func__, media_type);
+
+    UINT8 status = 0;
+    status = A2D_SUCCESS;
+    *p_result++ = A2D_APTX_HD_CODEC_LEN;
+    *p_result++ = media_type;
+    *p_result++ = A2D_NON_A2DP_MEDIA_CT;
+    *p_result++ = (UINT8)(p_ie->vendorId & 0x000000FF);
+    *p_result++ = (UINT8)(p_ie->vendorId & 0x0000FF00)>> 8;
+    *p_result++ = (UINT8)(p_ie->vendorId & 0x00FF0000)>> 16;
+    *p_result++ = (UINT8)(p_ie->vendorId & 0xFF000000)>> 24;
+    *p_result++ = (UINT8)(p_ie->codecId & 0x00FF);
+    *p_result++ = (UINT8)(p_ie->codecId & 0xFF00) >> 8;
+    *p_result++ = p_ie->sampleRate | p_ie->channelMode;
+    *p_result++ = p_ie->acl_sprint_reserved0;
+    *p_result++ = p_ie->acl_sprint_reserved1;
+    *p_result++ = p_ie->acl_sprint_reserved2;
+    *p_result++ = p_ie->acl_sprint_reserved3;
+    return status;
+}
+
+/******************************************************************************
+**
+** Function         A2D_ParsAptx_hdInfo
+**
+******************************************************************************/
+tA2D_STATUS A2D_ParsAptx_hdInfo(tA2D_APTX_HD_CIE *p_ie, UINT8 *p_info, BOOLEAN for_caps)
+{
+    tA2D_STATUS status;
+    UINT8 losc;
+    UINT8 mt;
+
+    A2D_TRACE_API("%s: - MediaType:%d", __func__, for_caps);
+
+    if (p_ie == NULL || p_info == NULL)
+    {
+        A2D_TRACE_ERROR("A2D_ParsAptx_hdInfo - Invalid Params");
+        status = A2D_INVALID_PARAMS;
+    }
+    else
+    {
+        losc    = *p_info++;
+        mt      = *p_info++;
+        A2D_TRACE_DEBUG("%s: losc %d, mt %02x", __func__, losc, mt);
+
+        /* If the function is called for the wrong Media Type or Media Codec Type */
+        if (losc != A2D_APTX_HD_CODEC_LEN || *p_info != A2D_NON_A2DP_MEDIA_CT) {
+            A2D_TRACE_ERROR("%s: wrong media type %02x", __func__, *p_info);
+            status = A2D_WRONG_CODEC;
+        }
+        else
+        {
+            p_info++;
+            p_ie->vendorId = (*p_info & 0x000000FF) |
+                             (*(p_info+1) << 8   & 0x0000FF00) |
+                             (*(p_info+2) << 16  & 0x00FF0000) |
+                             (*(p_info+3) << 24  & 0xFF000000);
+            p_info = p_info+4;
+            p_ie->codecId = (*p_info & 0x00FF) | (*(p_info+1) << 8 & 0xFF00);
+            p_info = p_info+2;
+            p_ie->channelMode= *p_info & 0x0F;
+            p_ie->sampleRate = *p_info & 0xF0;
+            p_info = p_info+1;
+            p_ie->acl_sprint_reserved0 = *(p_info ++);
+            p_ie->acl_sprint_reserved1 = *(p_info ++);
+            p_ie->acl_sprint_reserved2 = *(p_info ++);
+            p_ie->acl_sprint_reserved3 = *(p_info ++);
+
+            status = A2D_SUCCESS;
+
+            if (for_caps == FALSE)
+            {
+                if (A2D_BitsSet(p_ie->sampleRate) != A2D_SET_ONE_BIT)
+                    status = A2D_BAD_SAMP_FREQ;
+                if (A2D_BitsSet(p_ie->channelMode) != A2D_SET_ONE_BIT)
+                    status = A2D_BAD_CH_MODE;
+            }
+        }
+    }
+    return status;
+}
+
+/*******************************************************************************
+**
+** Function         a2d_av_aptx_hd_cfg_in_cap
+**
+** Description      This function checks whether an aptX HD codec configuration
+**                  is allowable for the given codec capabilities.
+**
+** Returns          0 if ok, nonzero if error.
+**
+*******************************************************************************/
+UINT8 a2d_av_aptx_hd_cfg_in_cap(UINT8 *p_cfg, tA2D_APTX_HD_CIE *p_cap)
+{
+    UINT8 status = 0;
+    tA2D_APTX_HD_CIE cfg_cie;
+
+    A2D_TRACE_API("%s", __func__);
+
+    /* parse configuration */
+    if ((status = A2D_ParsAptx_hdInfo(&cfg_cie, p_cfg, FALSE)) != 0)
+    {
+        A2D_TRACE_ERROR("%s: aptX HD parse failed", __func__);
+        return status;
+    }
+
+    /* verify that each parameter is in range */
+
+    /* sampling frequency */
+    if ((cfg_cie.sampleRate & p_cap->sampleRate) == 0)
+        status = A2D_NS_SAMP_FREQ;
+    /* channel mode */
+    else if ((cfg_cie.channelMode & p_cap->channelMode) == 0)
+        status = A2D_NS_CH_MODE;
+
+    return status;
+}
+
+/*******************************************************************************
+**
+** Function         A2D_check_and_init_aptX_HD
+**
+** Description      This function checks if all the libraries required for
+**                  aptX HD are present and needed function pointers are resolved
+**
+** Returns          returns true if aptX HD codec initialization succeeds
+**
+*******************************************************************************/
+BOOLEAN A2D_check_and_init_aptX_HD(void)
+{
+    A2D_TRACE_DEBUG("%s", __func__);
+
+    if (isA2dAptXEnabled && A2dAptXSchedLibHandle)
+    {
+        A2D_aptx_hd_encoder_init = (int (*)(void))dlsym(A2dAptXSchedLibHandle,
+                                                   "aptx_hd_encoder_init");
+        if (!A2D_aptx_hd_encoder_init)
+        {
+            A2D_TRACE_ERROR("%s: aptX HD encoder init missing", __func__);
+            goto error_exit;
+        }
+
+        A2D_aptx_hd_encoder_deinit = (void (*)(void))dlsym(A2dAptXSchedLibHandle,
+                                                      "aptx_hd_encoder_deinit");
+        if (!A2D_aptx_hd_encoder_deinit)
+        {
+            A2D_TRACE_ERROR("%s: aptX HD encoder deinit missing", __func__);
+            goto error_exit;
+        }
+
+        if (A2D_aptx_hd_encoder_init())
+        {
+            A2D_TRACE_ERROR("%s: aptX HD encoder init failed - %s", __func__, dlerror());
+            goto error_exit;
+        }
+    } else {
+        A2D_TRACE_ERROR("%s: isA2dAptXEnabled = false", __func__);
+        goto error_exit;
+    }
+    isA2dAptXHdEnabled = true;
+    return isA2dAptXHdEnabled;
+
+ error_exit:;
+    isA2dAptXHdEnabled = false;
+    return isA2dAptXHdEnabled;
+
+}
+
+/*******************************************************************************
+**
+** Function         A2D_deinit_aptX_HD
+**
+** Description      This function de-initialized aptX HD
+**
+** Returns          Nothing
+**
+*******************************************************************************/
+void A2D_deinit_aptX_HD(void)
+{
+    A2D_TRACE_DEBUG("%s", __func__);
+
+    if (isA2dAptXHdEnabled && isA2dAptXEnabled && A2dAptXSchedLibHandle)
+    {
+       A2D_aptx_hd_encoder_deinit();
+       isA2dAptXHdEnabled = false;
+    }
+
+    return;
+}

--- a/stack/avdt/avdt_scb_act.c
+++ b/stack/avdt/avdt_scb_act.c
@@ -69,9 +69,7 @@ const UINT8 avdt_scb_role_evt[] = {
     AVDT_OPEN_CFM_EVT           /* AVDT_OPEN_INT */
 };
 
-extern UINT8* bta_av_get_current_codecInfo();
 
-#define NON_A2DP_MEDIA_CT 0xff
 /*******************************************************************************
 **
 ** Function         avdt_scb_gen_ssrc
@@ -1239,11 +1237,9 @@ void avdt_scb_hdl_write_req_no_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
     }
     osi_free_and_reset((void **)&p_scb->p_pkt);
 
-    /* build a media packet if the codec type is not aptX */
-#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE)
-#else
-    if (p_data->apiwrite.m_pt != NON_A2DP_MEDIA_CT)
-#endif
+    /* build a media packet */
+    /* Add RTP header if required */
+    if ( !(p_data->apiwrite.opt & AVDT_DATA_OPT_NO_RTP) )
     {
         ssrc = avdt_scb_gen_ssrc(p_scb);
 

--- a/stack/include/a2d_api.h
+++ b/stack/include/a2d_api.h
@@ -86,7 +86,7 @@
 #define A2D_BAD_CP_FORMAT     0xE1  /* The format of Content Protection Service Capability/Content Protection Scheme Dependent Data is not correct. */
 
 
-#define A2D_NON_A2DP_MEDIA_CT 0xff  /* NON A2DP media codec */
+#define A2D_NON_A2DP_MEDIA_CT 0xFF  /* NON A2DP media codec */
 
 typedef UINT8 tA2D_STATUS;
 

--- a/stack/include/a2d_aptx.h
+++ b/stack/include/a2d_aptx.h
@@ -60,8 +60,7 @@
 typedef enum {
     APTX_CODEC_NONE=0,
     APTX_CODEC,
-    APTX_CODEC_LL,
-    APTX_CODEC_HD,
+    APTX_HD_CODEC,
 } A2D_AptXCodecType;
 
 typedef void (*A2D_AptXThreadFn)(void *context);
@@ -122,6 +121,7 @@ extern void (*A2D_aptx_encoder_deinit)(void);
 extern UINT8 a2d_av_aptx_cfg_in_cap(UINT8 *p_cfg, tA2D_APTX_CIE *p_cap);
 extern BOOLEAN A2D_check_and_init_aptX();
 extern void A2D_deinit_aptX();
+extern void A2D_close_aptX();
 
 #ifdef __cplusplus
 }

--- /dev/null
+++ b/stack/include/a2d_aptx_hd.h
@@ -0,0 +1,105 @@
+/******************************************************************************
+
+    Copyright (c) 2016, The Linux Foundation. All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the name of The Linux Foundation nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+    WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+    ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+    BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+    SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+    BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+    OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+    IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ ******************************************************************************/
+/******************************************************************************
+   interface to aptX HD codec
+ ******************************************************************************/
+#ifndef A2D_APTX_HD_H
+#define A2D_APTX_HD_H
+
+/* aptX HD codec specific settings*/
+#define A2D_APTX_HD_CODEC_LEN         13
+
+#define A2D_APTX_HD_VENDOR_ID               (0x000000D7)
+#define A2D_APTX_HD_CODEC_ID_BLUETOOTH      ((UINT16) 0x0024)
+#define A2D_APTX_HD_SAMPLERATE_44100        (0x20)
+#define A2D_APTX_HD_SAMPLERATE_48000        (0x10)
+#define A2D_APTX_HD_CHANNELS_STEREO         (0x02)
+#define A2D_APTX_HD_CHANNELS_MONO           (0x01)
+#define A2D_APTX_HD_ACL_SPRINT_RESERVED0    (0x00)
+#define A2D_APTX_HD_ACL_SPRINT_RESERVED1    (0x00)
+#define A2D_APTX_HD_ACL_SPRINT_RESERVED2    (0x00)
+#define A2D_APTX_HD_ACL_SPRINT_RESERVED3    (0x00)
+#define A2D_APTX_HD_OTHER_FEATURES_NONE     (0x00000000)
+#define A2D_APTX_HD_AV_AUDIO                (0x00)
+#define A2D_APTX_HD_CODEC_ID                (0xff)
+#define A2D_APTX_HD_CHANNEL                 (0x0001)
+#define A2D_APTX_HD_SAMPLERATE              (0x22)
+
+/*****************************************************************************
+**  Type Definitions
+*****************************************************************************/
+
+typedef struct {
+    UINT32 vendorId;
+    UINT16 codecId;         /* Codec ID for aptX HD */
+    UINT8  sampleRate;      /* Sampling Frequency */
+    UINT8  channelMode;     /* STEREO/DUAL/MONO */
+    UINT8 acl_sprint_reserved0;
+    UINT8 acl_sprint_reserved1;
+    UINT8 acl_sprint_reserved2;
+    UINT8 acl_sprint_reserved3;
+} tA2D_APTX_HD_CIE;
+
+typedef struct {
+    INT16 s16SamplingFreq;     /* 16k, 32k, 44.1k or 48k*/
+    INT16 s16ChannelMode;      /* mono, dual, streo or joint streo*/
+    UINT16 u16BitRate;
+    UINT16 *ps16NextPcmBuffer;
+    UINT8  *pu8Packet;
+    UINT8  *pu8NextPacket;
+    UINT16 u16PacketLength;
+    void* encoder;
+} A2D_APTX_HD_ENC_PARAMS;
+
+extern BOOLEAN isA2dAptXHdEnabled;
+
+/*****************************************************************************
+**  external function declarations
+*****************************************************************************/
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+extern UINT8 A2D_BldAptx_hdInfo(UINT8 media_type, tA2D_APTX_HD_CIE *p_ie,
+                             UINT8 *p_result);
+extern UINT8 A2D_ParsAptx_hdInfo(tA2D_APTX_HD_CIE *p_ie, UINT8 *p_info,
+                              BOOLEAN for_caps);
+extern int (*A2D_aptx_hd_encoder_init)(void);
+extern void (*A2D_aptx_hd_encoder_deinit)(void);
+extern UINT8 a2d_av_aptx_hd_cfg_in_cap(UINT8 *p_cfg, tA2D_APTX_HD_CIE *p_cap);
+extern BOOLEAN A2D_check_and_init_aptX_HD();
+extern void A2D_deinit_aptX_HD();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* A2D_APTX_HD_H */

--- a/stack/l2cap/l2c_csm.c
+++ b/stack/l2cap/l2c_csm.c
@@ -234,7 +234,7 @@ Event uninit_use_in_call: Using uninitialized value "settings.min" in call to fu
         p_ccb->chnl_state = CST_W4_L2CAP_CONNECT_RSP;
 
         /* Wait for the info resp in this state before sending connect req (if needed) */
-        if ((!p_ccb->p_lcb->w4_info_rsp) || (BT_PSM_SDP == p_ccb->p_rcb->psm))
+        if (!p_ccb->p_lcb->w4_info_rsp)
         {
             /* Need to have at least one compatible channel to continue */
             if (!l2c_fcr_chk_chan_modes(p_ccb))

--- a/stack/sdp/sdp_discovery.c
+++ b/stack/sdp/sdp_discovery.c
@@ -347,7 +347,7 @@ static void process_service_search_rsp (tCONN_CB *p_ccb, UINT8 *p_reply)
 #if (SDP_RAW_DATA_INCLUDED == TRUE)
 static void sdp_copy_raw_data (tCONN_CB *p_ccb, BOOLEAN offset)
 {
-    unsigned int    cpy_len;
+    unsigned int    cpy_len, rem_len;
     UINT32          list_len;
     UINT8           *p;
     UINT8           type;
@@ -378,6 +378,12 @@ static void sdp_copy_raw_data (tCONN_CB *p_ccb, BOOLEAN offset)
         {
             cpy_len = list_len;
         }
+        rem_len = SDP_MAX_LIST_BYTE_COUNT - (unsigned int) (p - &p_ccb->rsp_list[0]);
+        if (cpy_len > rem_len)
+        {
+            SDP_TRACE_WARNING("rem_len :%d less than cpy_len:%d", rem_len, cpy_len);
+            cpy_len = rem_len;
+        }
 #if (SDP_DEBUG_RAW == TRUE)
         SDP_TRACE_WARNING("list_len :%d cpy_len:%d raw_size:%d raw_used:%d",
             list_len, cpy_len, p_ccb->p_db->raw_size, p_ccb->p_db->raw_used);