| /****************************************************************************** |
| * |
| * Copyright (C) 2004-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * This module contains utility functions for dealing with SBC data frames |
| * and codec capabilities. |
| * |
| ******************************************************************************/ |
| |
| #include "a2d_api.h" |
| #include "a2d_sbc.h" |
| #include "bta_av_sbc.h" |
| #include "utl.h" |
| |
| typedef int (tBTA_AV_SBC_ACT)(void *p_src, void *p_dst, |
| UINT32 src_samples, UINT32 dst_samples, |
| UINT32 *p_ret); |
| |
| typedef struct |
| { |
| INT32 cur_pos; /* current position */ |
| UINT32 src_sps; /* samples per second (source audio data) */ |
| UINT32 dst_sps; /* samples per second (converted audio data) */ |
| tBTA_AV_SBC_ACT *p_act; /* the action function to do the conversion */ |
| UINT16 bits; /* number of bits per pcm sample */ |
| UINT16 n_channels; /* number of channels (i.e. mono(1), stereo(2)...) */ |
| INT16 worker1; |
| INT16 worker2; |
| UINT8 div; |
| } tBTA_AV_SBC_UPS_CB; |
| |
| tBTA_AV_SBC_UPS_CB bta_av_sbc_ups_cb; |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_init_up_sample |
| ** |
| ** Description initialize the up sample |
| ** |
| ** src_sps: samples per second (source audio data) |
| ** dst_sps: samples per second (converted audio data) |
| ** bits: number of bits per pcm sample |
| ** n_channels: number of channels (i.e. mono(1), stereo(2)...) |
| ** |
| ** Returns none |
| ** |
| *******************************************************************************/ |
| void bta_av_sbc_init_up_sample (UINT32 src_sps, UINT32 dst_sps, UINT16 bits, UINT16 n_channels) |
| { |
| bta_av_sbc_ups_cb.cur_pos = -1; |
| bta_av_sbc_ups_cb.src_sps = src_sps; |
| bta_av_sbc_ups_cb.dst_sps = dst_sps; |
| bta_av_sbc_ups_cb.bits = bits; |
| bta_av_sbc_ups_cb.n_channels= n_channels; |
| |
| if(n_channels == 1) |
| { |
| /* mono */ |
| if(bits == 8) |
| { |
| bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_8m; |
| bta_av_sbc_ups_cb.div = 1; |
| } |
| else |
| { |
| bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_16m; |
| bta_av_sbc_ups_cb.div = 2; |
| } |
| } |
| else |
| { |
| /* stereo */ |
| if(bits == 8) |
| { |
| bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_8s; |
| bta_av_sbc_ups_cb.div = 2; |
| } |
| else |
| { |
| bta_av_sbc_ups_cb.p_act = bta_av_sbc_up_sample_16s; |
| bta_av_sbc_ups_cb.div = 4; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_up_sample |
| ** |
| ** Description Given the source (p_src) audio data and |
| ** source speed (src_sps, samples per second), |
| ** This function converts it to audio data in the desired format |
| ** |
| ** p_src: the data buffer that holds the source audio data |
| ** p_dst: the data buffer to hold the converted audio data |
| ** src_samples: The number of source samples (number of bytes) |
| ** dst_samples: The size of p_dst (number of bytes) |
| ** |
| ** Note: An AE reported an issue with this function. |
| ** When called with bta_av_sbc_up_sample(src, uint8_array_dst..) |
| ** the byte before uint8_array_dst may get overwritten. |
| ** Using uint16_array_dst avoids the problem. |
| ** This issue is related to endian-ness and is hard to resolve |
| ** in a generic manner. |
| ** **************** Please use uint16 array as dst. |
| ** |
| ** Returns The number of bytes used in p_dst |
| ** The number of bytes used in p_src (in *p_ret) |
| ** |
| *******************************************************************************/ |
| int bta_av_sbc_up_sample (void *p_src, void *p_dst, |
| UINT32 src_samples, UINT32 dst_samples, |
| UINT32 *p_ret) |
| { |
| UINT32 src; |
| UINT32 dst; |
| |
| if(bta_av_sbc_ups_cb.p_act) |
| { |
| src = src_samples/bta_av_sbc_ups_cb.div; |
| dst = dst_samples/bta_av_sbc_ups_cb.div; |
| return (*bta_av_sbc_ups_cb.p_act)(p_src, p_dst, src, dst, p_ret); |
| } |
| else |
| { |
| *p_ret = 0; |
| return 0; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_up_sample_16s (16bits-stereo) |
| ** |
| ** Description Given the source (p_src) audio data and |
| ** source speed (src_sps, samples per second), |
| ** This function converts it to audio data in the desired format |
| ** |
| ** p_src: the data buffer that holds the source audio data |
| ** p_dst: the data buffer to hold the converted audio data |
| ** src_samples: The number of source samples (in uint of 4 bytes) |
| ** dst_samples: The size of p_dst (in uint of 4 bytes) |
| ** |
| ** Returns The number of bytes used in p_dst |
| ** The number of bytes used in p_src (in *p_ret) |
| ** |
| *******************************************************************************/ |
| int bta_av_sbc_up_sample_16s (void *p_src, void *p_dst, |
| UINT32 src_samples, UINT32 dst_samples, |
| UINT32 *p_ret) |
| { |
| INT16 *p_src_tmp = (INT16 *)p_src; |
| INT16 *p_dst_tmp = (INT16 *)p_dst; |
| INT16 *p_worker1 = &bta_av_sbc_ups_cb.worker1; |
| INT16 *p_worker2 = &bta_av_sbc_ups_cb.worker2; |
| UINT32 src_sps = bta_av_sbc_ups_cb.src_sps; |
| UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps; |
| |
| while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) |
| { |
| *p_dst_tmp++ = *p_worker1; |
| *p_dst_tmp++ = *p_worker2; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples--; |
| } |
| |
| bta_av_sbc_ups_cb.cur_pos = dst_sps; |
| |
| while (src_samples-- && dst_samples) |
| { |
| *p_worker1 = *p_src_tmp++; |
| *p_worker2 = *p_src_tmp++; |
| |
| do |
| { |
| *p_dst_tmp++ = *p_worker1; |
| *p_dst_tmp++ = *p_worker2; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples--; |
| } while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples); |
| |
| bta_av_sbc_ups_cb.cur_pos += dst_sps; |
| } |
| |
| if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) |
| bta_av_sbc_ups_cb.cur_pos = 0; |
| |
| *p_ret = ((char *)p_src_tmp - (char *)p_src); |
| return ((char *)p_dst_tmp - (char *)p_dst); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_up_sample_16m (16bits-mono) |
| ** |
| ** Description Given the source (p_src) audio data and |
| ** source speed (src_sps, samples per second), |
| ** This function converts it to audio data in the desired format |
| ** |
| ** p_src: the data buffer that holds the source audio data |
| ** p_dst: the data buffer to hold the converted audio data |
| ** src_samples: The number of source samples (in uint of 2 bytes) |
| ** dst_samples: The size of p_dst (in uint of 2 bytes) |
| ** |
| ** Returns The number of bytes used in p_dst |
| ** The number of bytes used in p_src (in *p_ret) |
| ** |
| *******************************************************************************/ |
| int bta_av_sbc_up_sample_16m (void *p_src, void *p_dst, |
| UINT32 src_samples, UINT32 dst_samples, |
| UINT32 *p_ret) |
| { |
| INT16 *p_src_tmp = (INT16 *)p_src; |
| INT16 *p_dst_tmp = (INT16 *)p_dst; |
| INT16 *p_worker = &bta_av_sbc_ups_cb.worker1; |
| UINT32 src_sps = bta_av_sbc_ups_cb.src_sps; |
| UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps; |
| |
| while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) |
| { |
| *p_dst_tmp++ = *p_worker; |
| *p_dst_tmp++ = *p_worker; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples--; |
| dst_samples--; |
| } |
| |
| |
| bta_av_sbc_ups_cb.cur_pos = dst_sps; |
| |
| while (src_samples-- && dst_samples) |
| { |
| *p_worker = *p_src_tmp++; |
| |
| do |
| { |
| *p_dst_tmp++ = *p_worker; |
| *p_dst_tmp++ = *p_worker; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples--; |
| dst_samples--; |
| |
| } while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples); |
| |
| bta_av_sbc_ups_cb.cur_pos += dst_sps; |
| } |
| |
| if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) |
| bta_av_sbc_ups_cb.cur_pos = 0; |
| |
| *p_ret = ((char *)p_src_tmp - (char *)p_src); |
| return ((char *)p_dst_tmp - (char *)p_dst); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_up_sample_8s (8bits-stereo) |
| ** |
| ** Description Given the source (p_src) audio data and |
| ** source speed (src_sps, samples per second), |
| ** This function converts it to audio data in the desired format |
| ** |
| ** p_src: the data buffer that holds the source audio data |
| ** p_dst: the data buffer to hold the converted audio data |
| ** src_samples: The number of source samples (in uint of 2 bytes) |
| ** dst_samples: The size of p_dst (in uint of 2 bytes) |
| ** |
| ** Returns The number of bytes used in p_dst |
| ** The number of bytes used in p_src (in *p_ret) |
| ** |
| *******************************************************************************/ |
| int bta_av_sbc_up_sample_8s (void *p_src, void *p_dst, |
| UINT32 src_samples, UINT32 dst_samples, |
| UINT32 *p_ret) |
| { |
| UINT8 *p_src_tmp = (UINT8 *)p_src; |
| INT16 *p_dst_tmp = (INT16 *)p_dst; |
| INT16 *p_worker1 = &bta_av_sbc_ups_cb.worker1; |
| INT16 *p_worker2 = &bta_av_sbc_ups_cb.worker2; |
| UINT32 src_sps = bta_av_sbc_ups_cb.src_sps; |
| UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps; |
| |
| while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) |
| { |
| *p_dst_tmp++ = *p_worker1; |
| *p_dst_tmp++ = *p_worker2; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples--; |
| dst_samples--; |
| } |
| |
| bta_av_sbc_ups_cb.cur_pos = dst_sps; |
| |
| while (src_samples -- && dst_samples) |
| { |
| *p_worker1 = *(UINT8 *)p_src_tmp++; |
| *p_worker1 -= 0x80; |
| *p_worker1 <<= 8; |
| *p_worker2 = *(UINT8 *)p_src_tmp++; |
| *p_worker2 -= 0x80; |
| *p_worker2 <<= 8; |
| |
| do |
| { |
| *p_dst_tmp++ = *p_worker1; |
| *p_dst_tmp++ = *p_worker2; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples--; |
| dst_samples--; |
| } while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples); |
| |
| bta_av_sbc_ups_cb.cur_pos += dst_sps; |
| } |
| |
| if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) |
| bta_av_sbc_ups_cb.cur_pos = 0; |
| |
| *p_ret = ((char *)p_src_tmp - (char *)p_src); |
| return ((char *)p_dst_tmp - (char *)p_dst); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_up_sample_8m (8bits-mono) |
| ** |
| ** Description Given the source (p_src) audio data and |
| ** source speed (src_sps, samples per second), |
| ** This function converts it to audio data in the desired format |
| ** |
| ** p_src: the data buffer that holds the source audio data |
| ** p_dst: the data buffer to hold the converted audio data |
| ** src_samples: The number of source samples (number of bytes) |
| ** dst_samples: The size of p_dst (number of bytes) |
| ** |
| ** Returns The number of bytes used in p_dst |
| ** The number of bytes used in p_src (in *p_ret) |
| ** |
| *******************************************************************************/ |
| int bta_av_sbc_up_sample_8m (void *p_src, void *p_dst, |
| UINT32 src_samples, UINT32 dst_samples, |
| UINT32 *p_ret) |
| { |
| UINT8 *p_src_tmp = (UINT8 *)p_src; |
| INT16 *p_dst_tmp = (INT16 *)p_dst; |
| INT16 *p_worker = &bta_av_sbc_ups_cb.worker1; |
| UINT32 src_sps = bta_av_sbc_ups_cb.src_sps; |
| UINT32 dst_sps = bta_av_sbc_ups_cb.dst_sps; |
| |
| while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples) |
| { |
| *p_dst_tmp++ = *p_worker; |
| *p_dst_tmp++ = *p_worker; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples -= 4; |
| } |
| |
| |
| bta_av_sbc_ups_cb.cur_pos = dst_sps; |
| |
| while (src_samples-- && dst_samples) |
| { |
| *p_worker = *(UINT8 *)p_src_tmp++; |
| *p_worker -= 0x80; |
| *p_worker <<= 8; |
| |
| do |
| { |
| *p_dst_tmp++ = *p_worker; |
| *p_dst_tmp++ = *p_worker; |
| |
| bta_av_sbc_ups_cb.cur_pos -= src_sps; |
| dst_samples -= 4; |
| |
| } while (bta_av_sbc_ups_cb.cur_pos > 0 && dst_samples); |
| |
| bta_av_sbc_ups_cb.cur_pos += dst_sps; |
| } |
| |
| if (bta_av_sbc_ups_cb.cur_pos == (INT32)dst_sps) |
| bta_av_sbc_ups_cb.cur_pos = 0; |
| |
| *p_ret = ((char *)p_src_tmp - (char *)p_src); |
| return ((char *)p_dst_tmp - (char *)p_dst); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_cfg_for_cap |
| ** |
| ** Description Determine the preferred SBC codec configuration for the |
| ** given codec capabilities. The function is passed the |
| ** preferred codec configuration and the peer codec |
| ** capabilities for the stream. The function attempts to |
| ** match the preferred capabilities with the configuration |
| ** as best it can. The resulting codec configuration is |
| ** returned in the same memory used for the capabilities. |
| ** |
| ** Returns 0 if ok, nonzero if error. |
| ** Codec configuration in p_cap. |
| ** |
| *******************************************************************************/ |
| UINT8 bta_av_sbc_cfg_for_cap(UINT8 *p_peer, tA2D_SBC_CIE *p_cap, tA2D_SBC_CIE *p_pref) |
| { |
| UINT8 status = A2D_SUCCESS; |
| tA2D_SBC_CIE peer_cie; |
| UNUSED(p_cap); |
| |
| /* parse peer capabilities */ |
| if ((status = A2D_ParsSbcInfo(&peer_cie, p_peer, TRUE)) != 0) |
| { |
| return status; |
| } |
| |
| /* Check if the peer supports our channel mode */ |
| if (peer_cie.ch_mode & p_pref->ch_mode) |
| { |
| peer_cie.ch_mode = p_pref->ch_mode; |
| } |
| else |
| { |
| APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: ch_mode(0x%02X) not supported", p_pref->ch_mode); |
| return A2D_FAIL; |
| } |
| |
| /* Check if the peer supports our sampling freq */ |
| if (peer_cie.samp_freq & p_pref->samp_freq) |
| { |
| peer_cie.samp_freq = p_pref->samp_freq; |
| } |
| else |
| { |
| APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: samp_freq(0x%02X) not supported", p_pref->samp_freq); |
| return A2D_FAIL; |
| } |
| |
| /* Check if the peer supports our block len */ |
| if (peer_cie.block_len & p_pref->block_len) |
| { |
| peer_cie.block_len = p_pref->block_len; |
| } |
| else |
| { |
| APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: block_len(0x%02X) not supported", p_pref->block_len); |
| return A2D_FAIL; |
| } |
| |
| /* Check if the peer supports our num subbands */ |
| if (peer_cie.num_subbands & p_pref->num_subbands) |
| { |
| peer_cie.num_subbands = p_pref->num_subbands; |
| } |
| else |
| { |
| APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: num_subbands(0x%02X) not supported", p_pref->num_subbands); |
| return A2D_FAIL; |
| } |
| |
| /* Check if the peer supports our alloc method */ |
| if (peer_cie.alloc_mthd & p_pref->alloc_mthd) |
| { |
| peer_cie.alloc_mthd = p_pref->alloc_mthd; |
| } |
| else |
| { |
| APPL_TRACE_ERROR("bta_av_sbc_cfg_for_cap: alloc_mthd(0x%02X) not supported", p_pref->alloc_mthd); |
| return A2D_FAIL; |
| } |
| |
| /* max bitpool */ |
| if (p_pref->max_bitpool != 0 && p_pref->max_bitpool < peer_cie.max_bitpool) |
| { |
| peer_cie.max_bitpool = p_pref->max_bitpool; |
| } |
| |
| /* min bitpool */ |
| if (p_pref->min_bitpool != 0 && p_pref->min_bitpool > peer_cie.min_bitpool) |
| { |
| peer_cie.min_bitpool = p_pref->min_bitpool; |
| } |
| |
| if (status == A2D_SUCCESS) |
| { |
| /* build configuration */ |
| A2D_BldSbcInfo(A2D_MEDIA_TYPE_AUDIO, &peer_cie, p_peer); |
| } |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_cfg_matches_cap |
| ** |
| ** Description This function checks whether an SBC codec configuration |
| ** matched with capabilities. Here we check subset. |
| ** |
| ** Returns 0 if ok, nonzero if error. |
| ** |
| *******************************************************************************/ |
| UINT8 bta_av_sbc_cfg_matches_cap(UINT8 *p_cfg, tA2D_SBC_CIE *p_cap) |
| { |
| UINT8 status = 0; |
| tA2D_SBC_CIE cfg_cie; |
| |
| /* parse configuration */ |
| if ((status = A2D_ParsSbcInfo(&cfg_cie, p_cfg, TRUE)) != 0) |
| { |
| APPL_TRACE_ERROR(" bta_av_sbc_cfg_matches_cap Parsing Failed %d", status); |
| return status; |
| } |
| |
| /* verify that each parameter is in range */ |
| |
| APPL_TRACE_DEBUG(" FREQ peer: 0%x, capability 0%x", cfg_cie.samp_freq, p_cap->samp_freq); |
| APPL_TRACE_DEBUG(" CH_MODE peer: 0%x, capability 0%x", cfg_cie.ch_mode, p_cap->ch_mode); |
| APPL_TRACE_DEBUG(" BLOCK_LEN peer: 0%x, capability 0%x", cfg_cie.block_len, p_cap->block_len); |
| APPL_TRACE_DEBUG(" SUB_BAND peer: 0%x, capability 0%x", cfg_cie.num_subbands, p_cap->num_subbands); |
| APPL_TRACE_DEBUG(" ALLOC_MTHD peer: 0%x, capability 0%x", cfg_cie.alloc_mthd, p_cap->alloc_mthd); |
| APPL_TRACE_DEBUG(" MAX_BitPool peer: 0%x, capability 0%x", cfg_cie.max_bitpool, p_cap->max_bitpool); |
| APPL_TRACE_DEBUG(" Min_bitpool peer: 0%x, capability 0%x", cfg_cie.min_bitpool, p_cap->min_bitpool); |
| |
| /* sampling frequency */ |
| if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0) |
| { |
| status = A2D_NS_SAMP_FREQ; |
| } |
| /* channel mode */ |
| else if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0) |
| { |
| status = A2D_NS_CH_MODE; |
| } |
| /* block length */ |
| else if ((cfg_cie.block_len & p_cap->block_len) == 0) |
| { |
| status = A2D_BAD_BLOCK_LEN; |
| } |
| /* subbands */ |
| else if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0) |
| { |
| status = A2D_NS_SUBBANDS; |
| } |
| /* allocation method */ |
| else if ((cfg_cie.alloc_mthd & p_cap->alloc_mthd) == 0) |
| { |
| status = A2D_NS_ALLOC_MTHD; |
| } |
| /* max bitpool */ |
| else if (cfg_cie.max_bitpool > p_cap->max_bitpool) |
| { |
| status = A2D_NS_MAX_BITPOOL; |
| } |
| /* min bitpool */ |
| else if (cfg_cie.min_bitpool < p_cap->min_bitpool) |
| { |
| status = A2D_NS_MIN_BITPOOL; |
| } |
| |
| return status; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_cfg_in_cap |
| ** |
| ** Description This function checks whether an SBC codec configuration |
| ** is allowable for the given codec capabilities. |
| ** |
| ** Returns 0 if ok, nonzero if error. |
| ** |
| *******************************************************************************/ |
| UINT8 bta_av_sbc_cfg_in_cap(UINT8 *p_cfg, tA2D_SBC_CIE *p_cap) |
| { |
| UINT8 status = 0; |
| tA2D_SBC_CIE cfg_cie; |
| |
| /* parse configuration */ |
| if ((status = A2D_ParsSbcInfo(&cfg_cie, p_cfg, FALSE)) != 0) |
| { |
| return status; |
| } |
| |
| /* verify that each parameter is in range */ |
| |
| |
| /* sampling frequency */ |
| if ((cfg_cie.samp_freq & p_cap->samp_freq) == 0) |
| { |
| status = A2D_NS_SAMP_FREQ; |
| } |
| /* channel mode */ |
| else if ((cfg_cie.ch_mode & p_cap->ch_mode) == 0) |
| { |
| status = A2D_NS_CH_MODE; |
| } |
| /* block length */ |
| else if ((cfg_cie.block_len & p_cap->block_len) == 0) |
| { |
| status = A2D_BAD_BLOCK_LEN; |
| } |
| /* subbands */ |
| else if ((cfg_cie.num_subbands & p_cap->num_subbands) == 0) |
| { |
| status = A2D_NS_SUBBANDS; |
| } |
| /* allocation method */ |
| else if ((cfg_cie.alloc_mthd & p_cap->alloc_mthd) == 0) |
| { |
| status = A2D_NS_ALLOC_MTHD; |
| } |
| /* max bitpool */ |
| else if (cfg_cie.max_bitpool > p_cap->max_bitpool) |
| { |
| status = A2D_NS_MAX_BITPOOL; |
| } |
| /* min bitpool */ |
| else if (cfg_cie.min_bitpool < p_cap->min_bitpool) |
| { |
| status = A2D_NS_MIN_BITPOOL; |
| } |
| |
| return status; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function bta_av_sbc_bld_hdr |
| ** |
| ** Description This function builds the packet header for MPF1. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void bta_av_sbc_bld_hdr(BT_HDR *p_buf, UINT16 fr_per_pkt) |
| { |
| UINT8 *p; |
| |
| p_buf->offset -= BTA_AV_SBC_HDR_SIZE; |
| p = (UINT8 *) (p_buf + 1) + p_buf->offset; |
| p_buf->len += BTA_AV_SBC_HDR_SIZE; |
| A2D_BldSbcMplHdr(p, FALSE, FALSE, FALSE, (UINT8) fr_per_pkt); |
| } |
| |
