blob: 49bc1d67a0a26f504baef149d1c081a7bbc3c4f2 [file] [log] [blame]
jiabin253bd322023-01-25 23:57:31 +00001/*
2 * Copyright (C) 2023 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "AHAL_StreamUsb"
18#include <android-base/logging.h>
19
jiabin783c48b2023-02-28 18:28:06 +000020#include <Utils.h>
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070021#include <error/expected_utils.h>
jiabin783c48b2023-02-28 18:28:06 +000022
23#include "UsbAlsaMixerControl.h"
jiabin253bd322023-01-25 23:57:31 +000024#include "UsbAlsaUtils.h"
25#include "core-impl/Module.h"
26#include "core-impl/StreamUsb.h"
27
28extern "C" {
29#include "alsa_device_profile.h"
30}
31
Mikhail Naganov872d4a62023-03-09 18:19:01 -080032using aidl::android::hardware::audio::common::getChannelCount;
jiabin253bd322023-01-25 23:57:31 +000033using aidl::android::hardware::audio::common::SinkMetadata;
34using aidl::android::hardware::audio::common::SourceMetadata;
35using aidl::android::media::audio::common::AudioDevice;
36using aidl::android::media::audio::common::AudioDeviceAddress;
37using aidl::android::media::audio::common::AudioOffloadInfo;
jiabin783c48b2023-02-28 18:28:06 +000038using aidl::android::media::audio::common::AudioPortExt;
Mikhail Naganov6725ef52023-02-09 17:52:50 -080039using aidl::android::media::audio::common::MicrophoneDynamicInfo;
40using aidl::android::media::audio::common::MicrophoneInfo;
jiabin783c48b2023-02-28 18:28:06 +000041using android::OK;
42using android::status_t;
jiabin253bd322023-01-25 23:57:31 +000043
44namespace aidl::android::hardware::audio::core {
45
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070046StreamUsb::StreamUsb(const Metadata& metadata, StreamContext&& context)
47 : StreamCommonImpl(metadata, std::move(context)),
48 mFrameSizeBytes(context.getFrameSize()),
49 mIsInput(isInput(metadata)) {
jiabin253bd322023-01-25 23:57:31 +000050 struct pcm_config config;
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070051 config.channels = usb::getChannelCountFromChannelMask(context.getChannelLayout(), mIsInput);
jiabin253bd322023-01-25 23:57:31 +000052 if (config.channels == 0) {
53 LOG(ERROR) << __func__ << ": invalid channel=" << context.getChannelLayout().toString();
54 return;
55 }
56 config.format = usb::aidl2legacy_AudioFormatDescription_pcm_format(context.getFormat());
57 if (config.format == PCM_FORMAT_INVALID) {
58 LOG(ERROR) << __func__ << ": invalid format=" << context.getFormat().toString();
59 return;
60 }
61 config.rate = context.getSampleRate();
62 if (config.rate == 0) {
63 LOG(ERROR) << __func__ << ": invalid sample rate=" << config.rate;
64 return;
65 }
66 mConfig = config;
67}
68
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070069::android::status_t StreamUsb::init() {
jiabin253bd322023-01-25 23:57:31 +000070 return mConfig.has_value() ? ::android::OK : ::android::NO_INIT;
71}
72
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070073const StreamCommonInterface::ConnectedDevices& StreamUsb::getConnectedDevices() const {
74 std::lock_guard guard(mLock);
75 return mConnectedDevices;
76}
77
78ndk::ScopedAStatus StreamUsb::setConnectedDevices(
jiabin253bd322023-01-25 23:57:31 +000079 const std::vector<AudioDevice>& connectedDevices) {
80 if (mIsInput && connectedDevices.size() > 1) {
81 LOG(ERROR) << __func__ << ": wrong device size(" << connectedDevices.size()
82 << ") for input stream";
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070083 return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
jiabin253bd322023-01-25 23:57:31 +000084 }
85 for (const auto& connectedDevice : connectedDevices) {
86 if (connectedDevice.address.getTag() != AudioDeviceAddress::alsa) {
87 LOG(ERROR) << __func__ << ": bad device address" << connectedDevice.address.toString();
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070088 return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
jiabin253bd322023-01-25 23:57:31 +000089 }
90 }
91 std::lock_guard guard(mLock);
92 mAlsaDeviceProxies.clear();
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070093 RETURN_STATUS_IF_ERROR(StreamCommonImpl::setConnectedDevices(connectedDevices));
94 return ndk::ScopedAStatus::ok();
jiabin253bd322023-01-25 23:57:31 +000095}
96
Mikhail Naganovd5554cf2023-06-21 15:20:31 -070097::android::status_t StreamUsb::drain(StreamDescriptor::DrainMode) {
jiabin253bd322023-01-25 23:57:31 +000098 usleep(1000);
99 return ::android::OK;
100}
101
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700102::android::status_t StreamUsb::flush() {
jiabin253bd322023-01-25 23:57:31 +0000103 usleep(1000);
104 return ::android::OK;
105}
106
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700107::android::status_t StreamUsb::pause() {
jiabin253bd322023-01-25 23:57:31 +0000108 usleep(1000);
109 return ::android::OK;
110}
111
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700112::android::status_t StreamUsb::transfer(void* buffer, size_t frameCount, size_t* actualFrameCount,
jiabin253bd322023-01-25 23:57:31 +0000113 int32_t* latencyMs) {
Mikhail Naganovb511b8a2023-05-15 14:35:24 -0700114 {
115 std::lock_guard guard(mLock);
116 if (!mConfig.has_value() || mConnectedDevices.empty()) {
117 LOG(ERROR) << __func__ << ": failed, has config: " << mConfig.has_value()
118 << ", has connected devices: " << mConnectedDevices.empty();
119 return ::android::NO_INIT;
120 }
jiabin253bd322023-01-25 23:57:31 +0000121 }
122 if (mIsStandby) {
123 if (::android::status_t status = exitStandby(); status != ::android::OK) {
jiabinfdee3222023-03-22 22:16:13 +0000124 LOG(ERROR) << __func__ << ": failed to exit standby, status=" << status;
jiabin253bd322023-01-25 23:57:31 +0000125 return status;
126 }
127 }
128 std::vector<std::shared_ptr<alsa_device_proxy>> alsaDeviceProxies;
129 {
130 std::lock_guard guard(mLock);
131 alsaDeviceProxies = mAlsaDeviceProxies;
132 }
133 const size_t bytesToTransfer = frameCount * mFrameSizeBytes;
134 if (mIsInput) {
135 // For input case, only support single device.
136 proxy_read(alsaDeviceProxies[0].get(), buffer, bytesToTransfer);
137 } else {
138 for (auto& proxy : alsaDeviceProxies) {
139 proxy_write(proxy.get(), buffer, bytesToTransfer);
140 }
141 }
142 *actualFrameCount = frameCount;
143 *latencyMs = Module::kLatencyMs;
144 return ::android::OK;
145}
146
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700147::android::status_t StreamUsb::standby() {
jiabin253bd322023-01-25 23:57:31 +0000148 if (!mIsStandby) {
149 std::lock_guard guard(mLock);
150 mAlsaDeviceProxies.clear();
151 mIsStandby = true;
152 }
153 return ::android::OK;
154}
155
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700156void StreamUsb::shutdown() {}
157
158::android::status_t StreamUsb::exitStandby() {
jiabin253bd322023-01-25 23:57:31 +0000159 std::vector<AudioDeviceAddress> connectedDevices;
160 {
161 std::lock_guard guard(mLock);
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700162 std::transform(mConnectedDevices.begin(), mConnectedDevices.end(),
163 std::back_inserter(connectedDevices),
164 [](const auto& device) { return device.address; });
jiabin253bd322023-01-25 23:57:31 +0000165 }
166 std::vector<std::shared_ptr<alsa_device_proxy>> alsaDeviceProxies;
167 for (const auto& device : connectedDevices) {
168 alsa_device_profile profile;
jiabinfdee3222023-03-22 22:16:13 +0000169 profile_init(&profile, mIsInput ? PCM_IN : PCM_OUT);
jiabin253bd322023-01-25 23:57:31 +0000170 profile.card = device.get<AudioDeviceAddress::alsa>()[0];
171 profile.device = device.get<AudioDeviceAddress::alsa>()[1];
172 if (!profile_read_device_info(&profile)) {
173 LOG(ERROR) << __func__
174 << ": unable to read device info, device address=" << device.toString();
175 return ::android::UNKNOWN_ERROR;
176 }
177
178 auto proxy = std::shared_ptr<alsa_device_proxy>(new alsa_device_proxy(),
179 [](alsa_device_proxy* proxy) {
180 proxy_close(proxy);
181 free(proxy);
182 });
183 // Always ask for alsa configure as required since the configuration should be supported
184 // by the connected device. That is guaranteed by `setAudioPortConfig` and
185 // `setAudioPatch`.
186 if (int err =
187 proxy_prepare(proxy.get(), &profile, &mConfig.value(), true /*is_bit_perfect*/);
188 err != 0) {
189 LOG(ERROR) << __func__ << ": fail to prepare for device address=" << device.toString()
190 << " error=" << err;
191 return ::android::UNKNOWN_ERROR;
192 }
jiabinfdee3222023-03-22 22:16:13 +0000193 if (int err = proxy_open(proxy.get()); err != 0) {
194 LOG(ERROR) << __func__ << ": failed to open device, address=" << device.toString()
195 << " error=" << err;
196 return ::android::UNKNOWN_ERROR;
197 }
jiabin253bd322023-01-25 23:57:31 +0000198 alsaDeviceProxies.push_back(std::move(proxy));
199 }
200 {
201 std::lock_guard guard(mLock);
202 mAlsaDeviceProxies = alsaDeviceProxies;
203 }
204 mIsStandby = false;
205 return ::android::OK;
206}
207
jiabin253bd322023-01-25 23:57:31 +0000208StreamInUsb::StreamInUsb(const SinkMetadata& sinkMetadata, StreamContext&& context,
209 const std::vector<MicrophoneInfo>& microphones)
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700210 : StreamUsb(sinkMetadata, std::move(context)), StreamIn(microphones) {}
jiabin253bd322023-01-25 23:57:31 +0000211
212ndk::ScopedAStatus StreamInUsb::getActiveMicrophones(
213 std::vector<MicrophoneDynamicInfo>* _aidl_return __unused) {
214 LOG(DEBUG) << __func__ << ": not supported";
215 return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
216}
217
jiabin253bd322023-01-25 23:57:31 +0000218StreamOutUsb::StreamOutUsb(const SourceMetadata& sourceMetadata, StreamContext&& context,
219 const std::optional<AudioOffloadInfo>& offloadInfo)
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700220 : StreamUsb(sourceMetadata, std::move(context)), StreamOut(offloadInfo) {
221 mChannelCount = getChannelCount(getContext().getChannelLayout());
jiabin783c48b2023-02-28 18:28:06 +0000222}
223
224ndk::ScopedAStatus StreamOutUsb::getHwVolume(std::vector<float>* _aidl_return) {
225 *_aidl_return = mHwVolumes;
226 return ndk::ScopedAStatus::ok();
227}
228
229ndk::ScopedAStatus StreamOutUsb::setHwVolume(const std::vector<float>& in_channelVolumes) {
Mikhail Naganovd5554cf2023-06-21 15:20:31 -0700230 for (const auto& device : getConnectedDevices()) {
jiabin783c48b2023-02-28 18:28:06 +0000231 if (device.address.getTag() != AudioDeviceAddress::alsa) {
232 LOG(DEBUG) << __func__ << ": skip as the device address is not alsa";
233 continue;
234 }
235 const int card = device.address.get<AudioDeviceAddress::alsa>()[0];
236 if (auto result =
237 usb::UsbAlsaMixerControl::getInstance().setVolumes(card, in_channelVolumes);
238 !result.isOk()) {
239 LOG(ERROR) << __func__ << ": failed to set volume for device, card=" << card;
240 return result;
241 }
242 }
243 mHwVolumes = in_channelVolumes;
244 return ndk::ScopedAStatus::ok();
245}
jiabin253bd322023-01-25 23:57:31 +0000246
Mikhail Naganov6725ef52023-02-09 17:52:50 -0800247} // namespace aidl::android::hardware::audio::core