Logging cleanup: A2D, AVDT, and AVCT.

Change-Id: I5a9d4bcdd65f6e965b434bf86949bba7155fd300

14 files changed, 168 insertions, 168 deletions

diff --git a/stack/a2dp/a2d_api.c b/stack/a2dp/a2d_api.c
index 71dcc1344..f0f4a8334 100644
--- a/stack/a2dp/a2d_api.c
+++ b/stack/a2dp/a2d_api.c
@@ -59,7 +59,7 @@ static void a2d_sdp_cback(UINT16 status)
     tA2D_Service        a2d_svc;
     tSDP_PROTOCOL_ELEM  elem;
 
-    A2D_TRACE_API1("a2d_sdp_cback status: %d", status);
+    A2D_TRACE_API("a2d_sdp_cback status: %d", status);
 
     if (status == SDP_SUCCESS)
     {
@@ -101,7 +101,7 @@ static void a2d_sdp_cback(UINT16 status)
             if (SDP_FindProtocolListElemInRec(p_rec, UUID_PROTOCOL_AVDTP, &elem))
             {
                 a2d_svc.avdt_version = elem.params[0];
-                A2D_TRACE_DEBUG1("avdt_version: 0x%x", a2d_svc.avdt_version);
+                A2D_TRACE_DEBUG("avdt_version: 0x%x", a2d_svc.avdt_version);
             }
 
             /* we've got everything, we're done */
@@ -175,7 +175,7 @@ tA2D_STATUS A2D_AddRecord(UINT16 service_uuid, char *p_service_name, char *p_pro
     UINT8       *p;
     tSDP_PROTOCOL_ELEM  proto_list [A2D_NUM_PROTO_ELEMS];
 
-    A2D_TRACE_API1("A2D_AddRecord uuid: %x", service_uuid);
+    A2D_TRACE_API("A2D_AddRecord uuid: %x", service_uuid);
 
     if( (sdp_handle == 0) ||
         (service_uuid != UUID_SERVCLASS_AUDIO_SOURCE && service_uuid != UUID_SERVCLASS_AUDIO_SINK) )
@@ -277,7 +277,7 @@ tA2D_STATUS A2D_FindService(UINT16 service_uuid, BD_ADDR bd_addr,
                                    ATTR_ID_PROTOCOL_DESC_LIST,
                                    ATTR_ID_PROVIDER_NAME};
 
-    A2D_TRACE_API1("A2D_FindService uuid: %x", service_uuid);
+    A2D_TRACE_API("A2D_FindService uuid: %x", service_uuid);
     if( (service_uuid != UUID_SERVCLASS_AUDIO_SOURCE && service_uuid != UUID_SERVCLASS_AUDIO_SINK) ||
         p_db == NULL || p_db->p_db == NULL || p_cback == NULL)
         return A2D_INVALID_PARAMS;
diff --git a/stack/avct/avct_api.c b/stack/avct/avct_api.c
index d590cb552..5b27cc879 100644
--- a/stack/avct/avct_api.c
+++ b/stack/avct/avct_api.c
@@ -56,7 +56,7 @@ void AVCT_Register(UINT16 mtu, UINT16 mtu_br, UINT8 sec_mask)
 {
     UNUSED(mtu_br);
 
-    AVCT_TRACE_API0("AVCT_Register");
+    AVCT_TRACE_API("AVCT_Register");
 
     /* register PSM with L2CAP */
     L2CA_Register(AVCT_PSM, (tL2CAP_APPL_INFO *) &avct_l2c_appl);
@@ -108,7 +108,7 @@ void AVCT_Register(UINT16 mtu, UINT16 mtu_br, UINT8 sec_mask)
 *******************************************************************************/
 void AVCT_Deregister(void)
 {
-    AVCT_TRACE_API0("AVCT_Deregister");
+    AVCT_TRACE_API("AVCT_Deregister");
 
     /* deregister PSM with L2CAP */
     L2CA_Deregister(AVCT_PSM);
@@ -136,7 +136,7 @@ UINT16 AVCT_CreateConn(UINT8 *p_handle, tAVCT_CC *p_cc, BD_ADDR peer_addr)
     tAVCT_CCB   *p_ccb;
     tAVCT_LCB   *p_lcb;
 
-    AVCT_TRACE_API2("AVCT_CreateConn: %d, control:%d", p_cc->role, p_cc->control);
+    AVCT_TRACE_API("AVCT_CreateConn: %d, control:%d", p_cc->role, p_cc->control);
 
     /* Allocate ccb; if no ccbs, return failure */
     if ((p_ccb = avct_ccb_alloc(p_cc)) == NULL)
@@ -172,7 +172,7 @@ UINT16 AVCT_CreateConn(UINT8 *p_handle, tAVCT_CC *p_cc, BD_ADDR peer_addr)
             {
                 /* bind lcb to ccb */
                 p_ccb->p_lcb = p_lcb;
-                AVCT_TRACE_DEBUG1("ch_state: %d", p_lcb->ch_state);
+                AVCT_TRACE_DEBUG("ch_state: %d", p_lcb->ch_state);
                 avct_lcb_event(p_lcb, AVCT_LCB_UL_BIND_EVT, (tAVCT_LCB_EVT *) &p_ccb);
             }
         }
@@ -198,7 +198,7 @@ UINT16 AVCT_RemoveConn(UINT8 handle)
     UINT16              result = AVCT_SUCCESS;
     tAVCT_CCB           *p_ccb;
 
-    AVCT_TRACE_API0("AVCT_RemoveConn");
+    AVCT_TRACE_API("AVCT_RemoveConn");
 
     /* map handle to ccb */
     if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
@@ -242,7 +242,7 @@ UINT16 AVCT_CreateBrowse (UINT8 handle, UINT8 role)
     tAVCT_BCB   *p_bcb;
     int         index;
 
-    AVCT_TRACE_API1("AVCT_CreateBrowse: %d", role);
+    AVCT_TRACE_API("AVCT_CreateBrowse: %d", role);
 
     /* map handle to ccb */
     if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
@@ -285,7 +285,7 @@ UINT16 AVCT_CreateBrowse (UINT8 handle, UINT8 role)
         {
             /* bind bcb to ccb */
             p_ccb->p_bcb = p_bcb;
-            AVCT_TRACE_DEBUG1("ch_state: %d", p_bcb->ch_state);
+            AVCT_TRACE_DEBUG("ch_state: %d", p_bcb->ch_state);
             avct_bcb_event(p_bcb, AVCT_LCB_UL_BIND_EVT, (tAVCT_LCB_EVT *) &p_ccb);
         }
     }
@@ -317,7 +317,7 @@ UINT16 AVCT_RemoveBrowse (UINT8 handle)
     UINT16              result = AVCT_SUCCESS;
     tAVCT_CCB           *p_ccb;
 
-    AVCT_TRACE_API0("AVCT_RemoveBrowse");
+    AVCT_TRACE_API("AVCT_RemoveBrowse");
 
     /* map handle to ccb */
     if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
@@ -416,14 +416,14 @@ UINT16 AVCT_MsgReq(UINT8 handle, UINT8 label, UINT8 cr, BT_HDR *p_msg)
     tAVCT_CCB       *p_ccb;
     tAVCT_UL_MSG    ul_msg;
 
-    AVCT_TRACE_API0("AVCT_MsgReq");
+    AVCT_TRACE_API("AVCT_MsgReq");
 
     /* verify p_msg parameter */
     if (p_msg == NULL)
     {
         return AVCT_NO_RESOURCES;
     }
-    AVCT_TRACE_API1("len: %d", p_msg->len);
+    AVCT_TRACE_API("len: %d", p_msg->len);
 
     /* map handle to ccb */
     if ((p_ccb = avct_ccb_by_idx(handle)) == NULL)
diff --git a/stack/avct/avct_ccb.c b/stack/avct/avct_ccb.c
index 09051b1b9..f2c821c13 100644
--- a/stack/avct/avct_ccb.c
+++ b/stack/avct/avct_ccb.c
@@ -50,7 +50,7 @@ tAVCT_CCB *avct_ccb_alloc(tAVCT_CC *p_cc)
         {
             p_ccb->allocated = AVCT_ALOC_LCB;
             memcpy(&p_ccb->cc, p_cc, sizeof(tAVCT_CC));
-            AVCT_TRACE_DEBUG1("avct_ccb_alloc %d", i);
+            AVCT_TRACE_DEBUG("avct_ccb_alloc %d", i);
             break;
         }
     }
@@ -59,7 +59,7 @@ tAVCT_CCB *avct_ccb_alloc(tAVCT_CC *p_cc)
     {
         /* out of ccbs */
         p_ccb = NULL;
-        AVCT_TRACE_WARNING0("Out of ccbs");
+        AVCT_TRACE_WARNING("Out of ccbs");
     }
     return p_ccb;
 }
@@ -79,7 +79,7 @@ void avct_ccb_dealloc(tAVCT_CCB *p_ccb, UINT8 event, UINT16 result, BD_ADDR bd_a
 {
     tAVCT_CTRL_CBACK    *p_cback = p_ccb->cc.p_ctrl_cback;
 
-    AVCT_TRACE_DEBUG1("avct_ccb_dealloc %d", avct_ccb_to_idx(p_ccb));
+    AVCT_TRACE_DEBUG("avct_ccb_dealloc %d", avct_ccb_to_idx(p_ccb));
 #if (AVCT_BROWSE_INCLUDED == TRUE)
     if(p_ccb->p_bcb == NULL)
         memset(p_ccb, 0, sizeof(tAVCT_CCB));
@@ -138,13 +138,13 @@ tAVCT_CCB *avct_ccb_by_idx(UINT8 idx)
         if (!p_ccb->allocated)
         {
             p_ccb = NULL;
-            AVCT_TRACE_WARNING1("ccb %d not allocated", idx);
+            AVCT_TRACE_WARNING("ccb %d not allocated", idx);
         }
     }
     else
     {
         p_ccb = NULL;
-        AVCT_TRACE_WARNING1("No ccb for idx %d", idx);
+        AVCT_TRACE_WARNING("No ccb for idx %d", idx);
     }
     return p_ccb;
 }
diff --git a/stack/avct/avct_l2c.c b/stack/avct/avct_l2c.c
index aabcd0e1c..bb01e89b0 100644
--- a/stack/avct/avct_l2c.c
+++ b/stack/avct/avct_l2c.c
@@ -80,7 +80,7 @@ static BOOLEAN avct_l2c_is_passive (tAVCT_LCB *p_lcb)
     {
         if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb))
         {
-            AVCT_TRACE_DEBUG1("avct_l2c_is_ct control:x%x", p_ccb->cc.control);
+            AVCT_TRACE_DEBUG("avct_l2c_is_ct control:x%x", p_ccb->cc.control);
             if (p_ccb->cc.control & AVCT_PASSIVE)
             {
                 is_passive = TRUE;
@@ -130,13 +130,13 @@ void avct_l2c_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8
         {
             /* TG role only - accept the connection from CT. move the channel ID to the conflict list */
             p_lcb->conflict_lcid = p_lcb->ch_lcid;
-            AVCT_TRACE_DEBUG1("avct_l2c_connect_ind_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
+            AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
         }
     }
 
     if(p_lcb)
     {
-        AVCT_TRACE_DEBUG3("avct_l2c_connect_ind_cback: 0x%x, res: %d, ch_state: %d",
+        AVCT_TRACE_DEBUG("avct_l2c_connect_ind_cback: 0x%x, res: %d, ch_state: %d",
             lcid, result, p_lcb->ch_state);
     }
     /* Send L2CAP connect rsp */
@@ -156,12 +156,12 @@ void avct_l2c_connect_ind_cback(BD_ADDR bd_addr, UINT16 lcid, UINT16 psm, UINT8
         cfg.mtu_present = TRUE;
         cfg.mtu = avct_cb.mtu;
         L2CA_ConfigReq(lcid, &cfg);
-        AVCT_TRACE_DEBUG0("avct_l2c snd Cfg Req");
+        AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req");
     }
 
 #if (BT_USE_TRACES == TRUE)
     if(p_lcb)
-        AVCT_TRACE_DEBUG1("ch_state cni: %d ", p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("ch_state cni: %d ", p_lcb->ch_state);
 #endif
 }
 
@@ -183,7 +183,7 @@ void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result)
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
-        AVCT_TRACE_DEBUG4("avct_l2c_connect_cfm_cback lcid:0x%x result: %d ch_state: %d, conflict_lcid:0x%x",
+        AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback lcid:0x%x result: %d ch_state: %d, conflict_lcid:0x%x",
             lcid, result, p_lcb->ch_state, p_lcb->conflict_lcid);
         /* if in correct state */
         if (p_lcb->ch_state == AVCT_CH_CONN)
@@ -199,12 +199,12 @@ void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result)
                 cfg.mtu_present = TRUE;
                 cfg.mtu = avct_cb.mtu;
                 L2CA_ConfigReq(lcid, &cfg);
-                AVCT_TRACE_DEBUG0("avct_l2c snd Cfg Req");
+                AVCT_TRACE_DEBUG("avct_l2c snd Cfg Req");
             }
             /* else failure */
             else
             {
-                AVCT_TRACE_DEBUG1("avct_l2c_connect_cfm_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
+                AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback conflict_lcid:0x%x", p_lcb->conflict_lcid);
                 if (p_lcb->conflict_lcid == lcid)
                     p_lcb->conflict_lcid = 0;
                 else
@@ -214,7 +214,7 @@ void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result)
         else if (p_lcb->conflict_lcid == lcid)
         {
             /* we must be in AVCT_CH_CFG state for the ch_lcid channel */
-            AVCT_TRACE_DEBUG2("avct_l2c_connect_cfm_cback ch_state: %d, conflict_lcid:0x%x", p_lcb->ch_state, p_lcb->conflict_lcid);
+            AVCT_TRACE_DEBUG("avct_l2c_connect_cfm_cback ch_state: %d, conflict_lcid:0x%x", p_lcb->ch_state, p_lcb->conflict_lcid);
             if (result == L2CAP_CONN_OK)
             {
                 /* just in case the peer also accepts our connection - Send L2CAP disconnect req */
@@ -222,7 +222,7 @@ void avct_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result)
             }
             p_lcb->conflict_lcid = 0;
         }
-        AVCT_TRACE_DEBUG1("ch_state cnc: %d ", p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("ch_state cnc: %d ", p_lcb->ch_state);
     }
 }
 
@@ -243,7 +243,7 @@ void avct_l2c_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
-        AVCT_TRACE_DEBUG3("avct_l2c_config_cfm_cback: 0x%x, ch_state: %d, res: %d",
+        AVCT_TRACE_DEBUG("avct_l2c_config_cfm_cback: 0x%x, ch_state: %d, res: %d",
             lcid, p_lcb->ch_state, p_cfg->result);
         /* if in correct state */
         if (p_lcb->ch_state == AVCT_CH_CFG)
@@ -264,7 +264,7 @@ void avct_l2c_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
             /* else failure */
             else
             {
-                AVCT_TRACE_DEBUG1("ERROR avct_l2c_config_cfm_cback L2CA_DisconnectReq %d ", p_lcb->ch_state);
+                AVCT_TRACE_DEBUG("ERROR avct_l2c_config_cfm_cback L2CA_DisconnectReq %d ", p_lcb->ch_state);
                 /* store result value */
                 p_lcb->ch_result = p_cfg->result;
 
@@ -272,7 +272,7 @@ void avct_l2c_config_cfm_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
                 L2CA_DisconnectReq(lcid);
             }
         }
-        AVCT_TRACE_DEBUG1("ch_state cfc: %d ", p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("ch_state cfc: %d ", p_lcb->ch_state);
     }
 }
 
@@ -293,7 +293,7 @@ void avct_l2c_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
-        AVCT_TRACE_DEBUG2("avct_l2c_config_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("avct_l2c_config_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
         /* store the mtu in tbl */
         if (p_cfg->mtu_present)
         {
@@ -322,7 +322,7 @@ void avct_l2c_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
                 avct_lcb_event(p_lcb, AVCT_LCB_LL_OPEN_EVT, NULL);
             }
         }
-        AVCT_TRACE_DEBUG1("ch_state cfi: %d ", p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("ch_state cfi: %d ", p_lcb->ch_state);
     }
 }
 
@@ -344,7 +344,7 @@ void avct_l2c_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed)
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
-        AVCT_TRACE_DEBUG2("avct_l2c_disconnect_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("avct_l2c_disconnect_ind_cback: 0x%x, ch_state: %d", lcid, p_lcb->ch_state);
         if (ack_needed)
         {
             /* send L2CAP disconnect response */
@@ -352,7 +352,7 @@ void avct_l2c_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed)
         }
 
         avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &result);
-        AVCT_TRACE_DEBUG1("ch_state di: %d ", p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("ch_state di: %d ", p_lcb->ch_state);
     }
 }
 
@@ -374,14 +374,14 @@ void avct_l2c_disconnect_cfm_cback(UINT16 lcid, UINT16 result)
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
-        AVCT_TRACE_DEBUG3("avct_l2c_disconnect_cfm_cback: 0x%x, ch_state: %d, res: %d",
+        AVCT_TRACE_DEBUG("avct_l2c_disconnect_cfm_cback: 0x%x, ch_state: %d, res: %d",
             lcid, p_lcb->ch_state, result);
         /* result value may be previously stored */
         res = (p_lcb->ch_result != 0) ? p_lcb->ch_result : result;
         p_lcb->ch_result = 0;
 
         avct_lcb_event(p_lcb, AVCT_LCB_LL_CLOSE_EVT, (tAVCT_LCB_EVT *) &res);
-        AVCT_TRACE_DEBUG1("ch_state dc: %d ", p_lcb->ch_state);
+        AVCT_TRACE_DEBUG("ch_state dc: %d ", p_lcb->ch_state);
     }
 }
 
@@ -399,7 +399,7 @@ void avct_l2c_congestion_ind_cback(UINT16 lcid, BOOLEAN is_congested)
 {
     tAVCT_LCB       *p_lcb;
 
-    AVCT_TRACE_DEBUG1("avct_l2c_congestion_ind_cback: 0x%x", lcid);
+    AVCT_TRACE_DEBUG("avct_l2c_congestion_ind_cback: 0x%x", lcid);
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
@@ -421,7 +421,7 @@ void avct_l2c_data_ind_cback(UINT16 lcid, BT_HDR *p_buf)
 {
     tAVCT_LCB       *p_lcb;
 
-    AVCT_TRACE_DEBUG1("avct_l2c_data_ind_cback: 0x%x", lcid);
+    AVCT_TRACE_DEBUG("avct_l2c_data_ind_cback: 0x%x", lcid);
     /* look up lcb for this channel */
     if ((p_lcb = avct_lcb_by_lcid(lcid)) != NULL)
     {
@@ -429,7 +429,7 @@ void avct_l2c_data_ind_cback(UINT16 lcid, BT_HDR *p_buf)
     }
     else /* prevent buffer leak */
     {
-        AVCT_TRACE_WARNING0("ERROR -> avct_l2c_data_ind_cback drop buffer");
+        AVCT_TRACE_WARNING("ERROR -> avct_l2c_data_ind_cback drop buffer");
         GKI_freebuf(p_buf);
     }
 }
diff --git a/stack/avct/avct_lcb.c b/stack/avct/avct_lcb.c
index 6bc7e51e1..6c8fd2e74 100644
--- a/stack/avct/avct_lcb.c
+++ b/stack/avct/avct_lcb.c
@@ -198,9 +198,9 @@ void avct_lcb_event(tAVCT_LCB *p_lcb, UINT8 event, tAVCT_LCB_EVT *p_data)
     int                 i;
 
 #if BT_TRACE_VERBOSE == TRUE
-    AVCT_TRACE_EVENT3("LCB lcb=%d event=%s state=%s", p_lcb->allocated, avct_lcb_evt_str[event], avct_lcb_st_str[p_lcb->state]);
+    AVCT_TRACE_EVENT("LCB lcb=%d event=%s state=%s", p_lcb->allocated, avct_lcb_evt_str[event], avct_lcb_st_str[p_lcb->state]);
 #else
-    AVCT_TRACE_EVENT3("LCB lcb=%d event=%d state=%d", p_lcb->allocated, event, p_lcb->state);
+    AVCT_TRACE_EVENT("LCB lcb=%d event=%d state=%d", p_lcb->allocated, event, p_lcb->state);
 #endif
 
     /* look up the state table for the current state */
@@ -241,9 +241,9 @@ void avct_bcb_event(tAVCT_BCB *p_bcb, UINT8 event, tAVCT_LCB_EVT *p_data)
     int                 i;
 
 #if BT_TRACE_VERBOSE == TRUE
-    AVCT_TRACE_EVENT3("BCB lcb=%d event=%s state=%s", p_bcb->allocated, avct_lcb_evt_str[event], avct_lcb_st_str[p_bcb->state]);
+    AVCT_TRACE_EVENT("BCB lcb=%d event=%s state=%s", p_bcb->allocated, avct_lcb_evt_str[event], avct_lcb_st_str[p_bcb->state]);
 #else
-    AVCT_TRACE_EVENT3("BCB lcb=%d event=%d state=%d", p_bcb->allocated, event, p_bcb->state);
+    AVCT_TRACE_EVENT("BCB lcb=%d event=%d state=%d", p_bcb->allocated, event, p_bcb->state);
 #endif
 
     /* look up the state table for the current state */
@@ -296,7 +296,7 @@ tAVCT_LCB *avct_lcb_by_bd(BD_ADDR bd_addr)
         /* if no lcb found */
         p_lcb = NULL;
 
-        AVCT_TRACE_DEBUG6("No lcb for addr %02x-%02x-%02x-%02x-%02x-%02x",
+        AVCT_TRACE_DEBUG("No lcb for addr %02x-%02x-%02x-%02x-%02x-%02x",
                           bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
     }
     return p_lcb;
@@ -323,7 +323,7 @@ tAVCT_LCB *avct_lcb_alloc(BD_ADDR bd_addr)
         {
             p_lcb->allocated = (UINT8)(i + 1);
             memcpy(p_lcb->peer_addr, bd_addr, BD_ADDR_LEN);
-            AVCT_TRACE_DEBUG1("avct_lcb_alloc %d", p_lcb->allocated);
+            AVCT_TRACE_DEBUG("avct_lcb_alloc %d", p_lcb->allocated);
             break;
         }
     }
@@ -332,7 +332,7 @@ tAVCT_LCB *avct_lcb_alloc(BD_ADDR bd_addr)
     {
         /* out of lcbs */
         p_lcb = NULL;
-        AVCT_TRACE_WARNING0("Out of lcbs");
+        AVCT_TRACE_WARNING("Out of lcbs");
     }
     return p_lcb;
 }
@@ -354,7 +354,7 @@ void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
     int         i;
     UNUSED(p_data);
 
-    AVCT_TRACE_DEBUG1("avct_lcb_dealloc %d", p_lcb->allocated);
+    AVCT_TRACE_DEBUG("avct_lcb_dealloc %d", p_lcb->allocated);
 
     for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
     {
@@ -363,7 +363,7 @@ void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
         {
             if (p_ccb->p_lcb == p_lcb)
             {
-                AVCT_TRACE_DEBUG1("avct_lcb_dealloc used by ccb: %d", i);
+                AVCT_TRACE_DEBUG("avct_lcb_dealloc used by ccb: %d", i);
                 found = TRUE;
                 break;
             }
@@ -372,7 +372,7 @@ void avct_lcb_dealloc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
 
     if (!found)
     {
-        AVCT_TRACE_DEBUG0("avct_lcb_dealloc now");
+        AVCT_TRACE_DEBUG("avct_lcb_dealloc now");
 
         /* clear reassembled msg buffer if in use */
         if (p_lcb->p_rx_msg != NULL)
@@ -410,7 +410,7 @@ tAVCT_LCB *avct_lcb_by_lcid(UINT16 lcid)
     {
         /* out of lcbs */
         p_lcb = NULL;
-        AVCT_TRACE_WARNING1("No lcb for lcid %x", lcid);
+        AVCT_TRACE_WARNING("No lcb for lcid %x", lcid);
     }
 
     return p_lcb;
@@ -456,10 +456,10 @@ BOOLEAN avct_lcb_last_ccb(tAVCT_LCB *p_lcb, tAVCT_CCB *p_ccb_last)
     tAVCT_CCB   *p_ccb = &avct_cb.ccb[0];
     int         i;
 
-    AVCT_TRACE_WARNING0("avct_lcb_last_ccb");
+    AVCT_TRACE_WARNING("avct_lcb_last_ccb");
     for (i = 0; i < AVCT_NUM_CONN; i++, p_ccb++)
     {
-        AVCT_TRACE_WARNING6("%x: aloc:%d, lcb:0x%x/0x%x, ccb:0x%x/0x%x",
+        AVCT_TRACE_WARNING("%x: aloc:%d, lcb:0x%x/0x%x, ccb:0x%x/0x%x",
             i, p_ccb->allocated, p_ccb->p_lcb, p_lcb, p_ccb, p_ccb_last);
         if (p_ccb->allocated && (p_ccb->p_lcb == p_lcb) && (p_ccb != p_ccb_last))
         {
diff --git a/stack/avct/avct_lcb_act.c b/stack/avct/avct_lcb_act.c
index 2fc92173e..17d5d3d30 100644
--- a/stack/avct/avct_lcb_act.c
+++ b/stack/avct/avct_lcb_act.c
@@ -65,7 +65,7 @@ static BT_HDR *avct_lcb_msg_asmbl(tAVCT_LCB *p_lcb, BT_HDR *p_buf)
     if (p_buf->len < avct_lcb_pkt_type_len[pkt_type])
     {
         GKI_freebuf(p_buf);
-        AVCT_TRACE_WARNING0("Bad length during reassembly");
+        AVCT_TRACE_WARNING("Bad length during reassembly");
         p_ret = NULL;
     }
     /* single packet */
@@ -76,7 +76,7 @@ static BT_HDR *avct_lcb_msg_asmbl(tAVCT_LCB *p_lcb, BT_HDR *p_buf)
         {
             GKI_freebuf(p_lcb->p_rx_msg);
             p_lcb->p_rx_msg = NULL;
-            AVCT_TRACE_WARNING0("Got single during reassembly");
+            AVCT_TRACE_WARNING("Got single during reassembly");
         }
         p_ret = p_buf;
     }
@@ -87,7 +87,7 @@ static BT_HDR *avct_lcb_msg_asmbl(tAVCT_LCB *p_lcb, BT_HDR *p_buf)
         if (p_lcb->p_rx_msg != NULL)
         {
             GKI_freebuf(p_lcb->p_rx_msg);
-            AVCT_TRACE_WARNING0("Got start during reassembly");
+            AVCT_TRACE_WARNING("Got start during reassembly");
         }
         p_lcb->p_rx_msg = p_buf;
 
@@ -109,7 +109,7 @@ static BT_HDR *avct_lcb_msg_asmbl(tAVCT_LCB *p_lcb, BT_HDR *p_buf)
         if (p_lcb->p_rx_msg == NULL)
         {
             GKI_freebuf(p_buf);
-            AVCT_TRACE_WARNING1("Pkt type=%d out of order", pkt_type);
+            AVCT_TRACE_WARNING("Pkt type=%d out of order", pkt_type);
             p_ret = NULL;
         }
         else
@@ -129,7 +129,7 @@ static BT_HDR *avct_lcb_msg_asmbl(tAVCT_LCB *p_lcb, BT_HDR *p_buf)
                 p_lcb->p_rx_msg = NULL;
                 GKI_freebuf(p_buf);
                 p_ret = NULL;
-                AVCT_TRACE_WARNING0("Fragmented message to big!");
+                AVCT_TRACE_WARNING("Fragmented message to big!");
             }
             else
             {
@@ -392,19 +392,19 @@ void avct_lcb_bind_conn(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
 *******************************************************************************/
 void avct_lcb_chk_disc(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
 {
-    AVCT_TRACE_WARNING0("avct_lcb_chk_disc");
+    AVCT_TRACE_WARNING("avct_lcb_chk_disc");
 #if (AVCT_BROWSE_INCLUDED == TRUE)
     avct_close_bcb(p_lcb, p_data);
 #endif
     if (avct_lcb_last_ccb(p_lcb, p_data->p_ccb))
     {
-        AVCT_TRACE_WARNING0("closing");
+        AVCT_TRACE_WARNING("closing");
         p_data->p_ccb->ch_close = TRUE;
         avct_lcb_event(p_lcb, AVCT_LCB_INT_CLOSE_EVT, p_data);
     }
     else
     {
-        AVCT_TRACE_WARNING0("dealloc ccb");
+        AVCT_TRACE_WARNING("dealloc ccb");
         avct_lcb_unbind_disc(p_lcb, p_data);
     }
 }
@@ -499,7 +499,7 @@ void avct_lcb_discard_msg(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
 {
     UNUSED(p_lcb);
 
-    AVCT_TRACE_WARNING0("Dropping msg");
+    AVCT_TRACE_WARNING("Dropping msg");
 
     GKI_freebuf(p_data->ul_msg.p_buf);
 }
@@ -556,7 +556,7 @@ void avct_lcb_send_msg(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
             if ((p_buf = (BT_HDR *) GKI_getbuf(buf_size)) == NULL)
             {
                 /* whoops; free original msg buf and bail */
-                AVCT_TRACE_ERROR0 ("avct_lcb_send_msg cannot alloc buffer!!");
+                AVCT_TRACE_ERROR ("avct_lcb_send_msg cannot alloc buffer!!");
                 GKI_freebuf(p_data->ul_msg.p_buf);
                 break;
             }
@@ -618,7 +618,7 @@ void avct_lcb_send_msg(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
             pkt_type = AVCT_PKT_TYPE_END;
         }
     }
-    AVCT_TRACE_DEBUG1 ("avct_lcb_send_msg tx_q_count:%d", p_lcb->tx_q.count);
+    AVCT_TRACE_DEBUG ("avct_lcb_send_msg tx_q_count:%d", p_lcb->tx_q.count);
     return;
 }
 
@@ -678,7 +678,7 @@ void avct_lcb_msg_ind(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
     /* check for invalid cr_ipid */
     if (cr_ipid == AVCT_CR_IPID_INVALID)
     {
-        AVCT_TRACE_WARNING1("Invalid cr_ipid", cr_ipid);
+        AVCT_TRACE_WARNING("Invalid cr_ipid", cr_ipid);
         GKI_freebuf(p_data->p_buf);
         return;
     }
@@ -695,7 +695,7 @@ void avct_lcb_msg_ind(tAVCT_LCB *p_lcb, tAVCT_LCB_EVT *p_data)
     else
     {
         /* PID not found; drop message */
-        AVCT_TRACE_WARNING1("No ccb for PID=%x", pid);
+        AVCT_TRACE_WARNING("No ccb for PID=%x", pid);
         GKI_freebuf(p_data->p_buf);
 
         /* if command send reject */
diff --git a/stack/avdt/avdt_ad.c b/stack/avdt/avdt_ad.c
index 5f9e60a85..46868878e 100644
--- a/stack/avdt/avdt_ad.c
+++ b/stack/avdt/avdt_ad.c
@@ -56,7 +56,7 @@ UINT8 avdt_ad_type_to_tcid(UINT8 type, tAVDT_SCB *p_scb)
     {
         scb_idx = avdt_scb_to_hdl(p_scb) - 1;
         /*
-        AVDT_TRACE_DEBUG2("type: %d, tcid: %d", type, ((scb_idx * (AVDT_CHAN_NUM_TYPES - 1)) + type));
+        AVDT_TRACE_DEBUG("type: %d, tcid: %d", type, ((scb_idx * (AVDT_CHAN_NUM_TYPES - 1)) + type));
         */
         return ((scb_idx * (AVDT_CHAN_NUM_TYPES - 1)) + type);
     }
@@ -89,7 +89,7 @@ static UINT8 avdt_ad_tcid_to_type(UINT8 tcid)
         */
         type = ((tcid + AVDT_CHAN_NUM_TYPES - 2) % (AVDT_CHAN_NUM_TYPES - 1)) + 1;
     }
-    AVDT_TRACE_DEBUG2("tcid: %d, type: %d", tcid, type);
+    AVDT_TRACE_DEBUG("tcid: %d, type: %d", tcid, type);
     return type;
 }
 
@@ -299,7 +299,7 @@ tAVDT_TC_TBL *avdt_ad_tc_tbl_alloc(tAVDT_CCB *p_ccb)
 *******************************************************************************/
 UINT8 avdt_ad_tc_tbl_to_idx(tAVDT_TC_TBL *p_tbl)
 {
-    AVDT_TRACE_DEBUG1("avdt_ad_tc_tbl_to_idx: %d", (p_tbl - avdt_cb.ad.tc_tbl));
+    AVDT_TRACE_DEBUG("avdt_ad_tc_tbl_to_idx: %d", (p_tbl - avdt_cb.ad.tc_tbl));
     /* use array arithmetic to determine index */
     return (UINT8) (p_tbl - avdt_cb.ad.tc_tbl);
 }
@@ -331,7 +331,7 @@ void avdt_ad_tc_close_ind(tAVDT_TC_TBL *p_tbl, UINT16 reason)
     p_tbl->cfg_flags = 0;
     p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
 
-    AVDT_TRACE_DEBUG2("avdt_ad_tc_close_ind tcid: %d, old: %d",
+    AVDT_TRACE_DEBUG("avdt_ad_tc_close_ind tcid: %d, old: %d",
         p_tbl->tcid, close.old_tc_state);
     /* if signaling channel, notify ccb that channel open */
     if (p_tbl->tcid == 0)
@@ -484,7 +484,7 @@ void avdt_ad_tc_data_ind(tAVDT_TC_TBL *p_tbl, BT_HDR *p_buf)
         else
         {
             GKI_freebuf(p_buf);
-            AVDT_TRACE_ERROR0(" avdt_ad_tc_data_ind buffer freed");
+            AVDT_TRACE_ERROR(" avdt_ad_tc_data_ind buffer freed");
         }
     }
 }
@@ -540,7 +540,7 @@ void avdt_ad_open_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb, UINT8 role
     p_tbl = avdt_ad_tc_tbl_alloc(p_ccb);
 
     p_tbl->tcid = avdt_ad_type_to_tcid(type, p_scb);
-    AVDT_TRACE_DEBUG3("avdt_ad_open_req: type: %d, role: %d, tcid:%d",
+    AVDT_TRACE_DEBUG("avdt_ad_open_req: type: %d, role: %d, tcid:%d",
         type, role, p_tbl->tcid);
 
     if (type == AVDT_CHAN_SIG)
@@ -557,7 +557,7 @@ void avdt_ad_open_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb, UINT8 role
 
         /* also set scb_hdl in rt_tbl */
         avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].scb_hdl = avdt_scb_to_hdl(p_scb);
-        AVDT_TRACE_DEBUG3("avdt_cb.ad.rt_tbl[%d][%d].scb_hdl = %d",
+        AVDT_TRACE_DEBUG("avdt_cb.ad.rt_tbl[%d][%d].scb_hdl = %d",
             avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
             avdt_scb_to_hdl(p_scb));
     }
@@ -577,11 +577,11 @@ void avdt_ad_open_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb, UINT8 role
         {
             /* if connect req ok, store tcid in lcid table  */
             avdt_cb.ad.lcid_tbl[lcid - L2CAP_BASE_APPL_CID] = avdt_ad_tc_tbl_to_idx(p_tbl);
-            AVDT_TRACE_DEBUG2("avdt_cb.ad.lcid_tbl[%d] = %d",
+            AVDT_TRACE_DEBUG("avdt_cb.ad.lcid_tbl[%d] = %d",
                 (lcid - L2CAP_BASE_APPL_CID), avdt_ad_tc_tbl_to_idx(p_tbl));
 
             avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_ccb)][p_tbl->tcid].lcid = lcid;
-            AVDT_TRACE_DEBUG3("avdt_cb.ad.rt_tbl[%d][%d].lcid = 0x%x",
+            AVDT_TRACE_DEBUG("avdt_cb.ad.rt_tbl[%d][%d].lcid = 0x%x",
                 avdt_ccb_to_idx(p_ccb), p_tbl->tcid,
                 lcid);
         }
@@ -611,7 +611,7 @@ void avdt_ad_close_req(UINT8 type, tAVDT_CCB *p_ccb, tAVDT_SCB *p_scb)
     tAVDT_TC_TBL    *p_tbl;
 
     p_tbl = avdt_ad_tc_tbl_by_type(type, p_ccb, p_scb);
-    AVDT_TRACE_DEBUG1("avdt_ad_close_req state: %d", p_tbl->state);
+    AVDT_TRACE_DEBUG("avdt_ad_close_req state: %d", p_tbl->state);
 
     switch(p_tbl->state)
     {
diff --git a/stack/avdt/avdt_api.c b/stack/avdt/avdt_api.c
index 5e5ea2bd6..f18c556ec 100644
--- a/stack/avdt/avdt_api.c
+++ b/stack/avdt/avdt_api.c
@@ -190,13 +190,13 @@ void AVDT_SINK_Activate()
 {
     tAVDT_SCB           *p_scb = &avdt_cb.scb[0];
     int                 i;
-    AVDT_TRACE_DEBUG0("AVDT_SINK_Activate");
+    AVDT_TRACE_DEBUG("AVDT_SINK_Activate");
     /* for all allocated scbs */
     for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
     {
         if ((p_scb->allocated) && (p_scb->cs.tsep == AVDT_TSEP_SNK))
         {
-            AVDT_TRACE_DEBUG0("AVDT_SINK_Activate found scb");
+            AVDT_TRACE_DEBUG("AVDT_SINK_Activate found scb");
             p_scb->sink_activated = TRUE;
             /* update in_use */
             p_scb->in_use = FALSE;
@@ -221,13 +221,13 @@ void AVDT_SINK_Deactivate()
 {
     tAVDT_SCB           *p_scb = &avdt_cb.scb[0];
     int                 i;
-    AVDT_TRACE_DEBUG0("AVDT_SINK_Deactivate");
+    AVDT_TRACE_DEBUG("AVDT_SINK_Deactivate");
     /* for all allocated scbs */
     for (i = 0; i < AVDT_NUM_SEPS; i++, p_scb++)
     {
         if ((p_scb->allocated) && (p_scb->cs.tsep == AVDT_TSEP_SNK))
         {
-            AVDT_TRACE_DEBUG0("AVDT_SINK_Deactivate, found scb");
+            AVDT_TRACE_DEBUG("AVDT_SINK_Deactivate, found scb");
             p_scb->sink_activated = FALSE;
             /* update in_use */
             p_scb->in_use = TRUE;
@@ -391,7 +391,7 @@ static UINT16 avdt_get_cap_req(BD_ADDR bd_addr, tAVDT_CCB_API_GETCAP *p_evt)
     /* verify SEID */
     if ((p_evt->single.seid < AVDT_SEID_MIN) || (p_evt->single.seid > AVDT_SEID_MAX))
     {
-        AVDT_TRACE_ERROR1("seid: %d", p_evt->single.seid);
+        AVDT_TRACE_ERROR("seid: %d", p_evt->single.seid);
         result = AVDT_BAD_PARAMS;
     }
     /* find channel control block for this bd addr; if none, allocate one */
@@ -1079,7 +1079,7 @@ UINT16 AVDT_ConnectReq(BD_ADDR bd_addr, UINT8 sec_mask, tAVDT_CTRL_CBACK *p_cbac
     }
     else if (p_ccb->ll_opened == FALSE)
     {
-        AVDT_TRACE_WARNING0("AVDT_ConnectReq: CCB LL is in the middle of opening");
+        AVDT_TRACE_WARNING("AVDT_ConnectReq: CCB LL is in the middle of opening");
 
         /* ccb was already allocated for the incoming signalling. */
         result = AVDT_BUSY;
@@ -1240,7 +1240,7 @@ AVDT_API extern UINT16 AVDT_WriteDataReq(UINT8 handle, UINT8 *p_data, UINT32 dat
             result = AVDT_BAD_HANDLE;
             break;
         }
-        AVDT_TRACE_WARNING1("mux_tsid_media:%d", p_scb->curr_cfg.mux_tsid_media);
+        AVDT_TRACE_WARNING("mux_tsid_media:%d", p_scb->curr_cfg.mux_tsid_media);
 
         if (p_scb->p_pkt != NULL
             || p_scb->p_ccb == NULL
@@ -1249,7 +1249,7 @@ AVDT_API extern UINT16 AVDT_WriteDataReq(UINT8 handle, UINT8 *p_data, UINT32 dat
             || p_scb->curr_cfg.mux_tsid_media == 0)
         {
             result = AVDT_ERR_BAD_STATE;
-            AVDT_TRACE_WARNING4("p_scb->p_pkt=%x, p_scb->p_ccb=%x, IsQueueEmpty=%x, p_scb->frag_off=%x",
+            AVDT_TRACE_WARNING("p_scb->p_pkt=%x, p_scb->p_ccb=%x, IsQueueEmpty=%x, p_scb->frag_off=%x",
                 p_scb->p_pkt, p_scb->p_ccb, GKI_queue_is_empty(&p_scb->frag_q), p_scb->frag_off);
             break;
         }
@@ -1262,7 +1262,7 @@ AVDT_API extern UINT16 AVDT_WriteDataReq(UINT8 handle, UINT8 *p_data, UINT32 dat
 
         if(GKI_queue_is_empty(&evt.apiwrite.frag_q))
         {
-            AVDT_TRACE_WARNING0("AVDT_WriteDataReq out of GKI buffers");
+            AVDT_TRACE_WARNING("AVDT_WriteDataReq out of GKI buffers");
             result = AVDT_ERR_RESOURCE;
             break;
         }
@@ -1278,7 +1278,7 @@ AVDT_API extern UINT16 AVDT_WriteDataReq(UINT8 handle, UINT8 *p_data, UINT32 dat
 #if (BT_USE_TRACES == TRUE)
     if(result != AVDT_SUCCESS)
     {
-        AVDT_TRACE_WARNING1("*** AVDT_WriteDataReq failed result=%d",result);
+        AVDT_TRACE_WARNING("*** AVDT_WriteDataReq failed result=%d",result);
     }
 #endif
     return result;
@@ -1405,9 +1405,9 @@ UINT16 AVDT_SendReport(UINT8 handle, AVDT_REPORT_TYPE type,
 
             case AVDT_RTCP_PT_RR:   /* Receiver Report */
                 *p++ = p_data->rr.frag_lost;
-                AVDT_TRACE_API1("packet_lost: %d", p_data->rr.packet_lost);
+                AVDT_TRACE_API("packet_lost: %d", p_data->rr.packet_lost);
                 p_data->rr.packet_lost &= 0xFFFFFF;
-                AVDT_TRACE_API1("packet_lost: %d", p_data->rr.packet_lost);
+                AVDT_TRACE_API("packet_lost: %d", p_data->rr.packet_lost);
                 UINT24_TO_BE_STREAM(p, p_data->rr.packet_lost);
                 UINT32_TO_BE_STREAM(p, p_data->rr.seq_num_rcvd);
                 UINT32_TO_BE_STREAM(p, p_data->rr.jitter);
diff --git a/stack/avdt/avdt_ccb.c b/stack/avdt/avdt_ccb.c
index c2ef2f47a..2a10ef8ab 100644
--- a/stack/avdt/avdt_ccb.c
+++ b/stack/avdt/avdt_ccb.c
@@ -302,7 +302,7 @@ void avdt_ccb_event(tAVDT_CCB *p_ccb, UINT8 event, tAVDT_CCB_EVT *p_data)
     int                 i;
 
 #if AVDT_DEBUG == TRUE
-    AVDT_TRACE_EVENT3("CCB ccb=%d event=%s state=%s", avdt_ccb_to_idx(p_ccb), avdt_ccb_evt_str[event], avdt_ccb_st_str[p_ccb->state]);
+    AVDT_TRACE_EVENT("CCB ccb=%d event=%s state=%s", avdt_ccb_to_idx(p_ccb), avdt_ccb_evt_str[event], avdt_ccb_st_str[p_ccb->state]);
 #endif
     BTTRC_AVDT_CCB_EVENT(event, p_ccb->state);
 
@@ -360,7 +360,7 @@ tAVDT_CCB *avdt_ccb_by_bd(BD_ADDR bd_addr)
         /* if no ccb found */
         p_ccb = NULL;
 
-        AVDT_TRACE_DEBUG6("No ccb for addr %02x-%02x-%02x-%02x-%02x-%02x",
+        AVDT_TRACE_DEBUG("No ccb for addr %02x-%02x-%02x-%02x-%02x-%02x",
                           bd_addr[0], bd_addr[1], bd_addr[2], bd_addr[3], bd_addr[4], bd_addr[5]);
     }
     return p_ccb;
@@ -390,7 +390,7 @@ tAVDT_CCB *avdt_ccb_alloc(BD_ADDR bd_addr)
             GKI_init_q(&p_ccb->cmd_q);
             GKI_init_q(&p_ccb->rsp_q);
             p_ccb->timer_entry.param = (UINT32) p_ccb;
-            AVDT_TRACE_DEBUG1("avdt_ccb_alloc %d", i);
+            AVDT_TRACE_DEBUG("avdt_ccb_alloc %d", i);
             break;
         }
     }
@@ -399,7 +399,7 @@ tAVDT_CCB *avdt_ccb_alloc(BD_ADDR bd_addr)
     {
         /* out of ccbs */
         p_ccb = NULL;
-        AVDT_TRACE_WARNING0("Out of ccbs");
+        AVDT_TRACE_WARNING("Out of ccbs");
     }
     return p_ccb;
 }
@@ -418,7 +418,7 @@ void avdt_ccb_dealloc(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 {
     UNUSED(p_data);
 
-    AVDT_TRACE_DEBUG1("avdt_ccb_dealloc %d", avdt_ccb_to_idx(p_ccb));
+    AVDT_TRACE_DEBUG("avdt_ccb_dealloc %d", avdt_ccb_to_idx(p_ccb));
     btu_stop_timer(&p_ccb->timer_entry);
     memset(p_ccb, 0, sizeof(tAVDT_CCB));
 }
@@ -461,7 +461,7 @@ tAVDT_CCB *avdt_ccb_by_idx(UINT8 idx)
     else
     {
         p_ccb = NULL;
-        AVDT_TRACE_WARNING1("No ccb for idx %d", idx);
+        AVDT_TRACE_WARNING("No ccb for idx %d", idx);
     }
     return p_ccb;
 }
diff --git a/stack/avdt/avdt_ccb_act.c b/stack/avdt/avdt_ccb_act.c
index 1249c6386..d87dbb1cf 100644
--- a/stack/avdt/avdt_ccb_act.c
+++ b/stack/avdt/avdt_ccb_act.c
@@ -1034,7 +1034,7 @@ void avdt_ccb_set_conn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 void avdt_ccb_set_disconn(tAVDT_CCB *p_ccb, tAVDT_CCB_EVT *p_data)
 {
     /*
-    AVDT_TRACE_EVENT2("avdt_ccb_set_disconn:conn:x%x, api:x%x",
+    AVDT_TRACE_EVENT("avdt_ccb_set_disconn:conn:x%x, api:x%x",
         p_ccb->p_conn_cback, p_data->disconnect.p_cback);
         */
     /* save callback */
diff --git a/stack/avdt/avdt_l2c.c b/stack/avdt/avdt_l2c.c
index 943a3cf87..c13b5b4ce 100644
--- a/stack/avdt/avdt_l2c.c
+++ b/stack/avdt/avdt_l2c.c
@@ -78,10 +78,10 @@ static void avdt_sec_check_complete_term (BD_ADDR bd_addr, tBT_TRANSPORT transpo
     tAVDT_TC_TBL    *p_tbl;
     UNUSED(p_ref_data);
 
-    AVDT_TRACE_DEBUG1("avdt_sec_check_complete_term res: %d", res);
+    AVDT_TRACE_DEBUG("avdt_sec_check_complete_term res: %d", res);
     if (!bd_addr)
     {
-        AVDT_TRACE_WARNING0("avdt_sec_check_complete_term: NULL BD_ADDR");
+        AVDT_TRACE_WARNING("avdt_sec_check_complete_term: NULL BD_ADDR");
         return;
 
     }
@@ -136,7 +136,7 @@ static void avdt_sec_check_complete_orig (BD_ADDR bd_addr, tBT_TRANSPORT trasnpo
     tAVDT_TC_TBL    *p_tbl;
     UNUSED(p_ref_data);
 
-    AVDT_TRACE_DEBUG1("avdt_sec_check_complete_orig res: %d", res);
+    AVDT_TRACE_DEBUG("avdt_sec_check_complete_orig res: %d", res);
     if (bd_addr)
         p_ccb = avdt_ccb_by_bd(bd_addr);
     p_tbl = avdt_ad_tc_tbl_by_st(AVDT_CHAN_SIG, p_ccb, AVDT_AD_ST_SEC_INT);
@@ -283,7 +283,7 @@ void avdt_l2c_connect_cfm_cback(UINT16 lcid, UINT16 result)
     tL2CAP_CFG_INFO cfg;
     tAVDT_CCB *p_ccb;
 
-    AVDT_TRACE_DEBUG2("avdt_l2c_connect_cfm_cback lcid: %d, result: %d",
+    AVDT_TRACE_DEBUG("avdt_l2c_connect_cfm_cback lcid: %d, result: %d",
         lcid, result);
     /* look up info for this channel */
     if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
@@ -407,7 +407,7 @@ void avdt_l2c_config_ind_cback(UINT16 lcid, tL2CAP_CFG_INFO *p_cfg)
         {
             p_tbl->peer_mtu = L2CAP_DEFAULT_MTU;
         }
-        AVDT_TRACE_DEBUG2("peer_mtu: %d, lcid: x%x",p_tbl->peer_mtu, lcid);
+        AVDT_TRACE_DEBUG("peer_mtu: %d, lcid: x%x",p_tbl->peer_mtu, lcid);
 
         /* send L2CAP configure response */
         memset(p_cfg, 0, sizeof(tL2CAP_CFG_INFO));
@@ -443,7 +443,7 @@ void avdt_l2c_disconnect_ind_cback(UINT16 lcid, BOOLEAN ack_needed)
 {
     tAVDT_TC_TBL    *p_tbl;
 
-    AVDT_TRACE_DEBUG2("avdt_l2c_disconnect_ind_cback lcid: %d, ack_needed: %d",
+    AVDT_TRACE_DEBUG("avdt_l2c_disconnect_ind_cback lcid: %d, ack_needed: %d",
         lcid, ack_needed);
     /* look up info for this channel */
     if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
@@ -472,7 +472,7 @@ void avdt_l2c_disconnect_cfm_cback(UINT16 lcid, UINT16 result)
 {
     tAVDT_TC_TBL    *p_tbl;
 
-    AVDT_TRACE_DEBUG2("avdt_l2c_disconnect_cfm_cback lcid: %d, result: %d",
+    AVDT_TRACE_DEBUG("avdt_l2c_disconnect_cfm_cback lcid: %d, result: %d",
         lcid, result);
     /* look up info for this channel */
     if ((p_tbl = avdt_ad_tc_tbl_by_lcid(lcid)) != NULL)
diff --git a/stack/avdt/avdt_msg.c b/stack/avdt/avdt_msg.c
index 7b18424b7..2f38c3af6 100644
--- a/stack/avdt/avdt_msg.c
+++ b/stack/avdt/avdt_msg.c
@@ -589,7 +589,7 @@ static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8* p_e
 
     if (!p_cfg)
     {
-        AVDT_TRACE_ERROR0 ("not expecting this cfg");
+        AVDT_TRACE_ERROR ("not expecting this cfg");
         return AVDT_ERR_BAD_STATE;
     }
 
@@ -633,7 +633,7 @@ static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8* p_e
             {
                 /* Skip unknown categories. */
                 p += elem_len;
-                AVDT_TRACE_DEBUG2("skipping unknown service category=%d len: %d", elem, elem_len);
+                AVDT_TRACE_DEBUG("skipping unknown service category=%d len: %d", elem, elem_len);
                 continue;
             }
         }
@@ -647,7 +647,7 @@ static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8* p_e
 
         /* add element to psc mask, but mask out codec or protect */
         p_cfg->psc_mask |= (1 << elem);
-        AVDT_TRACE_DEBUG3("elem=%d elem_len: %d psc_mask=0x%x", elem, elem_len, p_cfg->psc_mask);
+        AVDT_TRACE_DEBUG("elem=%d elem_len: %d psc_mask=0x%x", elem, elem_len, p_cfg->psc_mask);
 
         /* parse individual information elements with additional parameters */
         switch (elem)
@@ -689,7 +689,7 @@ static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8* p_e
 #if AVDT_MULTIPLEXING == TRUE
             case AVDT_CAT_MUX:
                 /* verify length */
-                AVDT_TRACE_WARNING2("psc_mask=0x%x elem_len=%d", p_cfg->psc_mask, elem_len);
+                AVDT_TRACE_WARNING("psc_mask=0x%x elem_len=%d", p_cfg->psc_mask, elem_len);
                 if( ((0 == (p_cfg->psc_mask & (AVDT_PSC_RECOV|AVDT_PSC_REPORT))) && (elem_len != 3))
                     || (((p_cfg->psc_mask & AVDT_PSC_REPORT) && !(p_cfg->psc_mask & AVDT_PSC_RECOV))
                     && (elem_len != 5))
@@ -760,7 +760,7 @@ static UINT8 avdt_msg_prs_cfg(tAVDT_CFG *p_cfg, UINT8 *p, UINT16 len, UINT8* p_e
         } /* switch */
     } /* while ! err, !end*/
     *p_elem = elem;
-    AVDT_TRACE_DEBUG3("err=0x%x, elem:0x%x psc_mask=0x%x", err, elem, p_cfg->psc_mask);
+    AVDT_TRACE_DEBUG("err=0x%x, elem:0x%x psc_mask=0x%x", err, elem, p_cfg->psc_mask);
 
     return err;
 }
@@ -914,7 +914,7 @@ static UINT8 avdt_msg_prs_reconfig_cmd(tAVDT_MSG *p_msg, UINT8 *p, UINT16 len)
             /* verify no protocol service capabilities in parameters */
             if (!err)
             {
-                AVDT_TRACE_DEBUG2("avdt_msg_prs_reconfig_cmd psc_mask=0x%x/0x%x", p_msg->config_cmd.p_cfg->psc_mask, AVDT_MSG_PSC_MASK);
+                AVDT_TRACE_DEBUG("avdt_msg_prs_reconfig_cmd psc_mask=0x%x/0x%x", p_msg->config_cmd.p_cfg->psc_mask, AVDT_MSG_PSC_MASK);
                 if ((p_msg->config_cmd.p_cfg->psc_mask != 0) ||
                     (p_msg->config_cmd.p_cfg->num_codec == 0 && p_msg->config_cmd.p_cfg->num_protect == 0))
                 {
@@ -1161,7 +1161,7 @@ static UINT8 avdt_msg_prs_delay_rpt (tAVDT_MSG *p_msg, UINT8 *p, UINT16 len)
     /* verify len */
     if (len != AVDT_LEN_DELAY_RPT)
     {
-        AVDT_TRACE_WARNING2("avdt_msg_prs_delay_rpt expected len: %u  got: %u", AVDT_LEN_DELAY_RPT, len);
+        AVDT_TRACE_WARNING("avdt_msg_prs_delay_rpt expected len: %u  got: %u", AVDT_LEN_DELAY_RPT, len);
         err = AVDT_ERR_LENGTH;
     }
     else
@@ -1176,7 +1176,7 @@ static UINT8 avdt_msg_prs_delay_rpt (tAVDT_MSG *p_msg, UINT8 *p, UINT16 len)
         else
         {
             BE_STREAM_TO_UINT16 (p_msg->delay_rpt_cmd.delay, p);
-            AVDT_TRACE_DEBUG1("avdt_msg_prs_delay_rpt delay: %u", p_msg->delay_rpt_cmd.delay);
+            AVDT_TRACE_DEBUG("avdt_msg_prs_delay_rpt delay: %u", p_msg->delay_rpt_cmd.delay);
         }
     }
     return err;
@@ -1289,7 +1289,7 @@ BOOLEAN avdt_msg_send(tAVDT_CCB *p_ccb, BT_HDR *p_msg)
         label = AVDT_LAYERSPEC_LABEL(p_ccb->p_curr_msg->layer_specific);
         msg = AVDT_LAYERSPEC_MSG(p_ccb->p_curr_msg->layer_specific);
         sig = (UINT8) p_ccb->p_curr_msg->event;
-        AVDT_TRACE_DEBUG3("avdt_msg_send label:%d, msg:%d, sig:%d", label, msg, sig);
+        AVDT_TRACE_DEBUG("avdt_msg_send label:%d, msg:%d, sig:%d", label, msg, sig);
 
         /* keep track of how much of msg we've sent */
         curr_msg_len -= p_buf->len;
@@ -1368,7 +1368,7 @@ BT_HDR *avdt_msg_asmbl(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
     if (p_buf->len < avdt_msg_pkt_type_len[pkt_type])
     {
         GKI_freebuf(p_buf);
-        AVDT_TRACE_WARNING0("Bad length during reassembly");
+        AVDT_TRACE_WARNING("Bad length during reassembly");
         p_ret = NULL;
     }
     /* single packet */
@@ -1379,7 +1379,7 @@ BT_HDR *avdt_msg_asmbl(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
         {
             GKI_freebuf(p_ccb->p_rx_msg);
             p_ccb->p_rx_msg = NULL;
-            AVDT_TRACE_WARNING0("Got single during reassembly");
+            AVDT_TRACE_WARNING("Got single during reassembly");
         }
         p_ret = p_buf;
     }
@@ -1390,7 +1390,7 @@ BT_HDR *avdt_msg_asmbl(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
         if (p_ccb->p_rx_msg != NULL)
         {
             GKI_freebuf(p_ccb->p_rx_msg);
-            AVDT_TRACE_WARNING0("Got start during reassembly");
+            AVDT_TRACE_WARNING("Got start during reassembly");
         }
         p_ccb->p_rx_msg = p_buf;
 
@@ -1412,7 +1412,7 @@ BT_HDR *avdt_msg_asmbl(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
         if (p_ccb->p_rx_msg == NULL)
         {
             GKI_freebuf(p_buf);
-            AVDT_TRACE_WARNING1("Pkt type=%d out of order", pkt_type);
+            AVDT_TRACE_WARNING("Pkt type=%d out of order", pkt_type);
             p_ret = NULL;
         }
         else
@@ -1484,7 +1484,7 @@ void avdt_msg_send_cmd(tAVDT_CCB *p_ccb, void *p_scb, UINT8 sig_id, tAVDT_MSG *p
     p_buf = (BT_HDR *) GKI_getpoolbuf(AVDT_CMD_POOL_ID);
     if (p_buf == NULL)
     {
-        AVDT_TRACE_ERROR0("avdt_msg_send_cmd out of buffer!!");
+        AVDT_TRACE_ERROR("avdt_msg_send_cmd out of buffer!!");
         return;
     }
 
@@ -1620,7 +1620,7 @@ void avdt_msg_send_rej(tAVDT_CCB *p_ccb, UINT8 sig_id, tAVDT_MSG *p_params)
         /* add the error code */
         AVDT_MSG_BLD_ERR(p, p_params->hdr.err_code);
     }
-    AVDT_TRACE_DEBUG0("avdt_msg_send_rej");
+    AVDT_TRACE_DEBUG("avdt_msg_send_rej");
 
     /* calculate length */
     p_buf->len = (UINT16) (p - p_start);
@@ -1671,7 +1671,7 @@ void avdt_msg_send_grej(tAVDT_CCB *p_ccb, UINT8 sig_id, tAVDT_MSG *p_params)
     AVDT_BLD_LAYERSPEC(p_buf->layer_specific, AVDT_MSG_TYPE_GRJ, p_params->hdr.label);
     //p_buf->event = 0;
     //AVDT_BLD_LAYERSPEC(p_buf->layer_specific, 0, p_params->hdr.label);
-    AVDT_TRACE_DEBUG0("avdt_msg_send_grej");
+    AVDT_TRACE_DEBUG("avdt_msg_send_grej");
 
     /* queue message and trigger ccb to send it */
     GKI_enqueue(&p_ccb->rsp_q, p_buf);
@@ -1719,7 +1719,7 @@ void avdt_msg_ind(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
     /* parse the message header */
     AVDT_MSG_PRS_HDR(p, label, pkt_type, msg_type);
 
-    /* AVDT_TRACE_DEBUG1("msg_type=%d", msg_type); */
+    /* AVDT_TRACE_DEBUG("msg_type=%d", msg_type); */
     /* set up label and ccb_idx in message hdr */
     msg.hdr.label = label;
     msg.hdr.ccb_idx = avdt_ccb_to_idx(p_ccb);
@@ -1727,7 +1727,7 @@ void avdt_msg_ind(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
     /* verify msg type */
     if (msg_type == AVDT_MSG_TYPE_GRJ)
     {
-        AVDT_TRACE_WARNING1("Dropping msg msg_type=%d", msg_type);
+        AVDT_TRACE_WARNING("Dropping msg msg_type=%d", msg_type);
         ok = FALSE;
     }
     /* check for general reject */
@@ -1749,7 +1749,7 @@ void avdt_msg_ind(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
         msg.hdr.sig_id = sig;
         if ((sig == 0) || (sig > AVDT_SIG_MAX))
         {
-            AVDT_TRACE_WARNING2("Dropping msg sig=%d msg_type:%d", sig, msg_type);
+            AVDT_TRACE_WARNING("Dropping msg sig=%d msg_type:%d", sig, msg_type);
             ok = FALSE;
 
             /* send a general reject */
@@ -1814,7 +1814,7 @@ void avdt_msg_ind(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
         /* if parsing failed */
         if (err != 0)
         {
-            AVDT_TRACE_WARNING2("Parsing failed sig=%d err=0x%x", sig, err);
+            AVDT_TRACE_WARNING("Parsing failed sig=%d err=0x%x", sig, err);
 
             /* if its a rsp or rej, drop it; if its a cmd, send a rej;
             ** note special case for abort; never send abort reject
@@ -1851,7 +1851,7 @@ void avdt_msg_ind(tAVDT_CCB *p_ccb, BT_HDR *p_buf)
             else
             {
                 ok = FALSE;
-                AVDT_TRACE_WARNING2("Cmd not found for rsp sig=%d label=%d", sig, label);
+                AVDT_TRACE_WARNING("Cmd not found for rsp sig=%d label=%d", sig, label);
             }
         }
     }
diff --git a/stack/avdt/avdt_scb.c b/stack/avdt/avdt_scb.c
index f509240ca..8eb5cc211 100644
--- a/stack/avdt/avdt_scb.c
+++ b/stack/avdt/avdt_scb.c
@@ -529,7 +529,7 @@ void avdt_scb_event(tAVDT_SCB *p_scb, UINT8 event, tAVDT_SCB_EVT *p_data)
     int                 i;
 
 #if AVDT_DEBUG == TRUE
-    AVDT_TRACE_EVENT4("SCB hdl=%d event=%d/%s state=%s", avdt_scb_to_hdl(p_scb), event, avdt_scb_evt_str[event], avdt_scb_st_str[p_scb->state]);
+    AVDT_TRACE_EVENT("SCB hdl=%d event=%d/%s state=%s", avdt_scb_to_hdl(p_scb), event, avdt_scb_evt_str[event], avdt_scb_st_str[p_scb->state]);
 #endif
     BTTRC_AVDT_SCB_EVENT(event, p_scb->state);
 
@@ -625,7 +625,7 @@ tAVDT_SCB *avdt_scb_alloc(tAVDT_CS *p_cs)
             }
 #endif
             p_scb->timer_entry.param = (UINT32) p_scb;
-            AVDT_TRACE_DEBUG2("avdt_scb_alloc hdl=%d, psc_mask:0x%x", i+1, p_cs->cfg.psc_mask);
+            AVDT_TRACE_DEBUG("avdt_scb_alloc hdl=%d, psc_mask:0x%x", i+1, p_cs->cfg.psc_mask);
             break;
         }
     }
@@ -634,7 +634,7 @@ tAVDT_SCB *avdt_scb_alloc(tAVDT_CS *p_cs)
     {
         /* out of ccbs */
         p_scb = NULL;
-        AVDT_TRACE_WARNING0("Out of scbs");
+        AVDT_TRACE_WARNING("Out of scbs");
     }
 
     return p_scb;
@@ -657,7 +657,7 @@ void avdt_scb_dealloc(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
 #endif
     UNUSED(p_data);
 
-    AVDT_TRACE_DEBUG1("avdt_scb_dealloc hdl=%d", avdt_scb_to_hdl(p_scb));
+    AVDT_TRACE_DEBUG("avdt_scb_dealloc hdl=%d", avdt_scb_to_hdl(p_scb));
     btu_stop_timer(&p_scb->timer_entry);
 
 #if AVDT_MULTIPLEXING == TRUE
@@ -708,13 +708,13 @@ tAVDT_SCB *avdt_scb_by_hdl(UINT8 hdl)
         if (!p_scb->allocated)
         {
             p_scb = NULL;
-            AVDT_TRACE_WARNING1("scb hdl %d not allocated", hdl);
+            AVDT_TRACE_WARNING("scb hdl %d not allocated", hdl);
         }
     }
     else
     {
         p_scb = NULL;
-        AVDT_TRACE_WARNING1("scb hdl %d out of range", hdl);
+        AVDT_TRACE_WARNING("scb hdl %d out of range", hdl);
     }
     return p_scb;
 }
@@ -737,7 +737,7 @@ UINT8 avdt_scb_verify(tAVDT_CCB *p_ccb, UINT8 state, UINT8 *p_seid, UINT16 num_s
     UINT8       chk_state;
     UINT8       ret = 0;
 
-    AVDT_TRACE_DEBUG1("avdt_scb_verify state %d", state);
+    AVDT_TRACE_DEBUG("avdt_scb_verify state %d", state);
     /* set nonsupported command mask */
     /* translate public state into private state */
     nsc_mask = 0;
@@ -777,7 +777,7 @@ UINT8 avdt_scb_verify(tAVDT_CCB *p_ccb, UINT8 state, UINT8 *p_seid, UINT16 num_s
     {
         ret = p_seid[i];
     }
-    AVDT_TRACE_DEBUG3("avdt_scb_verify state %d, nsc_mask0x%x, ret: %d",
+    AVDT_TRACE_DEBUG("avdt_scb_verify state %d, nsc_mask0x%x, ret: %d",
         chk_state, nsc_mask, ret);
     return ret;
 }
diff --git a/stack/avdt/avdt_scb_act.c b/stack/avdt/avdt_scb_act.c
index 87cc61f4b..73c2d9b49 100644
--- a/stack/avdt/avdt_scb_act.c
+++ b/stack/avdt/avdt_scb_act.c
@@ -285,7 +285,7 @@ void avdt_scb_hdl_pkt_no_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
     /* do sanity check */
     if ((offset > p_data->p_pkt->len) || ((pad_len + offset) > p_data->p_pkt->len))
     {
-        AVDT_TRACE_WARNING0("Got bad media packet");
+        AVDT_TRACE_WARNING("Got bad media packet");
         GKI_freebuf(p_data->p_pkt);
     }
     /* adjust offset and length and send it up */
@@ -340,7 +340,7 @@ UINT8 * avdt_scb_hdl_report(tAVDT_SCB *p_scb, UINT8 *p, UINT16 len)
     AVDT_REPORT_TYPE    pt;
     tAVDT_REPORT_DATA   report, *p_rpt;
 
-    AVDT_TRACE_DEBUG0( "avdt_scb_hdl_report");
+    AVDT_TRACE_DEBUG( "avdt_scb_hdl_report");
     if(p_scb->cs.p_report_cback)
     {
         p_rpt = &report;
@@ -377,14 +377,14 @@ UINT8 * avdt_scb_hdl_report(tAVDT_SCB *p_scb, UINT8 *p, UINT16 len)
             }
             else
             {
-                AVDT_TRACE_WARNING5( " - SDES SSRC=0x%08x sc=%d %d len=%d %s",
+                AVDT_TRACE_WARNING( " - SDES SSRC=0x%08x sc=%d %d len=%d %s",
                     ssrc, o_cc, *p, *(p+1), p+2);
                 result = AVDT_BUSY;
             }
             break;
 
         default:
-            AVDT_TRACE_ERROR1( "Bad Report pkt - packet type: %d", pt);
+            AVDT_TRACE_ERROR( "Bad Report pkt - packet type: %d", pt);
             result = AVDT_BAD_PARAMS;
         }
 
@@ -435,7 +435,7 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
     {
         if (p_end - p < 4) /* length check. maximum length of AL header = 4 */
         {
-            AVDT_TRACE_WARNING2("p_end: 0x%x - p:0x%x < 4", p_end, p);
+            AVDT_TRACE_WARNING("p_end: 0x%x - p:0x%x < 4", p_end, p);
             break;
         }
 
@@ -485,14 +485,14 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
             else
 #endif
             {
-                AVDT_TRACE_WARNING2("bad tsid: %d, mux_tsid_media:%d", al_tsid, p_scb->curr_cfg.mux_tsid_media);
+                AVDT_TRACE_WARNING("bad tsid: %d, mux_tsid_media:%d", al_tsid, p_scb->curr_cfg.mux_tsid_media);
                 break;
             }
         }
         /* check are buffer for assembling and related callback set */
         else if ((p_scb->p_media_buf == NULL) || (p_scb->cs.p_media_cback == NULL))
         {
-            AVDT_TRACE_WARNING0("NULL p_media_buf or p_media_cback");
+            AVDT_TRACE_WARNING("NULL p_media_buf or p_media_cback");
             break;
         }
 
@@ -500,7 +500,7 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
         /* it is media fragment beginning */
         if(!al_frag) /* is it first fragment of original media packet */
         {
-            AVDT_TRACE_DEBUG2("al:%d media:%d",
+            AVDT_TRACE_DEBUG("al:%d media:%d",
                 al_len, p_scb->media_buf_len);
 
             p_scb->frag_off = 0;
@@ -508,31 +508,31 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
             /* length check: minimum length of media header is 12 */
             if (p_scb->frag_org_len < 12)
             {
-                AVDT_TRACE_WARNING1("bad al_len: %d(<12)", al_len);
+                AVDT_TRACE_WARNING("bad al_len: %d(<12)", al_len);
                 break;
             }
             /* check that data fit into buffer */
             if (al_len > p_scb->media_buf_len)
             {
-                AVDT_TRACE_WARNING2("bad al_len: %d(>%d)", al_len, p_scb->media_buf_len);
+                AVDT_TRACE_WARNING("bad al_len: %d(>%d)", al_len, p_scb->media_buf_len);
                 break;
             }
             /* make sure it is the last fragment in l2cap packet */
             if (p + al_len < p_end)
             {
-                AVDT_TRACE_WARNING2("bad al_len: %d(>%d)", al_len, p_scb->media_buf_len);
+                AVDT_TRACE_WARNING("bad al_len: %d(>%d)", al_len, p_scb->media_buf_len);
                 break;
             }
         }
         else
         {
-            AVDT_TRACE_DEBUG4("al:%d media:%d frag_org_len:%d frag_off:%d",
+            AVDT_TRACE_DEBUG("al:%d media:%d frag_org_len:%d frag_off:%d",
                 al_len, p_scb->media_buf_len, p_scb->frag_org_len, p_scb->frag_off);
 
             /* check that remaining length from AL header equals to original len - length of already received fragments */
             if(al_len != p_scb->frag_org_len - p_scb->frag_off)
             {
-                AVDT_TRACE_WARNING4("al_len:%d != (frag_org_len:%d - frag_off:%d) %d",
+                AVDT_TRACE_WARNING("al_len:%d != (frag_org_len:%d - frag_off:%d) %d",
                     al_len, p_scb->frag_org_len, p_scb->frag_off,
                     (p_scb->frag_org_len- p_scb->frag_off));
                 break;
@@ -541,19 +541,19 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
             /* do sanity check */
             if (p_scb->frag_off == 0)
             {
-                AVDT_TRACE_WARNING0("frag_off=0");
+                AVDT_TRACE_WARNING("frag_off=0");
                 break;
             }
         }
         /* do common sanity check */
         if((p_scb->frag_org_len <= p_scb->frag_off) || (p_scb->frag_org_len >= p_scb->media_buf_len))
         {
-            AVDT_TRACE_WARNING3("common sanity frag_off:%d frag_org_len:%d media_buf_len:%d",
+            AVDT_TRACE_WARNING("common sanity frag_off:%d frag_org_len:%d media_buf_len:%d",
                 p_scb->frag_off, p_scb->frag_org_len, p_scb->media_buf_len);
             break;
         }
 
-        AVDT_TRACE_DEBUG4("Received fragment org_len=%d off=%d al_len=%d frag_len=%d",
+        AVDT_TRACE_DEBUG("Received fragment org_len=%d off=%d al_len=%d frag_len=%d",
             p_scb->frag_org_len, p_scb->frag_off, al_len, frag_len);
 
         /* copy fragment into buffer */
@@ -581,7 +581,7 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
             {
                 if(p_scb->p_media_buf + p_scb->frag_off - p_payload < 4)
                 {
-                    AVDT_TRACE_WARNING3("length check frag_off:%d p_media_buf:%d p_payload:%d",
+                    AVDT_TRACE_WARNING("length check frag_off:%d p_media_buf:%d p_payload:%d",
                         p_scb->frag_off, p_scb->p_media_buf, p_payload);
                     break;/* length check */
                 }
@@ -592,7 +592,7 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
 
             if(p_payload >= p_scb->p_media_buf + p_scb->frag_off)
             {
-                AVDT_TRACE_WARNING3("length check2 frag_off:%d p_media_buf:%d p_payload:%d",
+                AVDT_TRACE_WARNING("length check2 frag_off:%d p_media_buf:%d p_payload:%d",
                     p_scb->frag_off, p_scb->p_media_buf, p_payload);
                 break;/* length check */
             }
@@ -608,7 +608,7 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
             /* payload length */
             payload_len = (UINT32)(p_scb->p_media_buf + p_scb->frag_off - pad_len - p_payload);
 
-            AVDT_TRACE_DEBUG2("Received last fragment header=%d len=%d",
+            AVDT_TRACE_DEBUG("Received last fragment header=%d len=%d",
                 p_payload - p_scb->p_media_buf,payload_len);
 
             /* send total media packet up */
@@ -622,7 +622,7 @@ void avdt_scb_hdl_pkt_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
 
     if(p < p_end)
     {
-        AVDT_TRACE_WARNING0("*** Got bad media packet");
+        AVDT_TRACE_WARNING("*** Got bad media packet");
     }
     GKI_freebuf(p_data->p_pkt);
 }
@@ -678,7 +678,7 @@ void avdt_scb_drop_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
     UNUSED(p_scb);
 
     GKI_freebuf(p_data->p_pkt);
-    AVDT_TRACE_ERROR0(" avdt_scb_drop_pkt Dropped incoming media packet");
+    AVDT_TRACE_ERROR(" avdt_scb_drop_pkt Dropped incoming media packet");
 }
 
 /*******************************************************************************
@@ -1153,7 +1153,7 @@ void avdt_scb_hdl_tc_open(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
     event = (p_scb->role == AVDT_OPEN_INT) ? AVDT_OPEN_CFM_EVT : AVDT_OPEN_IND_EVT;
     p_data->open.hdr.err_code = 0;
 
-    AVDT_TRACE_DEBUG3("psc_mask: cfg: 0x%x, req:0x%x, cur: 0x%x",
+    AVDT_TRACE_DEBUG("psc_mask: cfg: 0x%x, req:0x%x, cur: 0x%x",
         p_scb->cs.cfg.psc_mask, p_scb->req_cfg.psc_mask, p_scb->curr_cfg.psc_mask);
 #if AVDT_REPORTING == TRUE
     if(p_scb->curr_cfg.psc_mask & AVDT_PSC_REPORT)
@@ -1223,7 +1223,7 @@ void avdt_scb_hdl_write_req_no_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
         GKI_freebuf(p_scb->p_pkt);
 
         /* this shouldn't be happening */
-        AVDT_TRACE_WARNING0("Dropped media packet; congested");
+        AVDT_TRACE_WARNING("Dropped media packet; congested");
     }
 
     /* build a media packet */
@@ -1274,7 +1274,7 @@ void avdt_scb_hdl_write_req_frag(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
             GKI_freebuf(p_frag);
 
         /* this shouldn't be happening */
-        AVDT_TRACE_WARNING0("*** Dropped media packet; congested");
+        AVDT_TRACE_WARNING("*** Dropped media packet; congested");
     }
 
     /* build a media fragments */
@@ -1422,7 +1422,7 @@ void avdt_scb_snd_stream_close(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
 #if AVDT_MULTIPLEXING == TRUE
     BT_HDR          *p_frag;
 
-    AVDT_TRACE_WARNING2("avdt_scb_snd_stream_close c:%d, off:%d",
+    AVDT_TRACE_WARNING("avdt_scb_snd_stream_close c:%d, off:%d",
         p_scb->frag_q.count, p_scb->frag_off);
     /* clean fragments queue */
     while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
@@ -1872,7 +1872,7 @@ void avdt_scb_free_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
          GKI_freebuf(p_frag);
 #endif
 
-    AVDT_TRACE_WARNING0("Dropped media packet");
+    AVDT_TRACE_WARNING("Dropped media packet");
 
     /* we need to call callback to keep data flow going */
     (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT,
@@ -1917,7 +1917,7 @@ void avdt_scb_clr_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
         GKI_freebuf(p_scb->p_pkt);
         p_scb->p_pkt = NULL;
 
-        AVDT_TRACE_DEBUG0("Dropped stored media packet");
+        AVDT_TRACE_DEBUG("Dropped stored media packet");
 
         /* we need to call callback to keep data flow going */
         (*p_scb->cs.p_ctrl_cback)(avdt_scb_to_hdl(p_scb), NULL, AVDT_WRITE_CFM_EVT,
@@ -1926,7 +1926,7 @@ void avdt_scb_clr_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
 #if AVDT_MULTIPLEXING == TRUE
     else if(!GKI_queue_is_empty (&p_scb->frag_q))
     {
-        AVDT_TRACE_DEBUG0("Dropped fragments queue");
+        AVDT_TRACE_DEBUG("Dropped fragments queue");
         /* clean fragments queue */
         while((p_frag = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
              GKI_freebuf(p_frag);
@@ -1980,24 +1980,24 @@ void avdt_scb_chk_snd_pkt(tAVDT_SCB *p_scb, tAVDT_SCB_EVT *p_data)
         else
         {
 #if 0
-            AVDT_TRACE_DEBUG1("num_q=%d",
+            AVDT_TRACE_DEBUG("num_q=%d",
                 L2CA_FlushChannel(avdt_cb.ad.rt_tbl[avdt_ccb_to_idx(p_scb->p_ccb)][avdt_ad_type_to_tcid(AVDT_CHAN_MEDIA, p_scb)].lcid),
                                   L2CAP_FLUSH_CHANS_GET);
 #endif
             while((p_pkt = (BT_HDR*)GKI_dequeue (&p_scb->frag_q)) != NULL)
             {
                 sent = TRUE;
-                AVDT_TRACE_DEBUG1("Send fragment len=%d",p_pkt->len);
+                AVDT_TRACE_DEBUG("Send fragment len=%d",p_pkt->len);
                 /* fragments queue contains fragment to send */
                 res = avdt_ad_write_req(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb, p_pkt);
                 if(AVDT_AD_CONGESTED == res)
                 {
                     p_scb->cong = TRUE;
-                    AVDT_TRACE_DEBUG0("avdt/l2c congested!!");
+                    AVDT_TRACE_DEBUG("avdt/l2c congested!!");
                     break;/* exit loop if channel became congested */
             }
             }
-            AVDT_TRACE_DEBUG2("res=%d left=%d",res, p_scb->frag_off);
+            AVDT_TRACE_DEBUG("res=%d left=%d",res, p_scb->frag_off);
 
             if(p_scb->frag_off)
             {
@@ -2106,7 +2106,7 @@ void avdt_scb_queue_frags(tAVDT_SCB *p_scb, UINT8 **pp_data, UINT32 *p_data_len,
     else
     {
         num_frag = L2CA_FlushChannel(lcid, L2CAP_FLUSH_CHANS_GET);
-        AVDT_TRACE_DEBUG2("num_q=%d lcid=%d", num_frag, lcid);
+        AVDT_TRACE_DEBUG("num_q=%d lcid=%d", num_frag, lcid);
         if(num_frag >= AVDT_MAX_FRAG_COUNT)
         {
             num_frag = 0;
@@ -2120,7 +2120,7 @@ void avdt_scb_queue_frags(tAVDT_SCB *p_scb, UINT8 **pp_data, UINT32 *p_data_len,
     /* look up transport channel table entry to get peer mtu */
     p_tbl = avdt_ad_tc_tbl_by_type(AVDT_CHAN_MEDIA, p_scb->p_ccb, p_scb);
     buf_size = p_tbl->peer_mtu + BT_HDR_SIZE;
-    AVDT_TRACE_DEBUG3("peer_mtu: %d, buf_size: %d num_frag=%d",
+    AVDT_TRACE_DEBUG("peer_mtu: %d, buf_size: %d num_frag=%d",
         p_tbl->peer_mtu, buf_size, num_frag);
 
     if(buf_size > AVDT_DATA_POOL_SIZE)
@@ -2133,7 +2133,7 @@ void avdt_scb_queue_frags(tAVDT_SCB *p_scb, UINT8 **pp_data, UINT32 *p_data_len,
         /* allocate buffer for fragment */
         if(NULL == (p_frag = (BT_HDR*)GKI_getbuf(buf_size)))
         {
-            AVDT_TRACE_WARNING1("avdt_scb_queue_frags len=%d(out of GKI buffers)",*p_data_len);
+            AVDT_TRACE_WARNING("avdt_scb_queue_frags len=%d(out of GKI buffers)",*p_data_len);
             break;
         }
         /* fill fragment by chunk of media payload */
@@ -2148,7 +2148,7 @@ void avdt_scb_queue_frags(tAVDT_SCB *p_scb, UINT8 **pp_data, UINT32 *p_data_len,
         memcpy((UINT8*)(p_frag+1) + p_frag->offset, *pp_data, p_frag->len);
         *pp_data += p_frag->len;
         *p_data_len -= p_frag->len;
-        AVDT_TRACE_DEBUG1("Prepared fragment len=%d", p_frag->len);
+        AVDT_TRACE_DEBUG("Prepared fragment len=%d", p_frag->len);
 
         if(al_hdr)
         {