diff options
64 files changed, 10640 insertions, 183 deletions
diff --git a/a2dp_audio_hw/Android.mk b/a2dp_audio_hw/Android.mk new file mode 100644 index 0000000..4487306 --- /dev/null +++ b/a2dp_audio_hw/Android.mk @@ -0,0 +1,19 @@ +LOCAL_PATH:= $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + audio_a2dp_hw.c \ + +LOCAL_SHARED_LIBRARIES := \ + libcutils + +LOCAL_SHARED_LIBRARIES += \ + libpower + +LOCAL_MODULE := audio.a2dp.default +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw + +LOCAL_MODULE_TAGS := optional + +include $(BUILD_SHARED_LIBRARY) diff --git a/a2dp_audio_hw/audio_a2dp_hw.c b/a2dp_audio_hw/audio_a2dp_hw.c new file mode 100644 index 0000000..a6d4cd1 --- /dev/null +++ b/a2dp_audio_hw/audio_a2dp_hw.c @@ -0,0 +1,716 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + +#define LOG_TAG "audio_a2dp_hw" +#define LOG_NDEBUG 0 + +#include <errno.h> +#include <pthread.h> +#include <stdint.h> +#include <sys/time.h> + +#include <sys/socket.h> +#include <sys/un.h> +#include <sys/poll.h> +#include <sys/errno.h> + +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> + +#include <cutils/str_parms.h> +#include <cutils/log.h> +#include <cutils/sockets.h> + + +#include <hardware/hardware.h> +#include <system/audio.h> +#include <hardware/audio.h> + +#define A2DP_AUDIO_HARDWARE_INTERFACE "audio.a2dp" + +#define A2DP_SOCK_PATH "/data/misc/bluedroid/.a2dp_sock" + +#define AUDIO_CHANNEL_DEFAULT_RATE 44100 +#define AUDIO_CHANNEL_DEFAULT_FORMAT AUDIO_FORMAT_PCM_16_BIT; +#define AUDIO_CHANNEL_OUTPUT_BUFFER_SZ (20*512) /* fixme -- tune this */ + +#define SKT_DISCONNECTED (-1) + +#define ADEV_TRACE() LOGV("%s", __FUNCTION__); +#define ADEV_LOG(fmt, ...) LOGD ("%s: " fmt,__FUNCTION__, ## __VA_ARGS__) + + +struct a2dp_stream_out; + +struct a2dp_audio_device { + struct audio_hw_device device; + struct a2dp_stream_out *output; +}; + +struct a2dp_stream_out { + struct audio_stream_out stream; + int sock_fd; +}; + +struct a2dp_stream_in { + struct audio_stream_in stream; +}; + +static size_t out_get_buffer_size(const struct audio_stream *stream); + +/***************************************************************************** +** +** BT stack adaptation +** +*****************************************************************************/ + +void set_blocking(int s) +{ + int opts; + opts = fcntl(s, F_GETFL); + if (opts < 0) + ADEV_LOG("set blocking (%s)", strerror(errno)); + opts &= ~O_NONBLOCK; + fcntl(s, F_SETFL, opts); +} + +static inline int connect_server_socket(const char* name) +{ + int s = socket(AF_LOCAL, SOCK_STREAM, 0); + + set_blocking(s); + + if(socket_local_client_connect(s, name, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM) >= 0) + { + ADEV_LOG("connect to %s (fd:%d)", name, s); + return s; + } + else + { + ADEV_LOG("connect to %s (fd:%d) failed, errno:%s", name, s, strerror(errno)); + } + + close(s); + + return -1; +} + +static int skt_connect(char *path) +{ + int ret; + int fd; + struct sockaddr_un remote; + int len; + + ADEV_LOG("connect to %s", path); + + if ((fd = connect_server_socket(path)) == -1) + { + ADEV_LOG("failed to connect (%s)", strerror(errno)); + close(fd); + return -1; + } + + len = AUDIO_CHANNEL_OUTPUT_BUFFER_SZ; + setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (char*)&len, (int)sizeof(len)); + + /* add checks for return status */ + + LOGD("sonnected to stack fd = %d", fd); + + return fd; +} + +static int skt_write(int fd, const void *p, size_t len) +{ + int sent; + struct pollfd pfd; + + ADEV_TRACE(); + + pfd.fd = fd; + pfd.events = POLLOUT; + + /* poll for 500 ms */ + + /* send time out */ + if (poll(&pfd, 1, 500) == 0) + return 0; + + if ((sent = send(fd, p, len, MSG_NOSIGNAL)) == -1) { + LOGE("stream_write failed with errno=%d", errno); + return -1; + } + + return sent; +} + +static int skt_disconnect(int fd) +{ + ADEV_LOG("fd %d", fd); + + if (fd != SKT_DISCONNECTED) + { + close(fd); + } + return 0; +} + +/***************************************************************************** +** +** audio output callbacks +** +*****************************************************************************/ + + +static uint32_t out_get_sample_rate(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return AUDIO_CHANNEL_DEFAULT_RATE; +} + +static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate) +{ + ADEV_LOG("out_set_sample_rate : %d", rate); + + if (rate != AUDIO_CHANNEL_DEFAULT_RATE) + { + LOGE("only rate %d supported", AUDIO_CHANNEL_DEFAULT_RATE); + return -1; + } + + return 0; +} + +static size_t out_get_buffer_size(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return AUDIO_CHANNEL_OUTPUT_BUFFER_SZ; +} + +static uint32_t out_get_channels(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return AUDIO_CHANNEL_OUT_STEREO; +} + +static int out_get_format(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return AUDIO_CHANNEL_DEFAULT_FORMAT; +} + +static int out_set_format(struct audio_stream *stream, int format) +{ + ADEV_LOG("out_set_format %x", format); + return 0; +} + +static int out_standby(struct audio_stream *stream) +{ + ADEV_TRACE(); + return 0; +} + +static int out_dump(const struct audio_stream *stream, int fd) +{ + ADEV_TRACE(); + return 0; +} + +static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) +{ + int ret; + struct str_parms *parms; + + ADEV_TRACE(); + + parms = str_parms_create_str(kvpairs); + + /* fixme -- translate parameter settings to bluedroid */ + + return 0; +} + +static char * out_get_parameters(const struct audio_stream *stream, const char *keys) +{ + ADEV_TRACE(); + return strdup(""); +} + +static uint32_t out_get_latency(const struct audio_stream_out *stream) +{ + ADEV_TRACE(); + return 0; +} + +static int out_set_volume(struct audio_stream_out *stream, float left, + float right) +{ + ADEV_TRACE(); + return 0; +} + +static ssize_t out_write(struct audio_stream_out *stream, const void* buffer, + size_t bytes) +{ + struct a2dp_stream_out *out = (struct a2dp_stream_out *)stream; + int sent; + + ADEV_LOG("write %d bytes", bytes); + + /* connect socket if not available */ + if (out->sock_fd == SKT_DISCONNECTED) + { + out->sock_fd = skt_connect(A2DP_SOCK_PATH); + if (out->sock_fd < 0) + return -1; + } + + sent = skt_write(out->sock_fd, buffer, bytes); + + ADEV_LOG("wrote %d bytes out of %d bytes", sent, bytes); + return sent; +} + +static int out_get_render_position(const struct audio_stream_out *stream, + uint32_t *dsp_frames) +{ + ADEV_TRACE(); + return -EINVAL; +} + +static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) +{ + ADEV_TRACE(); + return 0; +} + +static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) +{ + ADEV_TRACE(); + return 0; +} + +/* + * AUDIO INPUT STREAM + */ + +static uint32_t in_get_sample_rate(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return 8000; +} + +static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate) +{ + ADEV_TRACE(); + return 0; +} + +static size_t in_get_buffer_size(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return 320; +} + +static uint32_t in_get_channels(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return AUDIO_CHANNEL_IN_MONO; +} + +static int in_get_format(const struct audio_stream *stream) +{ + ADEV_TRACE(); + return AUDIO_FORMAT_PCM_16_BIT; +} + +static int in_set_format(struct audio_stream *stream, int format) +{ + ADEV_TRACE(); + return 0; +} + +static int in_standby(struct audio_stream *stream) +{ + ADEV_TRACE(); + return 0; +} + +static int in_dump(const struct audio_stream *stream, int fd) +{ + ADEV_TRACE(); + return 0; +} + +static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) +{ + ADEV_TRACE(); + return 0; +} + +static char * in_get_parameters(const struct audio_stream *stream, + const char *keys) +{ + ADEV_TRACE(); + return strdup(""); +} + +static int in_set_gain(struct audio_stream_in *stream, float gain) +{ + ADEV_TRACE(); + return 0; +} + +static ssize_t in_read(struct audio_stream_in *stream, void* buffer, + size_t bytes) +{ + ADEV_TRACE(); + return bytes; +} + +static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream) +{ + ADEV_TRACE(); + return 0; +} + +static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) +{ + ADEV_TRACE(); + return 0; +} + +static int in_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect) +{ + ADEV_TRACE(); + + return 0; +} + + +static int adev_open_output_stream(struct audio_hw_device *dev, + uint32_t devices, int *format, + uint32_t *channels, uint32_t *sample_rate, + struct audio_stream_out **stream_out) +{ + struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev; + + struct a2dp_stream_out *out; + int ret; + + ADEV_TRACE(); + + out = (struct a2dp_stream_out *)calloc(1, sizeof(struct a2dp_stream_out)); + if (!out) + return -ENOMEM; + + out->stream.common.get_sample_rate = out_get_sample_rate; + out->stream.common.set_sample_rate = out_set_sample_rate; + out->stream.common.get_buffer_size = out_get_buffer_size; + out->stream.common.get_channels = out_get_channels; + out->stream.common.get_format = out_get_format; + out->stream.common.set_format = out_set_format; + out->stream.common.standby = out_standby; + out->stream.common.dump = out_dump; + out->stream.common.set_parameters = out_set_parameters; + out->stream.common.get_parameters = out_get_parameters; + out->stream.common.add_audio_effect = out_add_audio_effect; + out->stream.common.remove_audio_effect = out_remove_audio_effect; + out->stream.get_latency = out_get_latency; + out->stream.set_volume = out_set_volume; + out->stream.write = out_write; + out->stream.get_render_position = out_get_render_position; + + /* initialize a2dp specifics */ + a2dp_dev->output = (struct a2dp_stream_out *)&out->stream; + a2dp_dev->output->sock_fd = SKT_DISCONNECTED; + + /* set output variables */ + if (format) + *format = out_get_format((const struct audio_stream *)&out->stream); + if (channels) + *channels = out_get_channels((const struct audio_stream *)&out->stream); + if (sample_rate) + *sample_rate = out_get_sample_rate((const struct audio_stream *)&out->stream); + + *stream_out = &out->stream; + + return 0; + +err_open: + free(out); + *stream_out = NULL; + return ret; +} + +static void adev_close_output_stream(struct audio_hw_device *dev, + struct audio_stream_out *stream) +{ + struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device *)dev; + ADEV_TRACE(); + skt_disconnect(a2dp_dev->output->sock_fd); + free(stream); +} + +static int adev_set_parameters(struct audio_hw_device *dev, const char *kvpairs) +{ + struct str_parms *parms; + + ADEV_TRACE(); + + parms = str_parms_create_str(kvpairs); + + str_parms_dump(parms); + + ADEV_LOG("### not handled ###"); + + return 0; +} + +static char * adev_get_parameters(const struct audio_hw_device *dev, + const char *keys) +{ + struct str_parms *parms; + + ADEV_TRACE(); + + parms = str_parms_create_str(keys); + + str_parms_dump(parms); + + return NULL; +} + +static int adev_init_check(const struct audio_hw_device *dev) +{ + struct a2dp_audio_device *a2dp_dev = (struct a2dp_audio_device*)dev; + + ADEV_TRACE(); + + /* fixme -- setup control path for a2dp datapath */ + + return 0; +} + +static int adev_set_voice_volume(struct audio_hw_device *dev, float volume) +{ + ADEV_TRACE(); + + return -ENOSYS; +} + +static int adev_set_master_volume(struct audio_hw_device *dev, float volume) +{ + ADEV_TRACE(); + + return -ENOSYS; +} + +static int adev_set_mode(struct audio_hw_device *dev, int mode) +{ + ADEV_TRACE(); + + return 0; +} + +static int adev_set_mic_mute(struct audio_hw_device *dev, bool state) +{ + ADEV_TRACE(); + + return -ENOSYS; +} + +static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state) +{ + ADEV_TRACE(); + + return -ENOSYS; +} + +static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev, + uint32_t sample_rate, int format, + int channel_count) +{ + ADEV_TRACE(); + + return 320; +} + +static int adev_open_input_stream(struct audio_hw_device *dev, uint32_t devices, + int *format, uint32_t *channels, + uint32_t *sample_rate, + audio_in_acoustics_t acoustics, + struct audio_stream_in **stream_in) +{ + struct a2dp_audio_device *ladev = (struct a2dp_audio_device *)dev; + struct a2dp_stream_in *in; + int ret; + + ADEV_TRACE(); + + in = (struct a2dp_stream_in *)calloc(1, sizeof(struct a2dp_stream_in)); + + if (!in) + return -ENOMEM; + + in->stream.common.get_sample_rate = in_get_sample_rate; + in->stream.common.set_sample_rate = in_set_sample_rate; + in->stream.common.get_buffer_size = in_get_buffer_size; + in->stream.common.get_channels = in_get_channels; + in->stream.common.get_format = in_get_format; + in->stream.common.set_format = in_set_format; + in->stream.common.standby = in_standby; + in->stream.common.dump = in_dump; + in->stream.common.set_parameters = in_set_parameters; + in->stream.common.get_parameters = in_get_parameters; + in->stream.common.add_audio_effect = in_add_audio_effect; + in->stream.common.remove_audio_effect = in_remove_audio_effect; + in->stream.set_gain = in_set_gain; + in->stream.read = in_read; + in->stream.get_input_frames_lost = in_get_input_frames_lost; + + *stream_in = &in->stream; + return 0; + +err_open: + free(in); + *stream_in = NULL; + return ret; +} + +static void adev_close_input_stream(struct audio_hw_device *dev, + struct audio_stream_in *in) +{ + ADEV_TRACE(); + + return; +} + +static int adev_dump(const audio_hw_device_t *device, int fd) +{ + ADEV_TRACE(); + + return 0; +} + +static int adev_close(hw_device_t *device) +{ + ADEV_TRACE(); + + free(device); + return 0; +} + +static uint32_t adev_get_supported_devices(const struct audio_hw_device *dev) +{ + ADEV_TRACE(); + + return (AUDIO_DEVICE_OUT_ALL_A2DP); +} + +static int adev_open(const hw_module_t* module, const char* name, + hw_device_t** device) +{ + struct a2dp_audio_device *adev; + int ret; + + ADEV_TRACE(); + + if (strcmp(name, AUDIO_HARDWARE_INTERFACE) != 0) + { + ADEV_LOG("interface %s not matching [%s]", name, AUDIO_HARDWARE_INTERFACE); + return -EINVAL; + } + + adev = calloc(1, sizeof(struct a2dp_audio_device)); + if (!adev) + return -ENOMEM; + + adev->device.common.tag = HARDWARE_DEVICE_TAG; + adev->device.common.version = 0; + adev->device.common.module = (struct hw_module_t *) module; + adev->device.common.close = adev_close; + + adev->device.get_supported_devices = adev_get_supported_devices; + adev->device.init_check = adev_init_check; + adev->device.set_voice_volume = adev_set_voice_volume; + adev->device.set_master_volume = adev_set_master_volume; + adev->device.set_mode = adev_set_mode; + adev->device.set_mic_mute = adev_set_mic_mute; + adev->device.get_mic_mute = adev_get_mic_mute; + adev->device.set_parameters = adev_set_parameters; + adev->device.get_parameters = adev_get_parameters; + adev->device.get_input_buffer_size = adev_get_input_buffer_size; + adev->device.open_output_stream = adev_open_output_stream; + adev->device.close_output_stream = adev_close_output_stream; + adev->device.open_input_stream = adev_open_input_stream; + adev->device.close_input_stream = adev_close_input_stream; + adev->device.dump = adev_dump; + + *device = &adev->device.common; + + return 0; +} + +static struct hw_module_methods_t hal_module_methods = { + .open = adev_open, +}; + +struct audio_module HAL_MODULE_INFO_SYM = { + .common = { + .tag = HARDWARE_MODULE_TAG, + .version_major = 1, + .version_minor = 0, + .id = AUDIO_HARDWARE_MODULE_ID, + .name = "A2DP Audio HW HAL", + .author = "The Android Open Source Project", + .methods = &hal_module_methods, + }, +}; diff --git a/bta/Android.mk b/bta/Android.mk index bbada7e..9471187 100644 --- a/bta/Android.mk +++ b/bta/Android.mk @@ -104,6 +104,8 @@ LOCAL_SRC_FILES:= \ ./av/bta_av_main.c \ ./av/bta_av_cfg.c \ ./av/bta_av_ssm.c \ + ./av/bta_av_sbc.c \ + ./ar/bta_ar.c \ ./hl/bta_hl_act.c \ ./hl/bta_hl_api.c \ ./hl/bta_hl_main.c \ @@ -134,6 +136,7 @@ LOCAL_C_INCLUDES+= . \ $(LOCAL_PATH)/../hcis \ $(LOCAL_PATH)/../hcis/patchram \ $(LOCAL_PATH)/../udrv/include \ + $(LOCAL_PATH)/../brcm/include \ include $(BUILD_STATIC_LIBRARY) diff --git a/bta/ar/bta_ar.c b/bta/ar/bta_ar.c new file mode 100644 index 0000000..b3e897c --- /dev/null +++ b/bta/ar/bta_ar.c @@ -0,0 +1,336 @@ +/***************************************************************************** +** +** Name: bta_ar.c +** +** Description: This is the implementation for the +** audio/video registration module. +** +** Copyright (c) 2008-2009, Broadcom Corp., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +*****************************************************************************/ + +#include <string.h> +#include "bta_ar_api.h" +#include "bta_ar_int.h" + + +/* AV control block */ +#if BTA_DYNAMIC_MEMORY == FALSE +tBTA_AR_CB bta_ar_cb; +#endif + +/******************************************************************************* +** +** Function bta_ar_id +** +** Description This function maps sys_id to ar id mask. +** +** Returns void +** +*******************************************************************************/ +static UINT8 bta_ar_id(tBTA_SYS_ID sys_id) +{ + UINT8 mask = 0; + if (sys_id == BTA_ID_AV) + { + mask = BTA_AR_AV_MASK; + } + else if (sys_id == BTA_ID_AVK) + { + mask = BTA_AR_AVK_MASK; + } + + return mask; +} + +/******************************************************************************* +** +** Function bta_ar_init +** +** Description This function is called to register to AVDTP. +** +** Returns void +** +*******************************************************************************/ +void bta_ar_init(void) +{ + /* initialize control block */ + memset(&bta_ar_cb, 0, sizeof(tBTA_AR_CB)); +} + +/******************************************************************************* +** +** Function bta_ar_reg_avdt +** +** Description This function is called to register to AVDTP. +** +** Returns void +** +*******************************************************************************/ +static void bta_ar_avdt_cback(UINT8 handle, BD_ADDR bd_addr, UINT8 event, tAVDT_CTRL *p_data) +{ + /* route the AVDT registration callback to av or avk */ + if (bta_ar_cb.p_av_conn_cback) + (*bta_ar_cb.p_av_conn_cback)(handle, bd_addr, event, p_data); + if (bta_ar_cb.p_avk_conn_cback) + (*bta_ar_cb.p_avk_conn_cback)(handle, bd_addr, event, p_data); +} + +/******************************************************************************* +** +** Function bta_ar_reg_avdt +** +** Description AR module registration to AVDT. +** +** Returns void +** +*******************************************************************************/ +void bta_ar_reg_avdt(tAVDT_REG *p_reg, tAVDT_CTRL_CBACK *p_cback, tBTA_SYS_ID sys_id) +{ + UINT8 mask = 0; + + if (sys_id == BTA_ID_AV) + { + bta_ar_cb.p_av_conn_cback = p_cback; + mask = BTA_AR_AV_MASK; + } + else if (sys_id == BTA_ID_AVK) + { + bta_ar_cb.p_avk_conn_cback = p_cback; + mask = BTA_AR_AVK_MASK; + } +#if (BTA_AR_DEBUG == TRUE) + else + { + APPL_TRACE_ERROR1("bta_ar_reg_avdt: the registration is from wrong sys_id:%d", sys_id); + } +#endif + + if (mask) + { + if (bta_ar_cb.avdt_registered == 0) + { + AVDT_Register(p_reg, bta_ar_avdt_cback); + } + bta_ar_cb.avdt_registered |= mask; + } +} + +/******************************************************************************* +** +** Function bta_ar_dereg_avdt +** +** Description This function is called to de-register from AVDTP. +** +** Returns void +** +*******************************************************************************/ +void bta_ar_dereg_avdt(tBTA_SYS_ID sys_id) +{ + UINT8 mask = 0; + + if (sys_id == BTA_ID_AV) + { + bta_ar_cb.p_av_conn_cback = NULL; + mask = BTA_AR_AV_MASK; + } + else if (sys_id == BTA_ID_AVK) + { + bta_ar_cb.p_avk_conn_cback = NULL; + mask = BTA_AR_AVK_MASK; + } + bta_ar_cb.avdt_registered &= ~mask; + + if (bta_ar_cb.avdt_registered == 0) + AVDT_Deregister(); +} + +/******************************************************************************* +** +** Function bta_ar_avdt_conn +** +** Description This function is called to let ar know that some AVDTP profile +** is connected for this sys_id. +** If the other sys modules started a timer for PENDING_EVT, +** the timer can be stopped now. +** +** Returns void +** +*******************************************************************************/ +void bta_ar_avdt_conn(tBTA_SYS_ID sys_id, BD_ADDR bd_addr) +{ + UINT8 event = BTA_AR_AVDT_CONN_EVT; + tAVDT_CTRL data; + + if (sys_id == BTA_ID_AV) + { + if (bta_ar_cb.p_avk_conn_cback) + { + (*bta_ar_cb.p_avk_conn_cback)(0, bd_addr, event, &data); + } + } + else if (sys_id == BTA_ID_AVK) + { + if (bta_ar_cb.p_av_conn_cback) + { + (*bta_ar_cb.p_av_conn_cback)(0, bd_addr, event, &data); + } + } +} + +/******************************************************************************* +** +** Function bta_ar_reg_avct +** +** Description This function is called to register to AVCTP. +** +** Returns void +** +*******************************************************************************/ +void bta_ar_reg_avct(UINT16 mtu, UINT16 mtu_br, UINT8 sec_mask, tBTA_SYS_ID sys_id) +{ + UINT8 mask = bta_ar_id (sys_id); + + if (mask) + { + if (bta_ar_cb.avct_registered == 0) + { + AVCT_Register(mtu, mtu_br, sec_mask); + } + bta_ar_cb.avct_registered |= mask; + } +} + +/******************************************************************************* +** +** Function bta_ar_dereg_avct +** +** Description This function is called to deregister from AVCTP. +** +** Returns void +** +*******************************************************************************/ +void bta_ar_dereg_avct(tBTA_SYS_ID sys_id) +{ + UINT8 mask = bta_ar_id (sys_id); + + bta_ar_cb.avct_registered &= ~mask; + + if (bta_ar_cb.avct_registered == 0) + AVCT_Deregister(); +} + +/****************************************************************************** +** +** Function bta_ar_reg_avrc +** +** Description This function is called to register an SDP record for AVRCP. +** +** Returns void +** +******************************************************************************/ +void bta_ar_reg_avrc(UINT16 service_uuid, char *service_name, char *provider_name, + UINT16 categories, tBTA_SYS_ID sys_id) +{ + UINT8 mask = bta_ar_id (sys_id); + UINT8 temp[8], *p; + + if (!mask || !categories) + return; + + if (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET) + { + if (bta_ar_cb.sdp_tg_handle == 0) + { + bta_ar_cb.tg_registered = mask; + bta_ar_cb.sdp_tg_handle = SDP_CreateRecord(); + AVRC_AddRecord(service_uuid, service_name, provider_name, categories, bta_ar_cb.sdp_tg_handle); +#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&(BTA_EIR_CANNED_UUID_LIST != TRUE) + bta_sys_add_uuid(service_uuid); +#endif + } + /* only one TG is allowed (first-come, first-served). + * If sdp_tg_handle is non-0, ignore this request */ + } + else if ((service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL) || (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_CONTROL)) + { + bta_ar_cb.ct_categories [mask - 1] = categories; + categories = bta_ar_cb.ct_categories[0]|bta_ar_cb.ct_categories[1]; + if (bta_ar_cb.sdp_ct_handle == 0) + { + bta_ar_cb.sdp_ct_handle = SDP_CreateRecord(); + AVRC_AddRecord(service_uuid, service_name, provider_name, categories, bta_ar_cb.sdp_ct_handle); +#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&(BTA_EIR_CANNED_UUID_LIST != TRUE) + bta_sys_add_uuid(service_uuid); +#endif + } + else + { + /* multiple CTs are allowed. + * Change supported categories on the second one */ + p = temp; + UINT16_TO_BE_STREAM(p, categories); + SDP_AddAttribute(bta_ar_cb.sdp_ct_handle, ATTR_ID_SUPPORTED_FEATURES, UINT_DESC_TYPE, + (UINT32)2, (UINT8*)temp); + } + } +} + +/****************************************************************************** +** +** Function bta_ar_dereg_avrc +** +** Description This function is called to de-register/delete an SDP record for AVRCP. +** +** Returns void +** +******************************************************************************/ +void bta_ar_dereg_avrc(UINT16 service_uuid, tBTA_SYS_ID sys_id) +{ + UINT8 mask = bta_ar_id (sys_id); + UINT16 categories = 0; + UINT8 temp[8], *p; + + if (!mask) + return; + + if (service_uuid == UUID_SERVCLASS_AV_REM_CTRL_TARGET) + { + if (bta_ar_cb.sdp_tg_handle && mask == bta_ar_cb.tg_registered) + { + bta_ar_cb.tg_registered = 0; + SDP_DeleteRecord(bta_ar_cb.sdp_tg_handle); + bta_ar_cb.sdp_tg_handle = 0; +#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&(BTA_EIR_CANNED_UUID_LIST != TRUE) + bta_sys_remove_uuid(service_uuid); +#endif + } + } + else if (service_uuid == UUID_SERVCLASS_AV_REMOTE_CONTROL) + { + if (bta_ar_cb.sdp_ct_handle) + { + bta_ar_cb.ct_categories [mask - 1] = 0; + categories = bta_ar_cb.ct_categories[0]|bta_ar_cb.ct_categories[1]; + if (!categories) + { + /* no CT is still registered - cleaup */ + SDP_DeleteRecord(bta_ar_cb.sdp_ct_handle); + bta_ar_cb.sdp_ct_handle = 0; +#if ( BTM_EIR_SERVER_INCLUDED == TRUE )&&(BTA_EIR_CANNED_UUID_LIST != TRUE) + bta_sys_remove_uuid(service_uuid); +#endif + } + else + { + /* change supported categories to the remaning one */ + p = temp; + UINT16_TO_BE_STREAM(p, categories); + SDP_AddAttribute(bta_ar_cb.sdp_ct_handle, ATTR_ID_SUPPORTED_FEATURES, UINT_DESC_TYPE, + (UINT32)2, (UINT8*)temp); + } + } + } + +} diff --git a/bta/ar/bta_ar_int.h b/bta/ar/bta_ar_int.h new file mode 100644 index 0000000..a6c5c8b --- /dev/null +++ b/bta/ar/bta_ar_int.h @@ -0,0 +1,51 @@ +/***************************************************************************** +** +** Name: bta_ar_int.h +** +** Description: This is the private interface file for the BTA +** audio/video registration module. +** +** Copyright (c) 2008-2009, Broadcom Corp., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +*****************************************************************************/ +#ifndef BTA_AR_INT_H +#define BTA_AR_INT_H + +#include "bta_av_api.h" + + +#ifndef BTA_AR_DEBUG +#define BTA_AR_DEBUG FALSE +#endif + +#define BTA_AR_AV_MASK 0x01 +#define BTA_AR_AVK_MASK 0x02 + +/* data associated with BTA_AR */ +typedef struct +{ + tAVDT_CTRL_CBACK *p_av_conn_cback; /* av connection callback function */ + tAVDT_CTRL_CBACK *p_avk_conn_cback; /* avk connection callback function */ + UINT8 avdt_registered; + UINT8 avct_registered; + UINT32 sdp_tg_handle; + UINT32 sdp_ct_handle; + UINT16 ct_categories[2]; + UINT8 tg_registered; + tBTA_AV_HNDL hndl; /* Handle associated with the stream that rejected the connection. */ +} tBTA_AR_CB; + +/***************************************************************************** +** Global data +*****************************************************************************/ + +/* control block declaration */ +#if BTA_DYNAMIC_MEMORY == FALSE +extern tBTA_AR_CB bta_ar_cb; +#else +extern tBTA_AR_CB *bta_ar_cb_ptr; +#define bta_ar_cb (*bta_ar_cb_ptr) +#endif + +#endif /* BTA_AR_INT_H */ diff --git a/bta/av/bta_av_aact.c b/bta/av/bta_av_aact.c index aa154b3..423c322 100644 --- a/bta/av/bta_av_aact.c +++ b/bta/av/bta_av_aact.c @@ -12,7 +12,7 @@ *****************************************************************************/ #include "bt_target.h" -#if defined(AV_INCLUDED) && (AV_INCLUDED == TRUE) +#if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE) #include <string.h> #include "bta_av_int.h" @@ -2685,4 +2685,4 @@ void bta_av_open_at_inc (tBTA_AV_SCB *p_scb, tBTA_AV_DATA *p_data) } } -#endif /* AV_INCLUDED */ +#endif /* BTA_AV_INCLUDED */ diff --git a/bta/av/bta_av_act.c b/bta/av/bta_av_act.c index 472ed21..e501e52 100644 --- a/bta/av/bta_av_act.c +++ b/bta/av/bta_av_act.c @@ -11,7 +11,7 @@ *****************************************************************************/ #include "bt_target.h" -#if defined(AV_INCLUDED) && (AV_INCLUDED == TRUE) +#if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE) #include <string.h> #include "bta_av_api.h" @@ -767,6 +767,7 @@ tBTA_AV_EVT bta_av_proc_meta_cmd(tAVRC_RESPONSE *p_rc_rsp, tBTA_AV_RC_MSG *p_ms p_vendor->hdr.ctype = BTA_AV_RSP_NOT_IMPL; AVRC_VendorRsp(p_msg->handle, p_msg->label, &p_msg->msg.vendor); } +#if (AVRC_METADATA_INCLUDED == TRUE) else if (!AVRC_IsValidAvcType(pdu, p_vendor->hdr.ctype) ) { APPL_TRACE_DEBUG2("Invalid pdu/ctype: 0x%x, %d", pdu, p_vendor->hdr.ctype); @@ -774,6 +775,7 @@ tBTA_AV_EVT bta_av_proc_meta_cmd(tAVRC_RESPONSE *p_rc_rsp, tBTA_AV_RC_MSG *p_ms evt = 0; p_rc_rsp->rsp.status = AVRC_STS_BAD_CMD; } +#endif else { switch (pdu) @@ -1997,4 +1999,4 @@ void bta_av_dereg_comp(tBTA_AV_DATA *p_data) utl_set_device_class(&cod, BTA_UTL_CLR_COD_SERVICE_CLASS); } } -#endif /* AV_INCLUDED */ +#endif /* BTA_AV_INCLUDED */ diff --git a/bta/av/bta_av_api.c b/bta/av/bta_av_api.c index 3bb59f7..762692f 100644 --- a/bta/av/bta_av_api.c +++ b/bta/av/bta_av_api.c @@ -12,7 +12,7 @@ *****************************************************************************/ #include "bt_target.h" -#if defined(AV_INCLUDED) && (AV_INCLUDED == TRUE) +#if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE) #include "bta_api.h" #include "bd.h" @@ -565,4 +565,4 @@ void BTA_AvMetaCmd(UINT8 rc_handle, UINT8 label, tBTA_AV_CMD cmd_code, BT_HDR *p } } -#endif /* AV_INCLUDED */ +#endif /* BTA_AV_INCLUDED */ diff --git a/bta/av/bta_av_cfg.c b/bta/av/bta_av_cfg.c index bb01366..1c6d335 100644 --- a/bta/av/bta_av_cfg.c +++ b/bta/av/bta_av_cfg.c @@ -15,24 +15,12 @@ #include "bta_api.h" #include "bta_av_int.h" -#ifndef BTA_AV_VDP_INCLUDED -#define BTA_AV_VDP_INCLUDED TRUE -#endif -#if ((VDP_INCLUDED == FALSE) && (BTA_AV_VDP_INCLUDED == TRUE)) -#undef BTA_AV_VDP_INCLUDED -#define BTA_AV_VDP_INCLUDED FALSE -#endif #ifndef BTA_AV_RC_PASS_RSP_CODE #define BTA_AV_RC_PASS_RSP_CODE BTA_AV_RSP_NOT_IMPL #endif -#if (BTA_AV_VDP_INCLUDED == TRUE) -#define BTA_AV_NUM_A2DP_STRS (BTA_AV_NUM_STRS - 1) -#else -#define BTA_AV_NUM_A2DP_STRS (BTA_AV_NUM_STRS) -#endif const UINT32 bta_av_meta_caps_co_ids[] = { AVRC_CO_METADATA, @@ -175,13 +163,6 @@ const tBTA_AV_CFG bta_av_cfg = BTA_AV_RC_PASS_RSP_CODE,/* the default response code for pass through commands */ bta_av_meta_caps_co_ids,/* the metadata Get Capabilities response for company id */ bta_av_meta_caps_evt_ids,/* the the metadata Get Capabilities response for event id */ -#if BTA_AV_VDP_INCLUDED == TRUE - (const tBTA_AV_ACT *)bta_av_vdp_action,/* the action table for VDP */ - bta_av_reg_vdp /* action function to register VDP */ -#else - (const tBTA_AV_ACT *)NULL,/* the action table for VDP */ - NULL /* action function to register VDP */ -#endif }; tBTA_AV_CFG *p_bta_av_cfg = (tBTA_AV_CFG *) &bta_av_cfg; diff --git a/bta/av/bta_av_main.c b/bta/av/bta_av_main.c index 65c2cfe..ebf11b4 100644 --- a/bta/av/bta_av_main.c +++ b/bta/av/bta_av_main.c @@ -11,7 +11,7 @@ *****************************************************************************/ #include "bt_target.h" -#if defined(AV_INCLUDED) && (AV_INCLUDED == TRUE) +#if defined(BTA_AV_INCLUDED) && (BTA_AV_INCLUDED == TRUE) #include <string.h> #include "bta_av_int.h" @@ -602,7 +602,6 @@ static void bta_av_api_register(tBTA_AV_DATA *p_data) bta_av_rc_create(&bta_av_cb, AVCT_ACP, 0, BTA_AV_NUM_LINKS + 1); /* if the AV and AVK are both supported, it cannot support the CT role */ -#if (BTA_AVK_INCLUDED == FALSE) if (bta_av_cb.features & (BTA_AV_FEAT_RCCT)) { /* if TG is not supported, we need to register to AVCT now */ @@ -624,7 +623,6 @@ static void bta_av_api_register(tBTA_AV_DATA *p_data) p_bta_av_cfg->avrc_ct_cat, BTA_ID_AV); #endif } -#endif } bta_av_cb.reg_audio |= BTA_AV_HNDL_TO_MSK(p_scb->hdi); APPL_TRACE_DEBUG1("reg_audio: 0x%x",bta_av_cb.reg_audio); @@ -705,14 +703,9 @@ static void bta_av_ci_data(tBTA_AV_DATA *p_data) ** *******************************************************************************/ #if (AVDT_REPORTING == TRUE) + static void bta_av_rpc_conn(tBTA_AV_DATA *p_data) { - tBTA_AV_SCB *p_scb = bta_av_hndl_to_scb(p_data->hdr.layer_specific); - if(p_scb) - { - bta_av_co_video_report_conn(p_data->str_msg.msg.report_conn.err_param, - p_scb->avdt_handle); - } } #endif @@ -1315,4 +1308,4 @@ char *bta_av_evt_code(UINT16 evt_code) } #endif -#endif /* AV_INCLUDED */ +#endif /* BTA_AV_INCLUDED */ diff --git a/bta/av/bta_av_sbc.c b/bta/av/bta_av_sbc.c new file mode 100644 index 0000000..ba11752 --- /dev/null +++ b/bta/av/bta_av_sbc.c @@ -0,0 +1,577 @@ +/***************************************************************************** +** +** Name: bta_av_sbc.c +** +** Description: This module contains utility functions for dealing with +** SBC data frames and codec capabilities. +** +** Copyright (c) 2004, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +*****************************************************************************/ + +#include "a2d_api.h" +#include "a2d_sbc.h" +#include "bta_av_sbc.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; + + /* 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_ERROR1("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_ERROR1("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_ERROR1("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_ERROR1("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_ERROR1("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_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); +} + diff --git a/bta/dm/bta_dm_act.c b/bta/dm/bta_dm_act.c index 30a77e3..3b3f93b 100755 --- a/bta/dm/bta_dm_act.c +++ b/bta/dm/bta_dm_act.c @@ -95,8 +95,8 @@ const UINT16 bta_service_id_to_uuid_lkup_tbl [BTA_MAX_SERVICE_ID] = UUID_SERVCLASS_DIALUP_NETWORKING, /* BTA_DUN_SERVICE_ID */ UUID_SERVCLASS_FAX, /* BTA_FAX_SERVICE_ID */ UUID_SERVCLASS_LAN_ACCESS_USING_PPP, /* BTA_LAP_SERVICE_ID */ - UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY, /* BTA_HSP_SERVICE_ID */ - UUID_SERVCLASS_AG_HANDSFREE, /* BTA_HFP_SERVICE_ID */ + UUID_SERVCLASS_HEADSET, /* BTA_HSP_HS_SERVICE_ID */ + UUID_SERVCLASS_HF_HANDSFREE, /* BTA_HFP_HS_SERVICE_ID */ UUID_SERVCLASS_OBEX_OBJECT_PUSH, /* BTA_OPP_SERVICE_ID */ UUID_SERVCLASS_OBEX_FILE_TRANSFER, /* BTA_FTP_SERVICE_ID */ UUID_SERVCLASS_CORDLESS_TELEPHONY, /* BTA_CTP_SERVICE_ID */ @@ -113,8 +113,8 @@ const UINT16 bta_service_id_to_uuid_lkup_tbl [BTA_MAX_SERVICE_ID] = UUID_SERVCLASS_HUMAN_INTERFACE, /* BTA_HID_SERVICE_ID */ UUID_SERVCLASS_VIDEO_SINK, /* BTA_VDP_SERVICE_ID */ UUID_SERVCLASS_PBAP_PSE, /* BTA_PBAP_SERVICE_ID */ - UUID_SERVCLASS_HEADSET, /* BTA_HSP_HS_SERVICE_ID */ - UUID_SERVCLASS_HF_HANDSFREE, /* BTA_HFP_HS_SERVICE_ID */ + UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY, /* BTA_HSP_SERVICE_ID */ + UUID_SERVCLASS_AG_HANDSFREE, /* BTA_HFP_SERVICE_ID */ UUID_SERVCLASS_MESSAGE_ACCESS, /* BTA_MAP_SERVICE_ID */ UUID_SERVCLASS_MESSAGE_NOTIFICATION, /* BTA_MN_SERVICE_ID */ UUID_SERVCLASS_HDP_PROFILE, /* BTA_HDP_SERVICE_ID */ diff --git a/bta/dm/bta_dm_api.c b/bta/dm/bta_dm_api.c index d798f5c..4c77f37 100755 --- a/bta/dm/bta_dm_api.c +++ b/bta/dm/bta_dm_api.c @@ -1191,7 +1191,7 @@ void BTA_SysFeatures (UINT16 sys_features) ** ** Description This function will request BTA to execute a call back in the context of BTU task ** This API was named in lower case because it is only intended -** for the internal customers(like BSA). +** for the internal customers(like BTIF). ** ** Returns void ** diff --git a/bta/include/bta_api.h b/bta/include/bta_api.h index e8f5892..57baa4d 100755 --- a/bta/include/bta_api.h +++ b/bta/include/bta_api.h @@ -1456,7 +1456,7 @@ BTA_API extern void BTA_SysFeatures (UINT16 sys_features); ** ** Description This function will request BTA to execute a call back in the context of BTU task ** This API was named in lower case because it is only intended -** for the internal customers(like BSA). +** for the internal customers(like BTIF). ** ** Returns void ** diff --git a/bta/include/bta_ar_api.h b/bta/include/bta_ar_api.h new file mode 100644 index 0000000..bf66dca --- /dev/null +++ b/bta/include/bta_ar_api.h @@ -0,0 +1,127 @@ +/***************************************************************************** +** +** Name: bta_ar_api.h +** +** Description: This is the public interface file for the simulatenous +** advanced audio/video streaming (AV) source and sink of BTA, +** Widcomm's Bluetooth application layer for mobile phones. +** +** Copyright (c) 2004-2008, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +*****************************************************************************/ +#ifndef BTA_AR_API_H +#define BTA_AR_API_H + +#include "avdt_api.h" +#include "avct_api.h" +#include "avrc_api.h" +#include "sdp_api.h" +#include "bta_av_api.h" +#include "bta_sys.h" + +/***************************************************************************** +** Constants and data types +*****************************************************************************/ +/* This event signal to AR user that other profile is connected */ +#define BTA_AR_AVDT_CONN_EVT (AVDT_MAX_EVT + 1) + +/******************************************************************************* +** +** Function bta_ar_init +** +** Description This function is called from bta_sys_init(). +** to initialize the control block +** +** Returns void +** +*******************************************************************************/ +extern void bta_ar_init(void); + +/******************************************************************************* +** +** Function bta_ar_reg_avdt +** +** Description This function is called to register to AVDTP. +** +** Returns void +** +*******************************************************************************/ +extern void bta_ar_reg_avdt(tAVDT_REG *p_reg, tAVDT_CTRL_CBACK *p_cback, tBTA_SYS_ID sys_id); + +/******************************************************************************* +** +** Function bta_ar_dereg_avdt +** +** Description This function is called to de-register from AVDTP. +** +** Returns void +** +*******************************************************************************/ +extern void bta_ar_dereg_avdt(tBTA_SYS_ID sys_id); + +/******************************************************************************* +** +** Function bta_ar_avdt_conn +** +** Description This function is called to let ar know that some AVDTP profile +** is connected for this sys_id. +** If the other sys modules started a timer for PENDING_EVT, +** the timer can be stopped now. +** +** Returns void +** +*******************************************************************************/ +extern void bta_ar_avdt_conn(tBTA_SYS_ID sys_id, BD_ADDR bd_addr); + +/******************************************************************************* +** +** Function bta_ar_reg_avct +** +** Description This function is called to register to AVCTP. +** +** Returns void +** +*******************************************************************************/ +extern void bta_ar_reg_avct(UINT16 mtu, UINT16 mtu_br, UINT8 sec_mask, tBTA_SYS_ID sys_id); + +/******************************************************************************* +** +** Function bta_ar_dereg_avct +** +** Description This function is called to deregister from AVCTP. +** +** Returns void +** +*******************************************************************************/ +extern void bta_ar_dereg_avct(tBTA_SYS_ID sys_id); + +/****************************************************************************** +** +** Function bta_ar_reg_avrc +** +** Description This function is called to register an SDP record for AVRCP. +** +** Returns void +** +******************************************************************************/ +extern void bta_ar_reg_avrc(UINT16 service_uuid, char *p_service_name, + char *p_provider_name, UINT16 categories, tBTA_SYS_ID sys_id); + +/****************************************************************************** +** +** Function bta_ar_dereg_avrc +** +** Description This function is called to de-register/delete an SDP record for AVRCP. +** +** Returns void +** +******************************************************************************/ +extern void bta_ar_dereg_avrc(UINT16 service_uuid, tBTA_SYS_ID sys_id); + + +#ifdef __cplusplus +} +#endif + +#endif /* BTA_AR_API_H */ diff --git a/bta/include/bta_av_api.h b/bta/include/bta_av_api.h index f639d22..02bc30c 100644 --- a/bta/include/bta_av_api.h +++ b/bta/include/bta_av_api.h @@ -17,9 +17,6 @@ #include "avdt_api.h" #include "a2d_api.h" #include "bta_api.h" -#if( defined VDP_INCLUDED) && (VDP_INCLUDED == TRUE) -#include "vdp_api.h" -#endif /***************************************************************************** ** Constants and data types @@ -238,6 +235,8 @@ typedef UINT8 tBTA_AV_ERR; #define BTA_AV_META_MSG_EVT 17 /* metadata messages */ #define BTA_AV_REJECT_EVT 18 /* incoming connection rejected */ #define BTA_AV_RC_FEAT_EVT 19 /* remote control channel peer supported features update */ +/* Max BTA event */ +#define BTA_AV_MAX_EVT 20 typedef UINT8 tBTA_AV_EVT; diff --git a/bta/include/bta_av_co.h b/bta/include/bta_av_co.h index 2f41180..f2fa83b 100644 --- a/bta/include/bta_av_co.h +++ b/bta/include/bta_av_co.h @@ -47,12 +47,6 @@ enum BTA_AV_CO_ST_STREAM }; -/* data type for the Video Codec Information Element*/ -typedef struct -{ - UINT8 codec_type; /* Codec type */ - UINT8 levels; /* level mask */ -} tBTA_AV_VIDEO_CFG; /* data type for the Audio Codec Information*/ typedef struct @@ -83,22 +77,6 @@ BTA_API extern BOOLEAN bta_av_co_audio_init(UINT8 *p_codec_type, UINT8 *p_codec_ /******************************************************************************* ** -** Function bta_av_co_video_init -** -** Description This callout function is executed by AV when it is -** started by calling BTA_AvEnable(). This function can be -** used by the phone to initialize video paths or for other -** initialization purposes. -** -** -** Returns Stream codec and content protection capabilities info. -** -*******************************************************************************/ -BTA_API extern BOOLEAN bta_av_co_video_init(UINT8 *p_codec_type, UINT8 *p_codec_info, - UINT8 *p_num_protect, UINT8 *p_protect_info, UINT8 index); - -/******************************************************************************* -** ** Function bta_av_co_audio_disc_res ** ** Description This callout function is executed by AV to report the @@ -263,7 +241,8 @@ BTA_API extern void bta_av_co_video_close(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec ** Returns void ** *******************************************************************************/ -BTA_API extern void bta_av_co_audio_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type); +BTA_API extern void bta_av_co_audio_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, + UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr); /******************************************************************************* ** @@ -276,7 +255,8 @@ BTA_API extern void bta_av_co_audio_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec ** Returns void ** *******************************************************************************/ -BTA_API extern void bta_av_co_video_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type); +BTA_API extern void bta_av_co_video_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, + UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr); /******************************************************************************* ** diff --git a/bta/include/bta_av_sbc.h b/bta/include/bta_av_sbc.h new file mode 100644 index 0000000..157ba08 --- /dev/null +++ b/bta/include/bta_av_sbc.h @@ -0,0 +1,194 @@ +/***************************************************************************** +** +** Name: bta_av_sbc.h +** +** Description: This is the interface to utility functions for dealing +** with SBC data frames and codec capabilities. +** +** Copyright (c) 2004, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +*****************************************************************************/ +#ifndef BTA_AV_SBC_H +#define BTA_AV_SBC_H + +/***************************************************************************** +** constants +*****************************************************************************/ + +/* SBC packet header size */ +#define BTA_AV_SBC_HDR_SIZE A2D_SBC_MPL_HDR_LEN + +/******************************************************************************* +** +** 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 +** +*******************************************************************************/ +extern void bta_av_sbc_init_up_sample (UINT32 src_sps, UINT32 dst_sps, + UINT16 bits, UINT16 n_channels); + +/******************************************************************************* +** +** 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) +** +*******************************************************************************/ +extern int bta_av_sbc_up_sample (void *p_src, void *p_dst, + UINT32 src_samples, UINT32 dst_samples, + UINT32 *p_ret); + +/******************************************************************************* +** +** 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) +** +*******************************************************************************/ +extern int bta_av_sbc_up_sample_16s (void *p_src, void *p_dst, + UINT32 src_samples, UINT32 dst_samples, + UINT32 *p_ret); + +/******************************************************************************* +** +** 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) +** +*******************************************************************************/ +extern int bta_av_sbc_up_sample_16m (void *p_src, void *p_dst, + UINT32 src_samples, UINT32 dst_samples, + UINT32 *p_ret); + +/******************************************************************************* +** +** 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) +** +*******************************************************************************/ +extern int bta_av_sbc_up_sample_8s (void *p_src, void *p_dst, + UINT32 src_samples, UINT32 dst_samples, + UINT32 *p_ret); + +/******************************************************************************* +** +** 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) +** +*******************************************************************************/ +extern int bta_av_sbc_up_sample_8m (void *p_src, void *p_dst, + UINT32 src_samples, UINT32 dst_samples, + UINT32 *p_ret); + +/******************************************************************************* +** +** 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. +** +*******************************************************************************/ +extern UINT8 bta_av_sbc_cfg_for_cap(UINT8 *p_peer, tA2D_SBC_CIE *p_cap, tA2D_SBC_CIE *p_pref); + +/******************************************************************************* +** +** 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. +** +*******************************************************************************/ +extern UINT8 bta_av_sbc_cfg_in_cap(UINT8 *p_cfg, tA2D_SBC_CIE *p_cap); + +/******************************************************************************* +** +** Function bta_av_sbc_bld_hdr +** +** Description This function builds the packet header for MPF1. +** +** Returns void +** +*******************************************************************************/ +extern void bta_av_sbc_bld_hdr(BT_HDR *p_buf, UINT16 fr_per_pkt); + +#endif /* BTA_AV_SBC_H */ + diff --git a/btif/co/bta_av_co.c b/btif/co/bta_av_co.c new file mode 100644 index 0000000..34a9a00 --- /dev/null +++ b/btif/co/bta_av_co.c @@ -0,0 +1,1422 @@ +/***************************************************************************** + ** + ** Name: bta_av_co.c + ** + ** Description: This is the advanced audio/video call-out function + ** implementation for BTIF. + ** + ** Copyright (c) 2004-2012, Broadcom Corp., All Rights Reserved. + ** Broadcom Bluetooth Core. Proprietary and confidential + ** + *****************************************************************************/ + +#include "string.h" +#include "a2d_api.h" +#include "a2d_sbc.h" +#include "bta_sys.h" +#include "bta_av_api.h" +#include "bta_av_co.h" +#include "bta_av_ci.h" +#include "bta_av_sbc.h" + +#include "btif_media.h" +#include "sbc_encoder.h" +#include "btif_av.h" + + +/***************************************************************************** + ** Constants + *****************************************************************************/ + +#define FUNC_TRACE() APPL_TRACE_DEBUG1("%s", __FUNCTION__); + +/* Macro to retrieve the number of elements in a statically allocated array */ +#define BTA_AV_CO_NUM_ELEMENTS(__a) (sizeof(__a)/sizeof((__a)[0])) + +/* MIN and MAX macros */ +#define BTA_AV_CO_MIN(X,Y) ((X) < (Y) ? (X) : (Y)) +#define BTA_AV_CO_MAX(X,Y) ((X) > (Y) ? (X) : (Y)) + +/* Macro to convert audio handle to index and vice versa */ +#define BTA_AV_CO_AUDIO_HNDL_TO_INDX(hndl) (((hndl) & (~BTA_AV_CHNL_MSK)) - 1) +#define BTA_AV_CO_AUDIO_INDX_TO_HNDL(indx) (((indx) + 1) | BTA_AV_CHNL_AUDIO) + + +/* Offsets to access codec information in SBC codec */ +#define BTA_AV_CO_SBC_FREQ_CHAN_OFF 3 +#define BTA_AV_CO_SBC_BLOCK_BAND_OFF 4 +#define BTA_AV_CO_SBC_MIN_BITPOOL_OFF 5 +#define BTA_AV_CO_SBC_MAX_BITPOOL_OFF 6 + + +#define BTA_AV_CO_SBC_MAX_BITPOOL 0x59 + + +/* SCMS-T protect info */ +const UINT8 bta_av_co_cp_scmst[BTA_AV_CP_INFO_LEN] = "\x02\x02\x00"; + +/* SBC codec capabilities */ +const tA2D_SBC_CIE bta_av_co_sbc_caps = +{ + (A2D_SBC_IE_SAMP_FREQ_44 | A2D_SBC_IE_SAMP_FREQ_48), /* samp_freq */ + (A2D_SBC_IE_CH_MD_MONO | A2D_SBC_IE_CH_MD_STEREO | A2D_SBC_IE_CH_MD_JOINT | A2D_SBC_IE_CH_MD_DUAL), /* ch_mode */ + (A2D_SBC_IE_BLOCKS_16 | A2D_SBC_IE_BLOCKS_12 | A2D_SBC_IE_BLOCKS_8 | A2D_SBC_IE_BLOCKS_4), /* block_len */ + (A2D_SBC_IE_SUBBAND_4 | A2D_SBC_IE_SUBBAND_8), /* num_subbands */ + (A2D_SBC_IE_ALLOC_MD_L | A2D_SBC_IE_ALLOC_MD_S), /* alloc_mthd */ + BTA_AV_CO_SBC_MAX_BITPOOL, /* max_bitpool */ + A2D_SBC_IE_MIN_BITPOOL /* min_bitpool */ +}; + +#if !defined(BTIF_AV_SBC_DEFAULT_SAMP_FREQ) +#define BTIF_AV_SBC_DEFAULT_SAMP_FREQ A2D_SBC_IE_SAMP_FREQ_44 +#endif + +/* Default SBC codec configuration */ +const tA2D_SBC_CIE btif_av_sbc_default_config = +{ + BTIF_AV_SBC_DEFAULT_SAMP_FREQ, /* samp_freq */ + A2D_SBC_IE_CH_MD_STEREO, /* ch_mode */ + A2D_SBC_IE_BLOCKS_16, /* block_len */ + A2D_SBC_IE_SUBBAND_8, /* num_subbands */ + A2D_SBC_IE_ALLOC_MD_L, /* alloc_mthd */ + BTA_AV_CO_SBC_MAX_BITPOOL, /* max_bitpool */ + A2D_SBC_IE_MIN_BITPOOL /* min_bitpool */ +}; + + +/***************************************************************************** +** Local data +*****************************************************************************/ +typedef struct +{ + UINT8 sep_info_idx; /* local SEP index (in BTA tables) */ + UINT8 seid; /* peer SEP index (in peer tables) */ + UINT8 codec_type; /* peer SEP codec type */ + UINT8 codec_caps[AVDT_CODEC_SIZE]; /* peer SEP codec capabilities */ + UINT8 num_protect; /* peer SEP number of CP elements */ + UINT8 protect_info[BTA_AV_CP_INFO_LEN]; /* peer SEP content protection info */ +} tBTA_AV_CO_SINK; + +typedef struct +{ + BD_ADDR addr; /* address of audio/video peer */ + tBTA_AV_CO_SINK snks[BTIF_SV_AV_AA_SEP_INDEX]; /* array of supported sinks */ + UINT8 num_snks; /* total number of sinks at peer */ + UINT8 num_rx_snks; /* number of received sinks */ + UINT8 num_sup_snks; /* number of supported sinks in the snks array */ + tBTA_AV_CO_SINK *p_snk; /* currently selected sink */ + UINT8 codec_cfg[AVDT_CODEC_SIZE]; /* current codec configuration */ + BOOLEAN cp_active; /* current CP configuration */ + BOOLEAN acp; /* acceptor */ + BOOLEAN recfg_needed; /* reconfiguration is needed */ + BOOLEAN opened; /* opened */ + UINT16 mtu; /* maximum transmit unit size */ +} tBTA_AV_CO_PEER; + +typedef struct +{ + BOOLEAN active; + UINT8 flag; +} tBTA_AV_CO_CP; + +typedef struct +{ + /* Connected peer information */ + tBTA_AV_CO_PEER peers[BTA_AV_NUM_STRS]; + /* Current codec configuration - access to this variable must be protected */ + tBTIF_AV_CODEC_INFO codec_cfg; + tBTA_AV_CO_CP cp; +} tBTA_AV_CO_CB; + +/* Control block instance */ +static tBTA_AV_CO_CB bta_av_co_cb; + +static BOOLEAN bta_av_co_audio_codec_build_config(const UINT8 *p_codec_caps, UINT8 *p_codec_cfg); +static void bta_av_co_audio_peer_reset_config(tBTA_AV_CO_PEER *p_peer); +static BOOLEAN bta_av_co_cp_is_scmst(const UINT8 *p_protectinfo); +static BOOLEAN bta_av_co_audio_sink_has_scmst(const tBTA_AV_CO_SINK *p_sink); +static BOOLEAN bta_av_co_audio_peer_supports_codec(tBTA_AV_CO_PEER *p_peer, UINT8 *p_snk_index); +static BOOLEAN bta_av_co_audio_media_supports_config(UINT8 codec_type, const UINT8 *p_codec_cfg); + + + + +/******************************************************************************* + ** + ** Function bta_av_co_cp_is_active + ** + ** Description Get the current configuration of content protection + ** + ** Returns TRUE if the current streaming has CP, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_cp_is_active(void) +{ + FUNC_TRACE(); + return bta_av_co_cb.cp.active; +} + +/******************************************************************************* + ** + ** Function bta_av_co_cp_get_flag + ** + ** Description Get content protection flag + ** BTA_AV_CP_SCMS_COPY_NEVER + ** BTA_AV_CP_SCMS_COPY_ONCE + ** BTA_AV_CP_SCMS_COPY_FREE + ** + ** Returns The current flag value + ** + *******************************************************************************/ +UINT8 bta_av_co_cp_get_flag(void) +{ + FUNC_TRACE(); + return bta_av_co_cb.cp.flag; +} + +/******************************************************************************* + ** + ** Function bta_av_co_cp_set_flag + ** + ** Description Set content protection flag + ** BTA_AV_CP_SCMS_COPY_NEVER + ** BTA_AV_CP_SCMS_COPY_ONCE + ** BTA_AV_CP_SCMS_COPY_FREE + ** + ** Returns TRUE if setting the SCMS flag is supported else FALSE + ** + *******************************************************************************/ +BOOLEAN bta_av_co_cp_set_flag(UINT8 cp_flag) +{ + FUNC_TRACE(); + +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) +#else + if (cp_flag != BTA_AV_CP_SCMS_COPY_FREE) + { + return FALSE; + } +#endif + bta_av_co_cb.cp.flag = cp_flag; + return TRUE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_get_peer + ** + ** Description find the peer entry for a given handle + ** + ** Returns the control block + ** + *******************************************************************************/ +static tBTA_AV_CO_PEER *bta_av_co_get_peer(tBTA_AV_HNDL hndl) +{ + UINT8 index; + FUNC_TRACE(); + + index = BTA_AV_CO_AUDIO_HNDL_TO_INDX(hndl); + + /* Sanity check */ + if (index >= BTA_AV_CO_NUM_ELEMENTS(bta_av_co_cb.peers)) + { + APPL_TRACE_ERROR1("bta_av_co_get_peer peer index out of bounds:%d", index); + return NULL; + } + + return &bta_av_co_cb.peers[index]; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_init + ** + ** Description This callout function is executed by AV when it is + ** started by calling BTA_AvRegister(). This function can be + ** used by the phone to initialize audio paths or for other + ** initialization purposes. + ** + ** + ** Returns Stream codec and content protection capabilities info. + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_init(UINT8 *p_codec_type, UINT8 *p_codec_info, UINT8 *p_num_protect, + UINT8 *p_protect_info, UINT8 index) +{ + FUNC_TRACE(); + + APPL_TRACE_DEBUG1("bta_av_co_audio_init: %d", index); + +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + { + UINT8 *p = p_protect_info; + + /* Content protection info - support SCMS-T */ + *p_num_protect = 1; + *p++ = BTA_AV_CP_LOSC; + UINT16_TO_STREAM(p, BTA_AV_CP_SCMS_T_ID); + + } +#else + /* By default - no content protection info */ + *p_num_protect = 0; + *p_protect_info = 0; +#endif + + switch (index) + { + case BTIF_SV_AV_AA_SBC_INDEX: + /* Set up for SBC codec */ + *p_codec_type = BTA_AV_CODEC_SBC; + + /* This should not fail because we are using constants for parameters */ + A2D_BldSbcInfo(AVDT_MEDIA_AUDIO, (tA2D_SBC_CIE *) &bta_av_co_sbc_caps, p_codec_info); + + /* Codec is valid */ + return TRUE; + + + default: + /* Not valid */ + return FALSE; + } +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_disc_res + ** + ** Description This callout function is executed by AV to report the + ** number of stream end points (SEP) were found during the + ** AVDT stream discovery process. + ** + ** + ** Returns void. + ** + *******************************************************************************/ +BTA_API void bta_av_co_audio_disc_res(tBTA_AV_HNDL hndl, UINT8 num_seps, UINT8 num_snk, + BD_ADDR addr) +{ + tBTA_AV_CO_PEER *p_peer; + + FUNC_TRACE(); + + APPL_TRACE_DEBUG3("bta_av_co_audio_disc_res h:x%x num_seps:%d num_snk:%d", + hndl, num_seps, num_snk); + + /* Find the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer == NULL) + { + APPL_TRACE_ERROR0("bta_av_co_audio_disc_res could not find peer entry"); + return; + } + + /* Sanity check : this should never happen */ + if (p_peer->opened) + { + APPL_TRACE_ERROR0("bta_av_co_audio_disc_res peer already opened"); + } + + /* Copy the discovery results */ + bdcpy(p_peer->addr, addr); + p_peer->num_snks = num_snk; + p_peer->num_rx_snks = 0; + p_peer->num_sup_snks = 0; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_getconfig + ** + ** Description This callout function is executed by AV to retrieve the + ** desired codec and content protection configuration for the + ** audio stream. + ** + ** + ** Returns Stream codec and content protection configuration info. + ** + *******************************************************************************/ +BTA_API UINT8 bta_av_co_audio_getconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, + UINT8 *p_codec_info, UINT8 *p_sep_info_idx, UINT8 seid, UINT8 *p_num_protect, + UINT8 *p_protect_info) + +{ + UINT8 result = A2D_FAIL; + BOOLEAN supported; + tBTA_AV_CO_PEER *p_peer; + tBTA_AV_CO_SINK *p_sink; + UINT8 codec_cfg[AVDT_CODEC_SIZE]; + UINT8 index; + + FUNC_TRACE(); + + APPL_TRACE_DEBUG3("bta_av_co_audio_getconfig handle:0x%x codec_type:%d seid:%d", hndl, codec_type, seid); + APPL_TRACE_DEBUG4("num_protect:0x%02x protect_info:0x%02x%02x%02x", + *p_num_protect, p_protect_info[0], p_protect_info[1], p_protect_info[2]); + + /* Retrieve the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer == NULL) + { + APPL_TRACE_ERROR0("bta_av_co_audio_getconfig could not find peer entry"); + return A2D_FAIL; + } + + APPL_TRACE_DEBUG4("bta_av_co_audio_getconfig peer(o=%d,n_snks=%d,n_rx_snks=%d,n_sup_snks=%d)", + p_peer->opened, p_peer->num_snks, p_peer->num_rx_snks, p_peer->num_sup_snks); + + /* Sanity check: should not be opened at this point */ + if (p_peer->opened) + { + APPL_TRACE_ERROR0("bta_av_co_audio_getconfig peer already in use"); + } + + /* Increment the number of received sinks capabilities */ + p_peer->num_rx_snks++; + + /* Check if this is a supported configuration */ + supported = FALSE; + switch (codec_type) + { + case BTA_AV_CODEC_SBC: + supported = TRUE; + break; + + + default: + break; + } + + if (supported) + { + /* If there is room for a new one */ + if (p_peer->num_sup_snks < BTA_AV_CO_NUM_ELEMENTS(p_peer->snks)) + { + p_sink = &p_peer->snks[p_peer->num_sup_snks++]; + + APPL_TRACE_DEBUG6("bta_av_co_audio_getconfig saved caps[%x:%x:%x:%x:%x:%x]", + p_codec_info[1], p_codec_info[2], p_codec_info[3], + p_codec_info[4], p_codec_info[5], p_codec_info[6]); + + memcpy(p_sink->codec_caps, p_codec_info, AVDT_CODEC_SIZE); + p_sink->codec_type = codec_type; + p_sink->sep_info_idx = *p_sep_info_idx; + p_sink->seid = seid; + p_sink->num_protect = *p_num_protect; + memcpy(p_sink->protect_info, p_protect_info, BTA_AV_CP_INFO_LEN); + } + else + { + APPL_TRACE_ERROR0("bta_av_co_audio_getconfig no more room for SNK info"); + } + } + + /* If last SNK get capabilities or all supported codec capa retrieved */ + if ((p_peer->num_rx_snks == p_peer->num_snks) || + (p_peer->num_sup_snks == BTA_AV_CO_NUM_ELEMENTS(p_peer->snks))) + { + APPL_TRACE_DEBUG0("bta_av_co_audio_getconfig last sink reached"); + + /* Protect access to bta_av_co_cb.codec_cfg */ + GKI_disable(); + + /* Find a sink that matches the codec config */ + if (bta_av_co_audio_peer_supports_codec(p_peer, &index)) + { + p_sink = &p_peer->snks[index]; + + /* Build the codec configuration for this sink */ + if (bta_av_co_audio_codec_build_config(p_sink->codec_caps, codec_cfg)) + { + APPL_TRACE_DEBUG6("bta_av_co_audio_getconfig reconfig p_codec_info[%x:%x:%x:%x:%x:%x]", + codec_cfg[1], codec_cfg[2], codec_cfg[3], + codec_cfg[4], codec_cfg[5], codec_cfg[6]); + + /* Save the new configuration */ + p_peer->p_snk = p_sink; + memcpy(p_peer->codec_cfg, codec_cfg, AVDT_CODEC_SIZE); + + /* By default, no content protection */ + *p_num_protect = 0; + +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + /* Check if this sink supports SCMS */ + if (bta_av_co_audio_sink_has_scmst(p_sink)) + { + p_peer->cp_active = TRUE; + bta_av_co_cb.cp.active = TRUE; + *p_num_protect = BTA_AV_CP_INFO_LEN; + memcpy(p_protect_info, bta_av_co_cp_scmst, BTA_AV_CP_INFO_LEN); + } + else + { + p_peer->cp_active = FALSE; + bta_av_co_cb.cp.active = FALSE; + } +#endif + + /* If acceptor -> reconfig otherwise reply for configuration */ + if (p_peer->acp) + { + if (p_peer->recfg_needed) + { + APPL_TRACE_DEBUG1("bta_av_co_audio_getconfig call BTA_AvReconfig(x%x)", hndl); + BTA_AvReconfig(hndl, TRUE, p_sink->sep_info_idx, p_peer->codec_cfg, *p_num_protect, (UINT8 *)bta_av_co_cp_scmst); + } + } + else + { + *p_sep_info_idx = p_sink->sep_info_idx; + memcpy(p_codec_info, p_peer->codec_cfg, AVDT_CODEC_SIZE); + } + result = A2D_SUCCESS; + } + } + /* Protect access to bta_av_co_cb.codec_cfg */ + GKI_enable(); + } + return result; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_setconfig + ** + ** Description This callout function is executed by AV to set the codec and + ** content protection configuration of the audio stream. + ** + ** + ** Returns void + ** + *******************************************************************************/ +BTA_API void bta_av_co_audio_setconfig(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, + UINT8 *p_codec_info, UINT8 seid, BD_ADDR addr, UINT8 num_protect, UINT8 *p_protect_info) + +{ + tBTA_AV_CO_PEER *p_peer; + UINT8 status = A2D_SUCCESS; + UINT8 category = A2D_SUCCESS; + BOOLEAN recfg_needed = FALSE; + + FUNC_TRACE(); + + APPL_TRACE_DEBUG6("bta_av_co_audio_setconfig p_codec_info[%x:%x:%x:%x:%x:%x]", + p_codec_info[1], p_codec_info[2], p_codec_info[3], + p_codec_info[4], p_codec_info[5], p_codec_info[6]); + APPL_TRACE_DEBUG4("num_protect:0x%02x protect_info:0x%02x%02x%02x", + num_protect, p_protect_info[0], p_protect_info[1], p_protect_info[2]); + + /* Retrieve the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer == NULL) + { + APPL_TRACE_ERROR0("bta_av_co_audio_setconfig could not find peer entry"); + + /* Call call-in rejecting the configuration */ + bta_av_ci_setconfig(hndl, A2D_BUSY, AVDT_ASC_CODEC, 0, NULL, FALSE); + return; + } + + /* Sanity check: should not be opened at this point */ + if (p_peer->opened) + { + APPL_TRACE_ERROR0("bta_av_co_audio_setconfig peer already in use"); + } + +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + if (num_protect != 0) + { + /* If CP is supported */ + if ((num_protect != 1) || + (bta_av_co_cp_is_scmst(p_protect_info) == FALSE)) + { + APPL_TRACE_ERROR0("bta_av_co_audio_setconfig wrong CP configuration"); + status = A2D_BAD_CP_TYPE; + category = AVDT_ASC_PROTECT; + } + } +#else + /* Do not support content protection for the time being */ + if (num_protect != 0) + { + APPL_TRACE_ERROR0("bta_av_co_audio_setconfig wrong CP configuration"); + status = A2D_BAD_CP_TYPE; + category = AVDT_ASC_PROTECT; + } +#endif + if (status == A2D_SUCCESS) + { + /* Check if codec configuration is supported */ + if (bta_av_co_audio_media_supports_config(codec_type, p_codec_info)) + { + /* Protect access to bta_av_co_cb.codec_cfg */ + GKI_disable(); + + /* Check if the configuration matches the current codec config */ + switch (bta_av_co_cb.codec_cfg.id) + { + case BTIF_AV_CODEC_SBC: + if ((codec_type != BTA_AV_CODEC_SBC) || memcmp(p_codec_info, bta_av_co_cb.codec_cfg.info, 5)) + { + recfg_needed = TRUE; + } + else if ((num_protect == 1) && (!bta_av_co_cb.cp.active)) + { + recfg_needed = TRUE; + } + break; + + + default: + APPL_TRACE_ERROR1("bta_av_co_audio_setconfig unsupported cid %d", bta_av_co_cb.codec_cfg.id); + recfg_needed = TRUE; + break; + } + /* Protect access to bta_av_co_cb.codec_cfg */ + GKI_enable(); + } + else + { + category = AVDT_ASC_CODEC; + status = A2D_WRONG_CODEC; + } + } + + if (status != A2D_SUCCESS) + { + APPL_TRACE_DEBUG2("bta_av_co_audio_setconfig reject s=%d c=%d", status, category); + + /* Call call-in rejecting the configuration */ + bta_av_ci_setconfig(hndl, status, category, 0, NULL, FALSE); + } + else + { + /* Mark that this is an acceptor peer */ + p_peer->acp = TRUE; + p_peer->recfg_needed = recfg_needed; + + APPL_TRACE_DEBUG1("bta_av_co_audio_setconfig accept reconf=%d", recfg_needed); + + /* Call call-in accepting the configuration */ + bta_av_ci_setconfig(hndl, A2D_SUCCESS, A2D_SUCCESS, 0, NULL, recfg_needed); + } +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_open + ** + ** Description This function is called by AV when the audio stream connection + ** is opened. + ** + ** + ** Returns void + ** + *******************************************************************************/ +BTA_API void bta_av_co_audio_open(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT8 *p_codec_info, + UINT16 mtu) +{ + tBTA_AV_CO_PEER *p_peer; + + FUNC_TRACE(); + + APPL_TRACE_DEBUG2("bta_av_co_audio_open mtu:%d codec_type:%d", mtu, codec_type); + + /* Retrieve the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer == NULL) + { + APPL_TRACE_ERROR0("bta_av_co_audio_setconfig could not find peer entry"); + } + else + { + p_peer->opened = TRUE; + p_peer->mtu = mtu; + } +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_close + ** + ** Description This function is called by AV when the audio stream connection + ** is closed. + ** + ** + ** Returns void + ** + *******************************************************************************/ +BTA_API void bta_av_co_audio_close(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, UINT16 mtu) + +{ + tBTA_AV_CO_PEER *p_peer; + + FUNC_TRACE(); + + APPL_TRACE_DEBUG0("bta_av_co_audio_close"); + + /* Retrieve the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer) + { + /* Mark the peer closed and clean the peer info */ + memset(p_peer, 0, sizeof(*p_peer)); + } + else + { + APPL_TRACE_ERROR0("bta_av_co_audio_close could not find peer entry"); + } +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_start + ** + ** Description This function is called by AV when the audio streaming data + ** transfer is started. + ** + ** + ** Returns void + ** + *******************************************************************************/ +BTA_API void bta_av_co_audio_start(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type, + UINT8 *p_codec_info, BOOLEAN *p_no_rtp_hdr) +{ + FUNC_TRACE(); + + APPL_TRACE_DEBUG0("bta_av_co_audio_start"); + +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_stop + ** + ** Description This function is called by AV when the audio streaming data + ** transfer is stopped. + ** + ** + ** Returns void + ** + *******************************************************************************/ +BTA_API extern void bta_av_co_audio_stop(tBTA_AV_HNDL hndl, tBTA_AV_CODEC codec_type) +{ + FUNC_TRACE(); + + APPL_TRACE_DEBUG0("bta_av_co_audio_stop"); +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_src_data_path + ** + ** Description This function is called to manage data transfer from + ** the audio codec to AVDTP. + ** + ** Returns Pointer to the GKI buffer to send, NULL if no buffer to send + ** + *******************************************************************************/ +BTA_API void * bta_av_co_audio_src_data_path(tBTA_AV_CODEC codec_type, UINT32 *p_len, + UINT32 *p_timestamp) +{ + BT_HDR *p_buf; + FUNC_TRACE(); + + p_buf = btif_media_aa_readbuf(); + if (p_buf != NULL) + { + switch (codec_type) + { + case BTA_AV_CODEC_SBC: + /* In media packet SBC, the following information is available: + * p_buf->layer_specific : number of SBC frames in the packet + * p_buf->word[0] : timestamp + */ + /* Retrieve the timestamp information from the media packet */ + *p_timestamp = *((UINT32 *) (p_buf + 1)); + + /* Set up packet header */ + bta_av_sbc_bld_hdr(p_buf, p_buf->layer_specific); + break; + + + default: + APPL_TRACE_ERROR1("bta_av_co_audio_src_data_path Unsupported codec type (%d)", codec_type); + break; + } +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + { + UINT8 *p; + if (bta_av_co_cp_is_active()) + { + p_buf->len++; + p_buf->offset--; + p = (UINT8 *)(p_buf + 1) + p_buf->offset; + *p = bta_av_co_cp_get_flag(); + } + } +#endif + } + return p_buf; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_drop + ** + ** Description An Audio packet is dropped. . + ** It's very likely that the connected headset with this handle + ** is moved far away. The implementation may want to reduce + ** the encoder bit rate setting to reduce the packet size. + ** + ** Returns void + ** + *******************************************************************************/ +void bta_av_co_audio_drop(tBTA_AV_HNDL hndl) +{ + FUNC_TRACE(); + + APPL_TRACE_ERROR1("bta_av_co_audio_drop dropped: x%x", hndl); +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_delay + ** + ** Description This function is called by AV when the audio stream connection + ** needs to send the initial delay report to the connected SRC. + ** + ** + ** Returns void + ** + *******************************************************************************/ +void bta_av_co_audio_delay(tBTA_AV_HNDL hndl, UINT16 delay) +{ + FUNC_TRACE(); + + APPL_TRACE_ERROR2("bta_av_co_audio_delay handle: x%x, delay:0x%x", hndl, delay); +} + + + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_build_config + ** + ** Description Build the codec configuration + ** + ** Returns TRUE if the codec was built successfully, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_codec_build_config(const UINT8 *p_codec_caps, UINT8 *p_codec_cfg) +{ + FUNC_TRACE(); + + /* By default, just copy the current codec configuration */ + memcpy(p_codec_cfg, bta_av_co_cb.codec_cfg.info, AVDT_CODEC_SIZE); + switch (bta_av_co_cb.codec_cfg.id) + { + case BTIF_AV_CODEC_SBC: + /* Update the bit pool boundaries with the codec capabilities */ + p_codec_cfg[BTA_AV_CO_SBC_MIN_BITPOOL_OFF] = p_codec_caps[BTA_AV_CO_SBC_MIN_BITPOOL_OFF]; + p_codec_cfg[BTA_AV_CO_SBC_MAX_BITPOOL_OFF] = p_codec_caps[BTA_AV_CO_SBC_MAX_BITPOOL_OFF]; + break; + default: + APPL_TRACE_ERROR1("bta_av_co_audio_codec_build_config: unsupported codec id %d", bta_av_co_cb.codec_cfg.id); + return FALSE; + break; + } + return TRUE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_cfg_matches_caps + ** + ** Description Check if a codec config matches a codec capabilities + ** + ** Returns TRUE if it codec config is supported, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_codec_cfg_matches_caps(UINT8 codec_id, const UINT8 *p_codec_caps, const UINT8 *p_codec_cfg) +{ + FUNC_TRACE(); + + switch(codec_id) + { + case BTIF_AV_CODEC_SBC: + /* Must match all items exactly except bitpool boundaries which can be adjusted */ + if (!((p_codec_caps[BTA_AV_CO_SBC_FREQ_CHAN_OFF] & p_codec_cfg[BTA_AV_CO_SBC_FREQ_CHAN_OFF]) && + (p_codec_caps[BTA_AV_CO_SBC_BLOCK_BAND_OFF] & p_codec_cfg[BTA_AV_CO_SBC_BLOCK_BAND_OFF]))) + { + APPL_TRACE_EVENT4("FALSE %x %x %x %x", + p_codec_caps[BTA_AV_CO_SBC_FREQ_CHAN_OFF], + p_codec_cfg[BTA_AV_CO_SBC_FREQ_CHAN_OFF], + p_codec_caps[BTA_AV_CO_SBC_BLOCK_BAND_OFF], + p_codec_cfg[BTA_AV_CO_SBC_BLOCK_BAND_OFF]); + return FALSE; + } + break; + + + default: + APPL_TRACE_ERROR1("bta_av_co_audio_codec_cfg_matches_caps: unsupported codec id %d", codec_id); + return FALSE; + break; + } + APPL_TRACE_EVENT0("TRUE"); + + return TRUE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_match + ** + ** Description Check if a codec capabilities supports the codec config + ** + ** Returns TRUE if the connection supports this codec, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_codec_match(const UINT8 *p_codec_caps) +{ + FUNC_TRACE(); + + return bta_av_co_audio_codec_cfg_matches_caps(bta_av_co_cb.codec_cfg.id, p_codec_caps, bta_av_co_cb.codec_cfg.info); +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_peer_reset_config + ** + ** Description Reset the peer codec configuration + ** + ** Returns Nothing + ** + *******************************************************************************/ +static void bta_av_co_audio_peer_reset_config(tBTA_AV_CO_PEER *p_peer) +{ + FUNC_TRACE(); + + /* Indicate that there is no currently selected sink */ + p_peer->p_snk = NULL; +} + +/******************************************************************************* + ** + ** Function bta_av_co_cp_is_scmst + ** + ** Description Check if a content protection service is SCMS-T + ** + ** Returns TRUE if this CP is SCMS-T, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_cp_is_scmst(const UINT8 *p_protectinfo) +{ + UINT16 cp_id; + FUNC_TRACE(); + + if (*p_protectinfo >= BTA_AV_CP_LOSC) + { + p_protectinfo++; + STREAM_TO_UINT16(cp_id, p_protectinfo); + if (cp_id == BTA_AV_CP_SCMS_T_ID) + { + APPL_TRACE_DEBUG0("bta_av_co_cp_is_scmst: SCMS-T found"); + return TRUE; + } + } + + return FALSE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_sink_has_scmst + ** + ** Description Check if a sink supports SCMS-T + ** + ** Returns TRUE if the sink supports this CP, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_sink_has_scmst(const tBTA_AV_CO_SINK *p_sink) +{ + UINT8 index; + const UINT8 *p; + FUNC_TRACE(); + + /* Check if sink supports SCMS-T */ + index = p_sink->num_protect; + p = &p_sink->protect_info[0]; + + while (index) + { + if (bta_av_co_cp_is_scmst(p)) + { + return TRUE; + } + /* Move to the next SC */ + p += *p + 1; + /* Decrement the SC counter */ + index--; + } + APPL_TRACE_DEBUG0("bta_av_co_audio_sink_has_scmst: SCMS-T not found"); + return FALSE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_sink_supports_cp + ** + ** Description Check if a sink supports the current content protection + ** + ** Returns TRUE if the sink supports this CP, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_sink_supports_cp(const tBTA_AV_CO_SINK *p_sink) +{ + FUNC_TRACE(); + + /* Check if content protection is enabled for this stream */ + if (bta_av_co_cp_get_flag() != BTA_AV_CP_SCMS_COPY_FREE) + { + return bta_av_co_audio_sink_has_scmst(p_sink); + } + else + { + APPL_TRACE_DEBUG0("bta_av_co_audio_sink_supports_cp: not required"); + return TRUE; + } +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_peer_supports_codec + ** + ** Description Check if a connection supports the codec config + ** + ** Returns TRUE if the connection supports this codec, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_peer_supports_codec(tBTA_AV_CO_PEER *p_peer, UINT8 *p_snk_index) +{ + int index; + UINT8 codec_type; + FUNC_TRACE(); + + /* Configure the codec type to look for */ + codec_type = bta_av_co_cb.codec_cfg.id; + + + for (index = 0; index < p_peer->num_sup_snks; index++) + { + if (p_peer->snks[index].codec_type == codec_type) + { + switch (bta_av_co_cb.codec_cfg.id) + { + case BTIF_AV_CODEC_SBC: + if (p_snk_index) *p_snk_index = index; + return bta_av_co_audio_codec_match(p_peer->snks[index].codec_caps); + break; + + + default: + APPL_TRACE_ERROR1("bta_av_co_audio_peer_supports_codec: unsupported codec id %d", bta_av_co_cb.codec_cfg.id); + return FALSE; + break; + } + } + } + return FALSE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_media_supports_config + ** + ** Description Check if the media source supports a given configuration + ** + ** Returns TRUE if the media source supports this config, FALSE otherwise + ** + *******************************************************************************/ +static BOOLEAN bta_av_co_audio_media_supports_config(UINT8 codec_type, const UINT8 *p_codec_cfg) +{ + FUNC_TRACE(); + + switch (codec_type) + { + case BTA_AV_CODEC_SBC: + if (bta_av_sbc_cfg_in_cap((UINT8 *)p_codec_cfg, (tA2D_SBC_CIE *)&bta_av_co_sbc_caps)) + { + return FALSE; + } + break; + + + default: + APPL_TRACE_ERROR1("bta_av_co_audio_media_supports_config unsupported codec type %d", codec_type); + return FALSE; + break; + } + return TRUE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_supported + ** + ** Description Check if all opened connections are compatible with a codec + ** configuration and content protection + ** + ** Returns TRUE if all opened devices support this codec, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_codec_supported(tBTIF_STATUS *p_status) +{ + UINT8 index; + UINT8 snk_index; + tBTA_AV_CO_PEER *p_peer; + tBTA_AV_CO_SINK *p_sink; + UINT8 codec_cfg[AVDT_CODEC_SIZE]; + UINT8 num_protect = 0; +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + BOOLEAN cp_active; +#endif + + FUNC_TRACE(); + + + APPL_TRACE_DEBUG0("bta_av_co_audio_codec_supported"); + + /* Check AV feeding is supported */ + *p_status = BTIF_ERROR_SRV_AV_FEEDING_NOT_SUPPORTED; + + for (index = 0; index < BTA_AV_CO_NUM_ELEMENTS(bta_av_co_cb.peers); index++) + { + p_peer = &bta_av_co_cb.peers[index]; + if (p_peer->opened) + { + if (bta_av_co_audio_peer_supports_codec(p_peer, &snk_index)) + { + p_sink = &p_peer->snks[snk_index]; + + /* Check that this sink is compatible with the CP */ + if (!bta_av_co_audio_sink_supports_cp(p_sink)) + { + APPL_TRACE_DEBUG2("bta_av_co_audio_codec_supported sink %d of peer %d doesn't support cp", + snk_index, index); + *p_status = BTIF_ERROR_SRV_AV_CP_NOT_SUPPORTED; + return FALSE; + } + + /* Build the codec configuration for this sink */ + if (bta_av_co_audio_codec_build_config(p_sink->codec_caps, codec_cfg)) + { +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + /* Check if this sink supports SCMS */ + cp_active = bta_av_co_audio_sink_has_scmst(p_sink); +#endif + /* Check if this is a new configuration (new sink or new config) */ + if ((p_sink != p_peer->p_snk) || + (memcmp(codec_cfg, p_peer->codec_cfg, AVDT_CODEC_SIZE)) +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + || (p_peer->cp_active != cp_active) +#endif + ) + { + /* Save the new configuration */ + p_peer->p_snk = p_sink; + memcpy(p_peer->codec_cfg, codec_cfg, AVDT_CODEC_SIZE); +#if defined(BTA_AV_CO_CP_SCMS_T) && (BTA_AV_CO_CP_SCMS_T == TRUE) + p_peer->cp_active = cp_active; + if (p_peer->cp_active) + { + bta_av_co_cb.cp.active = TRUE; + num_protect = BTA_AV_CP_INFO_LEN; + } + else + { + bta_av_co_cb.cp.active = FALSE; + } +#endif + APPL_TRACE_DEBUG1("bta_av_co_audio_codec_supported call BTA_AvReconfig(x%x)", BTA_AV_CO_AUDIO_INDX_TO_HNDL(index)); + BTA_AvReconfig(BTA_AV_CO_AUDIO_INDX_TO_HNDL(index), TRUE, p_sink->sep_info_idx, + p_peer->codec_cfg, num_protect, (UINT8 *)bta_av_co_cp_scmst); + } + } + } + else + { + APPL_TRACE_DEBUG1("bta_av_co_audio_codec_supported index %d doesn't support codec", index); + return FALSE; + } + } + } + + *p_status = BTIF_SUCCESS; + return TRUE; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_reset + ** + ** Description Reset the current codec configuration + ** + ** Returns void + ** + *******************************************************************************/ +void bta_av_co_audio_codec_reset(void) +{ + GKI_disable(); + FUNC_TRACE(); + + /* Reset the current configuration to SBC */ + bta_av_co_cb.codec_cfg.id = BTIF_AV_CODEC_SBC; + if (A2D_BldSbcInfo(A2D_MEDIA_TYPE_AUDIO, (tA2D_SBC_CIE *)&btif_av_sbc_default_config, bta_av_co_cb.codec_cfg.info) != A2D_SUCCESS) + { + APPL_TRACE_ERROR0("bta_av_co_audio_codec_reset A2D_BldSbcInfo failed"); + } + + GKI_enable(); +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_set_codec + ** + ** Description Set the current codec configuration from the feeding type. + ** This function is starting to modify the configuration, it + ** should be protected. + ** + ** Returns TRUE if successful, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTIF_STATUS *p_status) +{ + tA2D_SBC_CIE sbc_config; + tBTIF_AV_CODEC_INFO new_cfg; + + FUNC_TRACE(); + + /* Check AV feeding is supported */ + *p_status = BTIF_ERROR_SRV_AV_FEEDING_NOT_SUPPORTED; + + APPL_TRACE_DEBUG1("bta_av_co_audio_set_codec cid=%d", p_feeding->format); + + /* Supported codecs */ + switch (p_feeding->format) + { + case BTIF_AV_CODEC_PCM: + new_cfg.id = BTIF_AV_CODEC_SBC; + + sbc_config = btif_av_sbc_default_config; + if ((p_feeding->cfg.pcm.num_channel != 1) && + (p_feeding->cfg.pcm.num_channel != 2)) + { + APPL_TRACE_ERROR0("bta_av_co_audio_set_codec PCM channel number unsupported"); + return FALSE; + } + if ((p_feeding->cfg.pcm.bit_per_sample != 8) && + (p_feeding->cfg.pcm.bit_per_sample != 16)) + { + APPL_TRACE_ERROR0("bta_av_co_audio_set_codec PCM sample size unsupported"); + return FALSE; + } + switch (p_feeding->cfg.pcm.sampling_freq) + { + case 8000: + case 12000: + case 16000: + case 24000: + case 32000: + case 48000: + sbc_config.samp_freq = A2D_SBC_IE_SAMP_FREQ_48; + break; + + case 11025: + case 22050: + case 44100: + sbc_config.samp_freq = A2D_SBC_IE_SAMP_FREQ_44; + break; + default: + APPL_TRACE_ERROR0("bta_av_co_audio_set_codec PCM sampling frequency unsupported"); + return FALSE; + break; + } + /* Build the codec config */ + if (A2D_BldSbcInfo(A2D_MEDIA_TYPE_AUDIO, &sbc_config, new_cfg.info) != A2D_SUCCESS) + { + APPL_TRACE_ERROR0("bta_av_co_audio_set_codec A2D_BldSbcInfo failed"); + return FALSE; + } + break; + + + default: + APPL_TRACE_ERROR0("bta_av_co_audio_set_codec Feeding format unsupported"); + return FALSE; + break; + } + + /* The new config was correctly built */ + bta_av_co_cb.codec_cfg = new_cfg; + + + /* Check all devices support it */ + *p_status = BTIF_SUCCESS; + return bta_av_co_audio_codec_supported(p_status); +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_get_sbc_config + ** + ** Description Retrieves the SBC codec configuration. If the codec in use + ** is not SBC, return the default SBC codec configuration. + ** + ** Returns TRUE if codec is SBC, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_get_sbc_config(tA2D_SBC_CIE *p_sbc_config, UINT16 *p_minmtu) +{ + BOOLEAN result = FALSE; + UINT8 index, jndex; + tBTA_AV_CO_PEER *p_peer; + tBTA_AV_CO_SINK *p_sink; + + FUNC_TRACE(); + + /* Minimum MTU is by default very large */ + *p_minmtu = 0xFFFF; + + GKI_disable(); + if (bta_av_co_cb.codec_cfg.id == BTIF_AV_CODEC_SBC) + { + if (A2D_ParsSbcInfo(p_sbc_config, bta_av_co_cb.codec_cfg.info, FALSE) == A2D_SUCCESS) + { + for (index = 0; index < BTA_AV_CO_NUM_ELEMENTS(bta_av_co_cb.peers); index++) + { + p_peer = &bta_av_co_cb.peers[index]; + if (p_peer->opened) + { + if (p_peer->mtu < *p_minmtu) + { + *p_minmtu = p_peer->mtu; + } + for (jndex = 0; jndex < p_peer->num_sup_snks; jndex++) + { + p_sink = &p_peer->snks[jndex]; + if (p_sink->codec_type == A2D_MEDIA_CT_SBC) + { + /* Update the bitpool boundaries of the current config */ + p_sbc_config->min_bitpool = + BTA_AV_CO_MAX(p_sink->codec_caps[BTA_AV_CO_SBC_MIN_BITPOOL_OFF], + p_sbc_config->min_bitpool); + p_sbc_config->max_bitpool = + BTA_AV_CO_MIN(p_sink->codec_caps[BTA_AV_CO_SBC_MAX_BITPOOL_OFF], + p_sbc_config->max_bitpool); + break; + } + } + } + } + result = TRUE; + } + } + + if (!result) + { + /* Not SBC, still return the default values */ + *p_sbc_config = btif_av_sbc_default_config; + } + GKI_enable(); + + return result; +} + +/******************************************************************************* + ** + ** Function bta_av_co_audio_discard_config + ** + ** Description Discard the codec configuration of a connection + ** + ** Returns Nothing + ** + *******************************************************************************/ +void bta_av_co_audio_discard_config(tBTA_AV_HNDL hndl) +{ + tBTA_AV_CO_PEER *p_peer; + + FUNC_TRACE(); + + /* Find the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer == NULL) + { + APPL_TRACE_ERROR0("bta_av_co_audio_discard_config could not find peer entry"); + return; + } + + /* Reset the peer codec configuration */ + bta_av_co_audio_peer_reset_config(p_peer); +} + +/******************************************************************************* + ** + ** Function bta_av_co_init + ** + ** Description Initialization + ** + ** Returns Nothing + ** + *******************************************************************************/ +void bta_av_co_init(void) +{ + FUNC_TRACE(); + + /* Reset the control block */ + memset(&bta_av_co_cb, 0, sizeof(bta_av_co_cb)); + + /* Reset the current config */ + bta_av_co_audio_codec_reset(); +} + + +/******************************************************************************* + ** + ** Function bta_av_co_peer_cp_supported + ** + ** Description Checks if the peer supports CP + ** + ** Returns TRUE if the peer supports CP + ** + *******************************************************************************/ +BOOLEAN bta_av_co_peer_cp_supported(tBTA_AV_HNDL hndl) +{ + tBTA_AV_CO_PEER *p_peer; + tBTA_AV_CO_SINK *p_sink; + UINT8 index; + + FUNC_TRACE(); + + /* Find the peer info */ + p_peer = bta_av_co_get_peer(hndl); + if (p_peer == NULL) + { + APPL_TRACE_ERROR0("bta_av_co_peer_cp_supported could not find peer entry"); + return FALSE; + } + + for (index = 0; index < p_peer->num_sup_snks; index++) + { + p_sink = &p_peer->snks[index]; + if (p_sink->codec_type == A2D_MEDIA_CT_SBC) + { + return bta_av_co_audio_sink_has_scmst(p_sink); + } + } + APPL_TRACE_ERROR0("bta_av_co_peer_cp_supported did not find SBC sink"); + return FALSE; +} diff --git a/btif/include/btif_av.h b/btif/include/btif_av.h new file mode 100644 index 0000000..720fa87 --- /dev/null +++ b/btif/include/btif_av.h @@ -0,0 +1,190 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + +/***************************************************************************** +** +** Name: btif_av.h +** +** Description: +** +******************************************************************************/ + + +#ifndef BTIF_AV_H +#define BTIF_AV_H + +#include "btif_media.h" + +enum +{ + BTIF_SV_AV_AA_SBC_INDEX = 0, + BTIF_SV_AV_AA_SEP_INDEX /* Last index */ +}; + + +/******************************************************************************* + ** + ** Function bta_av_co_cp_is_active + ** + ** Description Get the current configuration of content protection + ** + ** Returns TRUE if the current streaming has CP, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_cp_is_active(void); + +/******************************************************************************* + ** + ** Function bta_av_co_cp_get_flag + ** + ** Description Get content protection flag + ** BTA_AV_CP_SCMS_COPY_NEVER + ** BTA_AV_CP_SCMS_COPY_ONCE + ** BTA_AV_CP_SCMS_COPY_FREE + ** + ** Returns The current flag value + ** + *******************************************************************************/ +UINT8 bta_av_co_cp_get_flag(void); + +/******************************************************************************* + ** + ** Function bta_av_co_cp_set_flag + ** + ** Description Set content protection flag + ** BTA_AV_CP_SCMS_COPY_NEVER + ** BTA_AV_CP_SCMS_COPY_ONCE + ** BTA_AV_CP_SCMS_COPY_FREE + ** + ** Returns TRUE if setting the SCMS flag is supported else FALSE + ** + *******************************************************************************/ +BOOLEAN bta_av_co_cp_set_flag(UINT8 cp_flag); + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_reset + ** + ** Description Reset the current codec configuration + ** + ** Returns void + ** + *******************************************************************************/ +void bta_av_co_audio_codec_reset(void); + +/******************************************************************************* + ** + ** Function bta_av_co_audio_codec_supported + ** + ** Description Check if all opened connections are compatible with a codec + ** configuration + ** + ** Returns TRUE if all opened devices support this codec, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_codec_supported(tBTIF_STATUS *p_status); + +/******************************************************************************* + ** + ** Function bta_av_co_audio_set_codec + ** + ** Description Set the current codec configuration from the feeding type. + ** This function is starting to modify the configuration, it + ** should be protected. + ** + ** Returns TRUE if successful, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_set_codec(const tBTIF_AV_MEDIA_FEEDINGS *p_feeding, tBTIF_STATUS *p_status); + +/******************************************************************************* + ** + ** Function bta_av_co_audio_get_sbc_config + ** + ** Description Retrieves the SBC codec configuration. If the codec in use + ** is not SBC, return the default SBC codec configuration. + ** + ** Returns TRUE if codec is SBC, FALSE otherwise + ** + *******************************************************************************/ +BOOLEAN bta_av_co_audio_get_sbc_config(tA2D_SBC_CIE *p_sbc_config, UINT16 *p_minmtu); + +/******************************************************************************* + ** + ** Function bta_av_co_audio_discard_config + ** + ** Description Discard the codec configuration of a connection + ** + ** Returns Nothing + ** + *******************************************************************************/ +void bta_av_co_audio_discard_config(tBTA_AV_HNDL hndl); + +/******************************************************************************* + ** + ** Function bta_av_co_init + ** + ** Description Initialization + ** + ** Returns Nothing + ** + *******************************************************************************/ +void bta_av_co_init(void); + + +/******************************************************************************* + ** + ** Function bta_av_co_peer_cp_supported + ** + ** Description Checks if the peer supports CP + ** + ** Returns TRUE if the peer supports CP + ** + *******************************************************************************/ +BOOLEAN bta_av_co_peer_cp_supported(tBTA_AV_HNDL hndl); + +#endif diff --git a/btif/include/btif_av_api.h b/btif/include/btif_av_api.h new file mode 100644 index 0000000..f7a0304 --- /dev/null +++ b/btif/include/btif_av_api.h @@ -0,0 +1,238 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + +/***************************************************************************** + ** + ** Name: btif_av_api.h + ** + ** Description: This is the public interface file for the advanced + ** audio/video streaming (AV) subsystem of BTIF, Widcomm's + ** Bluetooth application layer for mobile phones. + ** + *****************************************************************************/ +#ifndef BTIF_AV_API_H +#define BTIF_AV_API_H + +#include "bt_target.h" +#include "bta_av_api.h" +#include "uipc.h" + +#include "btif_media.h" +#include "a2d_api.h" +#include "a2d_sbc.h" +#include "a2d_m12.h" +#include "a2d_m24.h" + +/***************************************************************************** + ** Constants and data types + *****************************************************************************/ + +/* codec type */ +#define BTIF_AV_CODEC_SBC A2D_MEDIA_CT_SBC /* SBC media codec type */ + +#define BTIF_AV_CODEC_PCM 0x5 /* Raw PCM */ + +typedef UINT8 tBTIF_AV_CODEC_ID; + +/* AV features masks */ +#define BTIF_AV_FEAT_RCTG BTA_AV_FEAT_RCTG /* remote control target */ +#define BTIF_AV_FEAT_RCCT BTA_AV_FEAT_RCCT /* remote control controller */ +#define BTIF_AV_FEAT_METADATA BTA_AV_FEAT_METADATA /* remote control Metadata Transfer command/response */ + +typedef UINT16 tBTIF_AV_FEAT; + +/* AV channel values */ +#define BTIF_AV_CHNL_MSK BTA_AV_CHNL_MSK +#define BTIF_AV_CHNL_AUDIO BTA_AV_CHNL_AUDIO /* audio channel */ +#define BTIF_AV_CHNL_VIDEO BTA_AV_CHNL_VIDEO /* video channel */ +typedef UINT8 tBTIF_AV_CHNL; + +typedef UINT8 tBTIF_AV_HNDL; + +/* operation id list for BTIF_AvRemoteCmd */ +#define BTIF_AV_ID_SELECT 0x00 /* select */ +#define BTIF_AV_ID_UP 0x01 /* up */ +#define BTIF_AV_ID_DOWN 0x02 /* down */ +#define BTIF_AV_ID_LEFT 0x03 /* left */ +#define BTIF_AV_ID_RIGHT 0x04 /* right */ +#define BTIF_AV_ID_RIGHT_UP 0x05 /* right-up */ +#define BTIF_AV_ID_RIGHT_DOWN 0x06 /* right-down */ +#define BTIF_AV_ID_LEFT_UP 0x07 /* left-up */ +#define BTIF_AV_ID_LEFT_DOWN 0x08 /* left-down */ +#define BTIF_AV_ID_ROOT_MENU 0x09 /* root menu */ +#define BTIF_AV_ID_SETUP_MENU 0x0A /* setup menu */ +#define BTIF_AV_ID_CONT_MENU 0x0B /* contents menu */ +#define BTIF_AV_ID_FAV_MENU 0x0C /* favorite menu */ +#define BTIF_AV_ID_EXIT 0x0D /* exit */ +#define BTIF_AV_ID_0 0x20 /* 0 */ +#define BTIF_AV_ID_1 0x21 /* 1 */ +#define BTIF_AV_ID_2 0x22 /* 2 */ +#define BTIF_AV_ID_3 0x23 /* 3 */ +#define BTIF_AV_ID_4 0x24 /* 4 */ +#define BTIF_AV_ID_5 0x25 /* 5 */ +#define BTIF_AV_ID_6 0x26 /* 6 */ +#define BTIF_AV_ID_7 0x27 /* 7 */ +#define BTIF_AV_ID_8 0x28 /* 8 */ +#define BTIF_AV_ID_9 0x29 /* 9 */ +#define BTIF_AV_ID_DOT 0x2A /* dot */ +#define BTIF_AV_ID_ENTER 0x2B /* enter */ +#define BTIF_AV_ID_CLEAR 0x2C /* clear */ +#define BTIF_AV_ID_CHAN_UP 0x30 /* channel up */ +#define BTIF_AV_ID_CHAN_DOWN 0x31 /* channel down */ +#define BTIF_AV_ID_PREV_CHAN 0x32 /* previous channel */ +#define BTIF_AV_ID_SOUND_SEL 0x33 /* sound select */ +#define BTIF_AV_ID_INPUT_SEL 0x34 /* input select */ +#define BTIF_AV_ID_DISP_INFO 0x35 /* display information */ +#define BTIF_AV_ID_HELP 0x36 /* help */ +#define BTIF_AV_ID_PAGE_UP 0x37 /* page up */ +#define BTIF_AV_ID_PAGE_DOWN 0x38 /* page down */ +#define BTIF_AV_ID_POWER 0x40 /* power */ +#define BTIF_AV_ID_VOL_UP 0x41 /* volume up */ +#define BTIF_AV_ID_VOL_DOWN 0x42 /* volume down */ +#define BTIF_AV_ID_MUTE 0x43 /* mute */ +#define BTIF_AV_ID_PLAY 0x44 /* play */ +#define BTIF_AV_ID_STOP 0x45 /* stop */ +#define BTIF_AV_ID_PAUSE 0x46 /* pause */ +#define BTIF_AV_ID_RECORD 0x47 /* record */ +#define BTIF_AV_ID_REWIND 0x48 /* rewind */ +#define BTIF_AV_ID_FAST_FOR 0x49 /* fast forward */ +#define BTIF_AV_ID_EJECT 0x4A /* eject */ +#define BTIF_AV_ID_FORWARD 0x4B /* forward */ +#define BTIF_AV_ID_BACKWARD 0x4C /* backward */ +#define BTIF_AV_ID_ANGLE 0x50 /* angle */ +#define BTIF_AV_ID_SUBPICT 0x51 /* subpicture */ +#define BTIF_AV_ID_F1 0x71 /* F1 */ +#define BTIF_AV_ID_F2 0x72 /* F2 */ +#define BTIF_AV_ID_F3 0x73 /* F3 */ +#define BTIF_AV_ID_F4 0x74 /* F4 */ +#define BTIF_AV_ID_F5 0x75 /* F5 */ +#define BTIF_AV_ID_VENDOR 0x7E /* vendor unique */ +#define BTIF_AV_KEYPRESSED_RELEASE 0x80 + +typedef UINT8 tBTIF_AV_RC; + +/* state flag for pass through command */ +#define BTIF_AV_STATE_PRESS 0 /* key pressed */ +#define BTIF_AV_STATE_RELEASE 1 /* key released */ + +typedef UINT8 tBTIF_AV_STATE; + +typedef UINT8 tBTIF_AV_RC_HNDL; + +/* command codes for BTIF_AvVendorCmd */ +#define BTIF_AV_CMD_CTRL 0 +#define BTIF_AV_CMD_STATUS 1 +#define BTIF_AV_CMD_SPEC_INQ 2 +#define BTIF_AV_CMD_NOTIF 3 +#define BTIF_AV_CMD_GEN_INQ 4 + +typedef UINT8 tBTIF_AV_CMD; + +/* AV callback events */ +#define BTIF_AV_OPEN_EVT 0 /* connection opened */ +#define BTIF_AV_CLOSE_EVT 1 /* connection closed */ +#define BTIF_AV_START_EVT 2 /* stream data transfer started */ +#define BTIF_AV_STOP_EVT 3 /* stream data transfer stopped */ +#define BTIF_AV_RC_OPEN_EVT 4 /* remote control channel open */ +#define BTIF_AV_RC_CLOSE_EVT 5 /* remote control channel closed */ +#define BTIF_AV_REMOTE_CMD_EVT 6 /* remote control command */ +#define BTIF_AV_REMOTE_RSP_EVT 7 /* remote control response */ +#define BTIF_AV_META_MSG_EVT 8 /* metadata messages */ + +typedef UINT8 tBTIF_AV_EVT; + +#define BTIF_AV_FEEDING_ASYNCHRONOUS 0 /* asynchronous feeding, use tx av timer */ +#define BTIF_AV_FEEDING_SYNCHRONOUS 1 /* synchronous feeding, no av tx timer */ + +#define BTIF_AV_MAX_SYNCHRONOUS_LATENCY 80 /* max latency in ms for BTIF_AV_FEEDING_SYNCHRONOUS */ +#define BTIF_AV_MIN_SYNCHRONOUS_LATENCY 4 /* min latency in ms for BTIF_AV_FEEDING_SYNCHRONOUS */ + +typedef UINT8 tBTIF_AV_FEEDING_MODE; + +#define BTIF_AV_CHANNEL_MODE_MONO A2D_SBC_IE_CH_MD_MONO +#define BTIF_AV_CHANNEL_MODE_STEREO A2D_SBC_IE_CH_MD_STEREO +#define BTIF_AV_CHANNEL_MODE_JOINT A2D_SBC_IE_CH_MD_JOINT +#define BTIF_AV_CHANNEL_MODE_DUAL A2D_SBC_IE_CH_MD_DUAL + +typedef UINT8 tBTIF_AV_CHANNEL_MODE; +/* + * Structure used to configure the AV codec capabilities/config + */ +typedef struct +{ + tBTIF_AV_CODEC_ID id; /* Codec ID (in terms of BTIF) */ + UINT8 info[AVDT_CODEC_SIZE]; /* Codec info (can be config or capabilities) */ +} tBTIF_AV_CODEC_INFO; + +/* + * Structure used to configure the AV media feeding + */ +typedef struct +{ + UINT16 sampling_freq; /* 44100, 48000 etc */ + UINT16 num_channel; /* 1 for mono or 2 stereo */ + UINT8 bit_per_sample; /* Number of bits per sample (8, 16) */ +} tBTIF_AV_MEDIA_FEED_CFG_PCM; + + +typedef union +{ + tBTIF_AV_MEDIA_FEED_CFG_PCM pcm; /* raw PCM feeding format */ +}tBTIF_AV_MEDIA_FEED_CFG; + +typedef struct +{ + tBTIF_AV_CODEC_ID format; /* Media codec identifier */ + tBTIF_AV_MEDIA_FEED_CFG cfg; /* Media codec configuration */ +} tBTIF_AV_MEDIA_FEEDINGS; + + +#ifdef __cplusplus +} +#endif + +#endif /* BTIF_AV_API_H */ diff --git a/btif/include/btif_media.h b/btif/include/btif_media.h new file mode 100644 index 0000000..0280d5c --- /dev/null +++ b/btif/include/btif_media.h @@ -0,0 +1,265 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + +/**************************************************************************** + ** + ** Name: btif_media.h + ** + ** Description: This is the audio module for the BTIF system. It contains + ** task implementations of A2DP + ** + ******************************************************************************/ + +#ifndef BTIF_MEDIA_H +#define BTIF_MEDIA_H + +#include "bta_api.h" +#include "bd.h" +#include "gki.h" +#include "btif_av_api.h" + +/* Generic part */ +#define BTIF_SUCCESS 0 + +/* +* AV (Audio Video source) Errors + */ +#define BTIF_ERROR_SRV_AV_NOT_ENABLED 700 /* AV is not enabled */ +#define BTIF_ERROR_SRV_AV_FEEDING_NOT_SUPPORTED 701 /* Requested Feeding not supported */ +#define BTIF_ERROR_SRV_AV_BUSY 702 /* Another operation ongoing */ +#define BTIF_ERROR_SRV_AV_NOT_OPENED 703 /* No AV link opened */ +#define BTIF_ERROR_SRV_AV_NOT_STARTED 704 /* AV is not started */ +#define BTIF_ERROR_SRV_AV_CP_NOT_SUPPORTED 705 /* Content protection is not supported by all headsets */ + +/***************************************************************************** + ** Constants + *****************************************************************************/ + + +/* transcoding definition for TxTranscoding and RxTranscoding */ +#define BTIF_MEDIA_TRSCD_OFF 0 +#define BTIF_MEDIA_TRSCD_PCM_2_SBC 1 /* Tx */ + + +/***************************************************************************** + ** Data types + *****************************************************************************/ + +typedef int tBTIF_STATUS; + +/* tBTIF_MEDIA_INIT_AUDIO msg structure */ +typedef struct +{ + BT_HDR hdr; + UINT16 SamplingFreq; /* 16k, 32k, 44.1k or 48k*/ + UINT8 ChannelMode; /* mono, dual, stereo or joint stereo*/ + UINT8 NumOfSubBands; /* 4 or 8 */ + UINT8 NumOfBlocks; /* 4, 8, 12 or 16*/ + UINT8 AllocationMethod; /* loudness or SNR*/ + UINT16 MtuSize; /* peer mtu size */ +} tBTIF_MEDIA_INIT_AUDIO; + +#if (BTA_AV_INCLUDED == TRUE) +/* tBTIF_MEDIA_UPDATE_AUDIO msg structure */ +typedef struct +{ + BT_HDR hdr; + UINT16 MinMtuSize; /* Minimum peer mtu size */ + UINT8 MaxBitPool; /* Maximum peer bitpool */ + UINT8 MinBitPool; /* Minimum peer bitpool */ +} tBTIF_MEDIA_UPDATE_AUDIO; + +/* tBTIF_MEDIA_INIT_AUDIO_FEEDING msg structure */ +typedef struct +{ + BT_HDR hdr; + tBTIF_AV_FEEDING_MODE feeding_mode; + tBTIF_AV_MEDIA_FEEDINGS feeding; +} tBTIF_MEDIA_INIT_AUDIO_FEEDING; +#endif + + +/***************************************************************************** + ** Local data + *****************************************************************************/ + +/***************************************************************************** + ** public functions + *****************************************************************************/ + +/******************************************************************************* + ** + ** Function btif_av_task + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +extern int btif_media_task(void *p); + + +/******************************************************************************* + ** + ** Function btif_media_task_enc_init_req + ** + ** Description Request to initialize the media task encoder + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +extern BOOLEAN btif_media_task_enc_init_req(tBTIF_MEDIA_INIT_AUDIO * p_msg); + +/******************************************************************************* + ** + ** Function btif_media_task_enc_update_req + ** + ** Description Request to update the media task encoder + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +#if (BTA_AV_INCLUDED == TRUE) +extern BOOLEAN btif_media_task_enc_update_req(tBTIF_MEDIA_UPDATE_AUDIO * p_msg); +#endif +/******************************************************************************* + ** + ** Function btif_media_task_start_aa_req + ** + ** Description Request to start audio encoding task + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +extern BOOLEAN btif_media_task_start_aa_req(void); + +/******************************************************************************* + ** + ** Function btif_media_task_stop_aa_req + ** + ** Description Request to stop audio encoding task + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +extern BOOLEAN btif_media_task_stop_aa_req(void); + + +/******************************************************************************* + ** + ** Function btif_media_task_aa_tx_flush_req + ** + ** Description Request to flush audio encoding pipe + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +extern BOOLEAN btif_media_task_aa_tx_flush_req(void); + +/******************************************************************************* + ** + ** Function btif_media_aa_readbuf + ** + ** Description Read an audio GKI buffer from the BTIF media TX queue + ** + ** Returns pointer on a GKI aa buffer ready to send + ** + *******************************************************************************/ +extern BT_HDR *btif_media_aa_readbuf(void); + +/******************************************************************************* + ** + ** Function btif_media_aa_writebuf + ** + ** Description Enqueue a Advance Audio media GKI buffer to be processed by btif media task. + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +extern void btif_media_aa_writebuf(BT_HDR *pBuf, UINT32 timestamp, UINT16 seq_num); + +/******************************************************************************* + ** + ** Function btif_media_av_writebuf + ** + ** Description Enqueue a video media GKI buffer to be processed by btif media task. + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +extern BOOLEAN btif_media_av_writebuf(UINT8 *p_media, UINT32 media_len, + UINT32 timestamp, UINT16 seq_num); + +#if (BTA_AV_INCLUDED == TRUE) + +/******************************************************************************* + ** + ** Function btif_media_task_audio_feeding_init_req + ** + ** Description Request to initialize audio feeding + ** + ** Returns TRUE is success + ** + *******************************************************************************/ + +extern BOOLEAN btif_media_task_audio_feeding_init_req(tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_msg); +#endif + + +/******************************************************************************* + ** + ** Function dump_codec_info + ** + ** Description Decode and display codec_info (for debug) + ** + ** Returns void + ** + *******************************************************************************/ +extern void dump_codec_info(unsigned char *p_codec); + +#endif + diff --git a/btif/include/btif_sm.h b/btif/include/btif_sm.h new file mode 100644 index 0000000..f4d5ede --- /dev/null +++ b/btif/include/btif_sm.h @@ -0,0 +1,158 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + +/***************************************************************************** + * + * Filename: btif_sm.h + * + * Description: Generic BTIF state machine API + * + *****************************************************************************/ + +#ifndef BTIF_SM_H +#define BTIF_SM_H + +/***************************************************************************** +** Constants & Macros +******************************************************************************/ + +/***************************************************************************** +** Type definitions and return values +******************************************************************************/ +typedef UINT32 btif_sm_state_t; +typedef UINT32 btif_sm_event_t; +typedef void* btif_sm_handle_t; +typedef BOOLEAN(*btif_sm_handler_t)(btif_sm_event_t event, void *data); + +/* Generic Enter/Exit state machine events */ +#define BTIF_SM_ENTER_EVT 0xFFFF +#define BTIF_SM_EXIT_EVT 0xFFFE + +/***************************************************************************** +** Extern variables and functions +******************************************************************************/ + +/***************************************************************************** +** Functions +******************************************************************************/ + +/* + * + * ######################################################################## + * + * NOTE: THESE APIs SHOULD BE INVOKED ONLY IN THE BTIF CONTEXT + * + * ####################################################################### + * + */ + +/***************************************************************************** +** +** Function btif_sm_init +** +** Description Initializes the state machine with the state handlers +** The caller should ensure that the table and the corresponding +** states match. The location that 'p_handlers' points to shall +** be available until the btif_sm_shutdown API is invoked. +** +** Returns Returns a pointer to the initialized state machine handle. +** +******************************************************************************/ +btif_sm_handle_t btif_sm_init(const btif_sm_handler_t *p_handlers, + btif_sm_state_t initial_state); + +/***************************************************************************** +** +** Function btif_sm_shutdown +** +** Description Tears down the state machine +** +** Returns None +** +******************************************************************************/ +void btif_sm_shutdown(btif_sm_handle_t handle); + +/***************************************************************************** +** +** Function btif_sm_get_state +** +** Description Fetches the current state of the state machine +** +** Returns Current state +** +******************************************************************************/ +btif_sm_state_t btif_sm_get_state(btif_sm_handle_t handle); + +/***************************************************************************** +** +** Function btif_sm_dispatch +** +** Description Dispatches the 'event' along with 'data' to the current state handler +** +** Returns Returns BT_STATUS_OK on success, BT_STATUS_FAIL otherwise +** +******************************************************************************/ +bt_status_t btif_sm_dispatch(btif_sm_handle_t handle, btif_sm_event_t event, + void *data); + +/***************************************************************************** +** +** Function btif_sm_change_state +** +** Description Make a transition to the new 'state'. The 'BTIF_SM_EXIT_EVT' +** shall be invoked before exiting the current state. The +** 'BTIF_SM_ENTER_EVT' shall be invoked before entering the new state +** +** +** Returns Returns BT_STATUS_OK on success, BT_STATUS_FAIL otherwise +** +******************************************************************************/ +bt_status_t btif_sm_change_state(btif_sm_handle_t handle, btif_sm_state_t state); + +#endif /* BTIF_SM_H */ + + diff --git a/btif/include/btif_util.h b/btif/include/btif_util.h index 95a1279..d455e9e 100644 --- a/btif/include/btif_util.h +++ b/btif/include/btif_util.h @@ -94,6 +94,8 @@ const char* dump_hf_audio_state(UINT16 event); const char* dump_adapter_scan_mode(bt_scan_mode_t mode); const char* dump_thread_evt(bt_cb_thread_evt evt); +const char* dump_av_conn_state(UINT16 event); + int str2bd(char *str, bt_bdaddr_t *addr); char *bd2str(bt_bdaddr_t *addr, bdstr_t *bdstr); diff --git a/btif/src/bluetooth.c b/btif/src/bluetooth.c index c323c70..0b839ac 100644 --- a/btif/src/bluetooth.c +++ b/btif/src/bluetooth.c @@ -59,6 +59,7 @@ #include <hardware/bluetooth.h> #include <hardware/bt_hf.h> +#include <hardware/bt_av.h> #define LOG_NDDEBUG 0 #define LOG_TAG "bluedroid" @@ -93,6 +94,8 @@ bt_callbacks_t *bt_hal_cbacks = NULL; /* handsfree profile */ extern bthf_interface_t *btif_hf_get_interface(); +/* advanced audio profile */ +extern btav_interface_t *btif_av_get_interface(); /************************************************************************************ ** Functions @@ -294,12 +297,16 @@ static const void* get_profile_interface (const char *profile_id) { LOGI("get_profile_interface %s", profile_id); + /* sanity check */ + if (interface_ready() == FALSE) + return NULL; + /* check for supported profile interfaces */ if (is_profile(profile_id, BT_PROFILE_HANDSFREE_ID)) return btif_hf_get_interface(); if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID)) - return NULL; + return btif_av_get_interface(); return NULL; } diff --git a/btif/src/btif_av.c b/btif/src/btif_av.c new file mode 100644 index 0000000..d383926 --- /dev/null +++ b/btif/src/btif_av.c @@ -0,0 +1,544 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + + +/***************************************************************************** + * + * Filename: btif_av.c + * + * Description: Bluedroid AV implementation + * + *****************************************************************************/ +#include <hardware/bluetooth.h> +#include "hardware/bt_av.h" + +#define LOG_TAG "BTIF_AV" +#include "btif_common.h" +#include "btif_sm.h" +#include "bta_api.h" +#include "bta_av_api.h" +#include "gki.h" + +/***************************************************************************** +** Constants & Macros +******************************************************************************/ +#define BTIF_AV_SERVICE_NAME "Advanced Audio" + +typedef enum { + BTIF_AV_STATE_IDLE = 0x0, + BTIF_AV_STATE_OPENING, + BTIF_AV_STATE_OPENED, + BTIF_AV_STATE_STARTED +} btif_av_state_t; + +typedef enum { + /* Reuse BTA_AV_XXX_EVT - No need to redefine them here */ + BTIF_AV_CONNECT_REQ_EVT = BTA_AV_MAX_EVT, + BTIF_AV_DISCONNECT_REQ_EVT, + BTIF_AV_START_STREAM_REQ_EVT, + BTIF_AV_STOP_STREAM_REQ_EVT, + BTIF_AV_SUSPEND_STREAM_REQ_EVT, + BTIF_AV_RECONFIGURE_REQ_EVT, +} btif_av_sm_event_t; +/***************************************************************************** +** Local type definitions +******************************************************************************/ +typedef struct +{ + tBTA_AV_HNDL bta_handle; + bt_bdaddr_t peer_bda; + btif_sm_handle_t sm_handle; +} btif_av_cb_t; +/***************************************************************************** +** Static variables +******************************************************************************/ +static btav_callbacks_t *bt_av_callbacks = NULL; +static btif_av_cb_t btif_av_cb; + +#define CHECK_BTAV_INIT() if (bt_av_callbacks == NULL)\ +{\ + BTIF_TRACE_WARNING1("%s: BTAV not initialized", __FUNCTION__);\ + return BT_STATUS_NOT_READY;\ +}\ +else\ +{\ + BTIF_TRACE_EVENT1("%s", __FUNCTION__);\ +} + +static BOOLEAN btif_av_state_idle_handler(btif_sm_event_t event, void *data); +static BOOLEAN btif_av_state_opening_handler(btif_sm_event_t event, void *data); +static BOOLEAN btif_av_state_opened_handler(btif_sm_event_t event, void *data); +static BOOLEAN btif_av_state_started_handler(btif_sm_event_t event, void *data); + +static const btif_sm_handler_t btif_av_state_handlers[] = +{ + btif_av_state_idle_handler, + btif_av_state_opening_handler, + btif_av_state_opened_handler, + btif_av_state_started_handler +}; + + +/***************************************************************************** +** Local helper functions +******************************************************************************/ +const char *dump_av_sm_state_name(btif_av_state_t state) +{ + switch (state) { + case BTIF_AV_STATE_IDLE: return "BTIF_AV_STATE_IDLE"; + case BTIF_AV_STATE_OPENING: return "BTIF_AV_STATE_OPENING"; + case BTIF_AV_STATE_OPENED: return "BTIF_AV_STATE_OPENED"; + case BTIF_AV_STATE_STARTED: return "BTIF_AV_STATE_STARTED"; + default: return "UNKNOWN_STATE"; + } +} + +const char *dump_av_sm_event_name(btif_av_sm_event_t event) +{ + switch(event) { + case BTA_AV_ENABLE_EVT: return "BTA_AV_ENABLE_EVT"; + case BTA_AV_REGISTER_EVT: return "BTA_AV_REGISTER_EVT"; + case BTA_AV_OPEN_EVT: return "BTA_AV_OPEN_EVT"; + case BTA_AV_CLOSE_EVT: return "BTA_AV_CLOSE_EVT"; + case BTA_AV_START_EVT: return "BTA_AV_START_EVT"; + case BTA_AV_STOP_EVT: return "BTA_AV_STOP_EVT"; + case BTA_AV_PROTECT_REQ_EVT: return "BTA_AV_PROTECT_REQ_EVT"; + case BTA_AV_PROTECT_RSP_EVT: return "BTA_AV_PROTECT_RSP_EVT"; + case BTA_AV_RC_OPEN_EVT: return "BTA_AV_RC_OPEN_EVT"; + case BTA_AV_RC_CLOSE_EVT: return "BTA_AV_RC_CLOSE_EVT"; + case BTA_AV_REMOTE_CMD_EVT: return "BTA_AV_REMOTE_CMD_EVT"; + case BTA_AV_REMOTE_RSP_EVT: return "BTA_AV_REMOTE_RSP_EVT"; + case BTA_AV_VENDOR_CMD_EVT: return "BTA_AV_VENDOR_CMD_EVT"; + case BTA_AV_VENDOR_RSP_EVT: return "BTA_AV_VENDOR_RSP_EVT"; + case BTA_AV_RECONFIG_EVT: return "BTA_AV_RECONFIG_EVT"; + case BTA_AV_SUSPEND_EVT: return "BTA_AV_SUSPEND_EVT"; + case BTA_AV_PENDING_EVT: return "BTA_AV_PENDING_EVT"; + case BTA_AV_META_MSG_EVT: return "BTA_AV_META_MSG_EVT"; + case BTA_AV_REJECT_EVT: return "BTA_AV_REJECT_EVT"; + case BTA_AV_RC_FEAT_EVT: return "BTA_AV_RC_FEAT_EVT"; + + case BTIF_SM_ENTER_EVT: return "BTIF_SM_ENTER_EVT"; + case BTIF_SM_EXIT_EVT: return "BTIF_SM_EXIT_EVT"; + case BTIF_AV_CONNECT_REQ_EVT: return "BTIF_AV_CONNECT_REQ_EVT"; + case BTIF_AV_DISCONNECT_REQ_EVT: return "BTIF_AV_DISCONNECT_REQ_EVT"; + case BTIF_AV_START_STREAM_REQ_EVT: return "BTIF_AV_START_STREAM_REQ_EVT"; + case BTIF_AV_STOP_STREAM_REQ_EVT: return "BTIF_AV_STOP_STREAM_REQ_EVT"; + case BTIF_AV_SUSPEND_STREAM_REQ_EVT: return "BTIF_AV_SUSPEND_STREAM_REQ_EVT"; + case BTIF_AV_RECONFIGURE_REQ_EVT: return "BTIF_AV_RECONFIGURE_REQ_EVT"; + default: return "UNKNOWN_EVENT"; + } +} + +/***************************************************************************** +** Static functions +******************************************************************************/ + +void btif_a2dp_set_busy_level(UINT8 level); +void btif_a2dp_upon_init(void); +void btif_a2dp_upon_idle(void); +void btif_a2dp_upon_start_req(void); +void btif_a2dp_upon_started(void); +int btif_a2dp_start_media_task(void); +void btif_a2dp_stop_media_task(void); + +static BOOLEAN btif_av_state_idle_handler(btif_sm_event_t event, void *p_data) +{ + BTIF_TRACE_DEBUG2("%s event:%s", __FUNCTION__, dump_av_sm_event_name(event)); + + switch (event) + { + case BTIF_SM_ENTER_EVT: + { + /* clear the peer_bda */ + memset(&btif_av_cb.peer_bda, 0, sizeof(bt_bdaddr_t)); + btif_a2dp_upon_idle(); + } break; + + case BTIF_SM_EXIT_EVT: + break; + + case BTA_AV_ENABLE_EVT: + { + BTA_AvRegister(BTA_AV_CHNL_AUDIO, BTIF_AV_SERVICE_NAME, 0); + } break; + + case BTA_AV_REGISTER_EVT: + { + btif_av_cb.bta_handle = ((tBTA_AV*)p_data)->registr.hndl; + } break; + + case BTIF_AV_CONNECT_REQ_EVT: + { + memcpy(&btif_av_cb.peer_bda, (bt_bdaddr_t*)p_data, sizeof(bt_bdaddr_t)); + + BTA_AvOpen(btif_av_cb.peer_bda.address, btif_av_cb.bta_handle, + TRUE, BTA_SEC_NONE); + + btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_OPENING); + } break; + + default: + BTIF_TRACE_WARNING2("%s Unhandled event:%s", __FUNCTION__, + dump_av_sm_event_name(event)); + } + return TRUE; +} + + +static BOOLEAN btif_av_state_opening_handler(btif_sm_event_t event, void *p_data) +{ + BTIF_TRACE_DEBUG2("%s event:%s", __FUNCTION__, dump_av_sm_event_name(event)); + + switch (event) + { + case BTIF_SM_ENTER_EVT: + { + /* inform the application that we are entering connecting state */ + CHECK_CALL_CBACK(bt_av_callbacks, connection_state_cb, + BTAV_CONNECTION_STATE_CONNECTING, &(btif_av_cb.peer_bda)); + } break; + + case BTIF_SM_EXIT_EVT: + break; + + case BTA_AV_OPEN_EVT: + { + tBTA_AV *p_bta_data = (tBTA_AV*)p_data; + btav_connection_state_t state = BTAV_CONNECTION_STATE_DISCONNECTED; + BTIF_TRACE_DEBUG1("status:%d", p_bta_data->open.status); + if (p_bta_data->open.status == BTA_AV_SUCCESS) + { + state = BTAV_CONNECTION_STATE_CONNECTED; + /* change state to open */ + btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_OPENED); + } + else + { + BTIF_TRACE_WARNING1("BTA_AV_OPEN_EVT::FAILED status: %d", + p_bta_data->open.status ); + /* change state to idle */ + btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_IDLE); + } + /* inform the application of the event */ + CHECK_CALL_CBACK(bt_av_callbacks, connection_state_cb, + state, &(btif_av_cb.peer_bda)); + } break; + + default: + BTIF_TRACE_WARNING2("%s Unhandled event:%s", __FUNCTION__, + dump_av_sm_event_name(event)); + } + return TRUE; +} + + +static BOOLEAN btif_av_state_opened_handler(btif_sm_event_t event, void *p_data) +{ + BTIF_TRACE_DEBUG2("%s event:%s", __FUNCTION__, dump_av_sm_event_name(event)); + + switch (event) + { + case BTIF_SM_ENTER_EVT: + + BTIF_TRACE_DEBUG0("starting av"); + + btif_a2dp_upon_start_req(); + + /* autostart for now to test media task */ + BTA_AvStart(); + + break; + + case BTIF_SM_EXIT_EVT: + break; + + case BTIF_AV_START_STREAM_REQ_EVT: + /* fixme */ + break; + + case BTA_AV_START_EVT: + { + tBTA_AV *p_bta_data = (tBTA_AV*)p_data; + + if (p_bta_data->start.status == BTA_AV_SUCCESS) + { + /* change state to started */ + btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_STARTED); + } + else + { + /* fixme */ + } + } break; + + case BTIF_AV_DISCONNECT_REQ_EVT: + { + BTA_AvClose(btif_av_cb.bta_handle); + /* inform the application that we are disconnecting */ + CHECK_CALL_CBACK(bt_av_callbacks, connection_state_cb, + BTAV_CONNECTION_STATE_DISCONNECTING, &(btif_av_cb.peer_bda)); + } break; + + case BTA_AV_CLOSE_EVT: + { + /* inform the application that we are disconnecting */ + CHECK_CALL_CBACK(bt_av_callbacks, connection_state_cb, + BTAV_CONNECTION_STATE_DISCONNECTED, &(btif_av_cb.peer_bda)); + btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_IDLE); + } break; + + default: + BTIF_TRACE_WARNING2("%s Unhandled event:%s", __FUNCTION__, + dump_av_sm_event_name(event)); + } + return TRUE; +} + +static BOOLEAN btif_av_state_started_handler(btif_sm_event_t event, void *data) +{ + BTIF_TRACE_DEBUG2("%s event:%s", __FUNCTION__, dump_av_sm_event_name(event)); + + switch (event) + { + case BTIF_SM_ENTER_EVT: + btif_a2dp_upon_started(); + break; + + case BTIF_SM_EXIT_EVT: + break; + case BTIF_AV_DISCONNECT_REQ_EVT: + { + BTA_AvClose(btif_av_cb.bta_handle); + /* inform the application that we are disconnecting */ + CHECK_CALL_CBACK(bt_av_callbacks, connection_state_cb, + BTAV_CONNECTION_STATE_DISCONNECTING, &(btif_av_cb.peer_bda)); + } break; + + case BTA_AV_STOP_EVT: + { + /* inform the application that we are disconnecting */ + btif_sm_change_state(btif_av_cb.sm_handle, BTIF_AV_STATE_OPENED); + } break; + + default: + BTIF_TRACE_WARNING2("%s Unhandled event:%s", __FUNCTION__, + dump_av_sm_event_name(event)); + } + return TRUE; +} + +static void btif_av_handle_event(UINT16 event, char* p_param) +{ + btif_sm_dispatch(btif_av_cb.sm_handle, event, (void*)p_param); +} + +static void bte_av_callback(tBTA_AV_EVT event, tBTA_AV *p_data) +{ + /* Switch to BTIF context */ + btif_transfer_context(btif_av_handle_event, event, + (char*)p_data, sizeof(tBTA_AV), NULL); +} +/***************************************************************************** +** Externs +******************************************************************************/ + +/***************************************************************************** +** Functions +******************************************************************************/ + +/******************************************************************************* +** +** Function init +** +** Description Initializes the AV interface +** +** Returns bt_status_t +** +*******************************************************************************/ + +static bt_status_t init(btav_callbacks_t* callbacks ) +{ + int status; + + BTIF_TRACE_EVENT1("%s", __FUNCTION__); + + status = btif_a2dp_start_media_task(); + + if (status != GKI_SUCCESS) + return BT_STATUS_FAIL; + + bt_av_callbacks = callbacks; + + btif_enable_service(BTA_A2DP_SERVICE_ID); + /* Also initialize the AV state machine */ + btif_av_cb.sm_handle = btif_sm_init((const btif_sm_handler_t*)btif_av_state_handlers, BTIF_AV_STATE_IDLE); + + btif_a2dp_upon_init(); + + return BT_STATUS_SUCCESS; +} + +/******************************************************************************* +** +** Function connect +** +** Description Establishes the AV signalling channel with the remote headset +** +** Returns bt_status_t +** +*******************************************************************************/ +static bt_status_t connect(bt_bdaddr_t *bd_addr) +{ + BTIF_TRACE_EVENT1("%s", __FUNCTION__); + + BTIF_TRACE_ERROR1("callbacks is 0x%x", bt_av_callbacks); + CHECK_BTAV_INIT(); + + /* Switch to BTIF context */ + return btif_transfer_context(btif_av_handle_event, BTIF_AV_CONNECT_REQ_EVT, + (char*)bd_addr, sizeof(bt_bdaddr_t), NULL); +} + +/******************************************************************************* +** +** Function disconnect +** +** Description Tears down the AV signalling channel with the remote headset +** +** Returns bt_status_t +** +*******************************************************************************/ +static bt_status_t disconnect(bt_bdaddr_t *bd_addr) +{ + BTIF_TRACE_EVENT1("%s", __FUNCTION__); + + CHECK_BTAV_INIT(); + + /* Switch to BTIF context */ + return btif_transfer_context(btif_av_handle_event, BTIF_AV_DISCONNECT_REQ_EVT, + (char*)bd_addr, sizeof(bt_bdaddr_t), NULL); +} + +/******************************************************************************* +** +** Function cleanup +** +** Description Shuts down the AV interface and does the cleanup +** +** Returns None +** +*******************************************************************************/ +static void cleanup(void) +{ + BTIF_TRACE_EVENT1("%s", __FUNCTION__); + + if (bt_av_callbacks) + { + btif_a2dp_stop_media_task(); + + btif_disable_service(BTA_A2DP_SERVICE_ID); + bt_av_callbacks = NULL; + + /* Also shut down the AV state machine */ + btif_sm_shutdown(btif_av_cb.sm_handle); + btif_av_cb.sm_handle = NULL; + } + return; +} + +static const btav_interface_t bt_av_interface = { + sizeof(btav_interface_t), + init, + connect, + disconnect, + cleanup, +}; + +/******************************************************************************* +** +** Function btif_av_execute_service +** +** Description Initializes/Shuts down the service +** +** Returns BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise +** +*******************************************************************************/ +bt_status_t btif_av_execute_service(BOOLEAN b_enable) +{ + if (b_enable) + { +#if (AVRC_METADATA_INCLUDED == TRUE) + BTA_AvEnable(BTA_SEC_AUTHENTICATE|BTA_SEC_AUTHORIZE, + BTA_AV_FEAT_RCTG|BTA_AV_FEAT_METADATA|BTA_AV_FEAT_VENDOR, + bte_av_callback); +#else + BTA_AvEnable(BTA_SEC_AUTHENTICATE|BTA_SEC_AUTHORIZE, BTA_AV_FEAT_RCTG, + bte_av_callback); +#endif + BTA_AvRegister(BTA_AV_CHNL_AUDIO, BTIF_AV_SERVICE_NAME, 0); + } + else { + BTA_AvDeregister(btif_av_cb.bta_handle); + BTA_AvDisable(); + } + return BT_STATUS_SUCCESS; +} + +/******************************************************************************* +** +** Function btif_av_get_interface +** +** Description Get the AV callback interface +** +** Returns btav_interface_t +** +*******************************************************************************/ +const btav_interface_t *btif_av_get_interface() +{ + BTIF_TRACE_EVENT1("%s", __FUNCTION__); + return &bt_av_interface; +} diff --git a/btif/src/btif_core.c b/btif/src/btif_core.c index 022e1f4..e3d1866 100644 --- a/btif/src/btif_core.c +++ b/btif/src/btif_core.c @@ -73,13 +73,13 @@ ************************************************************************************/ #ifndef BTIF_TASK_STACK_SIZE -#define BTIF_TASK_STACK_SIZE 0//0x2000 /* In bytes */ +#define BTIF_TASK_STACK_SIZE 0x2000 /* In bytes */ #endif #define BTIF_TASK_STR ((INT8 *) "BTIF") - static UINT32 btif_task_stack[(BTIF_TASK_STACK_SIZE + 3) / 4]; + /* checks whether any HAL operation other than enable is permitted */ static int btif_enabled = 0; static int btif_shutdown_pending = 0; @@ -317,7 +317,7 @@ bt_status_t btif_init_bluetooth(void) bte_main_boot_entry(); - /* Start the BTIF task */ + /* start btif task */ status = GKI_create_task(btif_task, BTIF_TASK, BTIF_TASK_STR, (UINT16 *) ((UINT8 *)btif_task_stack + BTIF_TASK_STACK_SIZE), sizeof(btif_task_stack)); diff --git a/btif/src/btif_dm.c b/btif/src/btif_dm.c index 9626457..5df537c 100755 --- a/btif/src/btif_dm.c +++ b/btif/src/btif_dm.c @@ -97,6 +97,7 @@ static bt_status_t btif_dm_get_remote_services(bt_bdaddr_t *remote_addr); ******************************************************************************/ extern UINT16 bta_service_id_to_uuid_lkup_tbl [BTA_MAX_SERVICE_ID]; extern bt_status_t btif_hf_execute_service(BOOLEAN b_enable); +extern bt_status_t btif_av_execute_service(BOOLEAN b_enable); /****************************************************************************** ** Functions @@ -112,6 +113,10 @@ bt_status_t btif_in_execute_service_request(tBTA_SERVICE_ID service_id, { btif_hf_execute_service(b_enable); }break; + case BTA_A2DP_SERVICE_ID: + { + btif_av_execute_service(b_enable); + }break; default: BTIF_TRACE_ERROR1("%s: Unknown service being enabled", __FUNCTION__); return BT_STATUS_FAIL; @@ -604,6 +609,10 @@ static void btif_dm_search_services_evt(UINT16 event, char *p_param) } break; + case BTA_DM_DISC_CMPL_EVT: + /* fixme */ + break; + default: { ASSERTC(0, "unhandled search services event", event); @@ -1078,6 +1087,7 @@ bt_status_t btif_dm_pin_reply( const bt_bdaddr_t *bd_addr, uint8_t accept, return BT_STATUS_SUCCESS; } + /******************************************************************************* ** ** Function btif_dm_ssp_reply diff --git a/btif/src/btif_media_task.c b/btif/src/btif_media_task.c new file mode 100644 index 0000000..e11d307 --- /dev/null +++ b/btif/src/btif_media_task.c @@ -0,0 +1,1726 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + +/****************************************************************************** + ** + ** Name: btif_media_task.c + ** + ** Description: This is the multimedia module for the BTIF system. It + ** contains task implementations AV, HS and HF profiles + ** audio & video processing + ** + ******************************************************************************/ + +#include <string.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <pthread.h> +#include <stdint.h> +#include <sys/time.h> + +#include "bt_target.h" +#include "gki.h" +#include "bta_api.h" +#include "btu.h" +#include "bta_sys.h" +#include "bta_sys_int.h" + +#include "bta_av_api.h" +#include "a2d_api.h" +#include "a2d_sbc.h" +#include "a2d_int.h" +#include "bta_av_sbc.h" +#include "bta_av_ci.h" +#include "l2c_api.h" + + +#include "btif_av.h" +#include "btif_media.h" + + +#if (BTA_AV_INCLUDED == TRUE) +#include "sbc_encoder.h" +#endif + + + +/***************************************************************************** + ** Constants + *****************************************************************************/ + +//#define DEBUG_MEDIA_AV_FLOW TRUE + +/* BTIF media task gki event definition */ +#define BTIF_MEDIA_TASK_CMD TASK_MBOX_0_EVT_MASK +#define BTIF_MEDIA_TASK_DATA TASK_MBOX_1_EVT_MASK + +#define BTIF_MEDIA_TASK_KILL TASK_MBOX_3_EVT_MASK + +#define BTIF_MEDIA_AA_TASK_TIMER_ID TIMER_0 +#define BTIF_MEDIA_AV_TASK_TIMER_ID TIMER_1 +#define BTIF_MEDIA_AA_TASK_TIMER TIMER_0_EVT_MASK +#define BTIF_MEDIA_AV_TASK_TIMER TIMER_1_EVT_MASK + +#define BTIF_MEDIA_TASK_CMD_MBOX TASK_MBOX_0 /* cmd mailbox */ +#define BTIF_MEDIA_TASK_DATA_MBOX TASK_MBOX_1 /* data mailbox */ + +/* BTIF media cmd event definition : BTIF_MEDIA_TASK_CMD */ +enum +{ + BTIF_MEDIA_START_AA_TX = 1, + BTIF_MEDIA_STOP_AA_TX, + BTIF_MEDIA_AA_RX_RDY, + BTIF_MEDIA_UIPC_RX_RDY, + BTIF_MEDIA_SBC_ENC_INIT, + BTIF_MEDIA_SBC_ENC_UPDATE, + BTIF_MEDIA_SBC_DEC_INIT, + BTIF_MEDIA_VIDEO_DEC_INIT, + BTIF_MEDIA_FLUSH_AA_TX, + BTIF_MEDIA_FLUSH_AA_RX, + BTIF_MEDIA_AUDIO_FEEDING_INIT, + BTIF_MEDIA_AUDIO_RECEIVING_INIT +}; + + +/* Macro to multiply the media task tick */ +#ifndef BTIF_MEDIA_NUM_TICK +#define BTIF_MEDIA_NUM_TICK 1 +#endif + +/* Media task tick in milliseconds */ +#define BTIF_MEDIA_TIME_TICK (40 * BTIF_MEDIA_NUM_TICK) + +/* Number of frames per media task tick */ +#define BTIF_MEDIA_FR_PER_TICKS_48 (15 * BTIF_MEDIA_NUM_TICK) +#define BTIF_MEDIA_FR_PER_TICKS_44_1_H (14 * BTIF_MEDIA_NUM_TICK) +#define BTIF_MEDIA_FR_PER_TICKS_44_1_L (13 * BTIF_MEDIA_NUM_TICK) +#define BTIF_MEDIA_FR_PER_TICKS_32 (10 * BTIF_MEDIA_NUM_TICK) +#define BTIF_MEDIA_FR_PER_TICKS_16 ( 5 * BTIF_MEDIA_NUM_TICK) + + +/* buffer pool */ +#define BTIF_MEDIA_AA_POOL_ID GKI_POOL_ID_3 +#define BTIF_MEDIA_AA_BUF_SIZE GKI_BUF3_SIZE + +/* offset */ +#if (BTA_AV_CO_CP_SCMS_T == TRUE) +#define BTIF_MEDIA_AA_SBC_OFFSET (AVDT_MEDIA_OFFSET + BTA_AV_SBC_HDR_SIZE + 1) +#else +#define BTIF_MEDIA_AA_SBC_OFFSET (AVDT_MEDIA_OFFSET + BTA_AV_SBC_HDR_SIZE) +#endif + +/* Define the bitrate step when trying to match bitpool value */ +#ifndef BTIF_MEDIA_BITRATE_STEP +#define BTIF_MEDIA_BITRATE_STEP 10 +#endif + + + +#define DEFAULT_SBC_BITRATE 220 + + +/***************************************************************************** + ** Data types + *****************************************************************************/ + +typedef struct +{ + UINT32 aa_frame_counter; + INT32 aa_feed_counter; + INT32 aa_feed_residue; +} tBTIF_AV_MEDIA_FEEDINGS_PCM_STATE; + + +typedef union +{ + tBTIF_AV_MEDIA_FEEDINGS_PCM_STATE pcm; +} tBTIF_AV_MEDIA_FEEDINGS_STATE; + +typedef struct +{ +#if (BTA_AV_INCLUDED == TRUE) + BUFFER_Q TxAaQ; + BOOLEAN is_tx_timer; + UINT16 TxAaMtuSize; + UINT32 timestamp; + UINT8 TxTranscoding; + tBTIF_AV_FEEDING_MODE feeding_mode; + tBTIF_AV_MEDIA_FEEDINGS media_feeding; + tBTIF_AV_MEDIA_FEEDINGS_STATE media_feeding_state; + SBC_ENC_PARAMS encoder; + UINT8 busy_level; +#if ((defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE)) || \ + (defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE))) + UINT8 tx_counter; +#endif +#endif + +} tBTIF_MEDIA_CB; + +/***************************************************************************** + ** Local data + *****************************************************************************/ + +static tBTIF_MEDIA_CB btif_media_cb; + +/***************************************************************************** + ** Local functions + *****************************************************************************/ + +static void btif_media_task_handle_cmd(BT_HDR *p_msg); +static void btif_media_task_handle_media(BT_HDR *p_msg); + +#if (BTA_AV_INCLUDED == TRUE) +static void btif_media_send_aa_frame(void); +static void btif_media_task_feeding_state_reset(void); +static void btif_media_task_aa_start_tx(void); +static void btif_media_task_aa_stop_tx(void); +static void btif_media_task_enc_init(BT_HDR *p_msg); +static void btif_media_task_enc_update(BT_HDR *p_msg); +static void btif_media_task_audio_feeding_init(BT_HDR *p_msg); +static void btif_media_task_aa_tx_flush(BT_HDR *p_msg); +static void btif_media_aa_prep_2_send(UINT8 nb_frame); +#endif + + +/***************************************************************************** + ** + *****************************************************************************/ + +#define UIPC_CH_ID_AV_AUDIO 0 + +/* Events generated */ +#define UIPC_OPEN_EVT 0x01 +#define UIPC_CLOSE_EVT 0x02 +#define UIPC_RX_DATA_EVT 0x03 +#define UIPC_RX_DATA_READY_EVT 0x04 +#define UIPC_TX_DATA_READY_EVT 0x05 + +#ifndef A2DP_MEDIA_TASK_STACK_SIZE +#define A2DP_MEDIA_TASK_STACK_SIZE 0x2000 /* In bytes */ +#endif + +#define A2DP_MEDIA_TASK_TASK_STR ((INT8 *) "A2DP-MEDIA") +static UINT32 a2dp_media_task_stack[(A2DP_MEDIA_TASK_STACK_SIZE + 3) / 4]; + +#define BT_MEDIA_TASK A2DP_MEDIA_TASK + +#define CASE_RETURN_STR(const) case const: return #const; + + +#define USEC_PER_SEC 1000000L +#define TPUT_STATS_INTERVAL_US (1000*1000) + +typedef struct { + int rx; + int rx_tot; + int tx; + int tx_tot; + int ts_prev_us; +} t_stat; + +static void tput_mon(int is_rx, int len, int reset) +{ + /* only monitor one connection at a time for now */ + static t_stat cur_stat; + struct timespec now; + unsigned int prev_us; + unsigned int now_us; + + if (reset == TRUE) + { + memset(&cur_stat, 0, sizeof(t_stat)); + return; + } + + if (is_rx) + { + cur_stat.rx+=len; + cur_stat.rx_tot+=len; + } + else + { + cur_stat.tx+=len; + cur_stat.tx_tot+=len; + } + clock_gettime(CLOCK_MONOTONIC, &now); + + now_us = now.tv_sec*USEC_PER_SEC + now.tv_nsec/1000; + + //APPL_TRACE_EVENT1("%d us", now_us - cur_stat.ts_prev_us); + + if ((now_us - cur_stat.ts_prev_us) < TPUT_STATS_INTERVAL_US) + return; + + APPL_TRACE_WARNING4("tput rx:%d, tx:%d (kB/s) (tot : rx %d, tx %d bytes)", + (cur_stat.rx)/((now_us - cur_stat.ts_prev_us)/1000), + (cur_stat.tx)/((now_us - cur_stat.ts_prev_us)/1000), + cur_stat.rx_tot, cur_stat.tx_tot); + + /* stats dumped. now reset stats for next interval */ + cur_stat.rx = 0; + cur_stat.tx = 0; + cur_stat.ts_prev_us = now_us; +} + + +void log_tstamps_us(char *comment) +{ + #define USEC_PER_SEC 1000000L + static struct timespec prev = {0, 0}; + struct timespec now, diff; + unsigned int diff_us = 0; + unsigned int now_us = 0; + + clock_gettime(CLOCK_MONOTONIC, &now); + now_us = now.tv_sec*USEC_PER_SEC + now.tv_nsec/1000; + diff_us = (now.tv_sec - prev.tv_sec) * USEC_PER_SEC + (now.tv_nsec - prev.tv_nsec)/1000; + + APPL_TRACE_EVENT3("[%s] ts %08d, diff : %08d", comment, now_us, diff_us); + + prev = now; +} + +const char* dump_media_event(UINT16 event) +{ + switch(event) + { + CASE_RETURN_STR(BTIF_MEDIA_START_AA_TX) + CASE_RETURN_STR(BTIF_MEDIA_STOP_AA_TX) + CASE_RETURN_STR(BTIF_MEDIA_AA_RX_RDY) + CASE_RETURN_STR(BTIF_MEDIA_UIPC_RX_RDY) + CASE_RETURN_STR(BTIF_MEDIA_SBC_ENC_INIT) + CASE_RETURN_STR(BTIF_MEDIA_SBC_ENC_UPDATE) + CASE_RETURN_STR(BTIF_MEDIA_SBC_DEC_INIT) + CASE_RETURN_STR(BTIF_MEDIA_VIDEO_DEC_INIT) + CASE_RETURN_STR(BTIF_MEDIA_FLUSH_AA_TX) + CASE_RETURN_STR(BTIF_MEDIA_FLUSH_AA_RX) + CASE_RETURN_STR(BTIF_MEDIA_AUDIO_FEEDING_INIT) + CASE_RETURN_STR(BTIF_MEDIA_AUDIO_RECEIVING_INIT) + + default: + return "UNKNOWN MEDIA EVENT"; + } +} + +void btif_av_encoder_init(void) +{ + UINT16 minmtu; + tBTIF_MEDIA_INIT_AUDIO msg; + tA2D_SBC_CIE sbc_config; + + /* lookup table for converting channel mode */ + UINT16 codec_mode_tbl[5] = { SBC_JOINT_STEREO, SBC_STEREO, SBC_DUAL, 0, SBC_MONO }; + + /* lookup table for converting number of blocks */ + UINT16 codec_block_tbl[5] = { 16, 12, 8, 0, 4 }; + + /* lookup table to convert freq */ + UINT16 freq_block_tbl[5] = { SBC_sf48000, SBC_sf44100, SBC_sf32000, 0, SBC_sf16000 }; + + APPL_TRACE_DEBUG0("btif_av_encoder_init"); + + /* Retrieve the current SBC configuration (default if currently not used) */ + bta_av_co_audio_get_sbc_config(&sbc_config, &minmtu); + msg.NumOfSubBands = (sbc_config.num_subbands == A2D_SBC_IE_SUBBAND_4) ? 4 : 8; + msg.NumOfBlocks = codec_block_tbl[sbc_config.block_len >> 5]; + msg.AllocationMethod = (sbc_config.alloc_mthd == A2D_SBC_IE_ALLOC_MD_L) ? SBC_LOUDNESS : SBC_SNR; + msg.ChannelMode = codec_mode_tbl[sbc_config.ch_mode >> 1]; + msg.SamplingFreq = freq_block_tbl[sbc_config.samp_freq >> 5]; + msg.MtuSize = minmtu; + + /* Init the media task to encode SBC properly */ + btif_media_task_enc_init_req(&msg); +} + +static void btif_av_encoder_update(void) +{ + UINT16 minmtu; + tA2D_SBC_CIE sbc_config; + tBTIF_MEDIA_UPDATE_AUDIO msg; + + APPL_TRACE_DEBUG0("btif_av_encoder_update"); + + /* Retrieve the current SBC configuration (default if currently not used) */ + bta_av_co_audio_get_sbc_config(&sbc_config, &minmtu); + + APPL_TRACE_DEBUG4("btif_av_encoder_update: Common min_bitpool:%d(0x%x) max_bitpool:%d(0x%x)", + sbc_config.min_bitpool, sbc_config.min_bitpool, + sbc_config.max_bitpool, sbc_config.max_bitpool); + + if (sbc_config.min_bitpool > sbc_config.max_bitpool) + { + APPL_TRACE_ERROR0("btif_av_encoder_update: ERROR btif_av_encoder_update min_bitpool > max_bitpool"); + } + + msg.MinBitPool = sbc_config.min_bitpool; + msg.MaxBitPool = sbc_config.max_bitpool; + msg.MinMtuSize = minmtu; + /* Update the media task to encode SBC properly */ + btif_media_task_enc_update_req(&msg); +} + + +static int media_task_running = 0; + +int btif_a2dp_start_media_task(void) +{ + if (media_task_running) + { + APPL_TRACE_EVENT0("warning : media task already running"); + return GKI_FAILURE; + } + + media_task_running = 1; + + /* start a2dp media task */ + return GKI_create_task((TASKPTR)btif_media_task, A2DP_MEDIA_TASK, + A2DP_MEDIA_TASK_TASK_STR, + (UINT16 *) ((UINT8 *)a2dp_media_task_stack + A2DP_MEDIA_TASK_STACK_SIZE), + sizeof(a2dp_media_task_stack)); +} + +void btif_a2dp_stop_media_task(void) +{ + APPL_TRACE_EVENT1("%s", __FUNCTION__); + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_KILL, NULL); +} + +void btif_a2dp_upon_init(void) +{ + void btif_media_task_init(void); + btif_media_task_init(); + + //tput_mon(1, 0, 1); +} + +void btif_a2dp_upon_idle(void) +{ + APPL_TRACE_EVENT1("%s", __FUNCTION__); + + /* Make sure media task is stopped */ + btif_media_task_stop_aa_req(); + + bta_av_co_init(); +} + +void btif_a2dp_upon_start_req(void) +{ + tBTIF_AV_MEDIA_FEEDINGS media_feeding; + tBTIF_STATUS status; + + APPL_TRACE_EVENT1("%s", __FUNCTION__); + + GKI_disable(); + + /* for now hardcode 44.1 khz 16 bit stereo */ + media_feeding.cfg.pcm.sampling_freq = 44100; + media_feeding.cfg.pcm.bit_per_sample = 16; + media_feeding.cfg.pcm.num_channel = 2; + media_feeding.format = BTIF_AV_CODEC_PCM; + + if (bta_av_co_audio_set_codec(&media_feeding, &status)) + { + tBTIF_MEDIA_INIT_AUDIO_FEEDING mfeed; + + /* Init the encoding task */ + btif_av_encoder_init(); + + /* Build the media task configuration */ + mfeed.feeding = media_feeding; + mfeed.feeding_mode = BTIF_AV_FEEDING_ASYNCHRONOUS; + /* Send message to Media task to configure transcoding */ + btif_media_task_audio_feeding_init_req(&mfeed); + } + + GKI_enable(); +} + +void btif_a2dp_upon_started(void) +{ + APPL_TRACE_EVENT1("%s", __FUNCTION__); + btif_av_encoder_update(); + + /* Start the media task to encode SBC */ + btif_media_task_start_aa_req(); +} + +/******************************************************************************* + ** + ** Function btif_media_task_aa_handle_timer + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ + + +static void btif_media_task_aa_handle_timer(void) +{ +#if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) + static UINT16 Debug = 0; + APPL_TRACE_DEBUG1("btif_media_task_aa_handle_timer: %d", Debug++); +#endif + + //log_tstamps_us("timer"); + +#if (BTA_AV_INCLUDED == TRUE) + btif_media_send_aa_frame(); +#endif +} + +#if (BTA_AV_INCLUDED == TRUE) +/******************************************************************************* + ** + ** Function btif_media_task_aa_handle_timer + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_aa_handle_uipc_rx_rdy(void) +{ +#if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) + static UINT16 Debug = 0; + APPL_TRACE_DEBUG1("btif_media_task_aa_handle_uipc_rx_rdy: %d", Debug++); +#endif + + /* process all the UIPC data */ + btif_media_aa_prep_2_send(0xFF); + + /* send it */ + APPL_TRACE_DEBUG0("btif_media_task_aa_handle_uipc_rx_rdy calls bta_av_ci_src_data_ready"); + bta_av_ci_src_data_ready(BTA_AV_CHNL_AUDIO); +} +#endif + +/******************************************************************************* + ** + ** Function btif_media_task_init + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +void btif_media_task_init(void) +{ + memset(&(btif_media_cb), 0, sizeof(btif_media_cb)); + +#if (BTA_AV_INCLUDED == TRUE) + UIPC_Open(UIPC_CH_ID_AV_AUDIO , NULL); +#endif + +} +/******************************************************************************* + ** + ** Function btif_media_task + ** + ** Description Task for SBC encoder. This task receives an + ** event when the waveIn interface has a pcm data buffer + ** ready. On receiving the event, handle all ready pcm + ** data buffers. If stream is started, run the SBC encoder + ** on each chunk of pcm samples and build an output packet + ** consisting of one or more encoded SBC frames. + ** + ** Returns void + ** + *******************************************************************************/ +int btif_media_task(void *p) +{ + UINT16 event; + BT_HDR *p_msg; + + APPL_TRACE_EVENT0("MEDIA TASK STARTING"); + + btif_media_task_init(); + + while (1) + { + event = GKI_wait(0xffff, 0); + + if (event & BTIF_MEDIA_TASK_CMD) + { + /* Process all messages in the queue */ + while ((p_msg = (BT_HDR *) GKI_read_mbox(BTIF_MEDIA_TASK_CMD_MBOX)) != NULL) + { + btif_media_task_handle_cmd(p_msg); + } + } + + if (event & BTIF_MEDIA_TASK_DATA) + { + /* Process all messages in the queue */ + while ((p_msg = (BT_HDR *) GKI_read_mbox(BTIF_MEDIA_TASK_DATA_MBOX)) != NULL) + { + btif_media_task_handle_media(p_msg); + } + } + + if (event & BTIF_MEDIA_AA_TASK_TIMER) + { + /* advance audio timer expiration */ + btif_media_task_aa_handle_timer(); + } + + + /* When we get this event we exit the task - should only happen on GKI_shutdown */ + if (event & BTIF_MEDIA_TASK_KILL) + break; + + } + + APPL_TRACE_EVENT0("MEDIA TASK EXITING"); + + return 0; +} + + +/******************************************************************************* + ** + ** Function btif_media_task_send_cmd_evt + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_send_cmd_evt(UINT16 Evt) +{ + BT_HDR *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) + { + return FALSE; + } + + p_buf->event = Evt; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_flush_q + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_flush_q(BUFFER_Q *p_q) +{ + while (GKI_IS_QUEUE_EMPTY(p_q) == FALSE) + { + GKI_freebuf(GKI_dequeue(p_q)); + } +} + + +/******************************************************************************* + ** + ** Function btif_media_task_handle_cmd + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_handle_cmd(BT_HDR *p_msg) +{ + //APPL_TRACE_EVENT2("EVENT (%d) %s", p_msg->event, dump_media_event(p_msg->event)); + + switch (p_msg->event) + { +#if (BTA_AV_INCLUDED == TRUE) + case BTIF_MEDIA_START_AA_TX: + btif_media_task_aa_start_tx(); + break; + case BTIF_MEDIA_STOP_AA_TX: + btif_media_task_aa_stop_tx(); + break; + case BTIF_MEDIA_SBC_ENC_INIT: + btif_media_task_enc_init(p_msg); + break; + case BTIF_MEDIA_SBC_ENC_UPDATE: + btif_media_task_enc_update(p_msg); + break; + case BTIF_MEDIA_AUDIO_FEEDING_INIT: + btif_media_task_audio_feeding_init(p_msg); + break; + case BTIF_MEDIA_FLUSH_AA_TX: + btif_media_task_aa_tx_flush(p_msg); + break; + case BTIF_MEDIA_UIPC_RX_RDY: + btif_media_task_aa_handle_uipc_rx_rdy(); + break; +#endif + default: + APPL_TRACE_ERROR1("ERROR in btif_media_task_handle_cmd unknown event %d", p_msg->event); + } + GKI_freebuf(p_msg); + //APPL_TRACE_EVENT1("MEDIA TASK RX EVENT PROCESSED %s", dump_media_event(p_msg->event)); +} + +/******************************************************************************* + ** + ** Function btif_media_task_handle_media + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_handle_media(BT_HDR *p_msg) +{ + APPL_TRACE_ERROR0("ERROR btif_media_task_handle_media: TODO"); + + GKI_freebuf(p_msg); +} + + + + +#if (BTA_AV_INCLUDED == TRUE) +/******************************************************************************* + ** + ** Function btif_media_task_enc_init_req + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_enc_init_req(tBTIF_MEDIA_INIT_AUDIO *p_msg) +{ + tBTIF_MEDIA_INIT_AUDIO *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(tBTIF_MEDIA_INIT_AUDIO)))) + { + return FALSE; + } + + memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_INIT_AUDIO)); + p_buf->hdr.event = BTIF_MEDIA_SBC_ENC_INIT; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_task_enc_update_req + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_enc_update_req(tBTIF_MEDIA_UPDATE_AUDIO *p_msg) +{ + tBTIF_MEDIA_UPDATE_AUDIO *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(tBTIF_MEDIA_UPDATE_AUDIO)))) + { + return FALSE; + } + + memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_UPDATE_AUDIO)); + p_buf->hdr.event = BTIF_MEDIA_SBC_ENC_UPDATE; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_task_audio_feeding_init_req + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_audio_feeding_init_req(tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_msg) +{ + tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(tBTIF_MEDIA_INIT_AUDIO_FEEDING)))) + { + return FALSE; + } + + memcpy(p_buf, p_msg, sizeof(tBTIF_MEDIA_INIT_AUDIO_FEEDING)); + p_buf->hdr.event = BTIF_MEDIA_AUDIO_FEEDING_INIT; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_task_start_aa_req + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_start_aa_req(void) +{ + BT_HDR *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) + { + APPL_TRACE_EVENT0("GKI failed"); + return FALSE; + } + + p_buf->event = BTIF_MEDIA_START_AA_TX; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_task_stop_aa_req + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_stop_aa_req(void) +{ + BT_HDR *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) + { + return FALSE; + } + + p_buf->event = BTIF_MEDIA_STOP_AA_TX; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_task_aa_tx_flush_req + ** + ** Description + ** + ** Returns TRUE is success + ** + *******************************************************************************/ +BOOLEAN btif_media_task_aa_tx_flush_req(void) +{ + BT_HDR *p_buf; + if (NULL == (p_buf = GKI_getbuf(sizeof(BT_HDR)))) + { + return FALSE; + } + + p_buf->event = BTIF_MEDIA_FLUSH_AA_TX; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_buf); + return TRUE; +} + +/******************************************************************************* + ** + ** Function btif_media_task_aa_tx_flush + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_aa_tx_flush(BT_HDR *p_msg) +{ + /* Flush all enqueued GKI music buffers (encoded) */ + APPL_TRACE_DEBUG0("btif_media_task_aa_tx_flush"); + + btif_media_flush_q(&(btif_media_cb.TxAaQ)); + + UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REQ_RX_FLUSH, NULL); +} + +/******************************************************************************* + ** + ** Function btif_media_task_enc_init + ** + ** Description Initialize encoding task + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_enc_init(BT_HDR *p_msg) +{ + tBTIF_MEDIA_INIT_AUDIO *pInitAudio = (tBTIF_MEDIA_INIT_AUDIO *) p_msg; + + APPL_TRACE_DEBUG0("btif_media_task_enc_init"); + + btif_media_cb.timestamp = 0; + + /* SBC encoder config (enforced even if not used) */ + btif_media_cb.encoder.s16ChannelMode = pInitAudio->ChannelMode; + btif_media_cb.encoder.s16NumOfSubBands = pInitAudio->NumOfSubBands; + btif_media_cb.encoder.s16NumOfBlocks = pInitAudio->NumOfBlocks; + btif_media_cb.encoder.s16AllocationMethod = pInitAudio->AllocationMethod; + btif_media_cb.encoder.s16SamplingFreq = pInitAudio->SamplingFreq; + + btif_media_cb.encoder.u16BitRate = DEFAULT_SBC_BITRATE; + /* Default transcoding is PCM to SBC, modified by feeding configuration */ + btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_SBC; + btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR)) + < pInitAudio->MtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET + - sizeof(BT_HDR)) : pInitAudio->MtuSize; + + APPL_TRACE_DEBUG3("btif_media_task_enc_init busy %d, mtu %d, peer mtu %d", btif_media_cb.busy_level, btif_media_cb.TxAaMtuSize, pInitAudio->MtuSize); + APPL_TRACE_DEBUG6("btif_media_task_enc_init ch mode %d, nbsubd %d, nb blk %d, alloc method %d, bit rate %d, Smp freq %d", + btif_media_cb.encoder.s16ChannelMode, btif_media_cb.encoder.s16NumOfSubBands, btif_media_cb.encoder.s16NumOfBlocks, + btif_media_cb.encoder.s16AllocationMethod, btif_media_cb.encoder.u16BitRate, btif_media_cb.encoder.s16SamplingFreq); + + /* Reset entirely the SBC encoder */ + SBC_Encoder_Init(&(btif_media_cb.encoder)); + APPL_TRACE_DEBUG1("btif_media_task_enc_init bit pool %d", btif_media_cb.encoder.s16BitPool); +} + +/******************************************************************************* + ** + ** Function btif_media_task_enc_update + ** + ** Description Update encoding task + ** + ** Returns void + ** + *******************************************************************************/ + +static void btif_media_task_enc_update(BT_HDR *p_msg) +{ + tBTIF_MEDIA_UPDATE_AUDIO * pUpdateAudio = (tBTIF_MEDIA_UPDATE_AUDIO *) p_msg; + SBC_ENC_PARAMS *pstrEncParams = &btif_media_cb.encoder; + UINT16 s16SamplingFreq; + SINT16 s16BitPool; + SINT16 s16BitRate; + SINT16 s16FrameLen; + UINT8 protect = 0; + + APPL_TRACE_DEBUG3("btif_media_task_enc_update (minmtu %d, maxbp %d. minbp %d", + pUpdateAudio->MinMtuSize, pUpdateAudio->MaxBitPool, pUpdateAudio->MinBitPool); + + /* Only update the bitrate and MTU size while timer is running to make sure it has been initialized */ + if (btif_media_cb.is_tx_timer) + { + btif_media_cb.TxAaMtuSize = ((BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET - sizeof(BT_HDR)) + < pUpdateAudio->MinMtuSize) ? (BTIF_MEDIA_AA_BUF_SIZE - BTIF_MEDIA_AA_SBC_OFFSET + - sizeof(BT_HDR)) : pUpdateAudio->MinMtuSize; + + /* Set the initial target bit rate */ + pstrEncParams->u16BitRate = DEFAULT_SBC_BITRATE; + + if (pstrEncParams->s16SamplingFreq == SBC_sf16000) + s16SamplingFreq = 16000; + else if (pstrEncParams->s16SamplingFreq == SBC_sf32000) + s16SamplingFreq = 32000; + else if (pstrEncParams->s16SamplingFreq == SBC_sf44100) + s16SamplingFreq = 44100; + else + s16SamplingFreq = 48000; + + do + { + if ((pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) || + (pstrEncParams->s16ChannelMode == SBC_STEREO) ) + { + s16BitPool = (SINT16)( (pstrEncParams->u16BitRate * + pstrEncParams->s16NumOfSubBands * 1000 / s16SamplingFreq) + -( (32 + (4 * pstrEncParams->s16NumOfSubBands * + pstrEncParams->s16NumOfChannels) + + ( (pstrEncParams->s16ChannelMode - 2) * + pstrEncParams->s16NumOfSubBands ) ) + / pstrEncParams->s16NumOfBlocks) ); + + s16FrameLen = 4 + (4*pstrEncParams->s16NumOfSubBands* + pstrEncParams->s16NumOfChannels)/8 + + ( ((pstrEncParams->s16ChannelMode - 2) * + pstrEncParams->s16NumOfSubBands) + + (pstrEncParams->s16NumOfBlocks * s16BitPool) ) / 8; + + s16BitRate = (8 * s16FrameLen * s16SamplingFreq) + / (pstrEncParams->s16NumOfSubBands * + pstrEncParams->s16NumOfBlocks * 1000); + + if (s16BitRate > pstrEncParams->u16BitRate) + s16BitPool--; + + if(pstrEncParams->s16NumOfSubBands == 8) + s16BitPool = (s16BitPool > 255) ? 255 : s16BitPool; + else + s16BitPool = (s16BitPool > 128) ? 128 : s16BitPool; + } + else + { + s16BitPool = (SINT16)( ((pstrEncParams->s16NumOfSubBands * + pstrEncParams->u16BitRate * 1000) + / (s16SamplingFreq * pstrEncParams->s16NumOfChannels)) + -( ( (32 / pstrEncParams->s16NumOfChannels) + + (4 * pstrEncParams->s16NumOfSubBands) ) + / pstrEncParams->s16NumOfBlocks ) ); + + pstrEncParams->s16BitPool = (s16BitPool > + (16 * pstrEncParams->s16NumOfSubBands)) + ? (16*pstrEncParams->s16NumOfSubBands) : s16BitPool; + } + + if (s16BitPool < 0) + { + s16BitPool = 0; + } + + if (s16BitPool > pUpdateAudio->MaxBitPool) + { + APPL_TRACE_WARNING1("btif_media_task_enc_update computed bitpool too large (%d)", s16BitPool); + /* Decrease bitrate */ + btif_media_cb.encoder.u16BitRate -= BTIF_MEDIA_BITRATE_STEP; + /* Record that we have decreased the bitrate */ + protect |= 1; + } + else if (s16BitPool < pUpdateAudio->MinBitPool) + { + APPL_TRACE_WARNING1("btif_media_task_enc_update computed bitpool too small (%d)", s16BitPool); + /* Increase bitrate */ + btif_media_cb.encoder.u16BitRate += BTIF_MEDIA_BITRATE_STEP; + /* Record that we have increased the bitrate */ + protect |= 2; + } + else + { + break; + } + /* In case we have already increased and decreased the bitrate, just stop */ + if (protect == 3) + { + APPL_TRACE_ERROR0("btif_media_task_enc_update could not find bitpool in range"); + break; + } + } while (1); + + /* Finally update the bitpool in the encoder structure */ + pstrEncParams->s16BitPool = s16BitPool; + + APPL_TRACE_DEBUG2("btif_media_task_enc_update final bit rate %d, final bit pool %d", + btif_media_cb.encoder.u16BitRate, btif_media_cb.encoder.s16BitPool); + } +} + +/******************************************************************************* + ** + ** Function btif_media_task_pcm2sbc_init + ** + ** Description Init encoding task for PCM to SBC according to feeding + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_pcm2sbc_init(tBTIF_MEDIA_INIT_AUDIO_FEEDING * p_feeding) +{ + BOOLEAN reconfig_needed = FALSE; + + APPL_TRACE_DEBUG0("PCM feeding:"); + APPL_TRACE_DEBUG1("sampling_freq:%d", p_feeding->feeding.cfg.pcm.sampling_freq); + APPL_TRACE_DEBUG1("num_channel:%d", p_feeding->feeding.cfg.pcm.num_channel); + APPL_TRACE_DEBUG1("bit_per_sample:%d", 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.encoder.s16SamplingFreq != SBC_sf48000) + { + /* Reconfiguration needed at 48000 */ + APPL_TRACE_DEBUG0("SBC Reconfiguration needed at 48000"); + btif_media_cb.encoder.s16SamplingFreq = SBC_sf48000; + reconfig_needed = TRUE; + } + break; + + case 11025: + case 22050: + case 44100: + /* For these sampling_freq the AV connection must be 44100 */ + if (btif_media_cb.encoder.s16SamplingFreq != SBC_sf44100) + { + /* Reconfiguration needed at 44100 */ + APPL_TRACE_DEBUG0("SBC Reconfiguration needed at 44100"); + btif_media_cb.encoder.s16SamplingFreq = SBC_sf44100; + reconfig_needed = TRUE; + } + break; + default: + APPL_TRACE_DEBUG0("Feeding PCM sampling_freq unsupported"); + break; + } + + /* Some AV Headsets do not support Mono => always ask for Stereo */ + if (btif_media_cb.encoder.s16ChannelMode != SBC_STEREO) + { + APPL_TRACE_DEBUG0("SBC Reconfiguration needed in Stereo"); + btif_media_cb.encoder.s16ChannelMode = SBC_STEREO; + reconfig_needed = TRUE; + } + + if (reconfig_needed != FALSE) + { + APPL_TRACE_DEBUG0("btif_media_task_pcm2sbc_init calls SBC_Encoder_Init"); + APPL_TRACE_DEBUG1("btif_media_task_pcm2sbc_init mtu %d", btif_media_cb.TxAaMtuSize); + APPL_TRACE_DEBUG6("btif_media_task_pcm2sbc_init ch mode %d, nbsubd %d, nb blk %d, alloc method %d, bit rate %d, Smp freq %d", + btif_media_cb.encoder.s16ChannelMode, btif_media_cb.encoder.s16NumOfSubBands, btif_media_cb.encoder.s16NumOfBlocks, + btif_media_cb.encoder.s16AllocationMethod, btif_media_cb.encoder.u16BitRate, btif_media_cb.encoder.s16SamplingFreq); + SBC_Encoder_Init(&(btif_media_cb.encoder)); + } + else + { + APPL_TRACE_DEBUG0("btif_media_task_pcm2sbc_init no SBC reconfig needed"); + } +} + + +/******************************************************************************* + ** + ** Function btif_media_task_audio_feeding_init + ** + ** Description Initialize the audio path according to the feeding format + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_audio_feeding_init(BT_HDR *p_msg) +{ + tBTIF_MEDIA_INIT_AUDIO_FEEDING *p_feeding = (tBTIF_MEDIA_INIT_AUDIO_FEEDING *) p_msg; + + APPL_TRACE_DEBUG1("btif_media_task_audio_feeding_init format:%d", p_feeding->feeding.format); + + /* Save Media Feeding information */ + btif_media_cb.feeding_mode = p_feeding->feeding_mode; + btif_media_cb.media_feeding = p_feeding->feeding; + + /* Handle different feeding formats */ + switch (p_feeding->feeding.format) + { + case BTIF_AV_CODEC_PCM: + btif_media_cb.TxTranscoding = BTIF_MEDIA_TRSCD_PCM_2_SBC; + btif_media_task_pcm2sbc_init(p_feeding); + break; + + default : + APPL_TRACE_ERROR1("unknown feeding format %d", p_feeding->feeding.format); + break; + } +} + +/******************************************************************************* + ** + ** Function btif_media_task_uipc_cback + ** + ** Description UIPC call back function for synchronous mode only + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_uipc_cback(BT_HDR *p_msg) +{ + /* Sanity check */ + if (NULL == p_msg) + { + return; + } + + /* Just handle RX_EVT */ + if (p_msg->event != UIPC_RX_DATA_EVT) + { + return; + } + + p_msg->event = BTIF_MEDIA_UIPC_RX_RDY; + + GKI_send_msg(BT_MEDIA_TASK, BTIF_MEDIA_TASK_CMD_MBOX, p_msg); +} + +/******************************************************************************* + ** + ** Function btif_media_task_feeding_state_reset + ** + ** Description Reset the media feeding state + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_feeding_state_reset(void) +{ + /* By default, just clear the entire state */ + memset(&btif_media_cb.media_feeding_state, 0, sizeof(btif_media_cb.media_feeding_state)); + + +} +/******************************************************************************* + ** + ** Function btif_media_task_aa_start_tx + ** + ** Description Start media task encoding + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_aa_start_tx(void) +{ + APPL_TRACE_DEBUG2("btif_media_task_aa_start_tx is timer %d, feeding mode %d", + btif_media_cb.is_tx_timer, btif_media_cb.feeding_mode); + + + /* Use a timer to poll the UIPC, get rid of the UIPC call back */ + UIPC_Ioctl(UIPC_CH_ID_AV_AUDIO, UIPC_REG_CBACK, NULL); + + btif_media_cb.is_tx_timer = TRUE; + +#if ((defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE)) || \ + (defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE))) + btif_media_cb.tx_counter = 0; +#endif + + /* Reset the media feeding state */ + btif_media_task_feeding_state_reset(); + + APPL_TRACE_EVENT2("starting timer %d ticks (%d)", GKI_MS_TO_TICKS(BTIF_MEDIA_TIME_TICK), TICKS_PER_SEC); + GKI_start_timer(BTIF_MEDIA_AA_TASK_TIMER_ID, GKI_MS_TO_TICKS(BTIF_MEDIA_TIME_TICK), TRUE); +} + +/******************************************************************************* + ** + ** Function btif_media_task_aa_stop_tx + ** + ** Description Stop media task encoding + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_task_aa_stop_tx(void) +{ + APPL_TRACE_DEBUG1("btif_media_task_aa_stop_tx is timer: %d", btif_media_cb.is_tx_timer); + /* Stop the timer first */ + GKI_stop_timer(BTIF_MEDIA_AA_TASK_TIMER_ID); + btif_media_cb.is_tx_timer = FALSE; + + UIPC_Close(UIPC_CH_ID_AV_AUDIO); + + /* Reset the media feeding state */ + btif_media_task_feeding_state_reset(); +} + +/******************************************************************************* + ** + ** Function btif_get_num_aa_frame + ** + ** Description + ** + ** Returns The number of media frames in this time slice + ** + *******************************************************************************/ +static UINT8 btif_get_num_aa_frame(void) +{ + UINT8 result=0; + + switch (btif_media_cb.TxTranscoding) + { + case BTIF_MEDIA_TRSCD_PCM_2_SBC: + switch (btif_media_cb.encoder.s16SamplingFreq) + { + case SBC_sf16000: + result = BTIF_MEDIA_FR_PER_TICKS_16; + break; + case SBC_sf32000: + result = BTIF_MEDIA_FR_PER_TICKS_32; + break; + case SBC_sf48000: + result = BTIF_MEDIA_FR_PER_TICKS_48; + break; + case SBC_sf44100: + if ((btif_media_cb.media_feeding_state.pcm.aa_frame_counter++ % 32) < 7) + { + result = BTIF_MEDIA_FR_PER_TICKS_44_1_L; + } + else + { + result = BTIF_MEDIA_FR_PER_TICKS_44_1_H; + } + break; + } +#if ((defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE)) || \ + (defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE))) + btif_media_cb.tx_counter++; + if (btif_media_cb.tx_counter == 10) + { + btif_media_cb.tx_counter = 0; +#if defined(BTIF_MEDIA_OVERFEED_INCLUDED) && (BTIF_MEDIA_OVERFEED_INCLUDED == TRUE) + result++; +#endif +#if defined(BTIF_MEDIA_UNDERFEED_INCLUDED) && (BTIF_MEDIA_UNDERFEED_INCLUDED == TRUE) + result--; +#endif + } +#endif + break; + + default: + APPL_TRACE_ERROR1("ERROR btif_get_num_aa_frame Unsupported transcoding format 0x%x", + btif_media_cb.TxTranscoding); + result = 0; + break; + } + +#if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) + APPL_TRACE_DEBUG1("btif_get_num_aa_frame returns %d", result); +#endif + + return result; +} + +/******************************************************************************* + ** + ** Function btif_media_aa_readbuf + ** + ** Description This function is called by the av_co to get the next buffer to send + ** + ** + ** Returns void + *******************************************************************************/ +BT_HDR *btif_media_aa_readbuf(void) +{ + return GKI_dequeue(&(btif_media_cb.TxAaQ)); +} + +/******************************************************************************* + ** + ** Function btif_media_aa_read_feeding + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +BOOLEAN btif_media_aa_read_feeding(tUIPC_CH_ID channel_id) +{ + UINT16 event; + /* coverity[SIGN_EXTENSION] False-positive: Parameter are always in range avoiding sign extension*/ + UINT16 blocm_x_subband = btif_media_cb.encoder.s16NumOfSubBands * btif_media_cb.encoder.s16NumOfBlocks; + UINT32 read_size; + UINT16 sbc_sampling = 48000; + UINT32 src_samples; + UINT16 bytes_needed = blocm_x_subband * btif_media_cb.encoder.s16NumOfChannels * sizeof(SINT16); + 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]; + static UINT16 read_buffer[SBC_MAX_NUM_FRAME * SBC_MAX_NUM_OF_BLOCKS + * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS]; + UINT32 src_size_used; + UINT32 dst_size_used; + BOOLEAN fract_needed; + INT32 fract_max; + INT32 fract_threshold; + UINT32 nb_byte_read; + + /* Get the SBC sampling rate */ + switch (btif_media_cb.encoder.s16SamplingFreq) + { + case SBC_sf48000: + sbc_sampling = 48000; + break; + case SBC_sf44100: + sbc_sampling = 44100; + break; + case SBC_sf32000: + sbc_sampling = 32000; + break; + case SBC_sf16000: + sbc_sampling = 16000; + break; + } + + /* Some Feeding PCM frequencies require to split the number of sample */ + /* to read. */ + /* E.g 128/6=21.3333 => read 22 and 21 and 21 => max = 2; threshold = 0*/ + fract_needed = FALSE; /* Default */ + switch (btif_media_cb.media_feeding.cfg.pcm.sampling_freq) + { + case 32000: + case 8000: + fract_needed = TRUE; + fract_max = 2; /* 0, 1 and 2 */ + fract_threshold = 0; /* Add one for the first */ + break; + case 16000: + fract_needed = TRUE; + fract_max = 2; /* 0, 1 and 2 */ + fract_threshold = 1; /* Add one for the first two frames*/ + break; + } + + /* Compute number of sample to read from source */ + src_samples = blocm_x_subband; + src_samples *= btif_media_cb.media_feeding.cfg.pcm.sampling_freq; + src_samples /= sbc_sampling; + + /* The previous division may have a remainder not null */ + if (fract_needed) + { + if (btif_media_cb.media_feeding_state.pcm.aa_feed_counter <= fract_threshold) + { + src_samples++; /* for every read before threshold add one sample */ + } + + /* do nothing if counter >= threshold */ + btif_media_cb.media_feeding_state.pcm.aa_feed_counter++; /* one more read */ + if (btif_media_cb.media_feeding_state.pcm.aa_feed_counter > fract_max) + { + btif_media_cb.media_feeding_state.pcm.aa_feed_counter = 0; + } + } + + /* Compute number of bytes to read from source */ + read_size = src_samples; + read_size *= btif_media_cb.media_feeding.cfg.pcm.num_channel; + read_size *= (btif_media_cb.media_feeding.cfg.pcm.bit_per_sample / 8); + + /* Read Data from UIPC channel */ + nb_byte_read = UIPC_Read(channel_id, &event, (UINT8 *)read_buffer, read_size); + + //tput_mon(TRUE, nb_byte_read, FALSE); + + if (nb_byte_read == 0) + { + APPL_TRACE_EVENT0("REMOTE SOURCE DETACHED"); + + /* temp workaround before full socket interface implented + stop and restart media task as remote source disconnected + read socket will again wait for an incoming a2dp source connection */ + + btif_media_task_stop_aa_req(); + btif_a2dp_upon_started(); + return FALSE; + } + + if (nb_byte_read < read_size) + { + APPL_TRACE_WARNING2("btif_media_aa_read_feeding UIPC empty UIPC_Read returns:%d asked:%d", + nb_byte_read, read_size); + + if(btif_media_cb.feeding_mode == BTIF_AV_FEEDING_ASYNCHRONOUS) + { + /* Fill the unfilled part of the read buffer with silence (0) */ + memset(((UINT8 *)read_buffer) + nb_byte_read, 0, read_size - nb_byte_read); + nb_byte_read = read_size; + } + } + + /* Initialize PCM up-sampling engine */ + bta_av_sbc_init_up_sample(btif_media_cb.media_feeding.cfg.pcm.sampling_freq, + sbc_sampling, btif_media_cb.media_feeding.cfg.pcm.bit_per_sample, + btif_media_cb.media_feeding.cfg.pcm.num_channel); + + /* re-sample read buffer */ + /* The output PCM buffer will be stereo, 16 bit per sec */ + dst_size_used = bta_av_sbc_up_sample((UINT8 *)read_buffer, + (UINT8 *)up_sampled_buffer + btif_media_cb.media_feeding_state.pcm.aa_feed_residue, + nb_byte_read, + sizeof(up_sampled_buffer) - btif_media_cb.media_feeding_state.pcm.aa_feed_residue, + &src_size_used); +#if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) + APPL_TRACE_DEBUG3("btif_media_aa_read_feeding read_size:%d src_size_used:%d dst_size_used:%d", + read_size, src_size_used, dst_size_used); +#endif + + /* update the residue */ + btif_media_cb.media_feeding_state.pcm.aa_feed_residue += dst_size_used; + + /* only copy the pcm sample when we have up-sampled enough PCM */ + 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, + (UINT8 *)up_sampled_buffer, + bytes_needed); + /* update the residue */ + btif_media_cb.media_feeding_state.pcm.aa_feed_residue -= bytes_needed; + + if (btif_media_cb.media_feeding_state.pcm.aa_feed_residue != 0) + { + memcpy((UINT8 *)up_sampled_buffer, + (UINT8 *)up_sampled_buffer + bytes_needed, + btif_media_cb.media_feeding_state.pcm.aa_feed_residue); + } + return TRUE; + } + +#if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) + APPL_TRACE_DEBUG3("btif_media_aa_read_feeding residue:%d, dst_size_used %d, bytes_needed %d", + btif_media_cb.media_feeding_state.pcm.aa_feed_residue, dst_size_used, bytes_needed); +#endif + + return FALSE; +} + +/******************************************************************************* + ** + ** Function btif_media_aa_prep_sbc_2_send + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_aa_prep_sbc_2_send(UINT8 nb_frame) +{ + BT_HDR * p_buf; + UINT16 blocm_x_subband = btif_media_cb.encoder.s16NumOfSubBands * btif_media_cb.encoder.s16NumOfBlocks; + +#if (defined(DEBUG_MEDIA_AV_FLOW) && (DEBUG_MEDIA_AV_FLOW == TRUE)) + APPL_TRACE_DEBUG2("btif_media_aa_prep_sbc_2_send nb_frame %d, TxAaQ %d", nb_frame, btif_media_cb.TxAaQ.count); +#endif + while (nb_frame) + { + if (NULL == (p_buf = GKI_getpoolbuf(BTIF_MEDIA_AA_POOL_ID))) + { + APPL_TRACE_ERROR1 ("ERROR btif_media_aa_prep_sbc_2_send no buffer TxCnt %d ", btif_media_cb.TxAaQ.count); + return; + } + + /* Init buffer */ + p_buf->offset = BTIF_MEDIA_AA_SBC_OFFSET; + p_buf->len = 0; + p_buf->layer_specific = 0; + + do + { + /* 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 */ + /* coverity[SIGN_EXTENSION] False-positive: Parameter are always in range avoiding sign extension*/ + memset(btif_media_cb.encoder.as16PcmBuffer, 0, blocm_x_subband + * btif_media_cb.encoder.s16NumOfChannels); + /* Read PCM data and upsample them if needed */ + if (btif_media_aa_read_feeding(UIPC_CH_ID_AV_AUDIO)) + { + /* SBC encode and descramble frame */ + SBC_Encoder(&(btif_media_cb.encoder)); + A2D_SbcChkFrInit(btif_media_cb.encoder.pu8Packet); + A2D_SbcDescramble(btif_media_cb.encoder.pu8Packet, btif_media_cb.encoder.u16PacketLength); + /* Update SBC frame length */ + p_buf->len += btif_media_cb.encoder.u16PacketLength; + nb_frame--; + p_buf->layer_specific++; + } + else + { + /* no more pcm to read */ + nb_frame = 0; + } + + } while (((p_buf->len + btif_media_cb.encoder.u16PacketLength) < btif_media_cb.TxAaMtuSize) + && (p_buf->layer_specific < 0x0F) && nb_frame); + + /* coverity[SIGN_EXTENSION] False-positive: Parameter are always in range avoiding sign extension*/ + btif_media_cb.timestamp += p_buf->layer_specific * blocm_x_subband; + + /* store the time stamp in the buffer to send */ + *((UINT32 *) (p_buf + 1)) = btif_media_cb.timestamp; + + /* Enqueue the encoded SBC frame in AA Tx Queue */ + GKI_enqueue(&(btif_media_cb.TxAaQ), p_buf); + } +} + + +/******************************************************************************* + ** + ** Function btif_media_aa_prep_2_send + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_aa_prep_2_send(UINT8 nb_frame) +{ + /* Remove all the buffers not sent until there are only 4 in the queue */ + while (btif_media_cb.TxAaQ.count > 4) + { + APPL_TRACE_WARNING1("btif_media_aa_prep_2_send congestion buf count %d",btif_media_cb.TxAaQ.count); + GKI_freebuf(GKI_dequeue(&(btif_media_cb.TxAaQ))); + } + + switch (btif_media_cb.TxTranscoding) + { + case BTIF_MEDIA_TRSCD_PCM_2_SBC: + btif_media_aa_prep_sbc_2_send(nb_frame); + break; + + + default: + APPL_TRACE_ERROR1("ERROR btif_media_aa_prep_2_send unsupported transcoding format 0x%x",btif_media_cb.TxTranscoding); + break; + } +} + +/******************************************************************************* + ** + ** Function btif_media_send_aa_frame + ** + ** Description + ** + ** Returns void + ** + *******************************************************************************/ +static void btif_media_send_aa_frame(void) +{ + UINT8 nb_frame_2_send; + + /* get the number of frame to send */ + nb_frame_2_send = btif_get_num_aa_frame(); + + /* format and Q buffer to send */ + btif_media_aa_prep_2_send(nb_frame_2_send); + + /* send it */ + APPL_TRACE_DEBUG0("btif_media_send_aa_frame calls bta_av_ci_src_data_ready"); + bta_av_ci_src_data_ready(BTA_AV_CHNL_AUDIO); +} + +#endif /* BTA_AV_INCLUDED == TRUE */ + +/******************************************************************************* + ** + ** Function dump_codec_info + ** + ** Description Decode and display codec_info (for debug) + ** + ** Returns void + ** + *******************************************************************************/ +void dump_codec_info(unsigned char *p_codec) +{ + tA2D_STATUS a2d_status; + tA2D_SBC_CIE sbc_cie; + + a2d_status = A2D_ParsSbcInfo(&sbc_cie, p_codec, FALSE); + if (a2d_status != A2D_SUCCESS) + { + APPL_TRACE_ERROR1("ERROR dump_codec_info A2D_ParsSbcInfo fail:%d", a2d_status); + return; + } + + APPL_TRACE_DEBUG0("dump_codec_info"); + + if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_16) + { APPL_TRACE_DEBUG1("\tsamp_freq:%d (16000)", sbc_cie.samp_freq);} + else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_32) + { APPL_TRACE_DEBUG1("\tsamp_freq:%d (32000)", sbc_cie.samp_freq);} + else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_44) + { APPL_TRACE_DEBUG1("\tsamp_freq:%d (44.100)", sbc_cie.samp_freq);} + else if (sbc_cie.samp_freq == A2D_SBC_IE_SAMP_FREQ_48) + { APPL_TRACE_DEBUG1("\tsamp_freq:%d (48000)", sbc_cie.samp_freq);} + else + { APPL_TRACE_DEBUG1("\tBAD samp_freq:%d", sbc_cie.samp_freq);} + + if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_MONO) + { APPL_TRACE_DEBUG1("\tch_mode:%d (Mono)", sbc_cie.ch_mode);} + else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_DUAL) + { APPL_TRACE_DEBUG1("\tch_mode:%d (Dual)", sbc_cie.ch_mode);} + else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_STEREO) + { APPL_TRACE_DEBUG1("\tch_mode:%d (Stereo)", sbc_cie.ch_mode);} + else if (sbc_cie.ch_mode == A2D_SBC_IE_CH_MD_JOINT) + { APPL_TRACE_DEBUG1("\tch_mode:%d (Joint)", sbc_cie.ch_mode);} + else + { APPL_TRACE_DEBUG1("\tBAD ch_mode:%d", sbc_cie.ch_mode);} + + if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_4) + { APPL_TRACE_DEBUG1("\tblock_len:%d (4)", sbc_cie.block_len);} + else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_8) + { APPL_TRACE_DEBUG1("\tblock_len:%d (8)", sbc_cie.block_len);} + else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_12) + { APPL_TRACE_DEBUG1("\tblock_len:%d (12)", sbc_cie.block_len);} + else if (sbc_cie.block_len == A2D_SBC_IE_BLOCKS_16) + { APPL_TRACE_DEBUG1("\tblock_len:%d (16)", sbc_cie.block_len);} + else + { APPL_TRACE_DEBUG1("\tBAD block_len:%d", sbc_cie.block_len);} + + if (sbc_cie.num_subbands == A2D_SBC_IE_SUBBAND_4) + { APPL_TRACE_DEBUG1("\tnum_subbands:%d (4)", sbc_cie.num_subbands);} + else if (sbc_cie.num_subbands == A2D_SBC_IE_SUBBAND_8) + { APPL_TRACE_DEBUG1("\tnum_subbands:%d (8)", sbc_cie.num_subbands);} + else + { APPL_TRACE_DEBUG1("\tBAD num_subbands:%d", sbc_cie.num_subbands);} + + if (sbc_cie.alloc_mthd == A2D_SBC_IE_ALLOC_MD_S) + { APPL_TRACE_DEBUG1("\talloc_mthd:%d (SNR)", sbc_cie.alloc_mthd);} + else if (sbc_cie.alloc_mthd == A2D_SBC_IE_ALLOC_MD_L) + { APPL_TRACE_DEBUG1("\talloc_mthd:%d (Loundess)", sbc_cie.alloc_mthd);} + else + { APPL_TRACE_DEBUG1("\tBAD alloc_mthd:%d", sbc_cie.alloc_mthd);} + + APPL_TRACE_DEBUG2("\tBit pool Min:%d Max:%d", sbc_cie.min_bitpool, sbc_cie.max_bitpool); + +} + diff --git a/btif/src/btif_sm.c b/btif/src/btif_sm.c new file mode 100644 index 0000000..77d12d9 --- /dev/null +++ b/btif/src/btif_sm.c @@ -0,0 +1,223 @@ +/****************************************************************************** + * + * Copyright (C) 2009-2012 Broadcom Corporation + * + * This program is the proprietary software of Broadcom Corporation and/or its + * licensors, and may only be used, duplicated, modified or distributed + * pursuant to the terms and conditions of a separate, written license + * agreement executed between you and Broadcom (an "Authorized License"). + * Except as set forth in an Authorized License, Broadcom grants no license + * (express or implied), right to use, or waiver of any kind with respect to + * the Software, and Broadcom expressly reserves all rights in and to the + * Software and all intellectual property rights therein. + * IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE NO RIGHT TO USE THIS + * SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY BROADCOM AND DISCONTINUE + * ALL USE OF THE SOFTWARE. + * + * Except as expressly set forth in the Authorized License, + * + * 1. This program, including its structure, sequence and organization, + * constitutes the valuable trade secrets of Broadcom, and you shall + * use all reasonable efforts to protect the confidentiality thereof, + * and to use this information only in connection with your use of + * Broadcom integrated circuit products. + * + * 2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED + * "AS IS" AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, + * REPRESENTATIONS OR WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, + * OR OTHERWISE, WITH RESPECT TO THE SOFTWARE. BROADCOM SPECIFICALLY + * DISCLAIMS ANY AND ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, + * NONINFRINGEMENT, FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, + * ACCURACY OR COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR + * CORRESPONDENCE TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING + * OUT OF USE OR PERFORMANCE OF THE SOFTWARE. + * + * 3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM + * OR ITS LICENSORS BE LIABLE FOR + * (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL, INDIRECT, OR EXEMPLARY + * DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY WAY RELATING TO + * YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN IF BROADCOM + * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES; OR + * (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE + * SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE + * LIMITATIONS SHALL APPLY NOTWITHSTANDING ANY FAILURE OF + * ESSENTIAL PURPOSE OF ANY LIMITED REMEDY. + * + *****************************************************************************/ + + +/***************************************************************************** + * + * Filename: btif_sm.c + * + * Description: Generic BTIF state machine API + * + *****************************************************************************/ +#include <hardware/bluetooth.h> + +#define LOG_TAG "BTIF_SM" +#include "btif_common.h" +#include "btif_sm.h" +#include "gki.h" + +/***************************************************************************** +** Constants & Macros +******************************************************************************/ + + +/***************************************************************************** +** Local type definitions +******************************************************************************/ +typedef struct { + btif_sm_state_t state; + btif_sm_handler_t *p_handlers; +} btif_sm_cb_t; + +/***************************************************************************** +** Static variables +******************************************************************************/ + +/***************************************************************************** +** Static functions +******************************************************************************/ + +/***************************************************************************** +** Externs +******************************************************************************/ + +/***************************************************************************** +** Functions +******************************************************************************/ + +/***************************************************************************** +** +** Function btif_sm_init +** +** Description Initializes the state machine with the state handlers +** The caller should ensure that the table and the corresponding +** states match. The location that 'p_handlers' points to shall +** be available until the btif_sm_shutdown API is invoked. +** +** Returns Returns a pointer to the initialized state machine handle. +** +******************************************************************************/ +btif_sm_handle_t btif_sm_init(const btif_sm_handler_t *p_handlers, btif_sm_state_t initial_state) +{ + btif_sm_cb_t *p_cb; + + if (p_handlers == NULL) + { + BTIF_TRACE_ERROR1("%s : p_handlers is NULL", __FUNCTION__); + return NULL; + } + + p_cb = (btif_sm_cb_t*) GKI_os_malloc(sizeof(btif_sm_cb_t)); + p_cb->state = initial_state; + p_cb->p_handlers = (btif_sm_handler_t*)p_handlers; + + /* Send BTIF_SM_ENTER_EVT to the initial state */ + p_cb->p_handlers[initial_state](BTIF_SM_ENTER_EVT, NULL); + + return (btif_sm_handle_t)p_cb; +} + +/***************************************************************************** +** +** Function btif_sm_shutdown +** +** Description Tears down the state machine +** +** Returns None +** +******************************************************************************/ +void btif_sm_shutdown(btif_sm_handle_t handle) +{ + btif_sm_cb_t *p_cb = (btif_sm_cb_t*)handle; + + if (p_cb == NULL) + { + BTIF_TRACE_ERROR1("%s : Invalid handle", __FUNCTION__); + return; + } + GKI_os_free((void*)p_cb); +} + +/***************************************************************************** +** +** Function btif_sm_get_state +** +** Description Fetches the current state of the state machine +** +** Returns Current state +** +******************************************************************************/ +btif_sm_state_t btif_sm_get_state(btif_sm_handle_t handle) +{ + btif_sm_cb_t *p_cb = (btif_sm_cb_t*)handle; + + if (p_cb == NULL) + { + BTIF_TRACE_ERROR1("%s : Invalid handle", __FUNCTION__); + return 0; + } + + return p_cb->state; +} + +/***************************************************************************** +** +** Function btif_sm_dispatch +** +** Description Dispatches the 'event' along with 'data' to the current state handler +** +** Returns Returns BT_STATUS_OK on success, BT_STATUS_FAIL otherwise +** +******************************************************************************/ +bt_status_t btif_sm_dispatch(btif_sm_handle_t handle, btif_sm_event_t event, + void *data) +{ + btif_sm_cb_t *p_cb = (btif_sm_cb_t*)handle; + + if (p_cb == NULL) + { + BTIF_TRACE_ERROR1("%s : Invalid handle", __FUNCTION__); + return BT_STATUS_FAIL; + } + + p_cb->p_handlers[p_cb->state](event, data); + + return BT_STATUS_SUCCESS; +} + +/***************************************************************************** +** +** Function btif_sm_change_state +** +** Description Make a transition to the new 'state'. The 'BTIF_SM_EXIT_EVT' +** shall be invoked before exiting the current state. The +** 'BTIF_SM_ENTER_EVT' shall be invoked before entering the new state +** +** Returns Returns BT_STATUS_SUCCESS on success, BT_STATUS_FAIL otherwise +** +******************************************************************************/ +bt_status_t btif_sm_change_state(btif_sm_handle_t handle, btif_sm_state_t state) +{ + btif_sm_cb_t *p_cb = (btif_sm_cb_t*)handle; + + if (p_cb == NULL) + { + BTIF_TRACE_ERROR1("%s : Invalid handle", __FUNCTION__); + return BT_STATUS_FAIL; + } + + /* Send exit event to the current state */ + p_cb->p_handlers[p_cb->state](BTIF_SM_EXIT_EVT, NULL); + + /* Change to the new state */ + p_cb->state = state; + + /* Send enter event to the new state */ + p_cb->p_handlers[p_cb->state](BTIF_SM_ENTER_EVT, NULL); + + return BT_STATUS_SUCCESS; +} diff --git a/btif/src/btif_storage.c b/btif/src/btif_storage.c index 4905931..e3ca7ef 100644 --- a/btif/src/btif_storage.c +++ b/btif/src/btif_storage.c @@ -600,17 +600,26 @@ bt_status_t btif_storage_get_adapter_property(bt_property_t *property) BTIF_TRACE_ERROR2("%s service_mask:0x%x", __FUNCTION__, service_mask); for (i=0; i < BTA_MAX_SERVICE_ID; i++) { + /* This should eventually become a function when more services are enabled */ if(service_mask &(tBTA_SERVICE_MASK)(1 << i)) { - uuid16_to_uuid128(bta_service_id_to_uuid_lkup_tbl[i], p_uuid+num_uuids); + switch (i) { + case BTA_HFP_SERVICE_ID: + { + uuid16_to_uuid128(UUID_SERVCLASS_AG_HANDSFREE, + p_uuid+num_uuids); num_uuids++; - /* BTA_HSP_SERVICE_ID is a special case and gets enabled automatically - * when BTA_HFP_SERVICE_ID is enabled */ - if (i == BTA_HFP_SERVICE_ID) { - uuid16_to_uuid128(bta_service_id_to_uuid_lkup_tbl[BTA_HSP_SERVICE_ID], + uuid16_to_uuid128(UUID_SERVCLASS_HEADSET_AUDIO_GATEWAY, p_uuid+num_uuids); num_uuids++; + }break; + case BTA_A2DP_SERVICE_ID: + { + uuid16_to_uuid128(UUID_SERVCLASS_AUDIO_SOURCE, + p_uuid+num_uuids); + num_uuids++; + }break; } } } diff --git a/btif/src/btif_util.c b/btif/src/btif_util.c index bfa489b..6ce6657 100644 --- a/btif/src/btif_util.c +++ b/btif/src/btif_util.c @@ -56,6 +56,7 @@ #include <hardware/bluetooth.h> #include <hardware/bt_hf.h> +#include <hardware/bt_av.h> #include <netinet/in.h> #include <stdio.h> #include <stdlib.h> @@ -325,6 +326,18 @@ const char* dump_hf_audio_state(UINT16 event) } } +const char* dump_av_conn_state(UINT16 event) +{ + switch(event) + { + CASE_RETURN_STR(BTAV_CONNECTION_STATE_DISCONNECTED) + CASE_RETURN_STR(BTAV_CONNECTION_STATE_CONNECTING) + CASE_RETURN_STR(BTAV_CONNECTION_STATE_CONNECTED) + CASE_RETURN_STR(BTAV_CONNECTION_STATE_DISCONNECTING) + default: + return "UNKNOWN MSG ID"; + } +} const char* dump_adapter_scan_mode(bt_scan_mode_t mode) { diff --git a/embdrv/sbc/encoder/include/sbc_dct.h b/embdrv/sbc/encoder/include/sbc_dct.h new file mode 100644 index 0000000..be077e2 --- /dev/null +++ b/embdrv/sbc/encoder/include/sbc_dct.h @@ -0,0 +1,78 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_dct.h,v $ +** +** Description: Definitions for the fast DCT. +** +** Copyright (c) 1999-2008, Broadcom Corp., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#ifndef SBC_DCT_H +#define SBC_DCT_H + +#if (SBC_ARM_ASM_OPT==TRUE) +#define SBC_MULT_32_16_SIMPLIFIED(s16In2, s32In1, s32OutLow) \ +{ \ + __asm \ +{ \ + MUL s32OutLow,(SINT32)s16In2, (s32In1>>15) \ +} \ +} +#else +#if (SBC_DSP_OPT==TRUE) +#define SBC_MULT_32_16_SIMPLIFIED(s16In2, s32In1 , s32OutLow) s32OutLow = SBC_Multiply_32_16_Simplified((SINT32)s16In2,s32In1); +#else +#if (SBC_IPAQ_OPT==TRUE) +/*#define SBC_MULT_32_16_SIMPLIFIED(s16In2, s32In1 , s32OutLow) s32OutLow=(SINT32)((SINT32)(s16In2)*(SINT32)(s32In1>>15)); */ +#define SBC_MULT_32_16_SIMPLIFIED(s16In2, s32In1 , s32OutLow) s32OutLow=(SINT32)(((SINT64)s16In2*(SINT64)s32In1)>>15); +#if (SBC_IS_64_MULT_IN_IDCT == TRUE) +#define SBC_MULT_32_32(s32In2, s32In1, s32OutLow) \ +{ \ + s64Temp = ((SINT64) s32In2) * ((SINT64) s32In1)>>31; \ + s32OutLow = (SINT32) s64Temp; \ +} +#endif +#else +#define SBC_MULT_32_16_SIMPLIFIED(s16In2, s32In1 , s32OutLow) \ +{ \ + s32In1Temp = s32In1; \ + s32In2Temp = (SINT32)s16In2; \ + \ + /* Multiply one +ve and the other -ve number */ \ + if (s32In1Temp < 0) \ + { \ + s32In1Temp ^= 0xFFFFFFFF; \ + s32In1Temp++; \ + s32OutLow = (s32In2Temp * (s32In1Temp >> 16)); \ + s32OutLow += (( s32In2Temp * (s32In1Temp & 0xFFFF)) >> 16); \ + s32OutLow ^= 0xFFFFFFFF; \ + s32OutLow++; \ + } \ + else \ + { \ + s32OutLow = (s32In2Temp * (s32In1Temp >> 16)); \ + s32OutLow += (( s32In2Temp * (s32In1Temp & 0xFFFF)) >> 16); \ + } \ + s32OutLow <<= 1; \ +} +#if (SBC_IS_64_MULT_IN_IDCT == TRUE) +#define SBC_MULT_64(s32In1, s32In2, s32OutLow, s32OutHi) \ +{\ + s32OutLow=(SINT32)(((SINT64)s32In1*(SINT64)s32In2)& 0x00000000FFFFFFFF);\ + s32OutHi=(SINT32)(((SINT64)s32In1*(SINT64)s32In2)>>32);\ +} +#define SBC_MULT_32_32(s32In2, s32In1, s32OutLow) \ +{ \ + s32HiTemp = 0; \ + SBC_MULT_64(s32In2,s32In1 , s32OutLow, s32HiTemp); \ + s32OutLow = (((s32OutLow>>15)&0x1FFFF) | (s32HiTemp << 17)); \ +} +#endif + +#endif +#endif +#endif + +#endif diff --git a/embdrv/sbc/encoder/include/sbc_enc_func_declare.h b/embdrv/sbc/encoder/include/sbc_enc_func_declare.h new file mode 100644 index 0000000..cfe5777 --- /dev/null +++ b/embdrv/sbc/encoder/include/sbc_enc_func_declare.h @@ -0,0 +1,46 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_enc_func_declare.h,v $ +** +** Description: Function declarations. +** +** Revision : $Id: sbc_enc_func_declare.h,v 1.8 2006/04/13 16:59:58 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#ifndef SBC_FUNCDECLARE_H +#define SBC_FUNCDECLARE_H + +/*#include "sbc_encoder.h"*/ +/* Global data */ +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == FALSE) +extern const SINT16 gas32CoeffFor4SBs[]; +extern const SINT16 gas32CoeffFor8SBs[]; +#else +extern const SINT32 gas32CoeffFor4SBs[]; +extern const SINT32 gas32CoeffFor8SBs[]; +#endif + +/* Global functions*/ + +extern void sbc_enc_bit_alloc_mono(SBC_ENC_PARAMS *CodecParams); +extern void sbc_enc_bit_alloc_ste(SBC_ENC_PARAMS *CodecParams); + +extern void SbcAnalysisInit (void); + +extern void SbcAnalysisFilter4(SBC_ENC_PARAMS *strEncParams); +extern void SbcAnalysisFilter8(SBC_ENC_PARAMS *strEncParams); + +extern void SBC_FastIDCT8 (SINT32 *pInVect, SINT32 *pOutVect); +extern void SBC_FastIDCT4 (SINT32 *x0, SINT32 *pOutVect); + +extern void EncPacking(SBC_ENC_PARAMS *strEncParams); +extern void EncQuantizer(SBC_ENC_PARAMS *); +#if (SBC_DSP_OPT==TRUE) + SINT32 SBC_Multiply_32_16_Simplified(SINT32 s32In2Temp,SINT32 s32In1Temp); +#endif +#endif + diff --git a/embdrv/sbc/encoder/include/sbc_encoder.h b/embdrv/sbc/encoder/include/sbc_encoder.h new file mode 100644 index 0000000..b348de8 --- /dev/null +++ b/embdrv/sbc/encoder/include/sbc_encoder.h @@ -0,0 +1,191 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_encoder.h,v $ +** +** Description: This file contains constants and structures used by Encoder. +** +** Revision : $Id: sbc_encoder.h,v 1.28 2006/06/27 12:29:32 mjougit Exp $ +** +** Copyright (c) 1999-2008, Broadcom Corp., All Rights Reserved. +** Broadcom Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#ifndef SBC_ENCODER_H +#define SBC_ENCODER_H + +#define ENCODER_VERSION "0025" + +#ifdef BUILDCFG + #include "bt_target.h" +#endif + +/*DEFINES*/ +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef TRUE +#define TRUE (!FALSE) +#endif + +#define SBC_MAX_NUM_OF_SUBBANDS 8 +#define SBC_MAX_NUM_OF_CHANNELS 2 +#define SBC_MAX_NUM_OF_BLOCKS 16 + +#define SBC_LOUDNESS 0 +#define SBC_SNR 1 + +#define SUB_BANDS_8 8 +#define SUB_BANDS_4 4 + +#define SBC_sf16000 0 +#define SBC_sf32000 1 +#define SBC_sf44100 2 +#define SBC_sf48000 3 + +#define SBC_MONO 0 +#define SBC_DUAL 1 +#define SBC_STEREO 2 +#define SBC_JOINT_STEREO 3 + +#define SBC_BLOCK_0 4 +#define SBC_BLOCK_1 8 +#define SBC_BLOCK_2 12 +#define SBC_BLOCK_3 16 + +#define SBC_NULL 0 + +#ifndef SBC_MAX_NUM_FRAME +#define SBC_MAX_NUM_FRAME 1 +#endif + +#ifndef SBC_DSP_OPT +#define SBC_DSP_OPT FALSE +#endif + +/* Set SBC_USE_ARM_PRAGMA to TRUE to use "#pragma arm section zidata" */ +#ifndef SBC_USE_ARM_PRAGMA +#define SBC_USE_ARM_PRAGMA FALSE +#endif + +/* Set SBC_ARM_ASM_OPT to TRUE in case the target is an ARM */ +/* this will replace all the 32 and 64 bit mult by in line assembly code */ +#ifndef SBC_ARM_ASM_OPT +#define SBC_ARM_ASM_OPT FALSE +#endif + +/* green hill compiler option -> Used to distinguish the syntax for inline assembly code*/ +#ifndef SBC_GHS_COMPILER +#define SBC_GHS_COMPILER FALSE +#endif + +/* ARM compiler option -> Used to distinguish the syntax for inline assembly code */ +#ifndef SBC_ARM_COMPILER +#define SBC_ARM_COMPILER TRUE +#endif + +/* Set SBC_IPAQ_OPT to TRUE in case the target is an ARM */ +/* 32 and 64 bit mult will be performed using SINT64 ( usualy __int64 ) cast that usualy give optimal performance if supported */ +#ifndef SBC_IPAQ_OPT +#define SBC_IPAQ_OPT TRUE +#endif + +/* Debug only: set SBC_IS_64_MULT_IN_WINDOW_ACCU to TRUE to use 64 bit multiplication in the windowing */ +/* -> not recomended, more MIPS for the same restitution. */ +#ifndef SBC_IS_64_MULT_IN_WINDOW_ACCU +#define SBC_IS_64_MULT_IN_WINDOW_ACCU FALSE +#endif /*SBC_IS_64_MULT_IN_WINDOW_ACCU */ + +/* Set SBC_IS_64_MULT_IN_IDCT to TRUE to use 64 bits multiplication in the DCT of Matrixing */ +/* -> more MIPS required for a better audio quality. comparasion with the SIG utilities shows a division by 10 of the RMS */ +/* CAUTION: It only apply in the if SBC_FAST_DCT is set to TRUE */ +#ifndef SBC_IS_64_MULT_IN_IDCT +#define SBC_IS_64_MULT_IN_IDCT FALSE +#endif /*SBC_IS_64_MULT_IN_IDCT */ + +/* set SBC_IS_64_MULT_IN_QUANTIZER to TRUE to use 64 bits multiplication in the quantizer */ +/* setting this flag to FALSE add whistling noise at 5.5 and 11 KHz usualy not perceptible by human's hears. */ +#ifndef SBC_IS_64_MULT_IN_QUANTIZER +#define SBC_IS_64_MULT_IN_QUANTIZER TRUE +#endif /*SBC_IS_64_MULT_IN_IDCT */ + +/* Debug only: set this flag to FALSE to disable fast DCT algorithm */ +#ifndef SBC_FAST_DCT +#define SBC_FAST_DCT TRUE +#endif /*SBC_FAST_DCT */ + +/* In case we do not use joint stereo mode the flag save some RAM and ROM in case it is set to FALSE */ +#ifndef SBC_JOINT_STE_INCLUDED +#define SBC_JOINT_STE_INCLUDED TRUE +#endif + +/* TRUE -> application should provide PCM buffer, FALSE PCM buffer reside in SBC_ENC_PARAMS */ +#ifndef SBC_NO_PCM_CPY_OPTION +#define SBC_NO_PCM_CPY_OPTION FALSE +#endif + +#define MINIMUM_ENC_VX_BUFFER_SIZE (8*10*2) +#ifndef ENC_VX_BUFFER_SIZE +#define ENC_VX_BUFFER_SIZE (MINIMUM_ENC_VX_BUFFER_SIZE + 64) +/*#define ENC_VX_BUFFER_SIZE MINIMUM_ENC_VX_BUFFER_SIZE + 1024*/ +#endif + +#ifndef SBC_FOR_EMBEDDED_LINUX +#define SBC_FOR_EMBEDDED_LINUX FALSE +#endif + +/*constants used for index calculation*/ +#define SBC_BLK (SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS) + +#include "sbc_types.h" + +typedef struct SBC_ENC_PARAMS_TAG +{ + SINT16 s16SamplingFreq; /* 16k, 32k, 44.1k or 48k*/ + SINT16 s16ChannelMode; /* mono, dual, streo or joint streo*/ + SINT16 s16NumOfSubBands; /* 4 or 8 */ + SINT16 s16NumOfChannels; + SINT16 s16NumOfBlocks; /* 4, 8, 12 or 16*/ + SINT16 s16AllocationMethod; /* loudness or SNR*/ + SINT16 s16BitPool; /* 16*numOfSb for mono & dual; + 32*numOfSb for stereo & joint stereo */ + UINT16 u16BitRate; + UINT8 u8NumPacketToEncode; /* number of sbc frame to encode. Default is 1 */ +#if (SBC_JOINT_STE_INCLUDED == TRUE) + SINT16 as16Join[SBC_MAX_NUM_OF_SUBBANDS]; /*1 if JS, 0 otherwise*/ +#endif + + SINT16 s16MaxBitNeed; + SINT16 as16ScaleFactor[SBC_MAX_NUM_OF_CHANNELS*SBC_MAX_NUM_OF_SUBBANDS]; + + SINT16 *ps16NextPcmBuffer; +#if (SBC_NO_PCM_CPY_OPTION == TRUE) + SINT16 *ps16PcmBuffer; +#else + SINT16 as16PcmBuffer[SBC_MAX_NUM_FRAME*SBC_MAX_NUM_OF_BLOCKS * SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS]; +#endif + + SINT16 s16ScartchMemForBitAlloc[16]; + + SINT32 s32SbBuffer[SBC_MAX_NUM_OF_CHANNELS * SBC_MAX_NUM_OF_SUBBANDS * SBC_MAX_NUM_OF_BLOCKS]; + + SINT16 as16Bits[SBC_MAX_NUM_OF_CHANNELS*SBC_MAX_NUM_OF_SUBBANDS]; + + UINT8 *pu8Packet; + UINT8 *pu8NextPacket; + UINT16 FrameHeader; + UINT16 u16PacketLength; + +}SBC_ENC_PARAMS; + +#ifdef __cplusplus +extern "C" +{ +#endif +SBC_API extern void SBC_Encoder(SBC_ENC_PARAMS *strEncParams); +SBC_API extern void SBC_Encoder_Init(SBC_ENC_PARAMS *strEncParams); +#ifdef __cplusplus +} +#endif +#endif diff --git a/embdrv/sbc/encoder/include/sbc_if.h b/embdrv/sbc/encoder/include/sbc_if.h new file mode 100644 index 0000000..7e4c2c5 --- /dev/null +++ b/embdrv/sbc/encoder/include/sbc_if.h @@ -0,0 +1,28 @@ +#ifndef _SBC_IF_H +#define _SBC_IF_H + +#define PCM_BUFFER_SIZE 512 + +/* + SBC_Init - called once for each track played + + pcm_sample_freq - 4000 to 48000 + channels - 1 mono 2 stereo + bits_per_sample - 8 or 16 + return - 0 sucess +*/ + +int SBC_init(int pcm_sample_freq, int channels, int bits_per_sample); + +/* + SBC_write - called repeatedly with pcm_in pointer + increasing by length until track is finished. + + pcm_in - pointer to PCM buffer + length - any + sbc_out - pointer to SBC output buffer + return - number of bytes written to sbc_out +*/ + +int SBC_write(unsigned char *pcm_in, int length, unsigned char *sbc_out); +#endif diff --git a/embdrv/sbc/encoder/include/sbc_types.h b/embdrv/sbc/encoder/include/sbc_types.h new file mode 100644 index 0000000..531bb2c --- /dev/null +++ b/embdrv/sbc/encoder/include/sbc_types.h @@ -0,0 +1,46 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_types.h,v $ +** +** Description: Data type declarations. +** +** Revision : $Id: sbc_types.h,v 1.7 2006/04/11 17:07:39 mjougit Exp $ +** +** Copyright (c) 1999-2008, Broadcom Corp., All Rights Reserved. +** Broadcom Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#ifndef SBC_TYPES_H +#define SBC_TYPES_H + +#ifdef BUILDCFG +#include "bt_target.h" +#endif + +#include "data_types.h" + +typedef short SINT16; +typedef long SINT32; + +#if (SBC_IPAQ_OPT == TRUE) + +#if (SBC_FOR_EMBEDDED_LINUX == TRUE) +typedef long long SINT64; +#else +typedef __int64 SINT64; +#endif + +#elif (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) || (SBC_IS_64_MULT_IN_IDCT == TRUE) + +#if (SBC_FOR_EMBEDDED_LINUX == TRUE) +typedef long long SINT64; +#else +typedef __int64 SINT64; +#endif + +#endif + +#define abs32(x) ( (x >= 0) ? x : (-x) ) + +#endif diff --git a/embdrv/sbc/encoder/srce/sbc_analysis.c b/embdrv/sbc/encoder/srce/sbc_analysis.c new file mode 100644 index 0000000..77f4dbe --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_analysis.c @@ -0,0 +1,1096 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_analysis.c,v $ +** +** Description: This file contains the code that performs Analysis of the input +** audio stream. +** +** Revision : $Id: sbc_analysis.c,v 1.29 2006/04/13 17:00:37 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ +#include <string.h> +#include "sbc_encoder.h" +#include "sbc_enc_func_declare.h" +/*#include <math.h>*/ + +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) +#define WIND_4_SUBBANDS_0_1 (SINT32)0x01659F45 /* gas32CoeffFor4SBs[8] = -gas32CoeffFor4SBs[32] = 0x01659F45 */ +#define WIND_4_SUBBANDS_0_2 (SINT32)0x115B1ED2 /* gas32CoeffFor4SBs[16] = -gas32CoeffFor4SBs[24] = 0x115B1ED2 */ +#define WIND_4_SUBBANDS_1_0 (SINT32)0x001194E6 /* gas32CoeffFor4SBs[1 et 39] = 0x001194E6 */ +#define WIND_4_SUBBANDS_1_1 (SINT32)0x029DBAA3 /* gas32CoeffFor4SBs[9 et 31] = 0x029DBAA3 */ +#define WIND_4_SUBBANDS_1_2 (SINT32)0x18F55C90 /* gas32CoeffFor4SBs[17 et 23] = 0x18F55C90 */ +#define WIND_4_SUBBANDS_1_3 (SINT32)0xF60FAF37 /* gas32CoeffFor4SBs[15 et 25] = 0xF60FAF37 */ +#define WIND_4_SUBBANDS_1_4 (SINT32)0xFF9BB9D5 /* gas32CoeffFor4SBs[7 et 33] = 0xFF9BB9D5 */ +#define WIND_4_SUBBANDS_2_0 (SINT32)0x0030E2D3 /* gas32CoeffFor4SBs[2 et 38] = 0x0030E2D3 */ +#define WIND_4_SUBBANDS_2_1 (SINT32)0x03B23341 /* gas32CoeffFor4SBs[10 et 30] = 0x03B23341 */ +#define WIND_4_SUBBANDS_2_2 (SINT32)0x1F91CA46 /* gas32CoeffFor4SBs[18 et 22] = 0x1F91CA46 */ +#define WIND_4_SUBBANDS_2_3 (SINT32)0xFC4F91D4 /* gas32CoeffFor4SBs[14 et 26] = 0xFC4F91D4 */ +#define WIND_4_SUBBANDS_2_4 (SINT32)0x003D239B /* gas32CoeffFor4SBs[6 et 34] = 0x003D239B */ +#define WIND_4_SUBBANDS_3_0 (SINT32)0x00599403 /* gas32CoeffFor4SBs[3 et 37] = 0x00599403 */ +#define WIND_4_SUBBANDS_3_1 (SINT32)0x041EEE40 /* gas32CoeffFor4SBs[11 et 29] = 0x041EEE40 */ +#define WIND_4_SUBBANDS_3_2 (SINT32)0x2412F251 /* gas32CoeffFor4SBs[19 et 21] = 0x2412F251 */ +#define WIND_4_SUBBANDS_3_3 (SINT32)0x00C8F2BC /* gas32CoeffFor4SBs[13 et 27] = 0x00C8F2BC */ +#define WIND_4_SUBBANDS_3_4 (SINT32)0x007F88E4 /* gas32CoeffFor4SBs[5 et 35] = 0x007F88E4 */ +#define WIND_4_SUBBANDS_4_0 (SINT32)0x007DBCC8 /* gas32CoeffFor4SBs[4 et 36] = 0x007DBCC8 */ +#define WIND_4_SUBBANDS_4_1 (SINT32)0x034FEE2C /* gas32CoeffFor4SBs[12 et 28] = 0x034FEE2C */ +#define WIND_4_SUBBANDS_4_2 (SINT32)0x25AC1FF2 /* gas32CoeffFor4SBs[20] = 0x25AC1FF2 */ + +#define WIND_8_SUBBANDS_0_1 (SINT32)0x00B97348 /* 16 0x00B97348 */ +#define WIND_8_SUBBANDS_0_2 (SINT32)0x08B4307A /* 32 0x08B4307A */ +#define WIND_8_SUBBANDS_1_0 (SINT32)0x00052173 /* 1 et 79 = 0x00052173 */ +#define WIND_8_SUBBANDS_1_1 (SINT32)0x01071B96 /* 17 et 63 = 0x01071B96 */ +#define WIND_8_SUBBANDS_1_2 (SINT32)0x0A9F3E9A /* 33 et 47 = 0x0A9F3E9A*/ +#define WIND_8_SUBBANDS_1_3 (SINT32)0xF9312891 /* 31 et 49 = 0xF9312891 */ +#define WIND_8_SUBBANDS_1_4 (SINT32)0xFF8D6793 /* 15 et 65 = 0xFF8D6793 */ +#define WIND_8_SUBBANDS_2_0 (SINT32)0x000B3F71 /* 2 et 78 = 0x000B3F71 */ +#define WIND_8_SUBBANDS_2_1 (SINT32)0x0156B3CA /* 18 et 62 = 0x0156B3CA */ +#define WIND_8_SUBBANDS_2_2 (SINT32)0x0C7D59B6 /* 34 et 46 = 0x0C7D59B6 */ +#define WIND_8_SUBBANDS_2_3 (SINT32)0xFAFF95FC /* 30 et 50 = 0xFAFF95FC */ +#define WIND_8_SUBBANDS_2_4 (SINT32)0xFFC9F10E /* 14 et 66 = 0xFFC9F10E */ +#define WIND_8_SUBBANDS_3_0 (SINT32)0x00122C7D /* 3 et 77 = 0x00122C7D*/ +#define WIND_8_SUBBANDS_3_1 (SINT32)0x01A1B38B /* 19 et 61 = 0x01A1B38B */ +#define WIND_8_SUBBANDS_3_2 (SINT32)0x0E3BB16F /* 35 et 45 = 0x0E3BB16F */ +#define WIND_8_SUBBANDS_3_3 (SINT32)0xFCA86E7E /* 29 et 51 = 0xFCA86E7E */ +#define WIND_8_SUBBANDS_3_4 (SINT32)0xFFFA2413 /* 13 et 67 = 0xFFFA2413 */ +#define WIND_8_SUBBANDS_4_0 (SINT32)0x001AFF89 /* 4 et 66 = 0x001AFF89 */ +#define WIND_8_SUBBANDS_4_1 (SINT32)0x01E0224C /* 20 et 60 = 0x01E0224C */ +#define WIND_8_SUBBANDS_4_2 (SINT32)0x0FC721F9 /* 36 et 44 = 0x0FC721F9 */ +#define WIND_8_SUBBANDS_4_3 (SINT32)0xFE20435D /* 28 et 52 = 0xFE20435D */ +#define WIND_8_SUBBANDS_4_4 (SINT32)0x001D8FD2 /* 12 et 68 = 0x001D8FD2 */ +#define WIND_8_SUBBANDS_5_0 (SINT32)0x00255A62 /* 5 et 75 = 0x00255A62 */ +#define WIND_8_SUBBANDS_5_1 (SINT32)0x0209291F /* 21 et 59 = 0x0209291F */ +#define WIND_8_SUBBANDS_5_2 (SINT32)0x110ECEF0 /* 37 et 43 = 0x110ECEF0 */ +#define WIND_8_SUBBANDS_5_3 (SINT32)0xFF5EEB73 /* 27 et 53 = 0xFF5EEB73 */ +#define WIND_8_SUBBANDS_5_4 (SINT32)0x0034F8B6 /* 11 et 69 = 0x0034F8B6 */ +#define WIND_8_SUBBANDS_6_0 (SINT32)0x003060F4 /* 6 et 74 = 0x003060F4 */ +#define WIND_8_SUBBANDS_6_1 (SINT32)0x02138653 /* 22 et 58 = 0x02138653 */ +#define WIND_8_SUBBANDS_6_2 (SINT32)0x120435FA /* 38 et 42 = 0x120435FA */ +#define WIND_8_SUBBANDS_6_3 (SINT32)0x005FD0FF /* 26 et 54 = 0x005FD0FF */ +#define WIND_8_SUBBANDS_6_4 (SINT32)0x00415B75 /* 10 et 70 = 0x00415B75 */ +#define WIND_8_SUBBANDS_7_0 (SINT32)0x003A72E7 /* 7 et 73 = 0x003A72E7 */ +#define WIND_8_SUBBANDS_7_1 (SINT32)0x01F5F424 /* 23 et 57 = 0x01F5F424 */ +#define WIND_8_SUBBANDS_7_2 (SINT32)0x129C226F /* 39 et 41 = 0x129C226F */ +#define WIND_8_SUBBANDS_7_3 (SINT32)0x01223EBA /* 25 et 55 = 0x01223EBA */ +#define WIND_8_SUBBANDS_7_4 (SINT32)0x0044EF48 /* 9 et 71 = 0x0044EF48 */ +#define WIND_8_SUBBANDS_8_0 (SINT32)0x0041EC6A /* 8 et 72 = 0x0041EC6A */ +#define WIND_8_SUBBANDS_8_1 (SINT32)0x01A7ECEF /* 24 et 56 = 0x01A7ECEF */ +#define WIND_8_SUBBANDS_8_2 (SINT32)0x12CF6C75 /* 40 = 0x12CF6C75 */ +#else +#define WIND_4_SUBBANDS_0_1 (SINT16)0x0166 /* gas32CoeffFor4SBs[8] = -gas32CoeffFor4SBs[32] = 0x01659F45 */ +#define WIND_4_SUBBANDS_0_2 (SINT16)0x115B /* gas32CoeffFor4SBs[16] = -gas32CoeffFor4SBs[24] = 0x115B1ED2 */ +#define WIND_4_SUBBANDS_1_0 (SINT16)0x0012 /* gas32CoeffFor4SBs[1 et 39] = 0x001194E6 */ +#define WIND_4_SUBBANDS_1_1 (SINT16)0x029E /* gas32CoeffFor4SBs[9 et 31] = 0x029DBAA3 */ +#define WIND_4_SUBBANDS_1_2 (SINT16)0x18F5 /* gas32CoeffFor4SBs[17 et 23] = 0x18F55C90 */ +#define WIND_4_SUBBANDS_1_3 (SINT16)0xF610 /* gas32CoeffFor4SBs[15 et 25] = 0xF60FAF37 */ +#define WIND_4_SUBBANDS_1_4 (SINT16)0xFF9C /* gas32CoeffFor4SBs[7 et 33] = 0xFF9BB9D5 */ +#define WIND_4_SUBBANDS_2_0 (SINT16)0x0031 /* gas32CoeffFor4SBs[2 et 38] = 0x0030E2D3 */ +#define WIND_4_SUBBANDS_2_1 (SINT16)0x03B2 /* gas32CoeffFor4SBs[10 et 30] = 0x03B23341 */ +#define WIND_4_SUBBANDS_2_2 (SINT16)0x1F91 /* gas32CoeffFor4SBs[18 et 22] = 0x1F91CA46 */ +#define WIND_4_SUBBANDS_2_3 (SINT16)0xFC50 /* gas32CoeffFor4SBs[14 et 26] = 0xFC4F91D4 */ +#define WIND_4_SUBBANDS_2_4 (SINT16)0x003D /* gas32CoeffFor4SBs[6 et 34] = 0x003D239B */ +#define WIND_4_SUBBANDS_3_0 (SINT16)0x005A /* gas32CoeffFor4SBs[3 et 37] = 0x00599403 */ +#define WIND_4_SUBBANDS_3_1 (SINT16)0x041F /* gas32CoeffFor4SBs[11 et 29] = 0x041EEE40 */ +#define WIND_4_SUBBANDS_3_2 (SINT16)0x2413 /* gas32CoeffFor4SBs[19 et 21] = 0x2412F251 */ +#define WIND_4_SUBBANDS_3_3 (SINT16)0x00C9 /* gas32CoeffFor4SBs[13 et 27] = 0x00C8F2BC */ +#define WIND_4_SUBBANDS_3_4 (SINT16)0x0080 /* gas32CoeffFor4SBs[5 et 35] = 0x007F88E4 */ +#define WIND_4_SUBBANDS_4_0 (SINT16)0x007E /* gas32CoeffFor4SBs[4 et 36] = 0x007DBCC8 */ +#define WIND_4_SUBBANDS_4_1 (SINT16)0x0350 /* gas32CoeffFor4SBs[12 et 28] = 0x034FEE2C */ +#define WIND_4_SUBBANDS_4_2 (SINT16)0x25AC /* gas32CoeffFor4SBs[20] = 25AC1FF2 */ + +#define WIND_8_SUBBANDS_0_1 (SINT16)0x00B9 /* 16 0x12CF6C75 */ +#define WIND_8_SUBBANDS_0_2 (SINT16)0x08B4 /* 32 0x08B4307A */ +#define WIND_8_SUBBANDS_1_0 (SINT16)0x0005 /* 1 et 79 = 0x00052173 */ +#define WIND_8_SUBBANDS_1_1 (SINT16)0x0107 /* 17 et 63 = 0x01071B96 */ +#define WIND_8_SUBBANDS_1_2 (SINT16)0x0A9F /* 33 et 47 = 0x0A9F3E9A*/ +#define WIND_8_SUBBANDS_1_3 (SINT16)0xF931 /* 31 et 49 = 0xF9312891 */ +#define WIND_8_SUBBANDS_1_4 (SINT16)0xFF8D /* 15 et 65 = 0xFF8D6793 */ +#define WIND_8_SUBBANDS_2_0 (SINT16)0x000B /* 2 et 78 = 0x000B3F71 */ +#define WIND_8_SUBBANDS_2_1 (SINT16)0x0157 /* 18 et 62 = 0x0156B3CA */ +#define WIND_8_SUBBANDS_2_2 (SINT16)0x0C7D /* 34 et 46 = 0x0C7D59B6 */ +#define WIND_8_SUBBANDS_2_3 (SINT16)0xFB00 /* 30 et 50 = 0xFAFF95FC */ +#define WIND_8_SUBBANDS_2_4 (SINT16)0xFFCA /* 14 et 66 = 0xFFC9F10E */ +#define WIND_8_SUBBANDS_3_0 (SINT16)0x0012 /* 3 et 77 = 0x00122C7D*/ +#define WIND_8_SUBBANDS_3_1 (SINT16)0x01A2 /* 19 et 61 = 0x01A1B38B */ +#define WIND_8_SUBBANDS_3_2 (SINT16)0x0E3C /* 35 et 45 = 0x0E3BB16F */ +#define WIND_8_SUBBANDS_3_3 (SINT16)0xFCA8 /* 29 et 51 = 0xFCA86E7E */ +#define WIND_8_SUBBANDS_3_4 (SINT16)0xFFFA /* 13 et 67 = 0xFFFA2413 */ +#define WIND_8_SUBBANDS_4_0 (SINT16)0x001B /* 4 et 66 = 0x001AFF89 */ +#define WIND_8_SUBBANDS_4_1 (SINT16)0x01E0 /* 20 et 60 = 0x01E0224C */ +#define WIND_8_SUBBANDS_4_2 (SINT16)0x0FC7 /* 36 et 44 = 0x0FC721F9 */ +#define WIND_8_SUBBANDS_4_3 (SINT16)0xFE20 /* 28 et 52 = 0xFE20435D */ +#define WIND_8_SUBBANDS_4_4 (SINT16)0x001E /* 12 et 68 = 0x001D8FD2 */ +#define WIND_8_SUBBANDS_5_0 (SINT16)0x0025 /* 5 et 75 = 0x00255A62 */ +#define WIND_8_SUBBANDS_5_1 (SINT16)0x0209 /* 21 et 59 = 0x0209291F */ +#define WIND_8_SUBBANDS_5_2 (SINT16)0x110F /* 37 et 43 = 0x110ECEF0 */ +#define WIND_8_SUBBANDS_5_3 (SINT16)0xFF5F /* 27 et 53 = 0xFF5EEB73 */ +#define WIND_8_SUBBANDS_5_4 (SINT16)0x0035 /* 11 et 69 = 0x0034F8B6 */ +#define WIND_8_SUBBANDS_6_0 (SINT16)0x0030 /* 6 et 74 = 0x003060F4 */ +#define WIND_8_SUBBANDS_6_1 (SINT16)0x0214 /* 22 et 58 = 0x02138653 */ +#define WIND_8_SUBBANDS_6_2 (SINT16)0x1204 /* 38 et 42 = 0x120435FA */ +#define WIND_8_SUBBANDS_6_3 (SINT16)0x0060 /* 26 et 54 = 0x005FD0FF */ +#define WIND_8_SUBBANDS_6_4 (SINT16)0x0041 /* 10 et 70 = 0x00415B75 */ +#define WIND_8_SUBBANDS_7_0 (SINT16)0x003A /* 7 et 73 = 0x003A72E7 */ +#define WIND_8_SUBBANDS_7_1 (SINT16)0x01F6 /* 23 et 57 = 0x01F5F424 */ +#define WIND_8_SUBBANDS_7_2 (SINT16)0x129C /* 39 et 41 = 0x129C226F */ +#define WIND_8_SUBBANDS_7_3 (SINT16)0x0122 /* 25 et 55 = 0x01223EBA */ +#define WIND_8_SUBBANDS_7_4 (SINT16)0x0045 /* 9 et 71 = 0x0044EF48 */ +#define WIND_8_SUBBANDS_8_0 (SINT16)0x0042 /* 8 et 72 = 0x0041EC6A */ +#define WIND_8_SUBBANDS_8_1 (SINT16)0x01A8 /* 24 et 56 = 0x01A7ECEF */ +#define WIND_8_SUBBANDS_8_2 (SINT16)0x12CF /* 40 = 0x12CF6C75 */ +#endif + +#if (SBC_USE_ARM_PRAGMA==TRUE) +#pragma arm section zidata = "sbc_s32_analysis_section" +#endif +static SINT32 s32DCTY[16] = {0}; +static SINT32 s32X[ENC_VX_BUFFER_SIZE/2]; +static SINT16 *s16X=(SINT16*) s32X; /* s16X must be 32 bits aligned cf SHIFTUP_X8_2*/ +#if (SBC_USE_ARM_PRAGMA==TRUE) +#pragma arm section zidata +#endif + +/* This macro is for 4 subbands */ +#define SHIFTUP_X4 \ +{ \ + ps32X=(SINT32 *)(s16X+EncMaxShiftCounter+38); \ + for (i=0;i<9;i++) \ + { \ + *ps32X=*(ps32X-2-(ShiftCounter>>1)); ps32X--; \ + *ps32X=*(ps32X-2-(ShiftCounter>>1)); ps32X--; \ + } \ +} +#define SHIFTUP_X4_2 \ +{ \ + ps32X=(SINT32 *)(s16X+EncMaxShiftCounter+38); \ + ps32X2=(SINT32 *)(s16X+(EncMaxShiftCounter<<1)+78); \ + for (i=0;i<9;i++) \ + { \ + *ps32X=*(ps32X-2-(ShiftCounter>>1)); *(ps32X2)=*(ps32X2-2-(ShiftCounter>>1)); ps32X--; ps32X2--; \ + *ps32X=*(ps32X-2-(ShiftCounter>>1)); *(ps32X2)=*(ps32X2-2-(ShiftCounter>>1)); ps32X--; ps32X2--; \ + } \ +} + +/* This macro is for 8 subbands */ +#define SHIFTUP_X8 \ +{ \ + ps32X=(SINT32 *)(s16X+EncMaxShiftCounter+78); \ + for (i=0;i<9;i++) \ + { \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); ps32X--; \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); ps32X--; \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); ps32X--; \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); ps32X--; \ + } \ +} +#define SHIFTUP_X8_2 \ +{ \ + ps32X=(SINT32 *)(s16X+EncMaxShiftCounter+78); \ + ps32X2=(SINT32 *)(s16X+(EncMaxShiftCounter<<1)+158); \ + for (i=0;i<9;i++) \ + { \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); *(ps32X2)=*(ps32X2-4-(ShiftCounter>>1)); ps32X--; ps32X2--; \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); *(ps32X2)=*(ps32X2-4-(ShiftCounter>>1)); ps32X--; ps32X2--; \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); *(ps32X2)=*(ps32X2-4-(ShiftCounter>>1)); ps32X--; ps32X2--; \ + *ps32X=*(ps32X-4-(ShiftCounter>>1)); *(ps32X2)=*(ps32X2-4-(ShiftCounter>>1)); ps32X--; ps32X2--; \ + } \ +} + +#if (SBC_ARM_ASM_OPT==TRUE) +#define WINDOW_ACCU_8_0 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_0_1,(s16X[ChOffset+16]-s16X[ChOffset+64]);\ + MLA s32Hi,WIND_8_SUBBANDS_0_2,(s16X[ChOffset+32]-s16X[ChOffset+48]),s32Hi;\ + MOV s32DCTY[0],s32Hi;\ + }\ +} +#define WINDOW_ACCU_8_1_15 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_1_0,s16X[ChOffset+1];\ + MUL s32Hi2,WIND_8_SUBBANDS_1_0,s16X[ChOffset+64+15];\ + MLA s32Hi,WIND_8_SUBBANDS_1_1,s16X[ChOffset+16+1],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_1_1,s16X[ChOffset+48+15],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_1_2,s16X[ChOffset+32+1],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_1_2,s16X[ChOffset+32+15],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_1_3,s16X[ChOffset+48+1],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_1_3,s16X[ChOffset+16+15],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_1_4,s16X[ChOffset+64+1],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_1_4,s16X[ChOffset+15],s32Hi2;\ + MOV s32DCTY[1],s32Hi;\ + MOV s32DCTY[15],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_2_14 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_2_0,s16X[ChOffset+2];\ + MUL s32Hi2,WIND_8_SUBBANDS_2_0,s16X[ChOffset+64+14];\ + MLA s32Hi,WIND_8_SUBBANDS_2_1,s16X[ChOffset+16+2],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_2_1,s16X[ChOffset+48+14],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_2_2,s16X[ChOffset+32+2],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_2_2,s16X[ChOffset+32+14],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_2_3,s16X[ChOffset+48+2],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_2_3,s16X[ChOffset+16+14],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_2_4,s16X[ChOffset+64+2],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_2_4,s16X[ChOffset+14],s32Hi2;\ + MOV s32DCTY[2],s32Hi;\ + MOV s32DCTY[14],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_3_13 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_3_0,s16X[ChOffset+3];\ + MUL s32Hi2,WIND_8_SUBBANDS_3_0,s16X[ChOffset+64+13];\ + MLA s32Hi,WIND_8_SUBBANDS_3_1,s16X[ChOffset+16+3],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_3_1,s16X[ChOffset+48+13],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_3_2,s16X[ChOffset+32+3],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_3_2,s16X[ChOffset+32+13],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_3_3,s16X[ChOffset+48+3],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_3_3,s16X[ChOffset+16+13],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_3_4,s16X[ChOffset+64+3],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_3_4,s16X[ChOffset+13],s32Hi2;\ + MOV s32DCTY[3],s32Hi;\ + MOV s32DCTY[13],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_4_12 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_4_0,s16X[ChOffset+4];\ + MUL s32Hi2,WIND_8_SUBBANDS_4_0,s16X[ChOffset+64+12];\ + MLA s32Hi,WIND_8_SUBBANDS_4_1,s16X[ChOffset+16+4],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_4_1,s16X[ChOffset+48+12],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_4_2,s16X[ChOffset+32+4],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_4_2,s16X[ChOffset+32+12],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_4_3,s16X[ChOffset+48+4],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_4_3,s16X[ChOffset+16+12],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_4_4,s16X[ChOffset+64+4],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_4_4,s16X[ChOffset+12],s32Hi2;\ + MOV s32DCTY[4],s32Hi;\ + MOV s32DCTY[12],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_5_11 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_5_0,s16X[ChOffset+5];\ + MUL s32Hi2,WIND_8_SUBBANDS_5_0,s16X[ChOffset+64+11];\ + MLA s32Hi,WIND_8_SUBBANDS_5_1,s16X[ChOffset+16+5],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_5_1,s16X[ChOffset+48+11],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_5_2,s16X[ChOffset+32+5],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_5_2,s16X[ChOffset+32+11],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_5_3,s16X[ChOffset+48+5],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_5_3,s16X[ChOffset+16+11],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_5_4,s16X[ChOffset+64+5],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_5_4,s16X[ChOffset+11],s32Hi2;\ + MOV s32DCTY[5],s32Hi;\ + MOV s32DCTY[11],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_6_10 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_6_0,s16X[ChOffset+6];\ + MUL s32Hi2,WIND_8_SUBBANDS_6_0,s16X[ChOffset+64+10];\ + MLA s32Hi,WIND_8_SUBBANDS_6_1,s16X[ChOffset+16+6],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_6_1,s16X[ChOffset+48+10],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_6_2,s16X[ChOffset+32+6],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_6_2,s16X[ChOffset+32+10],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_6_3,s16X[ChOffset+48+6],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_6_3,s16X[ChOffset+16+10],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_6_4,s16X[ChOffset+64+6],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_6_4,s16X[ChOffset+10],s32Hi2;\ + MOV s32DCTY[6],s32Hi;\ + MOV s32DCTY[10],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_7_9 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_7_0,s16X[ChOffset+7];\ + MUL s32Hi2,WIND_8_SUBBANDS_7_0,s16X[ChOffset+64+9];\ + MLA s32Hi,WIND_8_SUBBANDS_7_1,s16X[ChOffset+16+7],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_7_1,s16X[ChOffset+48+9],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_7_2,s16X[ChOffset+32+7],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_7_2,s16X[ChOffset+32+9],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_7_3,s16X[ChOffset+48+7],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_7_3,s16X[ChOffset+16+9],s32Hi2;\ + MLA s32Hi,WIND_8_SUBBANDS_7_4,s16X[ChOffset+64+7],s32Hi;\ + MLA s32Hi2,WIND_8_SUBBANDS_7_4,s16X[ChOffset+9],s32Hi2;\ + MOV s32DCTY[7],s32Hi;\ + MOV s32DCTY[9],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_8_8 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_8_SUBBANDS_8_0,(s16X[ChOffset+8]+s16X[ChOffset+8+64]);\ + MLA s32Hi,WIND_8_SUBBANDS_8_1,(s16X[ChOffset+8+16]+s16X[ChOffset+8+64]),s32Hi;\ + MLA s32Hi,WIND_8_SUBBANDS_8_2,s16X[ChOffset+8+32],s32Hi;\ + MOV s32DCTY[8],s32Hi;\ + }\ +} +#define WINDOW_ACCU_4_0 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_4_SUBBANDS_0_1,(s16X[ChOffset+8]-s16X[ChOffset+32]);\ + MLA s32Hi,WIND_4_SUBBANDS_0_2,(s16X[ChOffset+16]-s16X[ChOffset+24]),s32Hi;\ + MOV s32DCTY[0],s32Hi;\ + }\ +} +#define WINDOW_ACCU_4_1_7 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_4_SUBBANDS_1_0,s16X[ChOffset+1];\ + MUL s32Hi2,WIND_4_SUBBANDS_1_0,s16X[ChOffset+32+7];\ + MLA s32Hi,WIND_4_SUBBANDS_1_1,s16X[ChOffset+8+1],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_1_1,s16X[ChOffset+24+7],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_1_2,s16X[ChOffset+16+1],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_1_2,s16X[ChOffset+16+7],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_1_3,s16X[ChOffset+24+1],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_1_3,s16X[ChOffset+8+7],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_1_4,s16X[ChOffset+32+1],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_1_4,s16X[ChOffset+7],s32Hi2;\ + MOV s32DCTY[1],s32Hi;\ + MOV s32DCTY[7],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_4_2_6 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_4_SUBBANDS_2_0,s16X[ChOffset+2];\ + MUL s32Hi2,WIND_4_SUBBANDS_2_0,s16X[ChOffset+32+6];\ + MLA s32Hi,WIND_4_SUBBANDS_2_1,s16X[ChOffset+8+2],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_2_1,s16X[ChOffset+24+6],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_2_2,s16X[ChOffset+16+2],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_2_2,s16X[ChOffset+16+6],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_2_3,s16X[ChOffset+24+2],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_2_3,s16X[ChOffset+8+6],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_2_4,s16X[ChOffset+32+2],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_2_4,s16X[ChOffset+6],s32Hi2;\ + MOV s32DCTY[2],s32Hi;\ + MOV s32DCTY[6],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_4_3_5 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_4_SUBBANDS_3_0,s16X[ChOffset+3];\ + MUL s32Hi2,WIND_4_SUBBANDS_3_0,s16X[ChOffset+32+5];\ + MLA s32Hi,WIND_4_SUBBANDS_3_1,s16X[ChOffset+8+3],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_3_1,s16X[ChOffset+24+5],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_3_2,s16X[ChOffset+16+3],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_3_2,s16X[ChOffset+16+5],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_3_3,s16X[ChOffset+24+3],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_3_3,s16X[ChOffset+8+5],s32Hi2;\ + MLA s32Hi,WIND_4_SUBBANDS_3_4,s16X[ChOffset+32+3],s32Hi;\ + MLA s32Hi2,WIND_4_SUBBANDS_3_4,s16X[ChOffset+5],s32Hi2;\ + MOV s32DCTY[3],s32Hi;\ + MOV s32DCTY[5],s32Hi2;\ + }\ +} +#define WINDOW_ACCU_4_4 \ +{\ + __asm\ + {\ + MUL s32Hi,WIND_4_SUBBANDS_4_0,(s16X[ChOffset+4]+s16X[ChOffset+4+32]);\ + MLA s32Hi,WIND_4_SUBBANDS_4_1,(s16X[ChOffset+4+8]+s16X[ChOffset+4+24]),s32Hi;\ + MLA s32Hi,WIND_4_SUBBANDS_4_2,s16X[ChOffset+4+16],s32Hi;\ + MOV s32DCTY[4],s32Hi;\ + }\ +} + +#define WINDOW_PARTIAL_4 \ +{\ + WINDOW_ACCU_4_0; WINDOW_ACCU_4_1_7;\ + WINDOW_ACCU_4_2_6; WINDOW_ACCU_4_3_5;\ + WINDOW_ACCU_4_4;\ +} + +#define WINDOW_PARTIAL_8 \ +{\ + WINDOW_ACCU_8_0; WINDOW_ACCU_8_1_15;\ + WINDOW_ACCU_8_2_14; WINDOW_ACCU_8_3_13;\ + WINDOW_ACCU_8_4_12; WINDOW_ACCU_8_5_11;\ + WINDOW_ACCU_8_6_10; WINDOW_ACCU_8_7_9;\ + WINDOW_ACCU_8_8;\ +} + +#else +#if (SBC_IPAQ_OPT==TRUE) + +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) +#define WINDOW_ACCU_8_0 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_0_1*(SINT64)(s16X[ChOffset+16]-s16X[ChOffset+64]);\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_0_2*(SINT64)(s16X[ChOffset+32]-s16X[ChOffset+48]);\ + s32DCTY[0]=(SINT32)(s64Temp>>16);\ +} +#define WINDOW_ACCU_8_1_15 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_1_0*(SINT64)s16X[ChOffset+1];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_1_0*(SINT64)s16X[ChOffset+64+15];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_1_1*(SINT64)s16X[ChOffset+16+1];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_1_1*(SINT64)s16X[ChOffset+48+15];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_1_2*(SINT64)s16X[ChOffset+32+1];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_1_2*(SINT64)s16X[ChOffset+32+15];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_1_3*(SINT64)s16X[ChOffset+48+1];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_1_3*(SINT64)s16X[ChOffset+16+15];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_1_4*(SINT64)s16X[ChOffset+64+1];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_1_4*(SINT64)s16X[ChOffset+15];\ + s32DCTY[1]=(SINT32)(s64Temp>>16);\ + s32DCTY[15]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_2_14 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_2_0*(SINT64)s16X[ChOffset+2];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_2_0*(SINT64)s16X[ChOffset+64+14];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_2_1*(SINT64)s16X[ChOffset+16+2];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_2_1*(SINT64)s16X[ChOffset+48+14];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_2_2*(SINT64)s16X[ChOffset+32+2];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_2_2*(SINT64)s16X[ChOffset+32+14];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_2_3*(SINT64)s16X[ChOffset+48+2];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_2_3*(SINT64)s16X[ChOffset+16+14];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_2_4*(SINT64)s16X[ChOffset+64+2];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_2_4*(SINT64)s16X[ChOffset+14];\ + s32DCTY[2]=(SINT32)(s64Temp>>16);\ + s32DCTY[14]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_3_13 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_3_0*(SINT64)s16X[ChOffset+3];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_3_0*(SINT64)s16X[ChOffset+64+13];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_3_1*(SINT64)s16X[ChOffset+16+3];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_3_1*(SINT64)s16X[ChOffset+48+13];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_3_2*(SINT64)s16X[ChOffset+32+3];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_3_2*(SINT64)s16X[ChOffset+32+13];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_3_3*(SINT64)s16X[ChOffset+48+3];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_3_3*(SINT64)s16X[ChOffset+16+13];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_3_4*(SINT64)s16X[ChOffset+64+3];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_3_4*(SINT64)s16X[ChOffset+13];\ + s32DCTY[3]=(SINT32)(s64Temp>>16);\ + s32DCTY[13]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_4_12 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_4_0*(SINT64)s16X[ChOffset+4];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_4_0*(SINT64)s16X[ChOffset+64+12];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_4_1*(SINT64)s16X[ChOffset+16+4];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_4_1*(SINT64)s16X[ChOffset+48+12];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_4_2*(SINT64)s16X[ChOffset+32+4];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_4_2*(SINT64)s16X[ChOffset+32+12];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_4_3*(SINT64)s16X[ChOffset+48+4];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_4_3*(SINT64)s16X[ChOffset+16+12];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_4_4*(SINT64)s16X[ChOffset+64+4];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_4_4*(SINT64)s16X[ChOffset+12];\ + s32DCTY[4]=(SINT32)(s64Temp>>16);\ + s32DCTY[12]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_5_11 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_5_0*(SINT64)s16X[ChOffset+5];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_5_0*(SINT64)s16X[ChOffset+64+11];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_5_1*(SINT64)s16X[ChOffset+16+5];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_5_1*(SINT64)s16X[ChOffset+48+11];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_5_2*(SINT64)s16X[ChOffset+32+5];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_5_2*(SINT64)s16X[ChOffset+32+11];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_5_3*(SINT64)s16X[ChOffset+48+5];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_5_3*(SINT64)s16X[ChOffset+16+11];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_5_4*(SINT64)s16X[ChOffset+64+5];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_5_4*(SINT64)s16X[ChOffset+11];\ + s32DCTY[5]=(SINT32)(s64Temp>>16);\ + s32DCTY[11]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_6_10 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_6_0*(SINT64)s16X[ChOffset+6];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_6_0*(SINT64)s16X[ChOffset+64+10];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_6_1*(SINT64)s16X[ChOffset+16+6];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_6_1*(SINT64)s16X[ChOffset+48+10];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_6_2*(SINT64)s16X[ChOffset+32+6];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_6_2*(SINT64)s16X[ChOffset+32+10];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_6_3*(SINT64)s16X[ChOffset+48+6];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_6_3*(SINT64)s16X[ChOffset+16+10];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_6_4*(SINT64)s16X[ChOffset+64+6];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_6_4*(SINT64)s16X[ChOffset+10];\ + s32DCTY[6]=(SINT32)(s64Temp>>16);\ + s32DCTY[10]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_7_9 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_7_0*(SINT64)s16X[ChOffset+7];\ + s64Temp2=(SINT64)WIND_8_SUBBANDS_7_0*(SINT64)s16X[ChOffset+64+9];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_7_1*(SINT64)s16X[ChOffset+16+7];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_7_1*(SINT64)s16X[ChOffset+48+9];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_7_2*(SINT64)s16X[ChOffset+32+7];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_7_2*(SINT64)s16X[ChOffset+32+9];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_7_3*(SINT64)s16X[ChOffset+48+7];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_7_3*(SINT64)s16X[ChOffset+16+9];\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_7_4*(SINT64)s16X[ChOffset+64+7];\ + s64Temp2+=(SINT64)WIND_8_SUBBANDS_7_4*(SINT64)s16X[ChOffset+9];\ + s32DCTY[7]=(SINT32)(s64Temp>>16);\ + s32DCTY[9]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_8_8 \ +{\ + s64Temp=(SINT64)WIND_8_SUBBANDS_8_0*(SINT64)(s16X[ChOffset+8]+s16X[ChOffset+64+8]);\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_8_1*(SINT64)(s16X[ChOffset+16+8]+s16X[ChOffset+48+8]);\ + s64Temp+=(SINT64)WIND_8_SUBBANDS_8_2*(SINT64)s16X[ChOffset+32+8];\ + s32DCTY[8]=(SINT32)(s64Temp>>16);\ +} +#define WINDOW_ACCU_4_0 \ +{\ + s64Temp=(SINT64)WIND_4_SUBBANDS_0_1*(SINT64)(s16X[ChOffset+8]-s16X[ChOffset+32]);\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_0_2*(SINT64)(s16X[ChOffset+16]-s16X[ChOffset+24]);\ + s32DCTY[0]=(SINT32)(s64Temp>>16);\ +} +#define WINDOW_ACCU_4_1_7 \ +{\ + s64Temp=(SINT64)WIND_4_SUBBANDS_1_0*(SINT64)s16X[ChOffset+1];\ + s64Temp2=(SINT64)WIND_4_SUBBANDS_1_0*(SINT64)s16X[ChOffset+32+7];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_1_1*(SINT64)s16X[ChOffset+8+1];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_1_1*(SINT64)s16X[ChOffset+24+7];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_1_2*(SINT64)s16X[ChOffset+16+1];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_1_2*(SINT64)s16X[ChOffset+16+7];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_1_3*(SINT64)s16X[ChOffset+24+1];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_1_3*(SINT64)s16X[ChOffset+8+7];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_1_4*(SINT64)s16X[ChOffset+32+1];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_1_4*(SINT64)s16X[ChOffset+7];\ + s32DCTY[1]=(SINT32)(s64Temp>>16);\ + s32DCTY[7]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_4_2_6 \ +{\ + s64Temp=(SINT64)WIND_4_SUBBANDS_2_0*(SINT64)s16X[ChOffset+2];\ + s64Temp2=(SINT64)WIND_4_SUBBANDS_2_0*(SINT64)s16X[ChOffset+32+6];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_2_1*(SINT64)s16X[ChOffset+8+2];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_2_1*(SINT64)s16X[ChOffset+24+6];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_2_2*(SINT64)s16X[ChOffset+16+2];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_2_2*(SINT64)s16X[ChOffset+16+6];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_2_3*(SINT64)s16X[ChOffset+24+2];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_2_3*(SINT64)s16X[ChOffset+8+6];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_2_4*(SINT64)s16X[ChOffset+32+2];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_2_4*(SINT64)s16X[ChOffset+6];\ + s32DCTY[2]=(SINT32)(s64Temp>>16);\ + s32DCTY[6]=(SINT32)(s64Temp2>>16);\ +} +#define WINDOW_ACCU_4_3_5 \ +{\ + s64Temp=(SINT64)WIND_4_SUBBANDS_3_0*(SINT64)s16X[ChOffset+3];\ + s64Temp2=(SINT64)WIND_4_SUBBANDS_3_0*(SINT64)s16X[ChOffset+32+5];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_3_1*(SINT64)s16X[ChOffset+8+3];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_3_1*(SINT64)s16X[ChOffset+24+5];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_3_2*(SINT64)s16X[ChOffset+16+3];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_3_2*(SINT64)s16X[ChOffset+16+5];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_3_3*(SINT64)s16X[ChOffset+24+3];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_3_3*(SINT64)s16X[ChOffset+8+5];\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_3_4*(SINT64)s16X[ChOffset+32+3];\ + s64Temp2+=(SINT64)WIND_4_SUBBANDS_3_4*(SINT64)s16X[ChOffset+5];\ + s32DCTY[3]=(SINT32)(s64Temp>>16);\ + s32DCTY[5]=(SINT32)(s64Temp2>>16);\ +} + +#define WINDOW_ACCU_4_4 \ +{\ + s64Temp=(SINT64)WIND_4_SUBBANDS_4_0*(SINT64)(s16X[ChOffset+4]+s16X[ChOffset+4+32]);\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_4_1*(SINT64)(s16X[ChOffset+4+8]+s16X[ChOffset+4+24]);\ + s64Temp+=(SINT64)WIND_4_SUBBANDS_4_2*(SINT64)s16X[ChOffset+4+16];\ + s32DCTY[4]=(SINT32)(s64Temp>>16);\ +} +#else /* SBC_IS_64_MULT_IN_WINDOW_ACCU == FALSE */ +#define WINDOW_ACCU_8_0 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_0_1*(SINT32)(s16X[ChOffset+16]-s16X[ChOffset+64]);\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_0_2*(SINT32)(s16X[ChOffset+32]-s16X[ChOffset+48]);\ + s32DCTY[0]=(SINT32)s32Temp;\ +} +#define WINDOW_ACCU_8_1_15 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_1_0*(SINT32)s16X[ChOffset+1];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_1_0*(SINT32)s16X[ChOffset+64+15];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_1_1*(SINT32)s16X[ChOffset+16+1];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_1_1*(SINT32)s16X[ChOffset+48+15];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_1_2*(SINT32)s16X[ChOffset+32+1];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_1_2*(SINT32)s16X[ChOffset+32+15];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_1_3*(SINT32)s16X[ChOffset+48+1];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_1_3*(SINT32)s16X[ChOffset+16+15];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_1_4*(SINT32)s16X[ChOffset+64+1];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_1_4*(SINT32)s16X[ChOffset+15];\ + s32DCTY[1]=(SINT32)s32Temp;\ + s32DCTY[15]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_2_14 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_2_0*(SINT32)s16X[ChOffset+2];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_2_0*(SINT32)s16X[ChOffset+64+14];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_2_1*(SINT32)s16X[ChOffset+16+2];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_2_1*(SINT32)s16X[ChOffset+48+14];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_2_2*(SINT32)s16X[ChOffset+32+2];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_2_2*(SINT32)s16X[ChOffset+32+14];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_2_3*(SINT32)s16X[ChOffset+48+2];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_2_3*(SINT32)s16X[ChOffset+16+14];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_2_4*(SINT32)s16X[ChOffset+64+2];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_2_4*(SINT32)s16X[ChOffset+14];\ + s32DCTY[2]=(SINT32)s32Temp;\ + s32DCTY[14]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_3_13 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_3_0*(SINT32)s16X[ChOffset+3];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_3_0*(SINT32)s16X[ChOffset+64+13];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_3_1*(SINT32)s16X[ChOffset+16+3];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_3_1*(SINT32)s16X[ChOffset+48+13];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_3_2*(SINT32)s16X[ChOffset+32+3];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_3_2*(SINT32)s16X[ChOffset+32+13];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_3_3*(SINT32)s16X[ChOffset+48+3];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_3_3*(SINT32)s16X[ChOffset+16+13];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_3_4*(SINT32)s16X[ChOffset+64+3];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_3_4*(SINT32)s16X[ChOffset+13];\ + s32DCTY[3]=(SINT32)s32Temp;\ + s32DCTY[13]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_4_12 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_4_0*(SINT32)s16X[ChOffset+4];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_4_0*(SINT32)s16X[ChOffset+64+12];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_4_1*(SINT32)s16X[ChOffset+16+4];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_4_1*(SINT32)s16X[ChOffset+48+12];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_4_2*(SINT32)s16X[ChOffset+32+4];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_4_2*(SINT32)s16X[ChOffset+32+12];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_4_3*(SINT32)s16X[ChOffset+48+4];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_4_3*(SINT32)s16X[ChOffset+16+12];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_4_4*(SINT32)s16X[ChOffset+64+4];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_4_4*(SINT32)s16X[ChOffset+12];\ + s32DCTY[4]=(SINT32)s32Temp;\ + s32DCTY[12]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_5_11 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_5_0*(SINT32)s16X[ChOffset+5];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_5_0*(SINT32)s16X[ChOffset+64+11];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_5_1*(SINT32)s16X[ChOffset+16+5];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_5_1*(SINT32)s16X[ChOffset+48+11];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_5_2*(SINT32)s16X[ChOffset+32+5];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_5_2*(SINT32)s16X[ChOffset+32+11];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_5_3*(SINT32)s16X[ChOffset+48+5];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_5_3*(SINT32)s16X[ChOffset+16+11];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_5_4*(SINT32)s16X[ChOffset+64+5];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_5_4*(SINT32)s16X[ChOffset+11];\ + s32DCTY[5]=(SINT32)s32Temp;\ + s32DCTY[11]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_6_10 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_6_0*(SINT32)s16X[ChOffset+6];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_6_0*(SINT32)s16X[ChOffset+64+10];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_6_1*(SINT32)s16X[ChOffset+16+6];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_6_1*(SINT32)s16X[ChOffset+48+10];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_6_2*(SINT32)s16X[ChOffset+32+6];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_6_2*(SINT32)s16X[ChOffset+32+10];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_6_3*(SINT32)s16X[ChOffset+48+6];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_6_3*(SINT32)s16X[ChOffset+16+10];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_6_4*(SINT32)s16X[ChOffset+64+6];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_6_4*(SINT32)s16X[ChOffset+10];\ + s32DCTY[6]=(SINT32)s32Temp;\ + s32DCTY[10]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_7_9 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_7_0*(SINT32)s16X[ChOffset+7];\ + s32Temp2=(SINT32)WIND_8_SUBBANDS_7_0*(SINT32)s16X[ChOffset+64+9];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_7_1*(SINT32)s16X[ChOffset+16+7];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_7_1*(SINT32)s16X[ChOffset+48+9];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_7_2*(SINT32)s16X[ChOffset+32+7];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_7_2*(SINT32)s16X[ChOffset+32+9];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_7_3*(SINT32)s16X[ChOffset+48+7];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_7_3*(SINT32)s16X[ChOffset+16+9];\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_7_4*(SINT32)s16X[ChOffset+64+7];\ + s32Temp2+=(SINT32)WIND_8_SUBBANDS_7_4*(SINT32)s16X[ChOffset+9];\ + s32DCTY[7]=(SINT32)s32Temp;\ + s32DCTY[9]=(SINT32)s32Temp2;\ +} +#define WINDOW_ACCU_8_8 \ +{\ + s32Temp=(SINT32)WIND_8_SUBBANDS_8_0*(SINT32)(s16X[ChOffset+8]+s16X[ChOffset+64+8]);\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_8_1*(SINT32)(s16X[ChOffset+16+8]+s16X[ChOffset+48+8]);\ + s32Temp+=(SINT32)WIND_8_SUBBANDS_8_2*(SINT32)s16X[ChOffset+32+8];\ + s32DCTY[8]=(SINT32)s32Temp;\ +} +#define WINDOW_ACCU_4_0 \ +{\ + s32Temp=(SINT32)WIND_4_SUBBANDS_0_1*(SINT32)(s16X[ChOffset+8]-s16X[ChOffset+32]);\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_0_2*(SINT32)(s16X[ChOffset+16]-s16X[ChOffset+24]);\ + s32DCTY[0]=(SINT32)(s32Temp);\ +} +#define WINDOW_ACCU_4_1_7 \ +{\ + s32Temp=(SINT32)WIND_4_SUBBANDS_1_0*(SINT32)s16X[ChOffset+1];\ + s32Temp2=(SINT32)WIND_4_SUBBANDS_1_0*(SINT32)s16X[ChOffset+32+7];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_1_1*(SINT32)s16X[ChOffset+8+1];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_1_1*(SINT32)s16X[ChOffset+24+7];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_1_2*(SINT32)s16X[ChOffset+16+1];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_1_2*(SINT32)s16X[ChOffset+16+7];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_1_3*(SINT32)s16X[ChOffset+24+1];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_1_3*(SINT32)s16X[ChOffset+8+7];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_1_4*(SINT32)s16X[ChOffset+32+1];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_1_4*(SINT32)s16X[ChOffset+7];\ + s32DCTY[1]=(SINT32)(s32Temp);\ + s32DCTY[7]=(SINT32)(s32Temp2);\ +} +#define WINDOW_ACCU_4_2_6 \ +{\ + s32Temp=(SINT32)WIND_4_SUBBANDS_2_0*(SINT32)s16X[ChOffset+2];\ + s32Temp2=(SINT32)WIND_4_SUBBANDS_2_0*(SINT32)s16X[ChOffset+32+6];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_2_1*(SINT32)s16X[ChOffset+8+2];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_2_1*(SINT32)s16X[ChOffset+24+6];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_2_2*(SINT32)s16X[ChOffset+16+2];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_2_2*(SINT32)s16X[ChOffset+16+6];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_2_3*(SINT32)s16X[ChOffset+24+2];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_2_3*(SINT32)s16X[ChOffset+8+6];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_2_4*(SINT32)s16X[ChOffset+32+2];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_2_4*(SINT32)s16X[ChOffset+6];\ + s32DCTY[2]=(SINT32)(s32Temp);\ + s32DCTY[6]=(SINT32)(s32Temp2);\ +} +#define WINDOW_ACCU_4_3_5 \ +{\ + s32Temp=(SINT32)WIND_4_SUBBANDS_3_0*(SINT32)s16X[ChOffset+3];\ + s32Temp2=(SINT32)WIND_4_SUBBANDS_3_0*(SINT32)s16X[ChOffset+32+5];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_3_1*(SINT32)s16X[ChOffset+8+3];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_3_1*(SINT32)s16X[ChOffset+24+5];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_3_2*(SINT32)s16X[ChOffset+16+3];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_3_2*(SINT32)s16X[ChOffset+16+5];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_3_3*(SINT32)s16X[ChOffset+24+3];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_3_3*(SINT32)s16X[ChOffset+8+5];\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_3_4*(SINT32)s16X[ChOffset+32+3];\ + s32Temp2+=(SINT32)WIND_4_SUBBANDS_3_4*(SINT32)s16X[ChOffset+5];\ + s32DCTY[3]=(SINT32)(s32Temp);\ + s32DCTY[5]=(SINT32)(s32Temp2);\ +} + +#define WINDOW_ACCU_4_4 \ +{\ + s32Temp=(SINT32)WIND_4_SUBBANDS_4_0*(SINT32)(s16X[ChOffset+4]+s16X[ChOffset+4+32]);\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_4_1*(SINT32)(s16X[ChOffset+4+8]+s16X[ChOffset+4+24]);\ + s32Temp+=(SINT32)WIND_4_SUBBANDS_4_2*(SINT32)s16X[ChOffset+4+16];\ + s32DCTY[4]=(SINT32)(s32Temp);\ +} +#endif +#define WINDOW_PARTIAL_4 \ +{\ + WINDOW_ACCU_4_0; WINDOW_ACCU_4_1_7;\ + WINDOW_ACCU_4_2_6; WINDOW_ACCU_4_3_5;\ + WINDOW_ACCU_4_4;\ +} + +#define WINDOW_PARTIAL_8 \ +{\ + WINDOW_ACCU_8_0; WINDOW_ACCU_8_1_15;\ + WINDOW_ACCU_8_2_14; WINDOW_ACCU_8_3_13;\ + WINDOW_ACCU_8_4_12; WINDOW_ACCU_8_5_11;\ + WINDOW_ACCU_8_6_10; WINDOW_ACCU_8_7_9;\ + WINDOW_ACCU_8_8;\ +} +#else +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) +#define WINDOW_ACCU_4(i) \ +{\ + s64Temp=((SINT64)gas32CoeffFor4SBs[i] * (SINT64)s16X[ChOffset+i]); \ + s64Temp+=((SINT64)gas32CoeffFor4SBs[(i+8)] * (SINT64)s16X[ChOffset+i+8]); \ + s64Temp+=((SINT64)gas32CoeffFor4SBs[(i+16)] * (SINT64)s16X[ChOffset+i+16]); \ + s64Temp+=((SINT64)gas32CoeffFor4SBs[(i+24)] * (SINT64)s16X[ChOffset+i+24]); \ + s64Temp+=((SINT64)gas32CoeffFor4SBs[(i+32)] * (SINT64)s16X[ChOffset+i+32]); \ + s32DCTY[i]=(SINT32)(s64Temp>>16);\ + /*printf("s32DCTY4: 0x%x \n", s32DCTY[i]);*/\ +} +#else +#define WINDOW_ACCU_4(i) \ +{\ + s32DCTY[i]=(gas32CoeffFor4SBs[i * 2] * s16X[ChOffset+i]) \ + + (((SINT32)(UINT16)(gas32CoeffFor4SBs[(i * 2) + 1]) * s16X[ChOffset+i]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor4SBs[(i+8) * 2] * s16X[ChOffset+i+8]) \ + + (((SINT32)(UINT16)(gas32CoeffFor4SBs[((i+8) * 2) + 1]) * s16X[ChOffset+i+8]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor4SBs[(i+16) * 2] * s16X[ChOffset+i+16]) \ + + (((SINT32)(UINT16)(gas32CoeffFor4SBs[((i+16) * 2) + 1]) * s16X[ChOffset+i+16]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor4SBs[(i+24) * 2] * s16X[ChOffset+i+24]) \ + + (((SINT32)(UINT16)(gas32CoeffFor4SBs[((i+24) * 2) + 1]) * s16X[ChOffset+i+24]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor4SBs[(i+32) * 2] * s16X[ChOffset+i+32]) \ + + (((SINT32)(UINT16)(gas32CoeffFor4SBs[((i+32) * 2) + 1]) * s16X[ChOffset+i+32]) >> 16); \ +} +#endif +#define WINDOW_PARTIAL_4 \ +{\ + WINDOW_ACCU_4(0); WINDOW_ACCU_4(1);\ + WINDOW_ACCU_4(2); WINDOW_ACCU_4(3);\ + WINDOW_ACCU_4(4); WINDOW_ACCU_4(5);\ + WINDOW_ACCU_4(6); WINDOW_ACCU_4(7);\ +} + +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) +#define WINDOW_ACCU_8(i) \ +{\ + s64Temp = ((((SINT64)gas32CoeffFor8SBs[i] * (SINT64)s16X[ChOffset+i] ))); \ + s64Temp+= ((((SINT64)gas32CoeffFor8SBs[(i+16)] * (SINT64)s16X[ChOffset+i+16]))); \ + s64Temp+= ((((SINT64)gas32CoeffFor8SBs[(i+32)] * (SINT64)s16X[ChOffset+i+32]))); \ + s64Temp+= ((((SINT64)gas32CoeffFor8SBs[(i+48)] * (SINT64)s16X[ChOffset+i+48]))); \ + s64Temp+= ((((SINT64)gas32CoeffFor8SBs[(i+64)] * (SINT64)s16X[ChOffset+i+64]))); \ + /*printf("s32DCTY8: %d= 0x%x * %d\n", s32DCTY[i], gas32CoeffFor8SBs[i], s16X[ChOffset+i]);*/ \ + s32DCTY[i]=(SINT32)(s64Temp>>16);\ +} +#else +#define WINDOW_ACCU_8(i) \ +{\ + s32DCTY[i]=(gas32CoeffFor8SBs[i * 2] * s16X[ChOffset+i]) \ + + (((SINT32)(UINT16)(gas32CoeffFor8SBs[(i * 2) + 1]) * s16X[ChOffset+i]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor8SBs[(i+16) * 2] * s16X[ChOffset+i+16]) \ + + (((SINT32)(UINT16)(gas32CoeffFor8SBs[((i+16) * 2) + 1]) * s16X[ChOffset+i+16]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor8SBs[(i+32) * 2] * s16X[ChOffset+i+32]) \ + + (((SINT32)(UINT16)(gas32CoeffFor8SBs[((i+32) * 2) + 1]) * s16X[ChOffset+i+32]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor8SBs[(i+48) * 2] * s16X[ChOffset+i+48]) \ + + (((SINT32)(UINT16)(gas32CoeffFor8SBs[((i+48) * 2) + 1]) * s16X[ChOffset+i+48]) >> 16); \ + s32DCTY[i]+=(gas32CoeffFor8SBs[(i+64) * 2] * s16X[ChOffset+i+64]) \ + + (((SINT32)(UINT16)(gas32CoeffFor8SBs[((i+64) * 2) + 1]) * s16X[ChOffset+i+64]) >> 16); \ + /*printf("s32DCTY8: %d = 0x%4x%4x * %d\n", s32DCTY[i], gas32CoeffFor8SBs[i * 2], (gas32CoeffFor8SBs[(i * 2) + 1]), s16X[ChOffset+i]);*/\ + /*s32DCTY[i]=(SINT32)(s64Temp>>16);*/\ +} +#endif +#define WINDOW_PARTIAL_8 \ +{\ + WINDOW_ACCU_8(0); WINDOW_ACCU_8(1);\ + WINDOW_ACCU_8(2); WINDOW_ACCU_8(3);\ + WINDOW_ACCU_8(4); WINDOW_ACCU_8(5);\ + WINDOW_ACCU_8(6); WINDOW_ACCU_8(7);\ + WINDOW_ACCU_8(8); WINDOW_ACCU_8(9);\ + WINDOW_ACCU_8(10); WINDOW_ACCU_8(11);\ + WINDOW_ACCU_8(12); WINDOW_ACCU_8(13);\ + WINDOW_ACCU_8(14); WINDOW_ACCU_8(15);\ +} +#endif +#endif + +static SINT16 ShiftCounter=0; +extern SINT16 EncMaxShiftCounter; +/**************************************************************************** +* SbcAnalysisFilter - performs Analysis of the input audio stream +* +* RETURNS : N/A +*/ +void SbcAnalysisFilter4(SBC_ENC_PARAMS *pstrEncParams) +{ + SINT16 *ps16PcmBuf; + SINT32 *ps32SbBuf; + SINT32 s32Blk,s32Ch; + SINT32 s32NumOfChannels, s32NumOfBlocks; + SINT32 i,*ps32X,*ps32X2; + SINT32 Offset,Offset2,ChOffset; +#if (SBC_ARM_ASM_OPT==TRUE) + register SINT32 s32Hi,s32Hi2; +#else +#if (SBC_IPAQ_OPT==TRUE) +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) + register SINT64 s64Temp,s64Temp2; +#else + register SINT32 s32Temp,s32Temp2; +#endif +#else + +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) + SINT64 s64Temp; +#endif + +#endif +#endif + + s32NumOfChannels = pstrEncParams->s16NumOfChannels; + s32NumOfBlocks = pstrEncParams->s16NumOfBlocks; + + ps16PcmBuf = pstrEncParams->ps16NextPcmBuffer; + + ps32SbBuf = pstrEncParams->s32SbBuffer; + Offset2=(SINT32)(EncMaxShiftCounter+40); + for (s32Blk=0; s32Blk <s32NumOfBlocks; s32Blk++) + { + Offset=(SINT32)(EncMaxShiftCounter-ShiftCounter); + /* Store new samples */ + if (s32NumOfChannels==1) + { + s16X[3+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[2+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[1+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[0+Offset] = *ps16PcmBuf; ps16PcmBuf++; + } + else + { + s16X[3+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+3+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[2+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+2+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[1+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+1+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[0+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+0+Offset] = *ps16PcmBuf; ps16PcmBuf++; + } + for (s32Ch=0;s32Ch<s32NumOfChannels;s32Ch++) + { + ChOffset=s32Ch*Offset2+Offset; + + WINDOW_PARTIAL_4 + + SBC_FastIDCT4(s32DCTY, ps32SbBuf); + + ps32SbBuf +=SUB_BANDS_4; + } + if (s32NumOfChannels==1) + { + if (ShiftCounter>=EncMaxShiftCounter) + { + SHIFTUP_X4; + ShiftCounter=0; + } + else + { + ShiftCounter+=SUB_BANDS_4; + } + } + else + { + if (ShiftCounter>=EncMaxShiftCounter) + { + SHIFTUP_X4_2; + ShiftCounter=0; + } + else + { + ShiftCounter+=SUB_BANDS_4; + } + } + } +} + +/* //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// */ +void SbcAnalysisFilter8 (SBC_ENC_PARAMS *pstrEncParams) +{ + SINT16 *ps16PcmBuf; + SINT32 *ps32SbBuf; + SINT32 s32Blk,s32Ch; /* counter for block*/ + SINT32 Offset,Offset2; + SINT32 s32NumOfChannels, s32NumOfBlocks; + SINT32 i,*ps32X,*ps32X2; + SINT32 ChOffset; +#if (SBC_ARM_ASM_OPT==TRUE) + register SINT32 s32Hi,s32Hi2; +#else +#if (SBC_IPAQ_OPT==TRUE) +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) + register SINT64 s64Temp,s64Temp2; +#else + register SINT32 s32Temp,s32Temp2; +#endif +#else +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == TRUE) + SINT64 s64Temp; +#endif +#endif +#endif + + s32NumOfChannels = pstrEncParams->s16NumOfChannels; + s32NumOfBlocks = pstrEncParams->s16NumOfBlocks; + + ps16PcmBuf = pstrEncParams->ps16NextPcmBuffer; + + ps32SbBuf = pstrEncParams->s32SbBuffer; + Offset2=(SINT32)(EncMaxShiftCounter+80); + for (s32Blk=0; s32Blk <s32NumOfBlocks; s32Blk++) + { + Offset=(SINT32)(EncMaxShiftCounter-ShiftCounter); + /* Store new samples */ + if (s32NumOfChannels==1) + { + s16X[7+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[6+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[5+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[4+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[3+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[2+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[1+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[0+Offset] = *ps16PcmBuf; ps16PcmBuf++; + } + else + { + s16X[7+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+7+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[6+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+6+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[5+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+5+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[4+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+4+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[3+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+3+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[2+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+2+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[1+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+1+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[0+Offset] = *ps16PcmBuf; ps16PcmBuf++; + s16X[Offset2+0+Offset] = *ps16PcmBuf; ps16PcmBuf++; + } + for (s32Ch=0;s32Ch<s32NumOfChannels;s32Ch++) + { + ChOffset=s32Ch*Offset2+Offset; + + WINDOW_PARTIAL_8 + + SBC_FastIDCT8 (s32DCTY, ps32SbBuf); + + ps32SbBuf +=SUB_BANDS_8; + } + if (s32NumOfChannels==1) + { + if (ShiftCounter>=EncMaxShiftCounter) + { + SHIFTUP_X8; + ShiftCounter=0; + } + else + { + ShiftCounter+=SUB_BANDS_8; + } + } + else + { + if (ShiftCounter>=EncMaxShiftCounter) + { + SHIFTUP_X8_2; + ShiftCounter=0; + } + else + { + ShiftCounter+=SUB_BANDS_8; + } + } + } +} + +void SbcAnalysisInit (void) +{ + memset(s16X,0,ENC_VX_BUFFER_SIZE*sizeof(SINT16)); + ShiftCounter=0; +} diff --git a/embdrv/sbc/encoder/srce/sbc_dct.c b/embdrv/sbc/encoder/srce/sbc_dct.c new file mode 100644 index 0000000..0ff7f1f --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_dct.c @@ -0,0 +1,234 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_dct.c,v $ +** +** Description: source file for fast dct operations +** +** Revision : $Id: sbc_dct.c,v 1.19 2006/04/13 17:01:04 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#include "sbc_encoder.h" +#include "sbc_enc_func_declare.h" +#include "sbc_dct.h" + + + +/******************************************************************************* +** +** Function SBC_FastIDCT8 +** +** Description implementation of fast DCT algorithm by Feig and Winograd +** +** +** Returns y = dct(pInVect) +** +** +*******************************************************************************/ + +#if (SBC_IS_64_MULT_IN_IDCT == FALSE) +#define SBC_COS_PI_SUR_4 (0x00005a82) /* ((0x8000) * 0.7071) = cos(pi/4) */ +#define SBC_COS_PI_SUR_8 (0x00007641) /* ((0x8000) * 0.9239) = (cos(pi/8)) */ +#define SBC_COS_3PI_SUR_8 (0x000030fb) /* ((0x8000) * 0.3827) = (cos(3*pi/8)) */ +#define SBC_COS_PI_SUR_16 (0x00007d8a) /* ((0x8000) * 0.9808)) = (cos(pi/16)) */ +#define SBC_COS_3PI_SUR_16 (0x00006a6d) /* ((0x8000) * 0.8315)) = (cos(3*pi/16)) */ +#define SBC_COS_5PI_SUR_16 (0x0000471c) /* ((0x8000) * 0.5556)) = (cos(5*pi/16)) */ +#define SBC_COS_7PI_SUR_16 (0x000018f8) /* ((0x8000) * 0.1951)) = (cos(7*pi/16)) */ +#define SBC_IDCT_MULT(a,b,c) SBC_MULT_32_16_SIMPLIFIED(a,b,c) +#else +#define SBC_COS_PI_SUR_4 (0x5A827999) /* ((0x80000000) * 0.707106781) = (cos(pi/4) ) */ +#define SBC_COS_PI_SUR_8 (0x7641AF3C) /* ((0x80000000) * 0.923879533) = (cos(pi/8) ) */ +#define SBC_COS_3PI_SUR_8 (0x30FBC54D) /* ((0x80000000) * 0.382683432) = (cos(3*pi/8) ) */ +#define SBC_COS_PI_SUR_16 (0x7D8A5F3F) /* ((0x80000000) * 0.98078528 )) = (cos(pi/16) ) */ +#define SBC_COS_3PI_SUR_16 (0x6A6D98A4) /* ((0x80000000) * 0.831469612)) = (cos(3*pi/16)) */ +#define SBC_COS_5PI_SUR_16 (0x471CECE6) /* ((0x80000000) * 0.555570233)) = (cos(5*pi/16)) */ +#define SBC_COS_7PI_SUR_16 (0x18F8B83C) /* ((0x80000000) * 0.195090322)) = (cos(7*pi/16)) */ +#define SBC_IDCT_MULT(a,b,c) SBC_MULT_32_32(a,b,c) +#endif /* SBC_IS_64_MULT_IN_IDCT */ + +#if (SBC_FAST_DCT == FALSE) +extern const SINT16 gas16AnalDCTcoeff8[]; +extern const SINT16 gas16AnalDCTcoeff4[]; +#endif + +void SBC_FastIDCT8(SINT32 *pInVect, SINT32 *pOutVect) +{ +#if (SBC_FAST_DCT == TRUE) +#if (SBC_ARM_ASM_OPT==TRUE) +#else +#if (SBC_IPAQ_OPT==TRUE) +#if (SBC_IS_64_MULT_IN_IDCT == TRUE) + SINT64 s64Temp; +#endif +#else +#if (SBC_IS_64_MULT_IN_IDCT == TRUE) + SINT32 s32HiTemp; +#else + SINT32 s32In2Temp; + register SINT32 s32In1Temp; +#endif +#endif +#endif + + register SINT32 x0, x1, x2, x3, x4, x5, x6, x7,temp; + SINT32 res_even[4], res_odd[4]; + /*x0= (pInVect[4])/2 ;*/ + SBC_IDCT_MULT(SBC_COS_PI_SUR_4,pInVect[4], x0); + /*printf("x0 0x%x = %d = %d * %d\n", x0, x0, SBC_COS_PI_SUR_4, pInVect[4]);*/ + + x1 = (pInVect[3] + pInVect[5]) >>1; + x2 = (pInVect[2] + pInVect[6]) >>1; + x3 = (pInVect[1] + pInVect[7]) >>1; + x4 = (pInVect[0] + pInVect[8]) >>1; + x5 = (pInVect[9] - pInVect[15]) >>1; + x6 = (pInVect[10] - pInVect[14])>>1; + x7 = (pInVect[11] - pInVect[13])>>1; + + /* 2-point IDCT of x0 and x4 as in (11) */ + temp = x0 ; + SBC_IDCT_MULT(SBC_COS_PI_SUR_4, ( x0 + x4 ), x0); /*x0 = ( x0 + x4 ) * cos(1*pi/4) ; */ + SBC_IDCT_MULT(SBC_COS_PI_SUR_4, ( temp - x4 ), x4); /*x4 = ( temp - x4 ) * cos(1*pi/4) ; */ + + /* rearrangement of x2 and x6 as in (15) */ + x2 -=x6; + x6 <<= 1 ; + + /* 2-point IDCT of x2 and x6 and post-multiplication as in (15) */ + SBC_IDCT_MULT(SBC_COS_PI_SUR_4,x6, x6); /*x6 = x6 * cos(1*pi/4) ; */ + temp = x2 ; + SBC_IDCT_MULT(SBC_COS_PI_SUR_8,( x2 + x6 ), x2); /*x2 = ( x2 + x6 ) * cos(1*pi/8) ; */ + SBC_IDCT_MULT(SBC_COS_3PI_SUR_8,( temp - x6 ), x6); /*x6 = ( temp - x6 ) * cos(3*pi/8) ;*/ + + /* 4-point IDCT of x0,x2,x4 and x6 as in (11) */ + res_even[ 0 ] = x0 + x2 ; + res_even[ 1 ] = x4 + x6 ; + res_even[ 2 ] = x4 - x6 ; + res_even[ 3 ] = x0 - x2 ; + + + /* rearrangement of x1,x3,x5,x7 as in (15) */ + x7 <<= 1 ; + x5 = ( x5 <<1 ) - x7 ; + x3 = ( x3 <<1 ) - x5 ; + x1 -= x3 >>1 ; + + /* two-dimensional IDCT of x1 and x5 */ + SBC_IDCT_MULT(SBC_COS_PI_SUR_4, x5, x5); /*x5 = x5 * cos(1*pi/4) ; */ + temp = x1 ; + x1 = x1 + x5 ; + x5 = temp - x5 ; + + /* rearrangement of x3 and x7 as in (15) */ + x3 -= x7; + x7 <<= 1 ; + SBC_IDCT_MULT(SBC_COS_PI_SUR_4, x7, x7); /*x7 = x7 * cos(1*pi/4) ; */ + + /* 2-point IDCT of x3 and x7 and post-multiplication as in (15) */ + temp = x3 ; + SBC_IDCT_MULT( SBC_COS_PI_SUR_8,( x3 + x7 ), x3); /*x3 = ( x3 + x7 ) * cos(1*pi/8) ; */ + SBC_IDCT_MULT( SBC_COS_3PI_SUR_8,( temp - x7 ), x7); /*x7 = ( temp - x7 ) * cos(3*pi/8) ;*/ + + /* 4-point IDCT of x1,x3,x5 and x7 and post multiplication by diagonal matrix as in (14) */ + SBC_IDCT_MULT((SBC_COS_PI_SUR_16), ( x1 + x3 ) , res_odd[0]); /*res_odd[ 0 ] = ( x1 + x3 ) * cos(1*pi/16) ; */ + SBC_IDCT_MULT((SBC_COS_3PI_SUR_16), ( x5 + x7 ) , res_odd[1]); /*res_odd[ 1 ] = ( x5 + x7 ) * cos(3*pi/16) ; */ + SBC_IDCT_MULT((SBC_COS_5PI_SUR_16), ( x5 - x7 ) , res_odd[2]); /*res_odd[ 2 ] = ( x5 - x7 ) * cos(5*pi/16) ; */ + SBC_IDCT_MULT((SBC_COS_7PI_SUR_16), ( x1 - x3 ) , res_odd[3]); /*res_odd[ 3 ] = ( x1 - x3 ) * cos(7*pi/16) ; */ + + /* additions and subtractions as in (9) */ + pOutVect[0] = (res_even[ 0 ] + res_odd[ 0 ]) ; + pOutVect[1] = (res_even[ 1 ] + res_odd[ 1 ]) ; + pOutVect[2] = (res_even[ 2 ] + res_odd[ 2 ]) ; + pOutVect[3] = (res_even[ 3 ] + res_odd[ 3 ]) ; + pOutVect[7] = (res_even[ 0 ] - res_odd[ 0 ]) ; + pOutVect[6] = (res_even[ 1 ] - res_odd[ 1 ]) ; + pOutVect[5] = (res_even[ 2 ] - res_odd[ 2 ]) ; + pOutVect[4] = (res_even[ 3 ] - res_odd[ 3 ]) ; +#else + UINT8 Index, k; + SINT32 temp; + /*Calculate 4 subband samples by matrixing*/ + for(Index=0; Index<8; Index++) + { + temp = 0; + for(k=0; k<16; k++) + { + /*temp += (SINT32)(((SINT64)M[(Index*strEncParams->numOfSubBands*2)+k] * Y[k]) >> 16 );*/ + temp += (gas16AnalDCTcoeff8[(Index*8*2)+k] * (pInVect[k] >> 16)); + temp += ((gas16AnalDCTcoeff8[(Index*8*2)+k] * (pInVect[k] & 0xFFFF)) >> 16); + } + pOutVect[Index] = temp; + } +#endif +/* printf("pOutVect: 0x%x;0x%x;0x%x;0x%x;0x%x;0x%x;0x%x;0x%x\n",\ + pOutVect[0],pOutVect[1],pOutVect[2],pOutVect[3],pOutVect[4],pOutVect[5],pOutVect[6],pOutVect[7]);*/ +} + +/******************************************************************************* +** +** Function SBC_FastIDCT4 +** +** Description implementation of fast DCT algorithm by Feig and Winograd +** +** +** Returns y = dct(x0) +** +** +*******************************************************************************/ +void SBC_FastIDCT4(SINT32 *pInVect, SINT32 *pOutVect) +{ +#if (SBC_FAST_DCT == TRUE) +#if (SBC_ARM_ASM_OPT==TRUE) +#else +#if (SBC_IPAQ_OPT==TRUE) +#if (SBC_IS_64_MULT_IN_IDCT == TRUE) + SINT64 s64Temp; +#endif +#else +#if (SBC_IS_64_MULT_IN_IDCT == TRUE) + SINT32 s32HiTemp; +#else + UINT16 s32In2Temp; + SINT32 s32In1Temp; +#endif +#endif +#endif + SINT32 temp,x2; + SINT32 tmp[8]; + + x2=pInVect[2]>>1; + temp=(pInVect[0]+pInVect[4]); + SBC_IDCT_MULT((SBC_COS_PI_SUR_4>>1), temp , tmp[0]); + tmp[1]=x2-tmp[0]; + tmp[0]+=x2; + temp=(pInVect[1]+pInVect[3]); + SBC_IDCT_MULT((SBC_COS_3PI_SUR_8>>1), temp , tmp[3]); + SBC_IDCT_MULT((SBC_COS_PI_SUR_8>>1), temp , tmp[2]); + temp=(pInVect[5]-pInVect[7]); + SBC_IDCT_MULT((SBC_COS_3PI_SUR_8>>1), temp , tmp[5]); + SBC_IDCT_MULT((SBC_COS_PI_SUR_8>>1), temp , tmp[4]); + tmp[6]=tmp[2]+tmp[5]; + tmp[7]=tmp[3]-tmp[4]; + pOutVect[0] = (tmp[0]+tmp[6]); + pOutVect[1] = (tmp[1]+tmp[7]); + pOutVect[2] = (tmp[1]-tmp[7]); + pOutVect[3] = (tmp[0]-tmp[6]); +#else + UINT8 Index, k; + SINT32 temp; + /*Calculate 4 subband samples by matrixing*/ + for(Index=0; Index<4; Index++) + { + temp = 0; + for(k=0; k<8; k++) + { + /*temp += (SINT32)(((SINT64)M[(Index*strEncParams->numOfSubBands*2)+k] * Y[k]) >> 16 ); */ + temp += (gas16AnalDCTcoeff4[(Index*4*2)+k] * (pInVect[k] >> 16)); + temp += ((gas16AnalDCTcoeff4[(Index*4*2)+k] * (pInVect[k] & 0xFFFF)) >> 16); + } + pOutVect[Index] = temp; + } +#endif +} diff --git a/embdrv/sbc/encoder/srce/sbc_dct_coeffs.c b/embdrv/sbc/encoder/srce/sbc_dct_coeffs.c new file mode 100644 index 0000000..03f632f --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_dct_coeffs.c @@ -0,0 +1,189 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_dct_coeffs.c,v $ +** +** Description: This file contains the coefficient table used for DCT computation +** in analysis. +** +** Revision : $Id: sbc_dct_coeffs.c,v 1.5 2006/04/13 17:01:16 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#include "sbc_encoder.h" +/*DCT coeff for 4 sub-band case.*/ +#if (SBC_FAST_DCT == FALSE) +const SINT16 gas16AnalDCTcoeff4[] = +{ + (SINT16)(0.7071*32768), + (SINT16)(0.9239*32768), + (SINT16)(1.0000*32767), + (SINT16)(0.9239*32768), + (SINT16)(0.7071*32768), + (SINT16)(0.3827*32768), + (SINT16)(0.0000*32768), + (SINT16)(-0.3827*32768), + + (SINT16)(-0.7071*32768), + (SINT16)(0.3827*32768), + (SINT16)(1.0000*32767), + (SINT16)(0.3827*32768), + (SINT16)(-0.7071*32768), + (SINT16)(-0.9239*32768), + (SINT16)(-0.0000*32768), + (SINT16)(0.9239*32768), + + (SINT16)(-0.7071*32768), + (SINT16)(-0.3827*32768), + (SINT16)(1.0000*32767), + (SINT16)(-0.3827*32768), + (SINT16)(-0.7071*32768), + (SINT16)(0.9239*32768), + (SINT16)(0.0000*32768), + (SINT16)(-0.9239*32768), + + (SINT16)(0.7071*32768), + (SINT16)(-0.9239*32768), + (SINT16)(1.0000*32767), + (SINT16)(-0.9239*32768), + (SINT16)(0.7071*32768), + (SINT16)(-0.3827*32768), + (SINT16)(-0.0000*32768), + (SINT16)(0.3827*32768) +}; + +/*DCT coeff for 8 sub-band case.*/ +const SINT16 gas16AnalDCTcoeff8[] = +{ + (SINT16)(0.7071*32768), + (SINT16)(0.8315*32768), + (SINT16)(0.9239*32768), + (SINT16)(0.9808*32768), + (SINT16)(1.0000*32767), + (SINT16)(0.9808*32768), + (SINT16)(0.9239*32768), + (SINT16)(0.8315*32768), + (SINT16)(0.7071*32768), + (SINT16)(0.5556*32768), + (SINT16)(0.3827*32768), + (SINT16)(0.1951*32768), + (SINT16)(0.0000*32768), + (SINT16)(-0.1951*32768), + (SINT16)(-0.3827*32768), + (SINT16)(-0.5556*32768), + (SINT16)(-0.7071*32768), + (SINT16)(-0.1951*32768), + (SINT16)(0.3827*32768), + (SINT16)(0.8315*32768), + (SINT16)(1.0000*32767), + (SINT16)(0.8315*32768), + (SINT16)(0.3827*32768), + (SINT16)(-0.1951*32768), + (SINT16)(-0.7071*32768), + (SINT16)(-0.9808*32768), + (SINT16)(-0.9239*32768), + (SINT16)(-0.5556*32768), + (SINT16)(-0.0000*32768), + (SINT16)(0.5556*32768), + (SINT16)(0.9239*32768), + (SINT16)(0.9808*32768), + (SINT16)(-0.7071*32768), + (SINT16)(-0.9808*32768), + (SINT16)(-0.3827*32768), + (SINT16)(0.5556*32768), + (SINT16)(1.0000*32767), + (SINT16)(0.5556*32768), + (SINT16)(-0.3827*32768), + (SINT16)(-0.9808*32768), + (SINT16)(-0.7071*32768), + (SINT16)(0.1951*32768), + (SINT16)(0.9239*32768), + (SINT16)(0.8315*32768), + (SINT16)(0.0000*32768), + (SINT16)(-0.8315*32768), + (SINT16)(-0.9239*32768), + (SINT16)(-0.1951*32768), + (SINT16)(0.7071*32768), + (SINT16)(-0.5556*32768), + (SINT16)(-0.9239*32768), + (SINT16)(0.1951*32768), + (SINT16)(1.0000*32767), + (SINT16)(0.1951*32768), + (SINT16)(-0.9239*32768), + (SINT16)(-0.5556*32768), + (SINT16)(0.7071*32768), + (SINT16)(0.8315*32768), + (SINT16)(-0.3827*32768), + (SINT16)(-0.9808*32768), + (SINT16)(-0.0000*32768), + (SINT16)(0.9808*32768), + (SINT16)(0.3827*32768), + (SINT16)(-0.8315*32768), + (SINT16)(0.7071*32768), + (SINT16)(0.5556*32768), + (SINT16)(-0.9239*32768), + (SINT16)(-0.1951*32768), + (SINT16)(1.0000*32767), + (SINT16)(-0.1951*32768), + (SINT16)(-0.9239*32768), + (SINT16)(0.5556*32768), + (SINT16)(0.7071*32768), + (SINT16)(-0.8315*32768), + (SINT16)(-0.3827*32768), + (SINT16)(0.9808*32768), + (SINT16)(0.0000*32768), + (SINT16)(-0.9808*32768), + (SINT16)(0.3827*32768), + (SINT16)(0.8315*32768), + (SINT16)(-0.7071*32768), + (SINT16)(0.9808*32768), + (SINT16)(-0.3827*32768), + (SINT16)(-0.5556*32768), + (SINT16)(1.0000*32767), + (SINT16)(-0.5556*32768), + (SINT16)(-0.3827*32768), + (SINT16)(0.9808*32768), + (SINT16)(-0.7071*32768), + (SINT16)(-0.1951*32768), + (SINT16)(0.9239*32768), + (SINT16)(-0.8315*32768), + (SINT16)(-0.0000*32768), + (SINT16)(0.8315*32768), + (SINT16)(-0.9239*32768), + (SINT16)(0.1951*32768), + (SINT16)(-0.7071*32768), + (SINT16)(0.1951*32768), + (SINT16)(0.3827*32768), + (SINT16)(-0.8315*32768), + (SINT16)(1.0000*32767), + (SINT16)(-0.8315*32768), + (SINT16)(0.3827*32768), + (SINT16)(0.1951*32768), + (SINT16)(-0.7071*32768), + (SINT16)(0.9808*32768), + (SINT16)(-0.9239*32768), + (SINT16)(0.5556*32768), + (SINT16)(-0.0000*32768), + (SINT16)(-0.5556*32768), + (SINT16)(0.9239*32768), + (SINT16)(-0.9808*32768), + (SINT16)(0.7071*32768), + (SINT16)(-0.8315*32768), + (SINT16)(0.9239*32768), + (SINT16)(-0.9808*32768), + (SINT16)(1.0000*32767), + (SINT16)(-0.9808*32768), + (SINT16)(0.9239*32768), + (SINT16)(-0.8315*32768), + (SINT16)(0.7071*32768), + (SINT16)(-0.5556*32768), + (SINT16)(0.3827*32768), + (SINT16)(-0.1951*32768), + (SINT16)(-0.0000*32768), + (SINT16)(0.1951*32768), + (SINT16)(-0.3827*32768), + (SINT16)(0.5556*32768) +}; +#endif diff --git a/embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_mono.c b/embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_mono.c new file mode 100644 index 0000000..c8b13a9 --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_mono.c @@ -0,0 +1,188 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_enc_bit_alloc_mono.c,v $ +** +** Description: This file contains the code for bit allocation algorithm. +** It calculates the number of bits required for the encoded stream of data. +** +** Revision : $Id: sbc_enc_bit_alloc_mono.c,v 1.9 2006/03/31 17:16:35 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +/*Includes*/ +#include "sbc_encoder.h" +#include "sbc_enc_func_declare.h" + +/*global arrays*/ +const SINT16 sbc_enc_as16Offset4[4][4] = { {-1, 0, 0, 0}, {-2, 0, 0, 1}, + {-2, 0, 0, 1}, {-2, 0, 0, 1} }; +const SINT16 sbc_enc_as16Offset8[4][8] = { {-2, 0, 0, 0, 0, 0, 0, 1}, + {-3, 0, 0, 0, 0, 0, 1, 2}, + {-4, 0, 0, 0, 0, 0, 1, 2}, + {-4, 0, 0, 0, 0, 0, 1, 2} }; + +/**************************************************************************** +* BitAlloc - Calculates the required number of bits for the given scale factor +* and the number of subbands. +* +* RETURNS : N/A +*/ + +void sbc_enc_bit_alloc_mono(SBC_ENC_PARAMS *pstrCodecParams) +{ + SINT32 s32MaxBitNeed; /*to store the max bits needed per sb*/ + SINT32 s32BitCount; /*the used number of bits*/ + SINT32 s32SliceCount; /*to store hwo many slices can be put in bitpool*/ + SINT32 s32BitSlice; /*number of bitslices in bitpool*/ + SINT32 s32Sb; /*counter for sub-band*/ + SINT32 s32Ch; /*counter for channel*/ + SINT16 *ps16BitNeed; /*temp memory to store required number of bits*/ + SINT32 s32Loudness; /*used in Loudness calculation*/ + SINT16 *ps16GenBufPtr; + SINT16 *ps16GenArrPtr; + SINT16 *ps16GenTabPtr; + SINT32 s32NumOfSubBands = pstrCodecParams->s16NumOfSubBands; + + ps16BitNeed = pstrCodecParams->s16ScartchMemForBitAlloc; + + for (s32Ch = 0; s32Ch < pstrCodecParams->s16NumOfChannels; s32Ch++) + { + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + ps16GenArrPtr = pstrCodecParams->as16Bits+s32Ch*SBC_MAX_NUM_OF_SUBBANDS; + + /* bitneed values are derived from scale factor */ + if (pstrCodecParams->s16AllocationMethod == SBC_SNR) + { + ps16BitNeed = pstrCodecParams->as16ScaleFactor; + ps16GenBufPtr = ps16BitNeed + s32Ch * s32NumOfSubBands; + } + else + { + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + if(s32NumOfSubBands == 4) + { + ps16GenTabPtr = (SINT16 *) + sbc_enc_as16Offset4[pstrCodecParams->s16SamplingFreq]; + } + else + { + ps16GenTabPtr = (SINT16 *) + sbc_enc_as16Offset8[pstrCodecParams->s16SamplingFreq]; + } + for(s32Sb=0; s32Sb<s32NumOfSubBands; s32Sb++) + { + if(pstrCodecParams->as16ScaleFactor[s32Ch*s32NumOfSubBands+s32Sb] == 0) + *(ps16GenBufPtr) = -5; + else + { + s32Loudness = + (SINT32)(pstrCodecParams->as16ScaleFactor[s32Ch*s32NumOfSubBands+s32Sb] + - *ps16GenTabPtr); + if(s32Loudness > 0) + *(ps16GenBufPtr) = (SINT16)(s32Loudness >>1); + else + *(ps16GenBufPtr) = (SINT16)s32Loudness; + } + ps16GenBufPtr++; + ps16GenTabPtr++; + } + + } + + /* max bitneed index is searched*/ + s32MaxBitNeed = 0; + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + for(s32Sb=0; s32Sb<s32NumOfSubBands; s32Sb++) + { + if( *(ps16GenBufPtr) > s32MaxBitNeed) + s32MaxBitNeed = *(ps16GenBufPtr); + + ps16GenBufPtr++; + } + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + /*iterative process to find hwo many bitslices fit into the bitpool*/ + s32BitSlice = s32MaxBitNeed + 1; + s32BitCount = pstrCodecParams->s16BitPool; + s32SliceCount = 0; + do + { + s32BitSlice --; + s32BitCount -= s32SliceCount; + s32SliceCount = 0; + + for(s32Sb=0; s32Sb<s32NumOfSubBands; s32Sb++) + { + if( (((*ps16GenBufPtr-s32BitSlice)< 16) && (*ps16GenBufPtr-s32BitSlice) >= 1)) + { + if((*ps16GenBufPtr-s32BitSlice) == 1) + s32SliceCount+=2; + else + s32SliceCount++; + } + ps16GenBufPtr++; + + }/*end of for*/ + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + }while(s32BitCount-s32SliceCount>0); + + if(s32BitCount == 0) + { + s32BitCount -= s32SliceCount; + s32BitSlice --; + } + + /*Bits are distributed until the last bitslice is reached*/ + ps16GenArrPtr = pstrCodecParams->as16Bits+s32Ch*s32NumOfSubBands; + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + for(s32Sb=0; s32Sb<s32NumOfSubBands; s32Sb++) + { + if(*(ps16GenBufPtr) < s32BitSlice+2) + *(ps16GenArrPtr) = 0; + else + *(ps16GenArrPtr) = ((*(ps16GenBufPtr)-s32BitSlice)<16) ? + (SINT16)(*(ps16GenBufPtr)-s32BitSlice) : 16; + + ps16GenBufPtr++; + ps16GenArrPtr++; + } + ps16GenArrPtr = pstrCodecParams->as16Bits+s32Ch*s32NumOfSubBands; + ps16GenBufPtr = ps16BitNeed + s32Ch*s32NumOfSubBands; + /*the remaining bits are allocated starting at subband 0*/ + s32Sb=0; + while( (s32BitCount > 0) && (s32Sb < s32NumOfSubBands) ) + { + if( (*(ps16GenArrPtr) >= 2) && (*(ps16GenArrPtr) < 16) ) + { + (*(ps16GenArrPtr))++; + s32BitCount--; + } + else if( (*(ps16GenBufPtr) == s32BitSlice+1) && + (s32BitCount > 1) ) + { + *(ps16GenArrPtr) = 2; + s32BitCount -= 2; + } + s32Sb++; + ps16GenArrPtr++; + ps16GenBufPtr++; + } + ps16GenArrPtr = pstrCodecParams->as16Bits+s32Ch*s32NumOfSubBands; + + + s32Sb=0; + while( (s32BitCount > 0) && (s32Sb < s32NumOfSubBands) ) + { + if( *(ps16GenArrPtr) < 16) + { + (*(ps16GenArrPtr))++; + s32BitCount--; + } + s32Sb++; + ps16GenArrPtr++; + } + } +} +/*End of BitAlloc() function*/ diff --git a/embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_ste.c b/embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_ste.c new file mode 100644 index 0000000..cbcb809 --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_ste.c @@ -0,0 +1,201 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_enc_bit_alloc_ste.c,v $ +** +** Description: This file contains the code for bit allocation algorithm. +** It calculates the number of bits required for the encoded stream of data. +** +** Revision : $Id: sbc_enc_bit_alloc_ste.c,v 1.9 2006/03/31 17:17:07 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +/*Includes*/ +#include "sbc_encoder.h" +#include "sbc_enc_func_declare.h" + +/*global arrays*/ +extern const SINT16 sbc_enc_as16Offset4[4][4]; +extern const SINT16 sbc_enc_as16Offset8[4][8]; + +/**************************************************************************** +* BitAlloc - Calculates the required number of bits for the given scale factor +* and the number of subbands. +* +* RETURNS : N/A +*/ + +void sbc_enc_bit_alloc_ste(SBC_ENC_PARAMS *pstrCodecParams) +{ + /* CAUTIOM -> mips optim for arm 32 require to use SINT32 instead of SINT16 */ + /* Do not change variable type or name */ + SINT32 s32MaxBitNeed; /*to store the max bits needed per sb*/ + SINT32 s32BitCount; /*the used number of bits*/ + SINT32 s32SliceCount; /*to store hwo many slices can be put in bitpool*/ + SINT32 s32BitSlice; /*number of bitslices in bitpool*/ + SINT32 s32Sb; /*counter for sub-band*/ + SINT32 s32Ch; /*counter for channel*/ + SINT16 *ps16BitNeed; /*temp memory to store required number of bits*/ + SINT32 s32Loudness; /*used in Loudness calculation*/ + SINT16 *ps16GenBufPtr,*pas16ScaleFactor; + SINT16 *ps16GenArrPtr; + SINT16 *ps16GenTabPtr; + SINT32 s32NumOfSubBands = pstrCodecParams->s16NumOfSubBands; + SINT32 s32BitPool = pstrCodecParams->s16BitPool; + + /* bitneed values are derived from scale factor */ + if (pstrCodecParams->s16AllocationMethod == SBC_SNR) + { + ps16BitNeed = pstrCodecParams->as16ScaleFactor; + s32MaxBitNeed = pstrCodecParams->s16MaxBitNeed; + } + else + { + ps16BitNeed = pstrCodecParams->s16ScartchMemForBitAlloc; + pas16ScaleFactor=pstrCodecParams->as16ScaleFactor; + s32MaxBitNeed = 0; + ps16GenBufPtr = ps16BitNeed; + for (s32Ch = 0; s32Ch < 2; s32Ch++) + { + if (s32NumOfSubBands == 4) + { + ps16GenTabPtr = (SINT16 *)sbc_enc_as16Offset4[pstrCodecParams->s16SamplingFreq]; + } + else + { + ps16GenTabPtr = (SINT16 *)sbc_enc_as16Offset8[pstrCodecParams->s16SamplingFreq]; + } + + for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) + { + if (*pas16ScaleFactor == 0) + *ps16GenBufPtr = -5; + else + { + s32Loudness = (SINT32)(*pas16ScaleFactor - *ps16GenTabPtr); + + if (s32Loudness > 0) + *ps16GenBufPtr = (SINT16)(s32Loudness >> 1); + else + *ps16GenBufPtr = (SINT16)s32Loudness; + } + + if (*ps16GenBufPtr > s32MaxBitNeed) + s32MaxBitNeed = *ps16GenBufPtr; + pas16ScaleFactor++; + ps16GenBufPtr++; + ps16GenTabPtr++; + } + } + } + + /* iterative process to find out hwo many bitslices fit into the bitpool */ + s32BitSlice = s32MaxBitNeed + 1; + s32BitCount = s32BitPool; + s32SliceCount = 0; + do + { + s32BitSlice --; + s32BitCount -= s32SliceCount; + s32SliceCount = 0; + ps16GenBufPtr = ps16BitNeed; + + for (s32Sb = 0; s32Sb < 2*s32NumOfSubBands; s32Sb++) + { + if ( (*ps16GenBufPtr >= s32BitSlice + 1) && (*ps16GenBufPtr < s32BitSlice + 16) ) + { + if (*(ps16GenBufPtr) == s32BitSlice+1) + s32SliceCount += 2; + else + s32SliceCount++; + } + ps16GenBufPtr++; + } + } while (s32BitCount-s32SliceCount>0); + + if (s32BitCount-s32SliceCount == 0) + { + s32BitCount -= s32SliceCount; + s32BitSlice --; + } + + /* Bits are distributed until the last bitslice is reached */ + ps16GenBufPtr = ps16BitNeed; + ps16GenArrPtr = pstrCodecParams->as16Bits; + for (s32Ch = 0; s32Ch < 2; s32Ch++) + { + for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) + { + if (*ps16GenBufPtr < s32BitSlice+2) + *ps16GenArrPtr = 0; + else + *ps16GenArrPtr = ((*(ps16GenBufPtr)-s32BitSlice) < 16) ? + (SINT16)(*(ps16GenBufPtr)-s32BitSlice):16; + ps16GenBufPtr++; + ps16GenArrPtr++; + } + } + + /* the remaining bits are allocated starting at subband 0 */ + s32Ch=0; + s32Sb=0; + ps16GenBufPtr = ps16BitNeed; + ps16GenArrPtr -= 2*s32NumOfSubBands; + + while ( (s32BitCount > 0) && (s32Sb < s32NumOfSubBands) ) + { + if ( (*(ps16GenArrPtr) >= 2) && (*(ps16GenArrPtr) < 16) ) + { + (*(ps16GenArrPtr))++; + s32BitCount--; + } + else if ((*ps16GenBufPtr == s32BitSlice+1) && (s32BitCount > 1)) + { + *(ps16GenArrPtr) = 2; + s32BitCount -= 2; + } + if(s32Ch == 1) + { + s32Ch = 0; + s32Sb++; + ps16GenBufPtr = ps16BitNeed+s32Sb; + ps16GenArrPtr = pstrCodecParams->as16Bits+s32Sb; + + } + else + { + s32Ch =1; + ps16GenBufPtr = ps16BitNeed+s32NumOfSubBands+s32Sb; + ps16GenArrPtr = pstrCodecParams->as16Bits+s32NumOfSubBands+s32Sb; + } + } + + s32Ch=0; + s32Sb=0; + ps16GenArrPtr = pstrCodecParams->as16Bits; + + while ((s32BitCount >0) && (s32Sb < s32NumOfSubBands)) + { + if(*(ps16GenArrPtr) < 16) + { + (*(ps16GenArrPtr))++; + s32BitCount--; + } + if (s32Ch == 1) + { + s32Ch = 0; + s32Sb++; + ps16GenArrPtr = pstrCodecParams->as16Bits+s32Sb; + } + else + { + s32Ch = 1; + ps16GenArrPtr = pstrCodecParams->as16Bits+s32NumOfSubBands+s32Sb; + } + } +} + +/*End of BitAlloc() function*/ + diff --git a/embdrv/sbc/encoder/srce/sbc_enc_coeffs.c b/embdrv/sbc/encoder/srce/sbc_enc_coeffs.c new file mode 100644 index 0000000..48cc22f --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_enc_coeffs.c @@ -0,0 +1,308 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_enc_coeffs.c,v $ +** +** Description: This file contains the Windowing coeffs for synthesis filter +** +** Revision : $Id: sbc_enc_coeffs.c,v 1.10 2006/04/11 17:05:34 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#include "sbc_encoder.h" + +#if (SBC_ARM_ASM_OPT==FALSE && SBC_IPAQ_OPT==FALSE) +#if (SBC_IS_64_MULT_IN_WINDOW_ACCU == FALSE) +/*Window coeff for 4 sub band case*/ +const SINT16 gas32CoeffFor4SBs[] = +{ + (SINT16)((SINT32)0x00000000 >> 16), (SINT16)0x00000000, + (SINT16)((SINT32)0x001194E6 >> 16), (SINT16)0x001194E6, + (SINT16)((SINT32)0x0030E2D3 >> 16), (SINT16)0x0030E2D3, + (SINT16)((SINT32)0x00599403 >> 16), (SINT16)0x00599403, + (SINT16)((SINT32)0x007DBCC8 >> 16), (SINT16)0x007DBCC8, + (SINT16)((SINT32)0x007F88E4 >> 16), (SINT16)0x007F88E4, + (SINT16)((SINT32)0x003D239B >> 16), (SINT16)0x003D239B, + (SINT16)((SINT32)0xFF9BB9D5 >> 16), (SINT16)0xFF9BB9D5, + + (SINT16)((SINT32)0x01659F45 >> 16), (SINT16)0x01659F45, + (SINT16)((SINT32)0x029DBAA3 >> 16), (SINT16)0x029DBAA3, + (SINT16)((SINT32)0x03B23341 >> 16), (SINT16)0x03B23341, + (SINT16)((SINT32)0x041EEE40 >> 16), (SINT16)0x041EEE40, + (SINT16)((SINT32)0x034FEE2C >> 16), (SINT16)0x034FEE2C, + (SINT16)((SINT32)0x00C8F2BC >> 16), (SINT16)0x00C8F2BC, + (SINT16)((SINT32)0xFC4F91D4 >> 16), (SINT16)0xFC4F91D4, + (SINT16)((SINT32)0xF60FAF37 >> 16), (SINT16)0xF60FAF37, + + (SINT16)((SINT32)0x115B1ED2 >> 16), (SINT16)0x115B1ED2, + (SINT16)((SINT32)0x18F55C90 >> 16), (SINT16)0x18F55C90, + (SINT16)((SINT32)0x1F91CA46 >> 16), (SINT16)0x1F91CA46, + (SINT16)((SINT32)0x2412F251 >> 16), (SINT16)0x2412F251, + (SINT16)((SINT32)0x25AC1FF2 >> 16), (SINT16)0x25AC1FF2, + (SINT16)((SINT32)0x2412F251 >> 16), (SINT16)0x2412F251, + (SINT16)((SINT32)0x1F91CA46 >> 16), (SINT16)0x1F91CA46, + (SINT16)((SINT32)0x18F55C90 >> 16), (SINT16)0x18F55C90, + + (SINT16)((SINT32)0xEEA4E12E >> 16), (SINT16)0xEEA4E12E, + (SINT16)((SINT32)0xF60FAF37 >> 16), (SINT16)0xF60FAF37, + (SINT16)((SINT32)0xFC4F91D4 >> 16), (SINT16)0xFC4F91D4, + (SINT16)((SINT32)0x00C8F2BC >> 16), (SINT16)0x00C8F2BC, + (SINT16)((SINT32)0x034FEE2C >> 16), (SINT16)0x034FEE2C, + (SINT16)((SINT32)0x041EEE40 >> 16), (SINT16)0x041EEE40, + (SINT16)((SINT32)0x03B23341 >> 16), (SINT16)0x03B23341, + (SINT16)((SINT32)0x029DBAA3 >> 16), (SINT16)0x029DBAA3, + + (SINT16)((SINT32)0xFE9A60BB >> 16), (SINT16)0xFE9A60BB, + (SINT16)((SINT32)0xFF9BB9D5 >> 16), (SINT16)0xFF9BB9D5, + (SINT16)((SINT32)0x003D239B >> 16), (SINT16)0x003D239B, + (SINT16)((SINT32)0x007F88E4 >> 16), (SINT16)0x007F88E4, + (SINT16)((SINT32)0x007DBCC8 >> 16), (SINT16)0x007DBCC8, + (SINT16)((SINT32)0x00599403 >> 16), (SINT16)0x00599403, + (SINT16)((SINT32)0x0030E2D3 >> 16), (SINT16)0x0030E2D3, + (SINT16)((SINT32)0x001194E6 >> 16), (SINT16)0x001194E6 +}; + +/*Window coeff for 8 sub band case*/ +const SINT16 gas32CoeffFor8SBs[] = +{ + (SINT16)((SINT32)0x00000000 >>16), (SINT16)0x00000000, + (SINT16)((SINT32)0x00052173 >>16), (SINT16)0x00052173, + (SINT16)((SINT32)0x000B3F71 >>16), (SINT16)0x000B3F71, + (SINT16)((SINT32)0x00122C7D >>16), (SINT16)0x00122C7D, + (SINT16)((SINT32)0x001AFF89 >>16), (SINT16)0x001AFF89, + (SINT16)((SINT32)0x00255A62 >>16), (SINT16)0x00255A62, + (SINT16)((SINT32)0x003060F4 >>16), (SINT16)0x003060F4, + (SINT16)((SINT32)0x003A72E7 >>16), (SINT16)0x003A72E7, + + (SINT16)((SINT32)0x0041EC6A >>16), (SINT16)0x0041EC6A, /* 8 */ + (SINT16)((SINT32)0x0044EF48 >>16), (SINT16)0x0044EF48, + (SINT16)((SINT32)0x00415B75 >>16), (SINT16)0x00415B75, + (SINT16)((SINT32)0x0034F8B6 >>16), (SINT16)0x0034F8B6, + (SINT16)((SINT32)0x001D8FD2 >>16), (SINT16)0x001D8FD2, + (SINT16)((SINT32)0xFFFA2413 >>16), (SINT16)0xFFFA2413, + (SINT16)((SINT32)0xFFC9F10E >>16), (SINT16)0xFFC9F10E, + (SINT16)((SINT32)0xFF8D6793 >>16), (SINT16)0xFF8D6793, + + (SINT16)((SINT32)0x00B97348 >>16), (SINT16)0x00B97348, /* 16 */ + (SINT16)((SINT32)0x01071B96 >>16), (SINT16)0x01071B96, + (SINT16)((SINT32)0x0156B3CA >>16), (SINT16)0x0156B3CA, + (SINT16)((SINT32)0x01A1B38B >>16), (SINT16)0x01A1B38B, + (SINT16)((SINT32)0x01E0224C >>16), (SINT16)0x01E0224C, + (SINT16)((SINT32)0x0209291F >>16), (SINT16)0x0209291F, + (SINT16)((SINT32)0x02138653 >>16), (SINT16)0x02138653, + (SINT16)((SINT32)0x01F5F424 >>16), (SINT16)0x01F5F424, + + (SINT16)((SINT32)0x01A7ECEF >>16), (SINT16)0x01A7ECEF, /* 24 */ + (SINT16)((SINT32)0x01223EBA >>16), (SINT16)0x01223EBA, + (SINT16)((SINT32)0x005FD0FF >>16), (SINT16)0x005FD0FF, + (SINT16)((SINT32)0xFF5EEB73 >>16), (SINT16)0xFF5EEB73, + (SINT16)((SINT32)0xFE20435D >>16), (SINT16)0xFE20435D, + (SINT16)((SINT32)0xFCA86E7E >>16), (SINT16)0xFCA86E7E, + (SINT16)((SINT32)0xFAFF95FC >>16), (SINT16)0xFAFF95FC, + (SINT16)((SINT32)0xF9312891 >>16), (SINT16)0xF9312891, + + (SINT16)((SINT32)0x08B4307A >>16), (SINT16)0x08B4307A, /* 32 */ + (SINT16)((SINT32)0x0A9F3E9A >>16), (SINT16)0x0A9F3E9A, + (SINT16)((SINT32)0x0C7D59B6 >>16), (SINT16)0x0C7D59B6, + (SINT16)((SINT32)0x0E3BB16F >>16), (SINT16)0x0E3BB16F, + (SINT16)((SINT32)0x0FC721F9 >>16), (SINT16)0x0FC721F9, + (SINT16)((SINT32)0x110ECEF0 >>16), (SINT16)0x110ECEF0, + (SINT16)((SINT32)0x120435FA >>16), (SINT16)0x120435FA, + (SINT16)((SINT32)0x129C226F >>16), (SINT16)0x129C226F, + + (SINT16)((SINT32)0x12CF6C75 >>16), (SINT16)0x12CF6C75, /* 40 */ + (SINT16)((SINT32)0x129C226F >>16), (SINT16)0x129C226F, + (SINT16)((SINT32)0x120435FA >>16), (SINT16)0x120435FA, + (SINT16)((SINT32)0x110ECEF0 >>16), (SINT16)0x110ECEF0, + (SINT16)((SINT32)0x0FC721F9 >>16), (SINT16)0x0FC721F9, + (SINT16)((SINT32)0x0E3BB16F >>16), (SINT16)0x0E3BB16F, + (SINT16)((SINT32)0x0C7D59B6 >>16), (SINT16)0x0C7D59B6, + (SINT16)((SINT32)0x0A9F3E9A >>16), (SINT16)0x0A9F3E9A, + + (SINT16)((SINT32)0xF74BCF86 >>16), (SINT16)0xF74BCF86, /* 48 */ + (SINT16)((SINT32)0xF9312891 >>16), (SINT16)0xF9312891, + (SINT16)((SINT32)0xFAFF95FC >>16), (SINT16)0xFAFF95FC, + (SINT16)((SINT32)0xFCA86E7E >>16), (SINT16)0xFCA86E7E, + (SINT16)((SINT32)0xFE20435D >>16), (SINT16)0xFE20435D, + (SINT16)((SINT32)0xFF5EEB73 >>16), (SINT16)0xFF5EEB73, + (SINT16)((SINT32)0x005FD0FF >>16), (SINT16)0x005FD0FF, + (SINT16)((SINT32)0x01223EBA >>16), (SINT16)0x01223EBA, + + (SINT16)((SINT32)0x01A7ECEF >>16), (SINT16)0x01A7ECEF, /* 56 */ + (SINT16)((SINT32)0x01F5F424 >>16), (SINT16)0x01F5F424, + (SINT16)((SINT32)0x02138653 >>16), (SINT16)0x02138653, + (SINT16)((SINT32)0x0209291F >>16), (SINT16)0x0209291F, + (SINT16)((SINT32)0x01E0224C >>16), (SINT16)0x01E0224C, + (SINT16)((SINT32)0x01A1B38B >>16), (SINT16)0x01A1B38B, + (SINT16)((SINT32)0x0156B3CA >>16), (SINT16)0x0156B3CA, + (SINT16)((SINT32)0x01071B96 >>16), (SINT16)0x01071B96, + + (SINT16)((SINT32)0xFF468CB8 >>16), (SINT16)0xFF468CB8, /* 64 */ + (SINT16)((SINT32)0xFF8D6793 >>16), (SINT16)0xFF8D6793, + (SINT16)((SINT32)0xFFC9F10E >>16), (SINT16)0xFFC9F10E, + (SINT16)((SINT32)0xFFFA2413 >>16), (SINT16)0xFFFA2413, + (SINT16)((SINT32)0x001D8FD2 >>16), (SINT16)0x001D8FD2, + (SINT16)((SINT32)0x0034F8B6 >>16), (SINT16)0x0034F8B6, + (SINT16)((SINT32)0x00415B75 >>16), (SINT16)0x00415B75, + (SINT16)((SINT32)0x0044EF48 >>16), (SINT16)0x0044EF48, + + (SINT16)((SINT32)0x0041EC6A >>16), (SINT16)0x0041EC6A, /* 72 */ + (SINT16)((SINT32)0x003A72E7 >>16), (SINT16)0x003A72E7, + (SINT16)((SINT32)0x003060F4 >>16), (SINT16)0x003060F4, + (SINT16)((SINT32)0x00255A62 >>16), (SINT16)0x00255A62, + (SINT16)((SINT32)0x001AFF89 >>16), (SINT16)0x001AFF89, + (SINT16)((SINT32)0x00122C7D >>16), (SINT16)0x00122C7D, + (SINT16)((SINT32)0x000B3F71 >>16), (SINT16)0x000B3F71, + (SINT16)((SINT32)0x00052173 >>16), (SINT16)0x00052173 +}; + +#else + +/*Window coeff for 4 sub band case*/ +const SINT32 gas32CoeffFor4SBs[] = +{ + (SINT32)0x00000000, + (SINT32)0x001194E6, + (SINT32)0x0030E2D3, + (SINT32)0x00599403, + (SINT32)0x007DBCC8, + (SINT32)0x007F88E4, + (SINT32)0x003D239B, + (SINT32)0xFF9BB9D5, + + (SINT32)0x01659F45, + (SINT32)0x029DBAA3, + (SINT32)0x03B23341, + (SINT32)0x041EEE40, + (SINT32)0x034FEE2C, + (SINT32)0x00C8F2BC, + (SINT32)0xFC4F91D4, + (SINT32)0xF60FAF37, + + (SINT32)0x115B1ED2, + (SINT32)0x18F55C90, + (SINT32)0x1F91CA46, + (SINT32)0x2412F251, + (SINT32)0x25AC1FF2, + (SINT32)0x2412F251, + (SINT32)0x1F91CA46, + (SINT32)0x18F55C90, + + (SINT32)0xEEA4E12E, + (SINT32)0xF60FAF37, + (SINT32)0xFC4F91D4, + (SINT32)0x00C8F2BC, + (SINT32)0x034FEE2C, + (SINT32)0x041EEE40, + (SINT32)0x03B23341, + (SINT32)0x029DBAA3, + + (SINT32)0xFE9A60BB, + (SINT32)0xFF9BB9D5, + (SINT32)0x003D239B, + (SINT32)0x007F88E4, + (SINT32)0x007DBCC8, + (SINT32)0x00599403, + (SINT32)0x0030E2D3, + (SINT32)0x001194E6 +}; + +/*Window coeff for 8 sub band case*/ +const SINT32 gas32CoeffFor8SBs[] = +{ + (SINT32)0x00000000, + (SINT32)0x00052173, + (SINT32)0x000B3F71, + (SINT32)0x00122C7D, + (SINT32)0x001AFF89, + (SINT32)0x00255A62, + (SINT32)0x003060F4, + (SINT32)0x003A72E7, + + (SINT32)0x0041EC6A, /* 8 */ + (SINT32)0x0044EF48, + (SINT32)0x00415B75, + (SINT32)0x0034F8B6, + (SINT32)0x001D8FD2, + (SINT32)0xFFFA2413, + (SINT32)0xFFC9F10E, + (SINT32)0xFF8D6793, + + (SINT32)0x00B97348, /* 16 */ + (SINT32)0x01071B96, + (SINT32)0x0156B3CA, + (SINT32)0x01A1B38B, + (SINT32)0x01E0224C, + (SINT32)0x0209291F, + (SINT32)0x02138653, + (SINT32)0x01F5F424, + + (SINT32)0x01A7ECEF, /* 24 */ + (SINT32)0x01223EBA, + (SINT32)0x005FD0FF, + (SINT32)0xFF5EEB73, + (SINT32)0xFE20435D, + (SINT32)0xFCA86E7E, + (SINT32)0xFAFF95FC, + (SINT32)0xF9312891, + + (SINT32)0x08B4307A, /* 32 */ + (SINT32)0x0A9F3E9A, + (SINT32)0x0C7D59B6, + (SINT32)0x0E3BB16F, + (SINT32)0x0FC721F9, + (SINT32)0x110ECEF0, + (SINT32)0x120435FA, + (SINT32)0x129C226F, + + (SINT32)0x12CF6C75, /* 40 */ + (SINT32)0x129C226F, + (SINT32)0x120435FA, + (SINT32)0x110ECEF0, + (SINT32)0x0FC721F9, + (SINT32)0x0E3BB16F, + (SINT32)0x0C7D59B6, + (SINT32)0x0A9F3E9A, + + (SINT32)0xF74BCF86, /* 48 */ + (SINT32)0xF9312891, + (SINT32)0xFAFF95FC, + (SINT32)0xFCA86E7E, + (SINT32)0xFE20435D, + (SINT32)0xFF5EEB73, + (SINT32)0x005FD0FF, + (SINT32)0x01223EBA, + + (SINT32)0x01A7ECEF, /* 56 */ + (SINT32)0x01F5F424, + (SINT32)0x02138653, + (SINT32)0x0209291F, + (SINT32)0x01E0224C, + (SINT32)0x01A1B38B, + (SINT32)0x0156B3CA, + (SINT32)0x01071B96, + + (SINT32)0xFF468CB8, /* 64 */ + (SINT32)0xFF8D6793, + (SINT32)0xFFC9F10E, + (SINT32)0xFFFA2413, + (SINT32)0x001D8FD2, + (SINT32)0x0034F8B6, + (SINT32)0x00415B75, + (SINT32)0x0044EF48, + + (SINT32)0x0041EC6A, /* 72 */ + (SINT32)0x003A72E7, + (SINT32)0x003060F4, + (SINT32)0x00255A62, + (SINT32)0x001AFF89, + (SINT32)0x00122C7D, + (SINT32)0x000B3F71, + (SINT32)0x00052173 +}; + +#endif +#endif + diff --git a/embdrv/sbc/encoder/srce/sbc_encoder.c b/embdrv/sbc/encoder/srce/sbc_encoder.c new file mode 100644 index 0000000..281c970 --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_encoder.c @@ -0,0 +1,386 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_encoder.c,v $ +** +** Description: contains code for encoder flow and initalization of encoder +** +** Revision : $Id: sbc_encoder.c,v 1.17 2006/04/13 17:24:47 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#include <string.h> +#include "sbc_encoder.h" +#include "sbc_enc_func_declare.h" + +SINT16 EncMaxShiftCounter; + +/************************************************************************************************* + * SBC encoder scramble code + * Purpose: to tie the SBC code with BTE/mobile stack code, + * especially for the case when the SBC is ported into a third-party Multimedia chip + * + * Algorithm: + * init process: all counters reset to 0, + * calculate base_index: (6 + s16NumOfChannels*s16NumOfSubBands/2) + * scramble side: the init process happens every time SBC_Encoder_Init() is called. + * descramble side: it would be nice to know if he "init" process has happened. + * alter the SBC SYNC word 0x9C (1001 1100) to 0x8C (1000 1100). + * + * scramble process: + * The CRC byte: + * Every SBC frame has a frame header. + * The 1st byte is the sync word and the following 2 bytes are about the stream format. + * They are supposed to be "constant" within a "song" + * The 4th byte is the CRC byte. The CRC byte is bound to be random. + * Derive 2 items from the CRC byte; one is the "use" bit, the other is the "index". + * + * SBC keeps 2 sets of "use" & "index"; derived the current and the previous frame. + * + * The "use" bit is any bit in SBC_PRTC_USE_MASK is set. + * If set, SBC uses the "index" from the current frame. + * If not set, SBC uses the "index" from the previous frame or 0. + * + * index = (CRC & 0x3) + ((CRC & 0x30) >> 2) // 8 is the max index + * + * if(index > 0) + * { + * p = &u8frame[base_index]; + * if((index&1)&&(u16PacketLength > (base_index+index*2))) + * { + * // odd index: swap 2 bytes + * tmp = p[index]; + * p[index] = p[index*2]; + * p[index*2] = tmp; + * } + * else + * { + * // even index: shift by 3 + * tmp = (p[index] >> 5) + (p[index] << 3); + * p[index] = tmp; + * } + * } + * //else index is 0. The frame stays unaltered + * + */ + +#define SBC_PRTC_CRC_IDX 3 +#define SBC_PRTC_USE_MASK 0x64 +#define SBC_PRTC_SYNC_MASK 0x10 +#define SBC_PRTC_CIDX 0 +#define SBC_PRTC_LIDX 1 +typedef struct +{ + UINT8 use; + UINT8 idx; +} tSBC_FR_CB; + +typedef struct +{ + tSBC_FR_CB fr[2]; + UINT8 init; + UINT8 index; + UINT8 base; +} tSBC_PRTC_CB; +tSBC_PRTC_CB sbc_prtc_cb; + +#define SBC_PRTC_IDX(sc) (((sc) & 0x3) + (((sc) & 0x30) >> 2)) +#define SBC_PRTC_CHK_INIT(ar) {if(sbc_prtc_cb.init == 0){sbc_prtc_cb.init=1; ar[0] &= ~SBC_PRTC_SYNC_MASK;}} +#define SBC_PRTC_C2L() {p_last=&sbc_prtc_cb.fr[SBC_PRTC_LIDX]; p_cur=&sbc_prtc_cb.fr[SBC_PRTC_CIDX]; \ + p_last->idx = p_cur->idx; p_last->use = p_cur->use;} +#define SBC_PRTC_GETC(ar) {p_cur->use = ar[SBC_PRTC_CRC_IDX] & SBC_PRTC_USE_MASK; \ + p_cur->idx = SBC_PRTC_IDX(ar[SBC_PRTC_CRC_IDX]);} +#define SBC_PRTC_CHK_CRC(ar) {SBC_PRTC_C2L();SBC_PRTC_GETC(ar);sbc_prtc_cb.index = (p_cur->use)?SBC_PRTC_CIDX:SBC_PRTC_LIDX;} +#define SBC_PRTC_SCRMB(ar) {idx = sbc_prtc_cb.fr[sbc_prtc_cb.index].idx; \ + if(idx > 0){if((idx&1)&&(pstrEncParams->u16PacketLength > (sbc_prtc_cb.base+(idx<<1)))) {tmp2=idx<<1; tmp=ar[idx];ar[idx]=ar[tmp2];ar[tmp2]=tmp;} \ + else{tmp2=ar[idx]; tmp=(tmp2>>5)+(tmp2<<3);ar[idx]=(UINT8)tmp;}}} + +#if (SBC_JOINT_STE_INCLUDED == TRUE) +SINT32 s32LRDiff[SBC_MAX_NUM_OF_BLOCKS] = {0}; +SINT32 s32LRSum[SBC_MAX_NUM_OF_BLOCKS] = {0}; +#endif + +void SBC_Encoder(SBC_ENC_PARAMS *pstrEncParams) +{ + SINT32 s32Ch; /* counter for ch*/ + SINT32 s32Sb; /* counter for sub-band*/ + UINT32 u32Count, maxBit = 0; /* loop count*/ + SINT32 s32MaxValue; /* temp variable to store max value */ + + SINT16 *ps16ScfL; + SINT32 *SbBuffer; + SINT32 s32Blk; /* counter for block*/ + SINT32 s32NumOfBlocks = pstrEncParams->s16NumOfBlocks; +#if (SBC_JOINT_STE_INCLUDED == TRUE) + SINT32 s32MaxValue2; + UINT32 u32CountSum,u32CountDiff; + SINT32 *pSum, *pDiff; +#endif + UINT8 *pu8; + tSBC_FR_CB *p_cur, *p_last; + UINT32 idx, tmp, tmp2; + register SINT32 s32NumOfSubBands = pstrEncParams->s16NumOfSubBands; + + pstrEncParams->pu8NextPacket = pstrEncParams->pu8Packet; + +#if (SBC_NO_PCM_CPY_OPTION == TRUE) + pstrEncParams->ps16NextPcmBuffer = pstrEncParams->ps16PcmBuffer; +#else + pstrEncParams->ps16NextPcmBuffer = pstrEncParams->as16PcmBuffer; +#endif + do + { + /* SBC ananlysis filter*/ + if (s32NumOfSubBands == 4) + SbcAnalysisFilter4(pstrEncParams); + else + SbcAnalysisFilter8(pstrEncParams); + + /* compute the scale factor, and save the max */ + ps16ScfL = pstrEncParams->as16ScaleFactor; + s32Ch=pstrEncParams->s16NumOfChannels*s32NumOfSubBands; + + pstrEncParams->ps16NextPcmBuffer+=s32Ch*s32NumOfBlocks; /* in case of multible sbc frame to encode update the pcm pointer */ + + for (s32Sb=0; s32Sb<s32Ch; s32Sb++) + { + SbBuffer=pstrEncParams->s32SbBuffer+s32Sb; + s32MaxValue=0; + for (s32Blk=s32NumOfBlocks;s32Blk>0;s32Blk--) + { + if (s32MaxValue<abs32(*SbBuffer)) + s32MaxValue=abs32(*SbBuffer); + SbBuffer+=s32Ch; + } + + u32Count = (s32MaxValue > 0x800000) ? 9 : 0; + + for ( ; u32Count < 15; u32Count++) + { + if (s32MaxValue <= (SINT32)(0x8000 << u32Count)) + break; + } + *ps16ScfL++ = (SINT16)u32Count; + + if (u32Count > maxBit) + maxBit = u32Count; + } + /* In case of JS processing,check whether to use JS */ +#if (SBC_JOINT_STE_INCLUDED == TRUE) + if (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) + { + /* Calculate sum and differance scale factors for making JS decision */ + ps16ScfL = pstrEncParams->as16ScaleFactor ; + /* calculate the scale factor of Joint stereo max sum and diff */ + for (s32Sb = 0; s32Sb < s32NumOfSubBands-1; s32Sb++) + { + SbBuffer=pstrEncParams->s32SbBuffer+s32Sb; + s32MaxValue2=0; + s32MaxValue=0; + pSum = s32LRSum; + pDiff = s32LRDiff; + for (s32Blk=0;s32Blk<s32NumOfBlocks;s32Blk++) + { + *pSum=(*SbBuffer+*(SbBuffer+s32NumOfSubBands))>>1; + if (abs32(*pSum)>s32MaxValue) + s32MaxValue=abs32(*pSum); + pSum++; + *pDiff=(*SbBuffer-*(SbBuffer+s32NumOfSubBands))>>1; + if (abs32(*pDiff)>s32MaxValue2) + s32MaxValue2=abs32(*pDiff); + pDiff++; + SbBuffer+=s32Ch; + } + u32Count = (s32MaxValue > 0x800000) ? 9 : 0; + for ( ; u32Count < 15; u32Count++) + { + if (s32MaxValue <= (SINT32)(0x8000 << u32Count)) + break; + } + u32CountSum=u32Count; + u32Count = (s32MaxValue2 > 0x800000) ? 9 : 0; + for ( ; u32Count < 15; u32Count++) + { + if (s32MaxValue2 <= (SINT32)(0x8000 << u32Count)) + break; + } + u32CountDiff=u32Count; + if ( (*ps16ScfL + *(ps16ScfL+s32NumOfSubBands)) > (SINT16)(u32CountSum + u32CountDiff) ) + { + + if (u32CountSum > maxBit) + maxBit = u32CountSum; + + if (u32CountDiff > maxBit) + maxBit = u32CountDiff; + + *ps16ScfL = (SINT16)u32CountSum; + *(ps16ScfL+s32NumOfSubBands) = (SINT16)u32CountDiff; + + SbBuffer=pstrEncParams->s32SbBuffer+s32Sb; + pSum = s32LRSum; + pDiff = s32LRDiff; + + for (s32Blk = 0; s32Blk < s32NumOfBlocks; s32Blk++) + { + *SbBuffer = *pSum; + *(SbBuffer+s32NumOfSubBands) = *pDiff; + + SbBuffer += s32NumOfSubBands<<1; + pSum++; + pDiff++; + } + + pstrEncParams->as16Join[s32Sb] = 1; + } + else + { + pstrEncParams->as16Join[s32Sb] = 0; + } + ps16ScfL++; + } + pstrEncParams->as16Join[s32Sb] = 0; + } +#endif + + pstrEncParams->s16MaxBitNeed = (SINT16)maxBit; + + /* bit allocation */ + if ((pstrEncParams->s16ChannelMode == SBC_STEREO) || (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO)) + sbc_enc_bit_alloc_ste(pstrEncParams); + else + sbc_enc_bit_alloc_mono(pstrEncParams); + + /* save the beginning of the frame. pu8NextPacket is modified in EncPacking() */ + pu8 = pstrEncParams->pu8NextPacket; + /* Quantize the encoded audio */ + EncPacking(pstrEncParams); + + /* scramble the code */ + SBC_PRTC_CHK_INIT(pu8); + SBC_PRTC_CHK_CRC(pu8); +#if 0 + if(pstrEncParams->u16PacketLength > ((sbc_prtc_cb.fr[sbc_prtc_cb.index].idx * 2) + sbc_prtc_cb.base)) + printf("len: %d, idx: %d\n", pstrEncParams->u16PacketLength, sbc_prtc_cb.fr[sbc_prtc_cb.index].idx); + else + printf("len: %d, idx: %d!!!!\n", pstrEncParams->u16PacketLength, sbc_prtc_cb.fr[sbc_prtc_cb.index].idx); +#endif + SBC_PRTC_SCRMB((&pu8[sbc_prtc_cb.base])); + } + while(--(pstrEncParams->u8NumPacketToEncode)); + + pstrEncParams->u8NumPacketToEncode = 1; /* default is one for retrocompatibility purpose */ + +} + +/**************************************************************************** +* InitSbcAnalysisFilt - Initalizes the input data to 0 +* +* RETURNS : N/A +*/ +void SBC_Encoder_Init(SBC_ENC_PARAMS *pstrEncParams) +{ + UINT16 s16SamplingFreq; /*temp variable to store smpling freq*/ + SINT16 s16Bitpool; /*to store bit pool value*/ + SINT16 s16BitRate; /*to store bitrate*/ + SINT16 s16FrameLen; /*to store frame length*/ + UINT16 HeaderParams; + + pstrEncParams->u8NumPacketToEncode = 1; /* default is one for retrocompatibility purpose */ + + /* Required number of channels */ + if (pstrEncParams->s16ChannelMode == SBC_MONO) + pstrEncParams->s16NumOfChannels = 1; + else + pstrEncParams->s16NumOfChannels = 2; + + /* Bit pool calculation */ + if (pstrEncParams->s16SamplingFreq == SBC_sf16000) + s16SamplingFreq = 16000; + else if (pstrEncParams->s16SamplingFreq == SBC_sf32000) + s16SamplingFreq = 32000; + else if (pstrEncParams->s16SamplingFreq == SBC_sf44100) + s16SamplingFreq = 44100; + else + s16SamplingFreq = 48000; + + if ( (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) + || (pstrEncParams->s16ChannelMode == SBC_STEREO) ) + { + s16Bitpool = (SINT16)( (pstrEncParams->u16BitRate * + pstrEncParams->s16NumOfSubBands * 1000 / s16SamplingFreq) + -( (32 + (4 * pstrEncParams->s16NumOfSubBands * + pstrEncParams->s16NumOfChannels) + + ( (pstrEncParams->s16ChannelMode - 2) * + pstrEncParams->s16NumOfSubBands ) ) + / pstrEncParams->s16NumOfBlocks) ); + + s16FrameLen = 4 + (4*pstrEncParams->s16NumOfSubBands* + pstrEncParams->s16NumOfChannels)/8 + + ( ((pstrEncParams->s16ChannelMode - 2) * + pstrEncParams->s16NumOfSubBands) + + (pstrEncParams->s16NumOfBlocks * s16Bitpool) ) / 8; + + s16BitRate = (8 * s16FrameLen * s16SamplingFreq) + / (pstrEncParams->s16NumOfSubBands * + pstrEncParams->s16NumOfBlocks * 1000); + + if (s16BitRate > pstrEncParams->u16BitRate) + s16Bitpool--; + + if(pstrEncParams->s16NumOfSubBands == 8) + pstrEncParams->s16BitPool = (s16Bitpool > 255) ? 255 : s16Bitpool; + else + pstrEncParams->s16BitPool = (s16Bitpool > 128) ? 128 : s16Bitpool; + } + else + { + s16Bitpool = (SINT16)( ((pstrEncParams->s16NumOfSubBands * + pstrEncParams->u16BitRate * 1000) + / (s16SamplingFreq * pstrEncParams->s16NumOfChannels)) + -( ( (32 / pstrEncParams->s16NumOfChannels) + + (4 * pstrEncParams->s16NumOfSubBands) ) + / pstrEncParams->s16NumOfBlocks ) ); + + pstrEncParams->s16BitPool = (s16Bitpool > + (16 * pstrEncParams->s16NumOfSubBands)) + ? (16*pstrEncParams->s16NumOfSubBands) : s16Bitpool; + } + + if (pstrEncParams->s16BitPool < 0) + pstrEncParams->s16BitPool = 0; + /* sampling freq */ + HeaderParams = ((pstrEncParams->s16SamplingFreq & 3)<< 6); + + /* number of blocks*/ + HeaderParams |= (((pstrEncParams->s16NumOfBlocks -4) & 12) << 2); + + /* channel mode: mono, dual...*/ + HeaderParams |= ((pstrEncParams->s16ChannelMode & 3)<< 2); + + /* Loudness or SNR */ + HeaderParams |= ((pstrEncParams->s16AllocationMethod & 1)<< 1); + HeaderParams |= ((pstrEncParams->s16NumOfSubBands >> 3) & 1); /*4 or 8*/ + pstrEncParams->FrameHeader=HeaderParams; + + if (pstrEncParams->s16NumOfSubBands==4) + { + if (pstrEncParams->s16NumOfChannels==1) + EncMaxShiftCounter=((ENC_VX_BUFFER_SIZE-4*10)>>2)<<2; + else + EncMaxShiftCounter=((ENC_VX_BUFFER_SIZE-4*10*2)>>3)<<2; + } + else + { + if (pstrEncParams->s16NumOfChannels==1) + EncMaxShiftCounter=((ENC_VX_BUFFER_SIZE-8*10)>>3)<<3; + else + EncMaxShiftCounter=((ENC_VX_BUFFER_SIZE-8*10*2)>>4)<<3; + } + SbcAnalysisInit(); + + memset(&sbc_prtc_cb, 0, sizeof(tSBC_PRTC_CB)); + sbc_prtc_cb.base = 6 + pstrEncParams->s16NumOfChannels*pstrEncParams->s16NumOfSubBands/2; +} diff --git a/embdrv/sbc/encoder/srce/sbc_packing.c b/embdrv/sbc/encoder/srce/sbc_packing.c new file mode 100644 index 0000000..55edb9b --- /dev/null +++ b/embdrv/sbc/encoder/srce/sbc_packing.c @@ -0,0 +1,264 @@ +/****************************************************************************** +** +** File Name: $RCSfile: sbc_packing.c,v $ +** +** Description: This file contains code for packing the Encoded data into bit +** streams. +** +** Revision : $Id: sbc_packing.c,v 1.17 2006/04/11 17:07:03 mjougit Exp $ +** +** Copyright (c) 1999-2002, Widcomm Inc., All Rights Reserved. +** Widcomm Bluetooth Core. Proprietary and confidential. +** +******************************************************************************/ + +#include "sbc_encoder.h" +#include "sbc_enc_func_declare.h" + +#if (SBC_ARM_ASM_OPT==TRUE) +#define Mult32(s32In1,s32In2,s32OutLow) \ +{ \ + __asm \ + { \ + MUL s32OutLow,s32In1,s32In2; \ + } \ +} +#define Mult64(s32In1, s32In2, s32OutLow, s32OutHi) \ +{ \ + __asm \ + { \ + SMULL s32OutLow,s32OutHi,s32In1,s32In2 \ + } \ +} +#else +#define Mult32(s32In1,s32In2,s32OutLow) s32OutLow=(SINT32)s32In1*(SINT32)s32In2; +#define Mult64(s32In1, s32In2, s32OutLow, s32OutHi) \ +{ \ + s32OutLow = ((SINT32)(UINT16)s32In1 * (UINT16)s32In2); \ + s32TempVal2 = (SINT32)((s32In1 >> 16) * (UINT16)s32In2); \ + s32Carry = ( (((UINT32)(s32OutLow)>>16)&0xFFFF) + \ + + (s32TempVal2 & 0xFFFF) ) >> 16; \ + s32OutLow += (s32TempVal2 << 16); \ + s32OutHi = (s32TempVal2 >> 16) + s32Carry; \ +} +#endif + +void EncPacking(SBC_ENC_PARAMS *pstrEncParams) +{ + UINT8 *pu8PacketPtr; /* packet ptr*/ + UINT8 Temp; + SINT32 s32Blk; /* counter for block*/ + SINT32 s32Ch; /* counter for channel*/ + SINT32 s32Sb; /* counter for sub-band*/ + SINT32 s32PresentBit; /* represents bit to be stored*/ + /*SINT32 s32LoopCountI; loop counter*/ + SINT32 s32LoopCountJ; /* loop counter*/ + UINT32 u32QuantizedSbValue,u32QuantizedSbValue0; /* temp variable to store quantized sb val*/ + SINT32 s32LoopCount; /* loop counter*/ + UINT8 u8XoredVal; /* to store XORed value in CRC calculation*/ + UINT8 u8CRC; /* to store CRC value*/ + SINT16 *ps16GenPtr; + SINT32 s32NumOfBlocks; + SINT32 s32NumOfSubBands = pstrEncParams->s16NumOfSubBands; + SINT32 s32NumOfChannels = pstrEncParams->s16NumOfChannels; + UINT32 u32SfRaisedToPow2; /*scale factor raised to power 2*/ + SINT16 *ps16ScfPtr; + SINT32 *ps32SbPtr; + UINT16 u16Levels; /*to store levels*/ + SINT32 s32Temp1; /*used in 64-bit multiplication*/ + SINT32 s32Low; /*used in 64-bit multiplication*/ +#if (SBC_IS_64_MULT_IN_QUANTIZER==TRUE) + SINT32 s32Hi1,s32Low1,s32Carry,s32TempVal2,s32Hi, s32Temp2; +#endif + + pu8PacketPtr = pstrEncParams->pu8NextPacket; /*Initialize the ptr*/ + *pu8PacketPtr++ = (UINT8)0x9C; /*Sync word*/ + *pu8PacketPtr++=(UINT8)(pstrEncParams->FrameHeader); + + *pu8PacketPtr = (UINT8)(pstrEncParams->s16BitPool & 0x00FF); + pu8PacketPtr += 2; /*skip for CRC*/ + + /*here it indicate if it is byte boundary or nibble boundary*/ + s32PresentBit = 8; + Temp=0; +#if (SBC_JOINT_STE_INCLUDED == TRUE) + if (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) + { + /* pack join stero parameters */ + for (s32Sb = 0; s32Sb < s32NumOfSubBands; s32Sb++) + { + Temp <<= 1; + Temp |= pstrEncParams->as16Join[s32Sb]; + } + + /* pack RFA */ + if (s32NumOfSubBands == SUB_BANDS_4) + { + s32PresentBit = 4; + } + else + { + *(pu8PacketPtr++)=Temp; + Temp = 0; + } + } +#endif + + /* Pack Scale factor */ + ps16GenPtr = pstrEncParams->as16ScaleFactor; + s32Sb=s32NumOfChannels*s32NumOfSubBands; + /*Temp=*pu8PacketPtr;*/ + for (s32Ch = s32Sb; s32Ch >0; s32Ch--) + { + Temp<<= 4; + Temp |= *ps16GenPtr++; + + if(s32PresentBit == 4) + { + s32PresentBit = 8; + *(pu8PacketPtr++)=Temp; + Temp = 0; + } + else + { + s32PresentBit = 4; + } + } + + /* Pack samples */ + ps32SbPtr = pstrEncParams->s32SbBuffer; + /*Temp=*pu8PacketPtr;*/ + s32NumOfBlocks= pstrEncParams->s16NumOfBlocks; + for (s32Blk = s32NumOfBlocks-1; s32Blk >=0; s32Blk--) + { + ps16GenPtr = pstrEncParams->as16Bits; + ps16ScfPtr = pstrEncParams->as16ScaleFactor; + for (s32Ch = s32Sb-1; s32Ch >= 0; s32Ch--) + { + s32LoopCount = *ps16GenPtr++; + if (s32LoopCount != 0) + { +#if (SBC_IS_64_MULT_IN_QUANTIZER==TRUE) + /* finding level from reconstruction part of decoder */ + u32SfRaisedToPow2 = ((UINT32)1 << ((*ps16ScfPtr)+1)); + u16Levels = (UINT16)(((UINT32)1 << s32LoopCount) - 1); + + /* quantizer */ + s32Temp1 = (*ps32SbPtr >> 2) + (u32SfRaisedToPow2 << 12); + s32Temp2 = u16Levels; + + Mult64 (s32Temp1, s32Temp2, s32Low, s32Hi); + + s32Low1 = s32Low >> ((*ps16ScfPtr)+2); + s32Low1 &= ((UINT32)1 << (32 - ((*ps16ScfPtr)+2))) - 1; + s32Hi1 = s32Hi << (32 - ((*ps16ScfPtr) +2)); + + u32QuantizedSbValue0 = (UINT16)((s32Low1 | s32Hi1) >> 12); +#else + /* finding level from reconstruction part of decoder */ + u32SfRaisedToPow2 = ((UINT32)1 << *ps16ScfPtr); + u16Levels = (UINT16)(((UINT32)1 << s32LoopCount)-1); + + /* quantizer */ + s32Temp1 = (*ps32SbPtr >> 15) + u32SfRaisedToPow2; + Mult32(s32Temp1,u16Levels,s32Low); + s32Low>>= (*ps16ScfPtr+1); + u32QuantizedSbValue0 = (UINT16)s32Low; +#endif + /*store the number of bits required and the quantized s32Sb + sample to ease the coding*/ + u32QuantizedSbValue = u32QuantizedSbValue0; + + if(s32PresentBit >= s32LoopCount) + { + Temp <<= s32LoopCount; + Temp |= u32QuantizedSbValue; + s32PresentBit -= s32LoopCount; + } + else + { + while (s32PresentBit < s32LoopCount) + { + s32LoopCount -= s32PresentBit; + u32QuantizedSbValue >>= s32LoopCount; + + /*remove the unwanted msbs*/ + /*u32QuantizedSbValue <<= 16 - s32PresentBit; + u32QuantizedSbValue >>= 16 - s32PresentBit;*/ + + Temp <<= s32PresentBit; + + Temp |= u32QuantizedSbValue ; + /*restore the original*/ + u32QuantizedSbValue=u32QuantizedSbValue0; + + *(pu8PacketPtr++)=Temp; + Temp = 0; + s32PresentBit = 8; + } + Temp <<= s32LoopCount; + + /* remove the unwanted msbs */ + /*u32QuantizedSbValue <<= 16 - s32LoopCount; + u32QuantizedSbValue >>= 16 - s32LoopCount;*/ + + Temp |= u32QuantizedSbValue; + + s32PresentBit -= s32LoopCount; + } + } + ps16ScfPtr++; + ps32SbPtr++; + } + } + + Temp <<= s32PresentBit; + *pu8PacketPtr=Temp; + pstrEncParams->u16PacketLength=pu8PacketPtr-pstrEncParams->pu8NextPacket+1; + /*find CRC*/ + pu8PacketPtr = pstrEncParams->pu8NextPacket+1; /*Initialize the ptr*/ + u8CRC = 0x0F; + s32LoopCount = s32Sb >> 1; + + /* + The loops is run from the start of the packet till the scale factor + parameters. In case of JS, 'join' parameter is included in the packet + so that many more bytes are included in CRC calculation. + */ + Temp=*pu8PacketPtr; + for (s32Ch=1; s32Ch < (s32LoopCount+4); s32Ch++) + { + /* skip sync word and CRC bytes */ + if (s32Ch != 3) + { + for (s32LoopCountJ=7; s32LoopCountJ>=0; s32LoopCountJ--) + { + u8XoredVal = ((u8CRC >> 7) & 0x01) ^((Temp >> s32LoopCountJ) & 0x01); + u8CRC <<= 1; + u8CRC ^= (u8XoredVal * 0x1D); + u8CRC &= 0xFF; + } + } + Temp=*(++pu8PacketPtr); + } + + if (pstrEncParams->s16ChannelMode == SBC_JOINT_STEREO) + { + for (s32LoopCountJ = 7; s32LoopCountJ >= (8 - s32NumOfSubBands); s32LoopCountJ--) + { + u8XoredVal = ((u8CRC >> 7) & 0x01) ^((Temp >> s32LoopCountJ) & 0x01); + u8CRC <<= 1; + u8CRC ^= (u8XoredVal * 0x1D); + u8CRC &= 0xFF; + } + } + + /* CRC calculation ends here */ + + /* store CRC in packet */ + pu8PacketPtr = pstrEncParams->pu8NextPacket; /*Initialize the ptr*/ + pu8PacketPtr += 3; + *pu8PacketPtr = u8CRC; + pstrEncParams->pu8NextPacket+=pstrEncParams->u16PacketLength; /* move the pointer to the end in case there is more than one frame to encode */ +} + diff --git a/gki/common/gki_buffer.c b/gki/common/gki_buffer.c index a32c275..fbf19b8 100644 --- a/gki/common/gki_buffer.c +++ b/gki/common/gki_buffer.c @@ -10,6 +10,7 @@ ** * *********************************************************************************/ #include "gki_int.h" +#include <cutils/log.h> #if (GKI_NUM_TOTAL_BUF_POOLS > 16) #error Number of pools out of range (16 Max)! @@ -88,7 +89,7 @@ static BOOLEAN gki_alloc_free_queue(UINT8 id) { FREE_QUEUE_T *Q; tGKI_COM_CB *p_cb = &gki_cb.com; - GKI_TRACE("\ngki_alloc_free_queue in, id:%d \n", id); + GKI_TRACE("\ngki_alloc_free_queue in, id:%d \n", (int)id ); Q = &p_cb->freeq[p_cb->pool_list[id]]; diff --git a/gki/common/gki_debug.c b/gki/common/gki_debug.c index 3ec8fc5..45b281a 100644 --- a/gki/common/gki_debug.c +++ b/gki/common/gki_debug.c @@ -210,7 +210,7 @@ GKI_API void gki_print_used_bufs (FP_PRINT print, UINT8 pool_id) UINT16 *p; - if (pool_id >= GKI_NUM_TOTAL_BUF_POOLS && gki_cb.com.pool_start[pool_id] != 0) + if ((pool_id >= GKI_NUM_TOTAL_BUF_POOLS) || (gki_cb.com.pool_start[pool_id] != 0)) { print("Not a valid Buffer pool\n"); return; diff --git a/gki/ulinux/gki_ulinux.c b/gki/ulinux/gki_ulinux.c index 73e93dc..8fdac95 100644 --- a/gki/ulinux/gki_ulinux.c +++ b/gki/ulinux/gki_ulinux.c @@ -268,8 +268,8 @@ UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16 int policy, ret = 0; pthread_attr_t attr1; - GKI_TRACE( "GKI_create_task %x %d %s %x %d\n", task_entry, task_id, taskname, stack, - stacksize); + GKI_TRACE( "GKI_create_task %x %d %s %x %d", (int)task_entry, (int)task_id, + (char*) taskname, (int) stack, (int)stacksize); if (task_id >= GKI_MAX_TASKS) { @@ -339,12 +339,12 @@ UINT8 GKI_create_task (TASKPTR task_entry, UINT8 task_id, INT8 *taskname, UINT16 } GKI_TRACE( "Leaving GKI_create_task %x %d %x %s %x %d\n", - task_entry, - task_id, - gki_cb.os.thread_id[task_id], - taskname, - stack, - stacksize); + (int)task_entry, + (int)task_id, + (int)gki_cb.os.thread_id[task_id], + (char*)taskname, + (int)stack, + (int)stacksize); return (GKI_SUCCESS); } @@ -754,7 +754,7 @@ UINT16 GKI_wait (UINT16 flag, UINT32 timeout) rtask = GKI_get_taskid(); - GKI_TRACE("GKI_wait %d %x %d", rtask, flag, timeout); + GKI_TRACE("GKI_wait %d %x %d", (int)rtask, (int)flag, (int)timeout); gki_cb.com.OSWaitForEvt[rtask] = flag; @@ -825,7 +825,7 @@ UINT16 GKI_wait (UINT16 flag, UINT32 timeout) /* unlock thread_evt_mutex as pthread_cond_wait() does auto lock mutex when cond is met */ pthread_mutex_unlock(&gki_cb.os.thread_evt_mutex[rtask]); - GKI_TRACE("GKI_wait %d %x %d %x done", rtask, flag, timeout, evt); + GKI_TRACE("GKI_wait %d %x %d %x done", (int)rtask, (int)flag, (int)timeout, (int)evt); return (evt); } @@ -849,7 +849,7 @@ void GKI_delay (UINT32 timeout) struct timespec delay; int err; - GKI_TRACE("GKI_delay %d %d", rtask, timeout); + GKI_TRACE("GKI_delay %d %d", (int)rtask, (int)timeout); delay.tv_sec = timeout / 1000; delay.tv_nsec = 1000 * 1000 * (timeout%1000); @@ -868,7 +868,7 @@ void GKI_delay (UINT32 timeout) { } - GKI_TRACE("GKI_delay %d %d done", rtask, timeout); + GKI_TRACE("GKI_delay %d %d done", (int)rtask, (int)timeout); return; } @@ -910,6 +910,7 @@ UINT8 GKI_send_event (UINT8 task_id, UINT16 event) GKI_TRACE("GKI_send_event %d %x done", task_id, event); return ( GKI_SUCCESS ); } + GKI_TRACE("############## GKI_send_event FAILED!! ##################"); return (GKI_FAILURE); } @@ -961,7 +962,7 @@ UINT8 GKI_get_taskid (void) pthread_t thread_id = pthread_self( ); - GKI_TRACE("GKI_get_taskid %x", thread_id); + GKI_TRACE("GKI_get_taskid %x", (int)thread_id); for (i = 0; i < GKI_MAX_TASKS; i++) { if (gki_cb.os.thread_id[i] == thread_id) { @@ -1025,9 +1026,9 @@ INT8 *GKI_map_taskname (UINT8 task_id) *******************************************************************************/ void GKI_enable (void) { - GKI_TRACE("GKI_enable"); + //GKI_TRACE("GKI_enable"); pthread_mutex_unlock(&gki_cb.os.GKI_mutex); - GKI_TRACE("Leaving GKI_enable"); + //GKI_TRACE("Leaving GKI_enable"); return; } @@ -1044,11 +1045,11 @@ void GKI_enable (void) void GKI_disable (void) { - GKI_TRACE("GKI_disable"); + //GKI_TRACE("GKI_disable"); pthread_mutex_lock(&gki_cb.os.GKI_mutex); - GKI_TRACE("Leaving GKI_disable"); + //GKI_TRACE("Leaving GKI_disable"); return; } diff --git a/include/bt_target.h b/include/bt_target.h index bedea09..1b4c128 100644 --- a/include/bt_target.h +++ b/include/bt_target.h @@ -3002,13 +3002,6 @@ Range: Minimum 12000 (12 secs) on BR/EDR when supporting PBF. #define A2D_M24_INCLUDED A2D_INCLUDED #endif -/************************************************************************* - * VDP Definitions - */ -#ifndef VDP_INCLUDED -#define VDP_INCLUDED FALSE -#endif - /****************************************************************************** ** ** AVCTP diff --git a/include/buildcfg_crespo.h b/include/buildcfg_crespo.h index b858686..0060149 100644 --- a/include/buildcfg_crespo.h +++ b/include/buildcfg_crespo.h @@ -1,21 +1,21 @@ #ifndef BUILDCFG_H #define BUILDCFG_H -#define AVCT_INCLUDED FALSE -#define AVRC_INCLUDED FALSE -//#define AVRC_METADATA_INCLUDED TRUE -//#define AVRC_ADV_CTRL_INCLUDED FALSE -#define AVDT_INCLUDED FALSE +#define AVCT_INCLUDED TRUE +#define AVRC_INCLUDED TRUE +#define AVRC_METADATA_INCLUDED TRUE +#define AVRC_ADV_CTRL_INCLUDED FALSE +#define AVDT_INCLUDED TRUE +#define AVDTC_INCLUDED FALSE # Makefile only #define AT91_MAIN_INCLUDED FALSE #define AT91_DRV_INCLUDED FALSE #define AT91_LIB_INCLUDED FALSE #define AT91_GKI_INCLUDED FALSE #define UNV_INCLUDED FALSE #define BBY_MAIN_INCLUDED FALSE -#define A2D_INCLUDED FALSE -#define A2D_SBC_INCLUDED FALSE +#define A2D_INCLUDED TRUE +#define A2D_SBC_INCLUDED TRUE #define A2D_M12_INCLUDED FALSE #define A2D_M24_INCLUDED FALSE -#define VDP_INCLUDED FALSE #define VDP_H263_INCLUDED FALSE #define VDP_MPEG_INCLUDED FALSE #define VDP_VEND_INCLUDED FALSE @@ -30,11 +30,15 @@ #define BIP_DISPLAY_INCLUDED FALSE #define BPP_INCLUDED FALSE #define BPP_SND_INCLUDED FALSE +#define BTM_INCLUDED FALSE # Makefile only +#define BTU_INCLUDED FALSE # Makefile only +#define BTUTHIN_INCLUDED FALSE # Makefile only #define DUN_INCLUDED FALSE #define GAP_INCLUDED FALSE #define GOEP_INCLUDED FALSE #define GOEP_FS_INCLUDED FALSE #define GATT_PTS FALSE +#define HCIC_INCLUDED TRUE # Makefile only #define HCITHIN_INCLUDED FALSE #define BTM_SEC_MAX_SERVICE_RECORDS 32 #define L2CAP_INCLUDED TRUE @@ -53,12 +57,11 @@ #define MAX_RFC_PORTS 30 #define MAX_BD_CONNECTIONS 7 #define BTA_RFC_MTU_SIZE (L2CAP_MTU_SIZE-L2CAP_MIN_OFFSET-RFCOMM_DATA_OVERHEAD) -#define BTA_JV_DEF_RFC_MTU BTA_RFC_MTU_SIZE -#define PORT_TX_BUF_HIGH_WM 15 +#define PORT_TX_BUF_HIGH_WM 10 #define PORT_RX_BUF_HIGH_WM 10 #define PORT_RX_BUF_LOW_WM 4 #define PORT_RX_BUF_CRITICAL_WM 15 -#define PORT_TX_BUF_CRITICAL_WM 25 +#define PORT_TX_BUF_CRITICAL_WM 15 #define PORT_RX_LOW_WM (BTA_RFC_MTU_SIZE * PORT_RX_BUF_LOW_WM) #define PORT_RX_HIGH_WM (BTA_RFC_MTU_SIZE * PORT_RX_BUF_HIGH_WM) #define PORT_RX_CRITICAL_WM (BTA_RFC_MTU_SIZE * PORT_RX_BUF_CRITICAL_WM) @@ -67,12 +70,18 @@ #define BTA_DUN_MTU BTA_RFC_MTU_SIZE #define BTA_SPP_MTU BTA_RFC_MTU_SIZE #define BTA_FAX_MTU BTA_RFC_MTU_SIZE +#define SDP_INCLUDED TRUE # Makefile only #define SDP_DI_INCLUDED TRUE #define SDP_RAW_DATA_INCLUDED TRUE #define SDP_RAW_PDU_INCLUDED TRUE #define SDP_POOL_ID 3 +#define SDP_MAX_REC_ATTR 25 +#define SDP_MAX_ATTR_LEN 400 +#define SDP_MAX_PAD_LEN 600 +#define XML_INCLUDED TRUE # Makefile only #define BNEP_INCLUDED FALSE #define PAN_INCLUDED FALSE +#define ANT_INCLUDED FALSE #define SAP_SERVER_INCLUDED FALSE #define HID_DEV_INCLUDED FALSE #define HID_HOST_INCLUDED FALSE @@ -86,14 +95,17 @@ #define SMP_INCLUDED FALSE #define SMP_HOST_ENCRYPT_INCLUDED FALSE #define CE_TEST_INCLUDED FALSE +#define FLASHEXE_INCLUDED TRUE # Makefile only #define SER_INCLUDED FALSE #define RPC_INCLUDED FALSE +#define HSA_INCLUDED FALSE # Makefile only #define MMI_INCLUDED FALSE #define SAP_INCLUDED FALSE +#define SBC_ENCODER_INCLUDED FALSE # Makefile only +#define SBC_DECODER_INCLUDED FALSE # Makefile only #define SBC_NO_PCM_CPY_OPTION FALSE #define SBC_IPAQ_OPT FALSE #define SBC_IS_64_MULT_IN_QUANTIZER FALSE -//#define MCA_INCLUDED TRUE #define BTE_HCIUTILS_HOOK_INCLUDED FALSE #define BTA_INCLUDED TRUE #define BTA_AG_INCLUDED TRUE @@ -114,10 +126,8 @@ #define BTA_HD_INCLUDED FALSE #define BTA_HH_INCLUDED FALSE #define HH_USE_BTHID FALSE -#define BTA_AR_INCLUDED FALSE -#define BTA_AV_INCLUDED FALSE -#define BTA_AV_VDP_INCLUDED FALSE -#define BTA_AVK_INCLUDED FALSE +#define BTA_AR_INCLUDED TRUE +#define BTA_AV_INCLUDED TRUE #define BTA_PBS_INCLUDED FALSE #define BTA_PBC_INCLUDED FALSE #define BTA_FM_INCLUDED FALSE @@ -134,18 +144,18 @@ #define BTA_JV_INCLUDED FALSE #define BTA_EIR_CANNED_UUID_LIST FALSE #define BTA_GATT_INCLUDED FALSE -#define BTA_HL_INCLUDED TRUE -#define BTA_HL_DEBUG TRUE +#define MMP_INCLUDED FALSE # Makefile only +#define BTELIB_INCLUDED FALSE # Makefile only #define RSI_INCLUDED TRUE #define RPC_TRACE_ONLY FALSE #define ANDROID_APP_INCLUDED TRUE #define ANDROID_USE_LOGCAT TRUE #define LINUX_GKI_INCLUDED TRUE -#define TICKS_PER_SEC 10 +#define TICKS_PER_SEC 100 #define QUICK_TIMER_TICKS_PER_SEC 10 #define BTA_SYS_TIMER_PERIOD 100 #define GKI_BUF1_SIZE 288 -#define GKI_BUF3_MAX 100 +#define GKI_BUF3_MAX 200 #define GKI_BUF3_SIZE (4096+16) #define GKI_BUF4_SIZE (8080+26) #define GKI_SHUTDOWN_EVT APPL_EVT_7 @@ -154,13 +164,9 @@ #define LINUX_OS TRUE #define BTU_TASK 0 #define BTIF_TASK 1 -#define GKI_MAX_TASKS 2 -//#define BTE_APPL_TASK 2 -//#define SBC_ENCODE_TASK 3 -//#define AV_SRC_READ_TASK 4 -//#define PBS_SQL_TASK 5 +#define A2DP_MEDIA_TASK 2 +#define GKI_MAX_TASKS 3 #define BTM_APP_DEV_INIT bte_main_post_reset_init -#define BTE_RESET_BAUD_ON_BT_DISABLE FALSE #define BTE_IDLE_TASK_INCLUDED FALSE #define APPL_INCLUDED TRUE #define USE_UART_HCI TRUE @@ -194,8 +200,6 @@ #define BTAPP_TESTMODE_INCLUDED TRUE #define HCILP_INCLUDED TRUE #define HCISU_H4_INCLUDED TRUE -#define BT_PCM_DEF_CLK 0 -#define BT_PCM_DEF_ROLE 0 #define BT_USE_TRACES TRUE #define BT_TRACE_BTIF TRUE #define BTTRC_INCLUDED FALSE @@ -223,13 +227,11 @@ #define BTAPP_TEST_OOB_INCLUDED TRUE #define ENABLE_PCM_LOGGER FALSE #define BTM_DISC_DURING_RS TRUE -#define PAN_DTUN TRUE #define BT_UART_PORT "/dev/s3c2410_serial0" #define BTM_WBS_INCLUDED FALSE - +#define HL_INCLUDED FALSE #define NO_GKI_RUN_RETURN TRUE - #define BTE_MAIN_CFG_DEFAULT_PATCHFILE_NAME ("/vendor/firmware/bcm4329.hcd") - #define AG_VOICE_SETTINGS HCI_DEFAULT_VOICE_SETTINGS #endif + diff --git a/include/buildcfg_maguro.h b/include/buildcfg_maguro.h index 556f8dd..a2e0123 100644 --- a/include/buildcfg_maguro.h +++ b/include/buildcfg_maguro.h @@ -1,8 +1,10 @@ #ifndef BUILDCFG_H #define BUILDCFG_H -#define AVCT_INCLUDED FALSE -#define AVRC_INCLUDED FALSE -#define AVDT_INCLUDED FALSE +#define AVCT_INCLUDED TRUE +#define AVRC_INCLUDED TRUE +#define AVRC_METADATA_INCLUDED TRUE +#define AVRC_ADV_CTRL_INCLUDED FALSE +#define AVDT_INCLUDED TRUE #define AVDTC_INCLUDED FALSE # Makefile only #define AT91_MAIN_INCLUDED FALSE #define AT91_DRV_INCLUDED FALSE @@ -10,11 +12,10 @@ #define AT91_GKI_INCLUDED FALSE #define UNV_INCLUDED FALSE #define BBY_MAIN_INCLUDED FALSE -#define A2D_INCLUDED FALSE -#define A2D_SBC_INCLUDED FALSE +#define A2D_INCLUDED TRUE +#define A2D_SBC_INCLUDED TRUE #define A2D_M12_INCLUDED FALSE #define A2D_M24_INCLUDED FALSE -#define VDP_INCLUDED FALSE #define VDP_H263_INCLUDED FALSE #define VDP_MPEG_INCLUDED FALSE #define VDP_VEND_INCLUDED FALSE @@ -125,10 +126,8 @@ #define BTA_HD_INCLUDED FALSE #define BTA_HH_INCLUDED FALSE #define HH_USE_BTHID FALSE -#define BTA_AR_INCLUDED FALSE -#define BTA_AV_INCLUDED FALSE -#define BTA_AV_VDP_INCLUDED FALSE -#define BTA_AVK_INCLUDED FALSE +#define BTA_AR_INCLUDED TRUE +#define BTA_AV_INCLUDED TRUE #define BTA_PBS_INCLUDED FALSE #define BTA_PBC_INCLUDED FALSE #define BTA_FM_INCLUDED FALSE @@ -152,7 +151,7 @@ #define ANDROID_APP_INCLUDED TRUE #define ANDROID_USE_LOGCAT TRUE #define LINUX_GKI_INCLUDED TRUE -#define TICKS_PER_SEC 10 +#define TICKS_PER_SEC 100 #define QUICK_TIMER_TICKS_PER_SEC 10 #define BTA_SYS_TIMER_PERIOD 100 #define GKI_BUF1_SIZE 288 @@ -165,7 +164,8 @@ #define LINUX_OS TRUE #define BTU_TASK 0 #define BTIF_TASK 1 -#define GKI_MAX_TASKS 2 +#define A2DP_MEDIA_TASK 2 +#define GKI_MAX_TASKS 3 #define BTM_APP_DEV_INIT bte_main_post_reset_init #define BTE_IDLE_TASK_INCLUDED FALSE #define APPL_INCLUDED TRUE diff --git a/main/Android.mk b/main/Android.mk index f30a24a..8e78c61 100644 --- a/main/Android.mk +++ b/main/Android.mk @@ -8,14 +8,14 @@ include $(CLEAR_VARS) # HAL layer LOCAL_SRC_FILES:= \ - ../btif/src/bluetooth.c\ + ../btif/src/bluetooth.c # platform specific LOCAL_SRC_FILES+= \ bte_main.c \ bte_init.c \ bte_version.c \ - bte_logmsg.c\ + bte_logmsg.c # BTIF LOCAL_SRC_FILES += \ @@ -23,7 +23,9 @@ LOCAL_SRC_FILES += \ ../btif/src/btif_dm.c \ ../btif/src/btif_storage.c \ ../btif/src/btif_util.c \ + ../btif/src/btif_sm.c \ ../btif/src/btif_hf.c \ + ../btif/src/btif_av.c # callouts LOCAL_SRC_FILES+= \ @@ -31,10 +33,24 @@ LOCAL_SRC_FILES+= \ ../btif/co/bta_fs_co.c \ ../btif/co/bta_ag_co.c \ ../btif/co/bta_dm_co.c \ + ../btif/co/bta_av_co.c + +# sbc encoder +LOCAL_SRC_FILES+= \ + ../embdrv/sbc/encoder/srce/sbc_analysis.c \ + ../embdrv/sbc/encoder/srce/sbc_dct.c \ + ../embdrv/sbc/encoder/srce/sbc_dct_coeffs.c \ + ../embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_mono.c \ + ../embdrv/sbc/encoder/srce/sbc_enc_bit_alloc_ste.c \ + ../embdrv/sbc/encoder/srce/sbc_enc_coeffs.c \ + ../embdrv/sbc/encoder/srce/sbc_encoder.c \ + ../embdrv/sbc/encoder/srce/sbc_packing.c \ + ../btif/src/btif_media_task.c # candidates for vendor lib (keep here for now) LOCAL_SRC_FILES+= \ ../udrv/ulinux/unv_linux.c\ + ../udrv/ulinux/uipc.c LOCAL_C_INCLUDES+= . \ @@ -46,13 +62,18 @@ LOCAL_C_INCLUDES+= . \ $(LOCAL_PATH)/../include \ $(LOCAL_PATH)/../stack/include \ $(LOCAL_PATH)/../stack/l2cap \ + $(LOCAL_PATH)/../stack/a2dp \ $(LOCAL_PATH)/../stack/btm \ + $(LOCAL_PATH)/../stack/avdt \ $(LOCAL_PATH)/../hcis \ $(LOCAL_PATH)/../hcis/include \ $(LOCAL_PATH)/../hcis/patchram \ $(LOCAL_PATH)/../udrv/include \ $(LOCAL_PATH)/../btif/include \ + $(LOCAL_PATH)/../btif/co \ $(LOCAL_PATH)/../vendor/libvendor/include\ + $(LOCAL_PATH)/../brcm/include \ + $(LOCAL_PATH)/../embdrv/sbc/encoder/include LOCAL_CFLAGS += -DBUILDCFG -Werror @@ -75,7 +96,7 @@ LOCAL_SHARED_LIBRARIES := \ libbt-vendor #LOCAL_WHOLE_STATIC_LIBRARIES := libbt-brcm_gki libbt-brcm_stack libbt-brcm_bta -LOCAL_STATIC_LIBRARIES := libbt-brcm_gki libbt-brcm_stack libbt-brcm_bta +LOCAL_STATIC_LIBRARIES := libbt-brcm_gki libbt-brcm_bta libbt-brcm_stack LOCAL_MODULE := bluetooth.default LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/hw diff --git a/main/bte_init.c b/main/bte_init.c index 638f2be..14a6006 100644 --- a/main/bte_init.c +++ b/main/bte_init.c @@ -113,9 +113,6 @@ #include "a2d_api.h" #endif -#if (defined(VDP_INCLUDED) && VDP_INCLUDED == TRUE) -#include "vdp_api.h" -#endif #if (defined(HID_DEV_INCLUDED) && HID_DEV_INCLUDED == TRUE) #include "hidd_api.h" @@ -211,9 +208,6 @@ #if BTA_AV_INCLUDED==TRUE #include "bta_av_int.h" #endif -#if BTA_AVK_INCLUDED==TRUE -#include "bta_avk_int.h" -#endif #if BTA_SC_INCLUDED==TRUE #include "bta_sc_int.h" @@ -384,9 +378,6 @@ BT_API void BTE_InitStack(void) A2D_Init(); #endif /* AADP */ -#if (defined(VDP_INCLUDED) && VDP_INCLUDED == TRUE) - VDP_Init(); -#endif #if (defined(AVRC_INCLUDED) && AVRC_INCLUDED == TRUE) AVRC_Init(); @@ -481,9 +472,6 @@ BT_API void BTE_InitStack(void) #if BTA_AV_INCLUDED==TRUE memset((void *)bta_av_cb_ptr, 0, sizeof(tBTA_AV_CB)); #endif -#if BTA_AVK_INCLUDED==TRUE - memset((void *)bta_avk_cb_ptr, 0, sizeof(tBTA_AVK_CB)); -#endif #if BTA_PR_INCLUDED==TRUE memset((void *)bta_pr_cb_ptr, 0, sizeof(tBTA_PR_CB)); #endif diff --git a/main/bte_logmsg.c b/main/bte_logmsg.c index 494c1a6..471728e 100644 --- a/main/bte_logmsg.c +++ b/main/bte_logmsg.c @@ -73,9 +73,6 @@ #include "pan_api.h" #endif #include "sdp_api.h" -#if (VDP_INCLUDED==TRUE) -#include "vdp_api.h" -#endif #if (BLE_INCLUDED==TRUE) #include "gatt_api.h" @@ -330,7 +327,7 @@ const tBTTRC_FUNC_MAP bttrc_set_level_map[] = { { BTTRC_ID_STK_OBEX, BTTRC_ID_STK_OBEX, (const tBTTRC_SET_TRACE_LEVEL *)OBX_SetTraceLevel, "TRC_OBEX" }, #endif #if (AVCT_INCLUDED==TRUE) - { BTTRC_ID_STK_AVCT, BTTRC_ID_STK_AVCT, (tBTTRC_SET_TRACE_LEVEL *)NULL, "TRC_AVCT" }, + //{ BTTRC_ID_STK_AVCT, BTTRC_ID_STK_AVCT, (tBTTRC_SET_TRACE_LEVEL *)NULL, "TRC_AVCT" }, #endif #if (AVDT_INCLUDED==TRUE) { BTTRC_ID_STK_AVDT, BTTRC_ID_STK_AVDT, (const tBTTRC_SET_TRACE_LEVEL *)AVDT_SetTraceLevel, "TRC_AVDT" }, @@ -339,7 +336,7 @@ const tBTTRC_FUNC_MAP bttrc_set_level_map[] = { { BTTRC_ID_STK_AVRC, BTTRC_ID_STK_AVRC, (const tBTTRC_SET_TRACE_LEVEL *)AVRC_SetTraceLevel, "TRC_AVRC" }, #endif #if (AVDT_INCLUDED==TRUE) - { BTTRC_ID_AVDT_SCB, BTTRC_ID_AVDT_CCB, (tBTTRC_SET_TRACE_LEVEL *)NULL, "TRC_AVDT_SCB" }, + //{ BTTRC_ID_AVDT_SCB, BTTRC_ID_AVDT_CCB, (tBTTRC_SET_TRACE_LEVEL *)NULL, "TRC_AVDT_SCB" }, #endif #if (A2D_INCLUDED==TRUE) { BTTRC_ID_STK_A2D, BTTRC_ID_STK_A2D, (const tBTTRC_SET_TRACE_LEVEL *)A2D_SetTraceLevel, "TRC_A2D" }, @@ -373,9 +370,6 @@ const tBTTRC_FUNC_MAP bttrc_set_level_map[] = { { BTTRC_ID_STK_SAP, BTTRC_ID_STK_SAP, (tBTTRC_SET_TRACE_LEVEL *)NULL, "TRC_SAP" }, #endif { BTTRC_ID_STK_SDP, BTTRC_ID_STK_SDP, (const tBTTRC_SET_TRACE_LEVEL *)SDP_SetTraceLevel, "TRC_SDP" }, -#if (VDP_INCLUDED==TRUE) - { BTTRC_ID_STK_VDP, BTTRC_ID_STK_VDP, (const tBTTRC_SET_TRACE_LEVEL *)VDP_SetTraceLevel, "TRC_VDP" }, -#endif #if (BLE_INCLUDED==TRUE) { BTTRC_ID_STK_GATT, BTTRC_ID_STK_GATT, (const tBTTRC_SET_TRACE_LEVEL *)GATT_SetTraceLevel , "TRC_GATT" }, #endif diff --git a/stack/Android.mk b/stack/Android.mk index 29d59d4..34c191c 100644 --- a/stack/Android.mk +++ b/stack/Android.mk @@ -8,6 +8,7 @@ LOCAL_C_INCLUDES:= . \ $(LOCAL_PATH)/include \ $(LOCAL_PATH)/avct \ $(LOCAL_PATH)/btm \ + $(LOCAL_PATH)/avrc \ $(LOCAL_PATH)/l2cap \ $(LOCAL_PATH)/avdt \ $(LOCAL_PATH)/gatt \ @@ -41,6 +42,10 @@ endif LOCAL_PRELINK_MODULE:=false LOCAL_SRC_FILES:= \ ./dun/dun_api.c \ + ./a2dp/a2d_api.c \ + ./a2dp/a2d_m24.c \ + ./a2dp/a2d_m12.c \ + ./a2dp/a2d_sbc.c \ ./avrc/avrc_bld_tg.c \ ./avrc/avrc_api.c \ ./avrc/avrc_utils.c \ @@ -157,10 +162,6 @@ LOCAL_SRC_FILES:= \ ./xml/xml_flp.c \ ./xml/xml_mlp.c \ ./xml/xml_bld.c \ - ./a2dp/a2d_api.c \ - ./a2dp/a2d_m24.c \ - ./a2dp/a2d_m12.c \ - ./a2dp/a2d_sbc.c \ ./pan/pan_main.c \ ./pan/pan_api.c \ ./pan/pan_utils.c \ diff --git a/stack/avdt/avdt_int.h b/stack/avdt/avdt_int.h index 837e943..cb62e31 100644 --- a/stack/avdt/avdt_int.h +++ b/stack/avdt/avdt_int.h @@ -27,7 +27,6 @@ #endif #endif - /***************************************************************************** ** constants *****************************************************************************/ diff --git a/stack/btm/btm_dev.c b/stack/btm/btm_dev.c index 3651589..f163403 100644 --- a/stack/btm/btm_dev.c +++ b/stack/btm/btm_dev.c @@ -111,7 +111,7 @@ BOOLEAN BTM_SecAddDevice (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name, p_dev_rec->link_key_type = key_type; } -#if defined(BSA_MIXED_MODE_INCLUDED) && (BSA_MIXED_MODE_INCLUDED == TRUE) +#if defined(BTIF_MIXED_MODE_INCLUDED) && (BTIF_MIXED_MODE_INCLUDED == TRUE) p_dev_rec->sm4 = BTM_SM4_KNOWN; #endif diff --git a/stack/include/avrc_api.h b/stack/include/avrc_api.h index 859c872..d7e8ee4 100644 --- a/stack/include/avrc_api.h +++ b/stack/include/avrc_api.h @@ -10,7 +10,7 @@ *****************************************************************************/ #ifndef AVRC_API_H #define AVRC_API_H - +#include "bt_target.h" #include "avct_api.h" #include "sdp_api.h" #include "avrc_defs.h" diff --git a/stack/include/btu.h b/stack/include/btu.h index c47839e..6a3b68f 100644 --- a/stack/include/btu.h +++ b/stack/include/btu.h @@ -21,7 +21,6 @@ #define BTU_HCI_RCV_MBOX TASK_MBOX_0 /* Messages from HCI */ #define BTU_BTIF_MBOX TASK_MBOX_1 /* Messages to BTIF */ - /* callbacks */ typedef void (*tBTU_TIMER_CALLBACK)(TIMER_LIST_ENT *p_tle); diff --git a/stack/include/goep_util.h b/stack/include/goep_util.h index 8bfe4af..600c6d0 100644 --- a/stack/include/goep_util.h +++ b/stack/include/goep_util.h @@ -226,7 +226,7 @@ GOEP_API extern void GOEP_TraceSupportedDataTypes(UINT8 data_types, UINT8 *p_dat #define GOEP_ErrorName(_x) "" #endif #define GOEP_TraceSupportedDataTypes(x, y) -#endif /* end if BT_TRACE_PROTOCOL */ +#endif /***************************************************************************** diff --git a/stack/l2cap/l2c_int.h b/stack/l2cap/l2c_int.h index 6dd93b0..0630e12 100644 --- a/stack/l2cap/l2c_int.h +++ b/stack/l2cap/l2c_int.h @@ -26,7 +26,7 @@ #define L2CAP_LINK_FLOW_CONTROL_TOUT 2 /* 2 seconds */ #define L2CAP_LINK_DISCONNECT_TOUT 30 /* 30 seconds */ -#ifndef L2CAP_CHNL_CONNECT_TOUT /* BSA needs to override for internal project needs */ +#ifndef L2CAP_CHNL_CONNECT_TOUT /* BTIF needs to override for internal project needs */ #define L2CAP_CHNL_CONNECT_TOUT 60 /* 60 seconds */ #endif diff --git a/stack/smp/smp_utils.c b/stack/smp/smp_utils.c index 7e4700f..89c9f5e 100644 --- a/stack/smp/smp_utils.c +++ b/stack/smp/smp_utils.c @@ -21,9 +21,6 @@ #include "l2c_int.h" #include "smp_int.h" - #if (BT_TRACE_PROTOCOL == TRUE) - #include "trace_api.h" - #endif #define SMP_PAIRING_REQ_SIZE 7 #define SMP_CONFIRM_CMD_SIZE (BT_OCTET16_LEN + 1) diff --git a/udrv/include/uipc.h b/udrv/include/uipc.h new file mode 100644 index 0000000..9fa6fbd --- /dev/null +++ b/udrv/include/uipc.h @@ -0,0 +1,163 @@ +/******************************************************************************** +** * +** Name uipc.h * +** * +** Function UIPC wrapper interface * +** * +** * +** Copyright (c) 2007, Broadcom Corp., All Rights Reserved. * +** Proprietary and confidential. * +** * +*********************************************************************************/ +#ifndef UIPC_H +#define UIPC_H + +#ifndef UDRV_API +#define UDRV_API +#endif + + +#define UIPC_CH_ID_ALL 0 /* used to address all the ch id at once */ +#define UIPC_CH_ID_0 1 /* shared mem interface */ +#define UIPC_CH_ID_1 2 /* TCP socket (GPS) */ +#define UIPC_CH_ID_2 3 /* BTIF control socket */ +#define UIPC_CH_ID_3 4 /* BTIF HH */ +#define UIPC_CH_ID_4 5 /* Future usage */ +#define UIPC_CH_ID_5 6 /* Future usage */ +#define UIPC_CH_ID_6 7 /* Future usage */ +#define UIPC_CH_ID_7 8 /* Future usage */ +#define UIPC_CH_ID_8 9 /* Future usage */ +#define UIPC_CH_ID_9 10 /* Future usage */ +#define UIPC_CH_ID_10 11 /* Future usage */ +#define UIPC_CH_ID_11 12 /* Future usage */ +#define UIPC_CH_ID_12 13 /* Future usage */ +#define UIPC_CH_ID_13 14 /* Future usage */ +#define UIPC_CH_ID_14 15 /* Future usage */ +#define UIPC_CH_ID_15 16 /* Future usage */ +#define UIPC_CH_ID_16 17 /* Future usage */ +#define UIPC_CH_ID_17 18 /* Future usage */ +#define UIPC_CH_ID_18 19 /* Future usage */ +#define UIPC_CH_ID_19 20 /* Future usage */ +#define UIPC_CH_ID_20 21 /* Future usage */ +#define UIPC_CH_ID_21 22 /* Future usage */ +#define UIPC_CH_ID_22 23 /* Future usage */ +#define UIPC_CH_ID_23 24 /* Future usage */ +#define UIPC_CH_ID_24 25 /* Future usage */ + + + +#define UIPC_CH_NUM 25 + +typedef UINT8 tUIPC_CH_ID; + +/* + * UIPC IOCTL Requests + */ +enum +{ + UIPC_REQ_TX_FLUSH = 1, /* Request to flush the TX FIFO */ + UIPC_REQ_RX_FLUSH, /* Request to flush the RX FIFO */ + + UIPC_WRITE_BLOCK, /* Make write blocking */ + UIPC_WRITE_NONBLOCK, /* Make write non blocking */ + + UIPC_REG_CBACK, /* Set a new call back */ + UIPC_SET_RX_WM, /* Set Rx water mark */ + + UIPC_REQ_TX_READY, /* Request an indication when Tx ready */ + UIPC_REQ_RX_READY /* Request an indication when Rx data ready */ +}; + +typedef void (tUIPC_RCV_CBACK)(BT_HDR *p_msg); /* points to BT_HDR which describes event type and length of data; len contains the number of bytes of entire message (sizeof(BT_HDR) + offset + size of data) */ + +#ifdef __cplusplus +extern "C" +{ +#endif + +/******************************************************************************* +** +** Function UIPC_Init +** +** Description Initialize UIPC module +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern void UIPC_Init(void *); + +/******************************************************************************* +** +** Function UIPC_Open +** +** Description Open UIPC interface +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern BOOLEAN UIPC_Open(tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK *p_cback); + +/******************************************************************************* +** +** Function UIPC_Close +** +** Description Close UIPC interface +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern void UIPC_Close(tUIPC_CH_ID ch_id); + +/******************************************************************************* +** +** Function UIPC_SendBuf +** +** Description Called to transmit a message over UIPC. +** Message buffer will be freed by UIPC_SendBuf. +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern BOOLEAN UIPC_SendBuf(tUIPC_CH_ID ch_id, BT_HDR *p_msg); + +/******************************************************************************* +** +** Function UIPC_Send +** +** Description Called to transmit a message over UIPC. +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern BOOLEAN UIPC_Send(tUIPC_CH_ID ch_id, UINT16 msg_evt, UINT8 *p_buf, UINT16 msglen); + +/******************************************************************************* +** +** Function UIPC_Read +** +** Description Called to read a message from UIPC. +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, UINT32 len); + +/******************************************************************************* +** +** Function UIPC_Ioctl +** +** Description Called to control UIPC. +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern BOOLEAN UIPC_Ioctl(tUIPC_CH_ID ch_id, UINT32 request, void *param); + +#ifdef __cplusplus +} +#endif + + +#endif /* UIPC_H */ + + diff --git a/udrv/ulinux/uipc.c b/udrv/ulinux/uipc.c new file mode 100644 index 0000000..a06a057 --- /dev/null +++ b/udrv/ulinux/uipc.c @@ -0,0 +1,258 @@ +/***************************************************************************** + ** + ** Name: uipc.c + ** + ** Description: UIPC wrapper interface definition + ** + ** Copyright (c) 2009-2011, Broadcom Corp., All Rights Reserved. + ** Broadcom Bluetooth Core. Proprietary and confidential. + ** + *****************************************************************************/ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include <sys/stat.h> +#include <unistd.h> +#include <fcntl.h> + +#include <cutils/sockets.h> + +#include <sys/socket.h> +#include <sys/un.h> +#include <signal.h> +#include <errno.h> + +#include "gki.h" +#include "data_types.h" +#include "uipc.h" + +#define PCM_FILENAME "/data/test.pcm" +#define SOCKPATH "/data/misc/bluedroid/.a2dp_sock" + +/* TEST CODE TO VERIFY DATAPATH */ + +#define SOURCE_MODE_PCMFILE 1 +#define SOURCE_MODE_A2DP_SOCKET 2 +#define SOURCE_MODE SOURCE_MODE_A2DP_SOCKET + +static int listen_fd = -1; +static int sock_fd = -1; +static int source_fd = -1; + +static inline int create_server_socket(const char* name) +{ + int s = socket(AF_LOCAL, SOCK_STREAM, 0); + + if(socket_local_server_bind(s, name, ANDROID_SOCKET_NAMESPACE_ABSTRACT) >= 0) + { + if(listen(s, 5) == 0) + { + APPL_TRACE_EVENT2("listen to local socket:%s, fd:%d", name, s); + return s; + } + else + APPL_TRACE_EVENT3("listen to local socket:%s, fd:%d failed, errno:%d", name, s, errno); + } + else + APPL_TRACE_EVENT3("create local socket:%s fd:%d, failed, errno:%d", name, s, errno); + close(s); + return -1; +} + +int wait_socket(void) +{ + struct sockaddr_un remote; + int t; + + APPL_TRACE_DEBUG0("wait socket"); + + listen_fd = create_server_socket(SOCKPATH); + + if ((sock_fd = accept(listen_fd, (struct sockaddr *)&remote, &t)) == -1) { + APPL_TRACE_ERROR1("a2dp sock accept failed (%d)", errno); + return -1; + } + + return sock_fd; +} + +int open_source(void) +{ + int s; +#if (SOURCE_MODE == SOURCE_MODE_PCMFILE) + s = open((char*)PCM_FILENAME , O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); + + if (s == -1) + { + APPL_TRACE_ERROR0("unable to open pcm file\n"); + s = -1; + return 0; + } +#endif + +#if (SOURCE_MODE == SOURCE_MODE_A2DP_SOCKET) + s = wait_socket(); +#endif + return s; +} + +void close_source(int fd) +{ + close(fd); + +#if (SOURCE_MODE == SOURCE_MODE_A2DP_SOCKET) + close(listen_fd); + listen_fd = -1; +#endif +} + + +/******************************************************************************* + ** + ** Function UIPC_Init + ** + ** Description Initialize UIPC module + ** + ** Returns void + ** + *******************************************************************************/ + +UDRV_API void UIPC_Init(void *p_data) +{ + APPL_TRACE_DEBUG0("UIPC_Init"); +} + +/******************************************************************************* + ** + ** Function UIPC_Open + ** + ** Description Open UIPC interface + ** + ** Returns TRUE in case of success, FALSE in case of failure. + ** + *******************************************************************************/ +UDRV_API BOOLEAN UIPC_Open(tUIPC_CH_ID ch_id, tUIPC_RCV_CBACK *p_cback) +{ + APPL_TRACE_DEBUG2("UIPC_Open : ch_id %d, p_cback %x", ch_id, p_cback); + + return FALSE; +} + +/******************************************************************************* + ** + ** Function UIPC_Close + ** + ** Description Close UIPC interface + ** + ** Returns void + ** + *******************************************************************************/ +UDRV_API void UIPC_Close(tUIPC_CH_ID ch_id) +{ + APPL_TRACE_DEBUG1("UIPC_Close : ch_id %d", ch_id); + close_source(source_fd); + source_fd = -1; +} + +/******************************************************************************* + ** + ** Function UIPC_SendBuf + ** + ** Description Called to transmit a message over UIPC. + ** Message buffer will be freed by UIPC_SendBuf. + ** + ** Returns TRUE in case of success, FALSE in case of failure. + ** + *******************************************************************************/ +UDRV_API BOOLEAN UIPC_SendBuf(tUIPC_CH_ID ch_id, BT_HDR *p_msg) +{ + APPL_TRACE_DEBUG1("UIPC_SendBuf : ch_id %d", ch_id); + return FALSE; +} + +/******************************************************************************* + ** + ** Function UIPC_Send + ** + ** Description Called to transmit a message over UIPC. + ** + ** Returns TRUE in case of success, FALSE in case of failure. + ** + *******************************************************************************/ +UDRV_API BOOLEAN UIPC_Send(tUIPC_CH_ID ch_id, UINT16 msg_evt, UINT8 *p_buf, + UINT16 msglen) +{ + APPL_TRACE_DEBUG1("UIPC_Send : ch_id:%d", ch_id); + return FALSE; +} + +/******************************************************************************* + ** + ** Function UIPC_ReadBuf + ** + ** Description Called to read a message from UIPC. + ** + ** Returns void + ** + *******************************************************************************/ +UDRV_API void UIPC_ReadBuf(tUIPC_CH_ID ch_id, BT_HDR *p_msg) +{ + APPL_TRACE_DEBUG1("UIPC_ReadBuf : ch_id:%d", ch_id); +} + +/******************************************************************************* + ** + ** Function UIPC_Read + ** + ** Description Called to read a message from UIPC. + ** + ** Returns return the number of bytes read. + ** + *******************************************************************************/ +UDRV_API UINT32 UIPC_Read(tUIPC_CH_ID ch_id, UINT16 *p_msg_evt, UINT8 *p_buf, + UINT32 len) +{ + int n; + int n_read = 0; + + //APPL_TRACE_DEBUG1("UIPC_Read : ch_id %d", ch_id); + + if (source_fd == -1) + { + source_fd = open_source(); + } + + while (n_read < (int)len) + { + n = read(source_fd, p_buf, len); + + if (n == 0) + { + APPL_TRACE_EVENT0("remote source detached"); + source_fd = -1; + return 0; + } + n_read+=n; + //APPL_TRACE_EVENT1("read %d bytes", n_read); + } + + return n_read; +} + +/******************************************************************************* +** +** Function UIPC_Ioctl +** +** Description Called to control UIPC. +** +** Returns void +** +*******************************************************************************/ +UDRV_API extern BOOLEAN UIPC_Ioctl(tUIPC_CH_ID ch_id, UINT32 request, void *param) +{ + APPL_TRACE_DEBUG2("#### UIPC_Ioctl : ch_ud %d, request %d ####", ch_id, request); + return FALSE; +} + |