android
/
device_phh_treble
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
device_phh_treble/bluetooth/audio/utils/aidl_session/HidlToAidlMiddleware.cpp

633 lines
24 KiB
C++
Raw Blame History

/*
* Copyright (C) 2022 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 "BtAudioNakahara"
#include <aidl/android/hardware/bluetooth/audio/AudioConfiguration.h>
#include <aidl/android/hardware/bluetooth/audio/BluetoothAudioStatus.h>
#include <aidl/android/hardware/bluetooth/audio/SessionType.h>
#include <android-base/logging.h>
#include <functional>
#include <unordered_map>
#include "../aidl_session/BluetoothAudioSession.h"
#include "../aidl_session/BluetoothAudioSessionControl.h"
#include "HidlToAidlMiddleware_2_0.h"
#include "HidlToAidlMiddleware_2_1.h"
namespace aidl {
namespace android {
namespace hardware {
namespace bluetooth {
namespace audio {
using HidlStatus = ::android::hardware::bluetooth::audio::V2_0::Status;
using PcmConfig_2_0 =
::android::hardware::bluetooth::audio::V2_0::PcmParameters;
using SampleRate_2_0 = ::android::hardware::bluetooth::audio::V2_0::SampleRate;
using ChannelMode_2_0 =
::android::hardware::bluetooth::audio::V2_0::ChannelMode;
using BitsPerSample_2_0 =
::android::hardware::bluetooth::audio::V2_0::BitsPerSample;
using CodecConfig_2_0 =
::android::hardware::bluetooth::audio::V2_0::CodecConfiguration;
using CodecType_2_0 = ::android::hardware::bluetooth::audio::V2_0::CodecType;
using SbcConfig_2_0 =
::android::hardware::bluetooth::audio::V2_0::SbcParameters;
using AacConfig_2_0 =
::android::hardware::bluetooth::audio::V2_0::AacParameters;
using LdacConfig_2_0 =
::android::hardware::bluetooth::audio::V2_0::LdacParameters;
using AptxConfig_2_0 =
::android::hardware::bluetooth::audio::V2_0::AptxParameters;
using SbcAllocMethod_2_0 =
::android::hardware::bluetooth::audio::V2_0::SbcAllocMethod;
using SbcBlockLength_2_0 =
::android::hardware::bluetooth::audio::V2_0::SbcBlockLength;
using SbcChannelMode_2_0 =
::android::hardware::bluetooth::audio::V2_0::SbcChannelMode;
using SbcNumSubbands_2_0 =
::android::hardware::bluetooth::audio::V2_0::SbcNumSubbands;
using AacObjectType_2_0 =
::android::hardware::bluetooth::audio::V2_0::AacObjectType;
using AacVarBitRate_2_0 =
::android::hardware::bluetooth::audio::V2_0::AacVariableBitRate;
using LdacChannelMode_2_0 =
::android::hardware::bluetooth::audio::V2_0::LdacChannelMode;
using LdacQualityIndex_2_0 =
::android::hardware::bluetooth::audio::V2_0::LdacQualityIndex;
using PcmConfig_2_1 =
::android::hardware::bluetooth::audio::V2_1::PcmParameters;
using SampleRate_2_1 = ::android::hardware::bluetooth::audio::V2_1::SampleRate;
using Lc3CodecConfig_2_1 =
::android::hardware::bluetooth::audio::V2_1::Lc3CodecConfiguration;
using Lc3Config_2_1 =
::android::hardware::bluetooth::audio::V2_1::Lc3Parameters;
using Lc3FrameDuration_2_1 =
::android::hardware::bluetooth::audio::V2_1::Lc3FrameDuration;
std::mutex legacy_callback_lock;
std::unordered_map<
SessionType,
std::unordered_map<uint16_t, std::shared_ptr<PortStatusCallbacks_2_0>>>
legacy_callback_table;
const static std::unordered_map<SessionType_2_1, SessionType>
session_type_2_1_to_aidl_map{
{SessionType_2_1::A2DP_SOFTWARE_ENCODING_DATAPATH,
SessionType::A2DP_SOFTWARE_ENCODING_DATAPATH},
{SessionType_2_1::A2DP_HARDWARE_OFFLOAD_DATAPATH,
SessionType::A2DP_HARDWARE_OFFLOAD_ENCODING_DATAPATH},
{SessionType_2_1::HEARING_AID_SOFTWARE_ENCODING_DATAPATH,
SessionType::HEARING_AID_SOFTWARE_ENCODING_DATAPATH},
{SessionType_2_1::LE_AUDIO_SOFTWARE_ENCODING_DATAPATH,
SessionType::LE_AUDIO_SOFTWARE_ENCODING_DATAPATH},
{SessionType_2_1::LE_AUDIO_SOFTWARE_DECODED_DATAPATH,
SessionType::LE_AUDIO_SOFTWARE_DECODING_DATAPATH},
{SessionType_2_1::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH,
SessionType::LE_AUDIO_HARDWARE_OFFLOAD_ENCODING_DATAPATH},
{SessionType_2_1::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH,
SessionType::LE_AUDIO_HARDWARE_OFFLOAD_DECODING_DATAPATH},
};
const static std::unordered_map<int32_t, SampleRate_2_1>
sample_rate_to_hidl_2_1_map{
{44100, SampleRate_2_1::RATE_44100},
{48000, SampleRate_2_1::RATE_48000},
{88200, SampleRate_2_1::RATE_88200},
{96000, SampleRate_2_1::RATE_96000},
{176400, SampleRate_2_1::RATE_176400},
{192000, SampleRate_2_1::RATE_192000},
{16000, SampleRate_2_1::RATE_16000},
{24000, SampleRate_2_1::RATE_24000},
{8000, SampleRate_2_1::RATE_8000},
{32000, SampleRate_2_1::RATE_32000},
};
const static std::unordered_map<CodecType, CodecType_2_0>
codec_type_to_hidl_2_0_map{
{CodecType::UNKNOWN, CodecType_2_0::UNKNOWN},
{CodecType::SBC, CodecType_2_0::SBC},
{CodecType::AAC, CodecType_2_0::AAC},
{CodecType::APTX, CodecType_2_0::APTX},
{CodecType::APTX_HD, CodecType_2_0::APTX_HD},
{CodecType::LDAC, CodecType_2_0::LDAC},
{CodecType::LC3, CodecType_2_0::UNKNOWN},
};
const static std::unordered_map<SbcChannelMode, SbcChannelMode_2_0>
sbc_channel_mode_to_hidl_2_0_map{
{SbcChannelMode::UNKNOWN, SbcChannelMode_2_0::UNKNOWN},
{SbcChannelMode::JOINT_STEREO, SbcChannelMode_2_0::JOINT_STEREO},
{SbcChannelMode::STEREO, SbcChannelMode_2_0::STEREO},
{SbcChannelMode::DUAL, SbcChannelMode_2_0::DUAL},
{SbcChannelMode::MONO, SbcChannelMode_2_0::MONO},
};
const static std::unordered_map<int8_t, SbcBlockLength_2_0>
sbc_block_length_to_hidl_map{
{4, SbcBlockLength_2_0::BLOCKS_4},
{8, SbcBlockLength_2_0::BLOCKS_8},
{12, SbcBlockLength_2_0::BLOCKS_12},
{16, SbcBlockLength_2_0::BLOCKS_16},
};
const static std::unordered_map<int8_t, SbcNumSubbands_2_0>
sbc_subbands_to_hidl_map{
{4, SbcNumSubbands_2_0::SUBBAND_4},
{8, SbcNumSubbands_2_0::SUBBAND_8},
};
const static std::unordered_map<SbcAllocMethod, SbcAllocMethod_2_0>
sbc_alloc_method_to_hidl_map{
{SbcAllocMethod::ALLOC_MD_S, SbcAllocMethod_2_0::ALLOC_MD_S},
{SbcAllocMethod::ALLOC_MD_L, SbcAllocMethod_2_0::ALLOC_MD_L},
};
const static std::unordered_map<AacObjectType, AacObjectType_2_0>
aac_object_type_to_hidl_map{
{AacObjectType::MPEG2_LC, AacObjectType_2_0::MPEG2_LC},
{AacObjectType::MPEG4_LC, AacObjectType_2_0::MPEG4_LC},
{AacObjectType::MPEG4_LTP, AacObjectType_2_0::MPEG4_LTP},
{AacObjectType::MPEG4_SCALABLE, AacObjectType_2_0::MPEG4_SCALABLE},
};
const static std::unordered_map<LdacChannelMode, LdacChannelMode_2_0>
ldac_channel_mode_to_hidl_map{
{LdacChannelMode::UNKNOWN, LdacChannelMode_2_0::UNKNOWN},
{LdacChannelMode::STEREO, LdacChannelMode_2_0::STEREO},
{LdacChannelMode::DUAL, LdacChannelMode_2_0::DUAL},
{LdacChannelMode::MONO, LdacChannelMode_2_0::MONO},
};
const static std::unordered_map<LdacQualityIndex, LdacQualityIndex_2_0>
ldac_qindex_to_hidl_map{
{LdacQualityIndex::HIGH, LdacQualityIndex_2_0::QUALITY_HIGH},
{LdacQualityIndex::MID, LdacQualityIndex_2_0::QUALITY_MID},
{LdacQualityIndex::LOW, LdacQualityIndex_2_0::QUALITY_LOW},
{LdacQualityIndex::ABR, LdacQualityIndex_2_0::QUALITY_ABR},
};
inline SessionType from_session_type_2_1(
const SessionType_2_1& session_type_hidl) {
auto it = session_type_2_1_to_aidl_map.find(session_type_hidl);
if (it != session_type_2_1_to_aidl_map.end()) return it->second;
return SessionType::UNKNOWN;
}
inline SessionType from_session_type_2_0(
const SessionType_2_0& session_type_hidl) {
return from_session_type_2_1(static_cast<SessionType_2_1>(session_type_hidl));
}
inline HidlStatus to_hidl_status(const BluetoothAudioStatus& status) {
switch (status) {
case BluetoothAudioStatus::SUCCESS:
return HidlStatus::SUCCESS;
case BluetoothAudioStatus::UNSUPPORTED_CODEC_CONFIGURATION:
return HidlStatus::UNSUPPORTED_CODEC_CONFIGURATION;
default:
return HidlStatus::FAILURE;
}
}
inline SampleRate_2_1 to_hidl_sample_rate_2_1(const int32_t sample_rate_hz) {
auto it = sample_rate_to_hidl_2_1_map.find(sample_rate_hz);
if (it != sample_rate_to_hidl_2_1_map.end()) return it->second;
return SampleRate_2_1::RATE_UNKNOWN;
}
inline SampleRate_2_0 to_hidl_sample_rate_2_0(const int32_t sample_rate_hz) {
auto it = sample_rate_to_hidl_2_1_map.find(sample_rate_hz);
if (it != sample_rate_to_hidl_2_1_map.end())
return static_cast<SampleRate_2_0>(it->second);
return SampleRate_2_0::RATE_UNKNOWN;
}
inline BitsPerSample_2_0 to_hidl_bits_per_sample(const int8_t bit_per_sample) {
switch (bit_per_sample) {
case 16:
return BitsPerSample_2_0::BITS_16;
case 24:
return BitsPerSample_2_0::BITS_24;
case 32:
return BitsPerSample_2_0::BITS_32;
default:
return BitsPerSample_2_0::BITS_UNKNOWN;
}
}
inline ChannelMode_2_0 to_hidl_channel_mode(const ChannelMode channel_mode) {
switch (channel_mode) {
case ChannelMode::MONO:
return ChannelMode_2_0::MONO;
case ChannelMode::STEREO:
return ChannelMode_2_0::STEREO;
default:
return ChannelMode_2_0::UNKNOWN;
}
}
inline PcmConfig_2_0 to_hidl_pcm_config_2_0(
const PcmConfiguration& pcm_config) {
PcmConfig_2_0 hidl_pcm_config;
hidl_pcm_config.sampleRate = to_hidl_sample_rate_2_0(pcm_config.sampleRateHz);
hidl_pcm_config.channelMode = to_hidl_channel_mode(pcm_config.channelMode);
hidl_pcm_config.bitsPerSample =
to_hidl_bits_per_sample(pcm_config.bitsPerSample);
return hidl_pcm_config;
}
inline CodecType_2_0 to_hidl_codec_type_2_0(const CodecType codec_type) {
auto it = codec_type_to_hidl_2_0_map.find(codec_type);
if (it != codec_type_to_hidl_2_0_map.end()) return it->second;
return CodecType_2_0::UNKNOWN;
}
inline SbcConfig_2_0 to_hidl_sbc_config(const SbcConfiguration sbc_config) {
SbcConfig_2_0 hidl_sbc_config;
hidl_sbc_config.minBitpool = sbc_config.minBitpool;
hidl_sbc_config.maxBitpool = sbc_config.maxBitpool;
hidl_sbc_config.sampleRate = to_hidl_sample_rate_2_0(sbc_config.sampleRateHz);
hidl_sbc_config.bitsPerSample =
to_hidl_bits_per_sample(sbc_config.bitsPerSample);
if (sbc_channel_mode_to_hidl_2_0_map.find(sbc_config.channelMode) !=
sbc_channel_mode_to_hidl_2_0_map.end()) {
hidl_sbc_config.channelMode =
sbc_channel_mode_to_hidl_2_0_map.at(sbc_config.channelMode);
}
if (sbc_block_length_to_hidl_map.find(sbc_config.blockLength) !=
sbc_block_length_to_hidl_map.end()) {
hidl_sbc_config.blockLength =
sbc_block_length_to_hidl_map.at(sbc_config.blockLength);
}
if (sbc_subbands_to_hidl_map.find(sbc_config.numSubbands) !=
sbc_subbands_to_hidl_map.end()) {
hidl_sbc_config.numSubbands =
sbc_subbands_to_hidl_map.at(sbc_config.numSubbands);
}
if (sbc_alloc_method_to_hidl_map.find(sbc_config.allocMethod) !=
sbc_alloc_method_to_hidl_map.end()) {
hidl_sbc_config.allocMethod =
sbc_alloc_method_to_hidl_map.at(sbc_config.allocMethod);
}
return hidl_sbc_config;
}
inline AacConfig_2_0 to_hidl_aac_config(const AacConfiguration aac_config) {
AacConfig_2_0 hidl_aac_config;
hidl_aac_config.sampleRate = to_hidl_sample_rate_2_0(aac_config.sampleRateHz);
hidl_aac_config.bitsPerSample =
to_hidl_bits_per_sample(aac_config.bitsPerSample);
hidl_aac_config.channelMode = to_hidl_channel_mode(aac_config.channelMode);
if (aac_object_type_to_hidl_map.find(aac_config.objectType) !=
aac_object_type_to_hidl_map.end()) {
hidl_aac_config.objectType =
aac_object_type_to_hidl_map.at(aac_config.objectType);
}
hidl_aac_config.variableBitRateEnabled = aac_config.variableBitRateEnabled
? AacVarBitRate_2_0::ENABLED
: AacVarBitRate_2_0::DISABLED;
return hidl_aac_config;
}
inline LdacConfig_2_0 to_hidl_ldac_config(const LdacConfiguration ldac_config) {
LdacConfig_2_0 hidl_ldac_config;
hidl_ldac_config.sampleRate =
to_hidl_sample_rate_2_0(ldac_config.sampleRateHz);
hidl_ldac_config.bitsPerSample =
to_hidl_bits_per_sample(ldac_config.bitsPerSample);
if (ldac_channel_mode_to_hidl_map.find(ldac_config.channelMode) !=
ldac_channel_mode_to_hidl_map.end()) {
hidl_ldac_config.channelMode =
ldac_channel_mode_to_hidl_map.at(ldac_config.channelMode);
}
if (ldac_qindex_to_hidl_map.find(ldac_config.qualityIndex) !=
ldac_qindex_to_hidl_map.end()) {
hidl_ldac_config.qualityIndex =
ldac_qindex_to_hidl_map.at(ldac_config.qualityIndex);
}
return hidl_ldac_config;
}
inline AptxConfig_2_0 to_hidl_aptx_config(const AptxConfiguration aptx_config) {
AptxConfig_2_0 hidl_aptx_config;
hidl_aptx_config.sampleRate =
to_hidl_sample_rate_2_0(aptx_config.sampleRateHz);
hidl_aptx_config.bitsPerSample =
to_hidl_bits_per_sample(aptx_config.bitsPerSample);
hidl_aptx_config.channelMode = to_hidl_channel_mode(aptx_config.channelMode);
return hidl_aptx_config;
}
inline CodecConfig_2_0 to_hidl_codec_config_2_0(
const CodecConfiguration& codec_config) {
CodecConfig_2_0 hidl_codec_config;
hidl_codec_config.codecType = to_hidl_codec_type_2_0(codec_config.codecType);
hidl_codec_config.encodedAudioBitrate =
static_cast<uint32_t>(codec_config.encodedAudioBitrate);
hidl_codec_config.peerMtu = static_cast<uint32_t>(codec_config.peerMtu);
hidl_codec_config.isScmstEnabled = codec_config.isScmstEnabled;
switch (codec_config.config.getTag()) {
case CodecConfiguration::CodecSpecific::sbcConfig:
hidl_codec_config.config.sbcConfig(to_hidl_sbc_config(
codec_config.config
.get<CodecConfiguration::CodecSpecific::sbcConfig>()));
break;
case CodecConfiguration::CodecSpecific::aacConfig:
hidl_codec_config.config.aacConfig(to_hidl_aac_config(
codec_config.config
.get<CodecConfiguration::CodecSpecific::aacConfig>()));
break;
case CodecConfiguration::CodecSpecific::ldacConfig:
hidl_codec_config.config.ldacConfig(to_hidl_ldac_config(
codec_config.config
.get<CodecConfiguration::CodecSpecific::ldacConfig>()));
break;
case CodecConfiguration::CodecSpecific::aptxConfig:
hidl_codec_config.config.aptxConfig(to_hidl_aptx_config(
codec_config.config
.get<CodecConfiguration::CodecSpecific::aptxConfig>()));
break;
default:
break;
}
return hidl_codec_config;
}
inline AudioConfig_2_0 to_hidl_audio_config_2_0(
const AudioConfiguration& audio_config) {
AudioConfig_2_0 hidl_audio_config;
if (audio_config.getTag() == AudioConfiguration::pcmConfig) {
hidl_audio_config.pcmConfig(to_hidl_pcm_config_2_0(
audio_config.get<AudioConfiguration::pcmConfig>()));
} else if (audio_config.getTag() == AudioConfiguration::a2dpConfig) {
hidl_audio_config.codecConfig(to_hidl_codec_config_2_0(
audio_config.get<AudioConfiguration::a2dpConfig>()));
}
return hidl_audio_config;
}
inline PcmConfig_2_1 to_hidl_pcm_config_2_1(
const PcmConfiguration& pcm_config) {
PcmConfig_2_1 hidl_pcm_config;
hidl_pcm_config.sampleRate = to_hidl_sample_rate_2_1(pcm_config.sampleRateHz);
hidl_pcm_config.channelMode = to_hidl_channel_mode(pcm_config.channelMode);
hidl_pcm_config.bitsPerSample =
to_hidl_bits_per_sample(pcm_config.bitsPerSample);
hidl_pcm_config.dataIntervalUs =
static_cast<uint32_t>(pcm_config.dataIntervalUs);
return hidl_pcm_config;
}
inline Lc3Config_2_1 to_hidl_lc3_config_2_1(
const Lc3Configuration& lc3_config) {
Lc3Config_2_1 hidl_lc3_config;
hidl_lc3_config.pcmBitDepth = to_hidl_bits_per_sample(lc3_config.pcmBitDepth);
hidl_lc3_config.samplingFrequency =
to_hidl_sample_rate_2_1(lc3_config.samplingFrequencyHz);
if (lc3_config.samplingFrequencyHz == 10000)
hidl_lc3_config.frameDuration = Lc3FrameDuration_2_1::DURATION_10000US;
else if (lc3_config.samplingFrequencyHz == 7500)
hidl_lc3_config.frameDuration = Lc3FrameDuration_2_1::DURATION_7500US;
hidl_lc3_config.octetsPerFrame =
static_cast<uint32_t>(lc3_config.octetsPerFrame);
hidl_lc3_config.blocksPerSdu = static_cast<uint32_t>(lc3_config.blocksPerSdu);
return hidl_lc3_config;
}
inline Lc3CodecConfig_2_1 to_hidl_leaudio_config_2_1(
const LeAudioConfiguration& unicast_config) {
Lc3CodecConfig_2_1 hidl_lc3_codec_config = {
.audioChannelAllocation = 0,
};
if (unicast_config.leAudioCodecConfig.getTag() ==
LeAudioCodecConfiguration::lc3Config) {
LOG(FATAL) << __func__ << ": unexpected codec type(vendor?)";
}
auto& le_codec_config = unicast_config.leAudioCodecConfig
.get<LeAudioCodecConfiguration::lc3Config>();
hidl_lc3_codec_config.lc3Config = to_hidl_lc3_config_2_1(le_codec_config);
for (const auto& map : unicast_config.streamMap) {
hidl_lc3_codec_config.audioChannelAllocation |= map.audioChannelAllocation;
}
return hidl_lc3_codec_config;
}
inline Lc3CodecConfig_2_1 to_hidl_leaudio_broadcast_config_2_1(
const LeAudioBroadcastConfiguration& broadcast_config) {
Lc3CodecConfig_2_1 hidl_lc3_codec_config = {
.audioChannelAllocation = 0,
};
// NOTE: Broadcast is not officially supported in HIDL
if (broadcast_config.streamMap.empty()) {
return hidl_lc3_codec_config;
}
if (broadcast_config.streamMap[0].leAudioCodecConfig.getTag() !=
LeAudioCodecConfiguration::lc3Config) {
LOG(FATAL) << __func__ << ": unexpected codec type(vendor?)";
}
auto& le_codec_config =
broadcast_config.streamMap[0]
.leAudioCodecConfig.get<LeAudioCodecConfiguration::lc3Config>();
hidl_lc3_codec_config.lc3Config = to_hidl_lc3_config_2_1(le_codec_config);
for (const auto& map : broadcast_config.streamMap) {
hidl_lc3_codec_config.audioChannelAllocation |= map.audioChannelAllocation;
}
return hidl_lc3_codec_config;
}
inline AudioConfig_2_1 to_hidl_audio_config_2_1(
const AudioConfiguration& audio_config) {
AudioConfig_2_1 hidl_audio_config;
switch (audio_config.getTag()) {
case AudioConfiguration::pcmConfig:
hidl_audio_config.pcmConfig(to_hidl_pcm_config_2_1(
audio_config.get<AudioConfiguration::pcmConfig>()));
break;
case AudioConfiguration::a2dpConfig:
hidl_audio_config.codecConfig(to_hidl_codec_config_2_0(
audio_config.get<AudioConfiguration::a2dpConfig>()));
break;
case AudioConfiguration::leAudioConfig:
hidl_audio_config.leAudioCodecConfig(to_hidl_leaudio_config_2_1(
audio_config.get<AudioConfiguration::leAudioConfig>()));
break;
case AudioConfiguration::leAudioBroadcastConfig:
hidl_audio_config.leAudioCodecConfig(to_hidl_leaudio_broadcast_config_2_1(
audio_config.get<AudioConfiguration::leAudioBroadcastConfig>()));
break;
}
return hidl_audio_config;
}
/***
*
* 2.0
*
***/
bool HidlToAidlMiddleware_2_0::IsSessionReady(
const SessionType_2_0& session_type) {
return BluetoothAudioSessionControl::IsSessionReady(
from_session_type_2_0(session_type));
}
uint16_t HidlToAidlMiddleware_2_0::RegisterControlResultCback(
const SessionType_2_0& session_type,
const PortStatusCallbacks_2_0& cbacks) {
LOG(INFO) << __func__ << ": " << toString(session_type);
auto aidl_session_type = from_session_type_2_0(session_type);
// Pass the exact reference to the lambda
auto& session_legacy_callback_table =
legacy_callback_table[aidl_session_type];
PortStatusCallbacks aidl_callbacks{};
if (cbacks.control_result_cb_) {
aidl_callbacks.control_result_cb_ =
[&session_legacy_callback_table](uint16_t cookie, bool start_resp,
const BluetoothAudioStatus& status) {
if (session_legacy_callback_table.find(cookie) ==
session_legacy_callback_table.end()) {
LOG(ERROR) << __func__ << ": Unknown callback invoked!";
return;
}
auto& cback = session_legacy_callback_table[cookie];
cback->control_result_cb_(cookie, start_resp, to_hidl_status(status));
};
}
if (cbacks.session_changed_cb_) {
aidl_callbacks.session_changed_cb_ =
[&session_legacy_callback_table](uint16_t cookie) {
if (session_legacy_callback_table.find(cookie) ==
session_legacy_callback_table.end()) {
LOG(ERROR) << __func__ << ": Unknown callback invoked!";
return;
}
auto& cback = session_legacy_callback_table[cookie];
cback->session_changed_cb_(cookie);
};
};
auto cookie = BluetoothAudioSessionControl::RegisterControlResultCback(
aidl_session_type, aidl_callbacks);
{
std::lock_guard<std::mutex> guard(legacy_callback_lock);
session_legacy_callback_table[cookie] =
std::make_shared<PortStatusCallbacks_2_0>(cbacks);
}
return cookie;
}
void HidlToAidlMiddleware_2_0::UnregisterControlResultCback(
const SessionType_2_0& session_type, uint16_t cookie) {
LOG(INFO) << __func__ << ": " << toString(session_type);
auto aidl_session_type = from_session_type_2_0(session_type);
BluetoothAudioSessionControl::UnregisterControlResultCback(aidl_session_type,
cookie);
auto& session_callback_table = legacy_callback_table[aidl_session_type];
if (session_callback_table.find(cookie) != session_callback_table.end()) {
std::lock_guard<std::mutex> guard(legacy_callback_lock);
session_callback_table.erase(cookie);
}
}
const AudioConfig_2_0 HidlToAidlMiddleware_2_0::GetAudioConfig(
const SessionType_2_0& session_type) {
return to_hidl_audio_config_2_0(BluetoothAudioSessionControl::GetAudioConfig(
from_session_type_2_0(session_type)));
}
bool HidlToAidlMiddleware_2_0::StartStream(
const SessionType_2_0& session_type) {
return BluetoothAudioSessionControl::StartStream(
from_session_type_2_0(session_type));
}
void HidlToAidlMiddleware_2_0::StopStream(const SessionType_2_0& session_type) {
return BluetoothAudioSessionControl::StopStream(
from_session_type_2_0(session_type));
}
bool HidlToAidlMiddleware_2_0::SuspendStream(
const SessionType_2_0& session_type) {
return BluetoothAudioSessionControl::SuspendStream(
from_session_type_2_0(session_type));
}
bool HidlToAidlMiddleware_2_0::GetPresentationPosition(
const SessionType_2_0& session_type, uint64_t* remote_delay_report_ns,
uint64_t* total_bytes_readed, timespec* data_position) {
PresentationPosition presentation_position;
auto ret_val = BluetoothAudioSessionControl::GetPresentationPosition(
from_session_type_2_0(session_type), presentation_position);
if (remote_delay_report_ns)
*remote_delay_report_ns = presentation_position.remoteDeviceAudioDelayNanos;
if (total_bytes_readed)
*total_bytes_readed = presentation_position.transmittedOctets;
if (data_position)
*data_position = {
.tv_sec = static_cast<__kernel_old_time_t>(
presentation_position.transmittedOctetsTimestamp.tvSec),
.tv_nsec = static_cast<long>(
presentation_position.transmittedOctetsTimestamp.tvNSec)};
return ret_val;
}
void HidlToAidlMiddleware_2_0::UpdateTracksMetadata(
const SessionType_2_0& session_type,
const struct source_metadata* source_metadata) {
return BluetoothAudioSessionControl::UpdateSourceMetadata(
from_session_type_2_0(session_type), *source_metadata);
}
size_t HidlToAidlMiddleware_2_0::OutWritePcmData(
const SessionType_2_0& session_type, const void* buffer, size_t bytes) {
return BluetoothAudioSessionControl::OutWritePcmData(
from_session_type_2_0(session_type), buffer, bytes);
}
size_t HidlToAidlMiddleware_2_0::InReadPcmData(
const SessionType_2_0& session_type, void* buffer, size_t bytes) {
return BluetoothAudioSessionControl::InReadPcmData(
from_session_type_2_0(session_type), buffer, bytes);
}
bool HidlToAidlMiddleware_2_0::IsAidlAvailable() {
return BluetoothAudioSession::IsAidlAvailable();
}
/***
*
* 2.1
*
***/
const AudioConfig_2_1 HidlToAidlMiddleware_2_1::GetAudioConfig(
const SessionType_2_1& session_type) {
return to_hidl_audio_config_2_1(BluetoothAudioSessionControl::GetAudioConfig(
from_session_type_2_1(session_type)));
}
} // namespace audio
} // namespace bluetooth
} // namespace hardware
} // namespace android
} // namespace aidl
Reference in New Issue View Git Blame Copy Permalink