| /* |
| * Copyright 2016 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "a2dp_vendor_ldac_decoder" |
| #define ATRACE_TAG ATRACE_TAG_AUDIO |
| |
| #include "a2dp_vendor_ldac_decoder.h" |
| |
| #ifndef OS_GENERIC |
| #include <cutils/trace.h> |
| #endif |
| #include <dlfcn.h> |
| #include <inttypes.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <ldacBT.h> |
| |
| #include "a2dp_vendor.h" |
| #include "a2dp_vendor_ldac.h" |
| #include "bt_common.h" |
| #include "osi/include/log.h" |
| #include "osi/include/osi.h" |
| |
| // |
| // Decoder for LDAC Source Codec |
| // |
| |
| // |
| // The LDAC decoder shared library, and the functions to use |
| // |
| static const char* LDAC_DECODER_LIB_NAME = "libldacBT_dec.so"; |
| static void* ldac_decoder_lib_handle = NULL; |
| |
| static const char* LDAC_GET_HANDLE_NAME = "ldacBT_get_handle"; |
| typedef HANDLE_LDAC_BT (*tLDAC_GET_HANDLE)(void); |
| |
| static const char* LDAC_FREE_HANDLE_NAME = "ldacBT_free_handle"; |
| typedef void (*tLDAC_FREE_HANDLE)(HANDLE_LDAC_BT hLdacParam); |
| |
| static const char* LDAC_CLOSE_HANDLE_NAME = "ldacBT_close_handle"; |
| typedef void (*tLDAC_CLOSE_HANDLE)(HANDLE_LDAC_BT hLdacParam); |
| |
| static const char* LDAC_GET_VERSION_NAME = "ldacBT_get_version"; |
| typedef int (*tLDAC_GET_VERSION)(void); |
| |
| static const char* LDAC_GET_BITRATE_NAME = "ldacBT_get_bitrate"; |
| typedef int (*tLDAC_GET_BITRATE)(HANDLE_LDAC_BT hLdacParam); |
| |
| static const char* LDAC_GET_SAMPLING_FREQ_NAME = "ldacBT_get_sampling_freq"; |
| typedef int (*tLDAC_GET_SAMPLING_FREQ)(HANDLE_LDAC_BT hLdacParam); |
| |
| static const char* LDAC_INIT_HANDLE_DECODE_NAME = "ldacBT_init_handle_decode"; |
| typedef int (*tLDAC_INIT_HANDLE_DECODE)(HANDLE_LDAC_BT hLdacParam, int cm, |
| int sf, int var0, int var1, int var2); |
| |
| static const char* LDAC_DECODE_NAME = "ldacBT_decode"; |
| typedef int (*tLDAC_DECODE)(HANDLE_LDAC_BT hLdacBt, unsigned char* p_bs, |
| unsigned char* p_pcm, LDACBT_SMPL_FMT_T fmt, |
| int bs_bytes, int* used_bytes, int* wrote_bytes); |
| |
| static const char* LDAC_GET_ERROR_CODE_NAME = "ldacBT_get_error_code"; |
| typedef int (*tLDAC_GET_ERROR_CODE)(HANDLE_LDAC_BT hLdacParam); |
| |
| static tLDAC_GET_HANDLE ldac_get_handle_func; |
| static tLDAC_FREE_HANDLE ldac_free_handle_func; |
| static tLDAC_CLOSE_HANDLE ldac_close_handle_func; |
| static tLDAC_GET_VERSION ldac_get_version_func; |
| static tLDAC_GET_BITRATE ldac_get_bitrate_func; |
| static tLDAC_GET_SAMPLING_FREQ ldac_get_sampling_freq_func; |
| static tLDAC_INIT_HANDLE_DECODE ldac_init_handle_decode_func; |
| static tLDAC_DECODE ldac_decode_func; |
| static tLDAC_GET_ERROR_CODE ldac_get_error_code_func; |
| |
| // offset |
| #if (BTA_AV_CO_CP_SCMS_T == TRUE) |
| #define A2DP_LDAC_OFFSET (AVDT_MEDIA_OFFSET + A2DP_LDAC_MPL_HDR_LEN + 1) |
| #else |
| #define A2DP_LDAC_OFFSET (AVDT_MEDIA_OFFSET + A2DP_LDAC_MPL_HDR_LEN) |
| #endif |
| |
| typedef struct { |
| uint32_t sample_rate; |
| uint8_t channel_mode; |
| uint8_t bits_per_sample; |
| int pcm_wlength; |
| LDACBT_SMPL_FMT_T pcm_fmt; |
| } tA2DP_LDAC_DECODER_PARAMS; |
| |
| typedef struct { |
| bool use_SCMS_T; |
| bool is_peer_edr; // True if the peer device supports EDR |
| bool peer_supports_3mbps; // True if the peer device supports 3Mbps EDR |
| uint16_t peer_mtu; // MTU of the A2DP peer |
| uint32_t timestamp; // Timestamp for the A2DP frames |
| |
| HANDLE_LDAC_BT ldac_handle; |
| bool has_ldac_handle; // True if ldac_handle is valid |
| unsigned char* decode_buf; |
| decoded_data_callback_t decode_callback; |
| } tA2DP_LDAC_DECODER_CB; |
| |
| static tA2DP_LDAC_DECODER_CB a2dp_ldac_decoder_cb; |
| |
| static void* load_func(const char* func_name) { |
| void* func_ptr = dlsym(ldac_decoder_lib_handle, func_name); |
| if (func_ptr == NULL) { |
| LOG_ERROR(LOG_TAG, |
| "%s: cannot find function '%s' in the decoder library: %s", |
| __func__, func_name, dlerror()); |
| A2DP_VendorUnloadDecoderLdac(); |
| return NULL; |
| } |
| return func_ptr; |
| } |
| |
| bool A2DP_VendorLoadDecoderLdac(void) { |
| if (ldac_decoder_lib_handle != NULL) return true; // Already loaded |
| |
| // Initialize the control block |
| memset(&a2dp_ldac_decoder_cb, 0, sizeof(a2dp_ldac_decoder_cb)); |
| |
| // Open the decoder library |
| ldac_decoder_lib_handle = dlopen(LDAC_DECODER_LIB_NAME, RTLD_NOW); |
| if (ldac_decoder_lib_handle == NULL) { |
| LOG_ERROR(LOG_TAG, "%s: cannot open LDAC decoder library %s: %s", __func__, |
| LDAC_DECODER_LIB_NAME, dlerror()); |
| return false; |
| } |
| |
| // Load all functions |
| ldac_get_handle_func = (tLDAC_GET_HANDLE)load_func(LDAC_GET_HANDLE_NAME); |
| if (ldac_get_handle_func == NULL) return false; |
| ldac_free_handle_func = (tLDAC_FREE_HANDLE)load_func(LDAC_FREE_HANDLE_NAME); |
| if (ldac_free_handle_func == NULL) return false; |
| ldac_close_handle_func = |
| (tLDAC_CLOSE_HANDLE)load_func(LDAC_CLOSE_HANDLE_NAME); |
| if (ldac_close_handle_func == NULL) return false; |
| ldac_get_version_func = (tLDAC_GET_VERSION)load_func(LDAC_GET_VERSION_NAME); |
| if (ldac_get_version_func == NULL) return false; |
| ldac_get_bitrate_func = (tLDAC_GET_BITRATE)load_func(LDAC_GET_BITRATE_NAME); |
| if (ldac_get_bitrate_func == NULL) return false; |
| ldac_get_sampling_freq_func = |
| (tLDAC_GET_SAMPLING_FREQ)load_func(LDAC_GET_SAMPLING_FREQ_NAME); |
| if (ldac_get_sampling_freq_func == NULL) return false; |
| ldac_init_handle_decode_func = |
| (tLDAC_INIT_HANDLE_DECODE)load_func(LDAC_INIT_HANDLE_DECODE_NAME); |
| if (ldac_init_handle_decode_func == NULL) return false; |
| ldac_decode_func = (tLDAC_DECODE)load_func(LDAC_DECODE_NAME); |
| if (ldac_decode_func == NULL) return false; |
| ldac_get_error_code_func = |
| (tLDAC_GET_ERROR_CODE)load_func(LDAC_GET_ERROR_CODE_NAME); |
| if (ldac_get_error_code_func == NULL) return false; |
| |
| return true; |
| } |
| |
| void A2DP_VendorUnloadDecoderLdac(void) { |
| // Cleanup any LDAC-related state |
| if (a2dp_ldac_decoder_cb.has_ldac_handle && ldac_free_handle_func != NULL) |
| ldac_free_handle_func(a2dp_ldac_decoder_cb.ldac_handle); |
| memset(&a2dp_ldac_decoder_cb, 0, sizeof(a2dp_ldac_decoder_cb)); |
| |
| ldac_get_handle_func = NULL; |
| ldac_free_handle_func = NULL; |
| ldac_close_handle_func = NULL; |
| ldac_get_version_func = NULL; |
| ldac_get_bitrate_func = NULL; |
| ldac_get_sampling_freq_func = NULL; |
| ldac_init_handle_decode_func = NULL; |
| ldac_decode_func = NULL; |
| ldac_get_error_code_func = NULL; |
| |
| if (ldac_decoder_lib_handle != NULL) { |
| dlclose(ldac_decoder_lib_handle); |
| ldac_decoder_lib_handle = NULL; |
| } |
| } |
| |
| bool a2dp_vendor_ldac_decoder_init(decoded_data_callback_t decode_callback) { |
| if (a2dp_ldac_decoder_cb.has_ldac_handle) |
| ldac_free_handle_func(a2dp_ldac_decoder_cb.ldac_handle); |
| memset(&a2dp_ldac_decoder_cb, 0, sizeof(a2dp_ldac_decoder_cb)); |
| |
| a2dp_vendor_ldac_decoder_cleanup(); |
| |
| a2dp_ldac_decoder_cb.ldac_handle = ldac_get_handle_func(); |
| a2dp_ldac_decoder_cb.has_ldac_handle = true; |
| a2dp_ldac_decoder_cb.decode_buf = static_cast<unsigned char*>( |
| osi_malloc(sizeof(a2dp_ldac_decoder_cb.decode_buf[0]) * LDACBT_MAX_LSU * |
| LDAC_PRCNCH * sizeof(int))); |
| a2dp_ldac_decoder_cb.decode_callback = decode_callback; |
| |
| // initialize |
| ldac_init_handle_decode_func(a2dp_ldac_decoder_cb.ldac_handle, |
| LDACBT_CHANNEL_MODE_STEREO, 96000, 0, 0, 0); |
| return true; |
| } |
| |
| void a2dp_vendor_ldac_decoder_cleanup(void) { |
| if (a2dp_ldac_decoder_cb.has_ldac_handle) |
| ldac_free_handle_func(a2dp_ldac_decoder_cb.ldac_handle); |
| memset(&a2dp_ldac_decoder_cb, 0, sizeof(a2dp_ldac_decoder_cb)); |
| } |
| |
| bool a2dp_vendor_ldac_decoder_decode_packet(BT_HDR* p_buf) { |
| unsigned char* pBuffer = |
| reinterpret_cast<unsigned char*>(p_buf->data + p_buf->offset); |
| // unsigned int bufferSize = p_buf->len; |
| unsigned int bytesValid = p_buf->len; |
| int err; |
| LDACBT_SMPL_FMT_T fmt; |
| int bs_bytes, used_bytes, wrote_bytes, frame_number; |
| |
| fmt = LDACBT_SMPL_FMT_S32; |
| frame_number = (int)pBuffer[0]; |
| pBuffer++; |
| bs_bytes = (int)bytesValid - 1; |
| bytesValid -= 1; |
| LOG_VERBOSE(LOG_TAG, "%s:INPUT size : %d, frame : %d", __func__, bs_bytes, |
| frame_number); |
| |
| while (bytesValid > 0) { |
| #if 0 |
| err = ldacDecoder_Fill(a2dp_ldac_decoder_cb.ldac_handle, |
| &pBuffer, &bufferSize, &bytesValid); |
| if (err != LDACBT_ERR_NONE) { |
| LOG_ERROR(LOG_TAG, "%s: ldacDecoder_Fill failed: 0x%x", __func__, |
| static_cast<unsigned>(err)); |
| return false; |
| } |
| #endif |
| while (true) { |
| // Todo : implement LDAC Buffer Control Operation instead of |
| // ldac_decode_func(). |
| err = ldac_decode_func(a2dp_ldac_decoder_cb.ldac_handle, pBuffer, |
| a2dp_ldac_decoder_cb.decode_buf, fmt, bs_bytes, |
| &used_bytes, &wrote_bytes); |
| // if (err == LDAC_DEC_NOT_ENOUGH_FRAMES) { |
| // break; |
| // } |
| if (LDACBT_ERROR(err)) { |
| err = ldac_get_error_code_func(a2dp_ldac_decoder_cb.ldac_handle); |
| LOG_ERROR(LOG_TAG, "%s: ldacDecoder_DecodeFrame failed: %d:%d:%d", |
| __func__, LDACBT_API_ERR(err), LDACBT_HANDLE_ERR(err), |
| LDACBT_BLOCK_ERR(err)); |
| if (LDACBT_FATAL(err)) { |
| break; |
| } |
| } |
| |
| if (wrote_bytes > 0) { |
| size_t frame_len = (size_t)wrote_bytes; |
| a2dp_ldac_decoder_cb.decode_callback( |
| reinterpret_cast<uint8_t*>(a2dp_ldac_decoder_cb.decode_buf), |
| frame_len); |
| } |
| pBuffer += used_bytes; |
| bs_bytes -= used_bytes; |
| if (bs_bytes <= 1) { |
| bytesValid = 0; |
| break; |
| } |
| } |
| } |
| |
| return true; |
| } |