blob: 88e7396130671093858057fbcac5755f222e81e8 [file] [log] [blame]
Marco Nelissen3a34bef2011-08-02 13:33:41 -07001/*
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18#define LOG_TAG "IAudioFlinger"
Eric Laurentc2f1f072009-07-17 12:17:14 -070019//#define LOG_NDEBUG 0
Jiabin Huangebe64102021-09-07 20:01:07 +000020
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080021#include <utils/Log.h>
22
23#include <stdint.h>
24#include <sys/types.h>
25
Eric Laurentb1cc36b2017-12-11 12:14:16 -080026#include <binder/IPCThreadState.h>
Mathias Agopian75624082009-05-19 19:08:10 -070027#include <binder/Parcel.h>
Steven Moreland25a9e552017-04-17 14:30:39 -070028#include "IAudioFlinger.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080029
30namespace android {
31
Andy Hung1131b6e2020-12-08 20:47:45 -080032using aidl_utils::statusTFromBinderStatus;
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -080033using binder::Status;
Mikhail Naganov57bd06f2021-08-10 16:41:54 -070034using media::audio::common::AudioChannelLayout;
35using media::audio::common::AudioFormatDescription;
jiabine99d0882021-09-17 05:21:25 +000036using media::audio::common::AudioMMapPolicyInfo;
37using media::audio::common::AudioMMapPolicyType;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070038using media::audio::common::AudioMode;
Mikhail Naganovdbf03642021-08-25 18:15:32 -070039using media::audio::common::AudioStreamType;
Mikhail Naganovddceecc2021-09-03 13:58:56 -070040using media::audio::common::AudioUuid;
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -080041
Eric Laurentf75c2fe2015-04-02 13:49:15 -070042#define MAX_ITEMS_PER_LIST 1024
43
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -080044#define VALUE_OR_RETURN_BINDER(x) \
45 ({ \
46 auto _tmp = (x); \
47 if (!_tmp.ok()) return Status::fromStatusT(_tmp.error()); \
48 std::move(_tmp.value()); \
49 })
50
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -080051#define RETURN_BINDER_IF_ERROR(x) \
52 { \
53 auto _tmp = (x); \
54 if (_tmp != OK) return Status::fromStatusT(_tmp); \
55 }
56
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080057ConversionResult<media::CreateTrackRequest> IAudioFlinger::CreateTrackInput::toAidl() const {
58 media::CreateTrackRequest aidl;
59 aidl.attr = VALUE_OR_RETURN(legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
Mikhail Naganovde3fa182021-07-30 15:06:42 -070060 // Do not be mislead by 'Input'--this is an input to 'createTrack', which creates output tracks.
61 aidl.config = VALUE_OR_RETURN(legacy2aidl_audio_config_t_AudioConfig(
62 config, false /*isInput*/));
Andy Hung973638a2020-12-08 20:47:45 -080063 aidl.clientInfo = VALUE_OR_RETURN(legacy2aidl_AudioClient_AudioClient(clientInfo));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080064 aidl.sharedBuffer = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(sharedBuffer));
65 aidl.notificationsPerBuffer = VALUE_OR_RETURN(convertIntegral<int32_t>(notificationsPerBuffer));
66 aidl.speed = speed;
67 aidl.audioTrackCallback = audioTrackCallback;
Andy Hung973638a2020-12-08 20:47:45 -080068 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080069 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
70 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
71 aidl.selectedDeviceId = VALUE_OR_RETURN(
72 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
73 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
74 return aidl;
75}
76
77ConversionResult<IAudioFlinger::CreateTrackInput>
78IAudioFlinger::CreateTrackInput::fromAidl(const media::CreateTrackRequest& aidl) {
79 IAudioFlinger::CreateTrackInput legacy;
80 legacy.attr = VALUE_OR_RETURN(aidl2legacy_AudioAttributesInternal_audio_attributes_t(aidl.attr));
Mikhail Naganovde3fa182021-07-30 15:06:42 -070081 // Do not be mislead by 'Input'--this is an input to 'createTrack', which creates output tracks.
82 legacy.config = VALUE_OR_RETURN(
83 aidl2legacy_AudioConfig_audio_config_t(aidl.config, false /*isInput*/));
Andy Hung973638a2020-12-08 20:47:45 -080084 legacy.clientInfo = VALUE_OR_RETURN(aidl2legacy_AudioClient_AudioClient(aidl.clientInfo));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080085 legacy.sharedBuffer = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.sharedBuffer));
86 legacy.notificationsPerBuffer = VALUE_OR_RETURN(
87 convertIntegral<uint32_t>(aidl.notificationsPerBuffer));
88 legacy.speed = aidl.speed;
89 legacy.audioTrackCallback = aidl.audioTrackCallback;
Andy Hung973638a2020-12-08 20:47:45 -080090 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_output_flags_t_mask(aidl.flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -080091 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
92 legacy.notificationFrameCount = VALUE_OR_RETURN(
93 convertIntegral<size_t>(aidl.notificationFrameCount));
94 legacy.selectedDeviceId = VALUE_OR_RETURN(
95 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
96 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
97 return legacy;
98}
99
100ConversionResult<media::CreateTrackResponse>
101IAudioFlinger::CreateTrackOutput::toAidl() const {
102 media::CreateTrackResponse aidl;
Andy Hung973638a2020-12-08 20:47:45 -0800103 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800104 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
105 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
106 aidl.selectedDeviceId = VALUE_OR_RETURN(
107 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
108 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
109 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));
Andy Hunga2159aa2021-07-20 13:01:52 -0700110 aidl.streamType = VALUE_OR_RETURN(
111 legacy2aidl_audio_stream_type_t_AudioStreamType(streamType));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800112 aidl.afFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(afFrameCount));
113 aidl.afSampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(afSampleRate));
114 aidl.afLatencyMs = VALUE_OR_RETURN(convertIntegral<int32_t>(afLatencyMs));
115 aidl.outputId = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(outputId));
116 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(portId));
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -0800117 aidl.audioTrack = audioTrack;
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800118 return aidl;
119}
120
121ConversionResult<IAudioFlinger::CreateTrackOutput>
122IAudioFlinger::CreateTrackOutput::fromAidl(
123 const media::CreateTrackResponse& aidl) {
124 IAudioFlinger::CreateTrackOutput legacy;
Andy Hung973638a2020-12-08 20:47:45 -0800125 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_output_flags_t_mask(aidl.flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800126 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
127 legacy.notificationFrameCount = VALUE_OR_RETURN(
128 convertIntegral<size_t>(aidl.notificationFrameCount));
129 legacy.selectedDeviceId = VALUE_OR_RETURN(
130 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
131 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
132 legacy.sampleRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
Andy Hunga2159aa2021-07-20 13:01:52 -0700133 legacy.streamType = VALUE_OR_RETURN(
134 aidl2legacy_AudioStreamType_audio_stream_type_t(aidl.streamType));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800135 legacy.afFrameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.afFrameCount));
136 legacy.afSampleRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.afSampleRate));
137 legacy.afLatencyMs = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.afLatencyMs));
138 legacy.outputId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.outputId));
139 legacy.portId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -0800140 legacy.audioTrack = aidl.audioTrack;
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800141 return legacy;
142}
143
144ConversionResult<media::CreateRecordRequest>
145IAudioFlinger::CreateRecordInput::toAidl() const {
146 media::CreateRecordRequest aidl;
147 aidl.attr = VALUE_OR_RETURN(legacy2aidl_audio_attributes_t_AudioAttributesInternal(attr));
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700148 aidl.config = VALUE_OR_RETURN(
149 legacy2aidl_audio_config_base_t_AudioConfigBase(config, true /*isInput*/));
Andy Hung973638a2020-12-08 20:47:45 -0800150 aidl.clientInfo = VALUE_OR_RETURN(legacy2aidl_AudioClient_AudioClient(clientInfo));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800151 aidl.riid = VALUE_OR_RETURN(legacy2aidl_audio_unique_id_t_int32_t(riid));
Eric Laurentec376dc2021-04-08 20:41:22 +0200152 aidl.maxSharedAudioHistoryMs = VALUE_OR_RETURN(
153 convertIntegral<int32_t>(maxSharedAudioHistoryMs));
Andy Hung973638a2020-12-08 20:47:45 -0800154 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800155 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
156 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
157 aidl.selectedDeviceId = VALUE_OR_RETURN(
158 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
159 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
160 return aidl;
161}
162
163ConversionResult<IAudioFlinger::CreateRecordInput>
164IAudioFlinger::CreateRecordInput::fromAidl(
165 const media::CreateRecordRequest& aidl) {
166 IAudioFlinger::CreateRecordInput legacy;
Eric Laurentec376dc2021-04-08 20:41:22 +0200167 legacy.attr = VALUE_OR_RETURN(
168 aidl2legacy_AudioAttributesInternal_audio_attributes_t(aidl.attr));
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700169 legacy.config = VALUE_OR_RETURN(
170 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.config, true /*isInput*/));
Andy Hung973638a2020-12-08 20:47:45 -0800171 legacy.clientInfo = VALUE_OR_RETURN(aidl2legacy_AudioClient_AudioClient(aidl.clientInfo));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800172 legacy.riid = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_unique_id_t(aidl.riid));
Eric Laurentec376dc2021-04-08 20:41:22 +0200173 legacy.maxSharedAudioHistoryMs = VALUE_OR_RETURN(
174 convertIntegral<int32_t>(aidl.maxSharedAudioHistoryMs));
Andy Hung973638a2020-12-08 20:47:45 -0800175 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_input_flags_t_mask(aidl.flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800176 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
177 legacy.notificationFrameCount = VALUE_OR_RETURN(
178 convertIntegral<size_t>(aidl.notificationFrameCount));
179 legacy.selectedDeviceId = VALUE_OR_RETURN(
180 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
181 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
182 return legacy;
183}
184
185ConversionResult<media::CreateRecordResponse>
186IAudioFlinger::CreateRecordOutput::toAidl() const {
187 media::CreateRecordResponse aidl;
Andy Hung973638a2020-12-08 20:47:45 -0800188 aidl.flags = VALUE_OR_RETURN(legacy2aidl_audio_input_flags_t_int32_t_mask(flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800189 aidl.frameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(frameCount));
190 aidl.notificationFrameCount = VALUE_OR_RETURN(convertIntegral<int64_t>(notificationFrameCount));
191 aidl.selectedDeviceId = VALUE_OR_RETURN(
192 legacy2aidl_audio_port_handle_t_int32_t(selectedDeviceId));
193 aidl.sessionId = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
194 aidl.sampleRate = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));
195 aidl.inputId = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(inputId));
196 aidl.cblk = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(cblk));
197 aidl.buffers = VALUE_OR_RETURN(legacy2aidl_NullableIMemory_SharedFileRegion(buffers));
198 aidl.portId = VALUE_OR_RETURN(legacy2aidl_audio_port_handle_t_int32_t(portId));
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -0800199 aidl.audioRecord = audioRecord;
jiabinb00edc32021-08-16 16:27:54 +0000200 aidl.serverConfig = VALUE_OR_RETURN(
201 legacy2aidl_audio_config_base_t_AudioConfigBase(serverConfig, true /*isInput*/));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800202 return aidl;
203}
204
205ConversionResult<IAudioFlinger::CreateRecordOutput>
206IAudioFlinger::CreateRecordOutput::fromAidl(
207 const media::CreateRecordResponse& aidl) {
208 IAudioFlinger::CreateRecordOutput legacy;
Andy Hung973638a2020-12-08 20:47:45 -0800209 legacy.flags = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_input_flags_t_mask(aidl.flags));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800210 legacy.frameCount = VALUE_OR_RETURN(convertIntegral<size_t>(aidl.frameCount));
211 legacy.notificationFrameCount = VALUE_OR_RETURN(
212 convertIntegral<size_t>(aidl.notificationFrameCount));
213 legacy.selectedDeviceId = VALUE_OR_RETURN(
214 aidl2legacy_int32_t_audio_port_handle_t(aidl.selectedDeviceId));
215 legacy.sessionId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_session_t(aidl.sessionId));
216 legacy.sampleRate = VALUE_OR_RETURN(convertIntegral<uint32_t>(aidl.sampleRate));
217 legacy.inputId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_io_handle_t(aidl.inputId));
218 legacy.cblk = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.cblk));
219 legacy.buffers = VALUE_OR_RETURN(aidl2legacy_NullableSharedFileRegion_IMemory(aidl.buffers));
220 legacy.portId = VALUE_OR_RETURN(aidl2legacy_int32_t_audio_port_handle_t(aidl.portId));
Ytai Ben-Tsvi16d87612020-11-03 16:32:36 -0800221 legacy.audioRecord = aidl.audioRecord;
jiabinb00edc32021-08-16 16:27:54 +0000222 legacy.serverConfig = VALUE_OR_RETURN(
223 aidl2legacy_AudioConfigBase_audio_config_base_t(aidl.serverConfig, true /*isInput*/));
Ytai Ben-Tsvi4dfeb622020-11-02 12:47:30 -0800224 return legacy;
225}
Eric Laurent42896a02019-09-27 15:40:33 -0700226
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800227////////////////////////////////////////////////////////////////////////////////////////////////////
228// AudioFlingerClientAdapter
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800229
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800230AudioFlingerClientAdapter::AudioFlingerClientAdapter(
231 const sp<media::IAudioFlingerService> delegate) : mDelegate(delegate) {}
Eric Laurent21da6472017-11-09 16:29:26 -0800232
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800233status_t AudioFlingerClientAdapter::createTrack(const media::CreateTrackRequest& input,
234 media::CreateTrackResponse& output) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800235 return statusTFromBinderStatus(mDelegate->createTrack(input, &output));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800236}
237
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800238status_t AudioFlingerClientAdapter::createRecord(const media::CreateRecordRequest& input,
239 media::CreateRecordResponse& output) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800240 return statusTFromBinderStatus(mDelegate->createRecord(input, &output));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800241}
242
243uint32_t AudioFlingerClientAdapter::sampleRate(audio_io_handle_t ioHandle) const {
244 auto result = [&]() -> ConversionResult<uint32_t> {
245 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
246 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800247 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->sampleRate(ioHandleAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800248 return convertIntegral<uint32_t>(aidlRet);
249 }();
250 // Failure is ignored.
251 return result.value_or(0);
252}
253
254audio_format_t AudioFlingerClientAdapter::format(audio_io_handle_t output) const {
255 auto result = [&]() -> ConversionResult<audio_format_t> {
256 int32_t outputAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output));
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700257 AudioFormatDescription aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800258 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->format(outputAidl, &aidlRet)));
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -0700259 return aidl2legacy_AudioFormatDescription_audio_format_t(aidlRet);
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800260 }();
261 return result.value_or(AUDIO_FORMAT_INVALID);
262}
263
264size_t AudioFlingerClientAdapter::frameCount(audio_io_handle_t ioHandle) const {
265 auto result = [&]() -> ConversionResult<size_t> {
266 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
267 int64_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800268 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->frameCount(ioHandleAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800269 return convertIntegral<size_t>(aidlRet);
270 }();
271 // Failure is ignored.
272 return result.value_or(0);
273}
274
275uint32_t AudioFlingerClientAdapter::latency(audio_io_handle_t output) const {
276 auto result = [&]() -> ConversionResult<uint32_t> {
277 int32_t outputAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output));
278 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800279 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->latency(outputAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800280 return convertIntegral<uint32_t>(aidlRet);
281 }();
282 // Failure is ignored.
283 return result.value_or(0);
284}
285
286status_t AudioFlingerClientAdapter::setMasterVolume(float value) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800287 return statusTFromBinderStatus(mDelegate->setMasterVolume(value));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800288}
289
290status_t AudioFlingerClientAdapter::setMasterMute(bool muted) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800291 return statusTFromBinderStatus(mDelegate->setMasterMute(muted));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800292}
293
294float AudioFlingerClientAdapter::masterVolume() const {
295 auto result = [&]() -> ConversionResult<float> {
296 float aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800297 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->masterVolume(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800298 return aidlRet;
299 }();
300 // Failure is ignored.
301 return result.value_or(0.f);
302}
303
304bool AudioFlingerClientAdapter::masterMute() const {
305 auto result = [&]() -> ConversionResult<bool> {
306 bool aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800307 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->masterMute(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800308 return aidlRet;
309 }();
310 // Failure is ignored.
311 return result.value_or(false);
312}
313
314status_t AudioFlingerClientAdapter::setMasterBalance(float balance) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800315 return statusTFromBinderStatus(mDelegate->setMasterBalance(balance));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800316}
317
318status_t AudioFlingerClientAdapter::getMasterBalance(float* balance) const{
Andy Hung1131b6e2020-12-08 20:47:45 -0800319 return statusTFromBinderStatus(mDelegate->getMasterBalance(balance));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800320}
321
322status_t AudioFlingerClientAdapter::setStreamVolume(audio_stream_type_t stream, float value,
323 audio_io_handle_t output) {
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700324 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800325 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
326 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Andy Hung1131b6e2020-12-08 20:47:45 -0800327 return statusTFromBinderStatus(mDelegate->setStreamVolume(streamAidl, value, outputAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800328}
329
330status_t AudioFlingerClientAdapter::setStreamMute(audio_stream_type_t stream, bool muted) {
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700331 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800332 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
Andy Hung1131b6e2020-12-08 20:47:45 -0800333 return statusTFromBinderStatus(mDelegate->setStreamMute(streamAidl, muted));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800334}
335
336float AudioFlingerClientAdapter::streamVolume(audio_stream_type_t stream,
337 audio_io_handle_t output) const {
338 auto result = [&]() -> ConversionResult<float> {
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700339 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800340 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
341 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
342 float aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800343 RETURN_IF_ERROR(statusTFromBinderStatus(
344 mDelegate->streamVolume(streamAidl, outputAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800345 return aidlRet;
346 }();
347 // Failure is ignored.
348 return result.value_or(0.f);
349}
350
351bool AudioFlingerClientAdapter::streamMute(audio_stream_type_t stream) const {
352 auto result = [&]() -> ConversionResult<bool> {
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700353 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800354 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
355 bool aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800356 RETURN_IF_ERROR(statusTFromBinderStatus(
357 mDelegate->streamMute(streamAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800358 return aidlRet;
359 }();
360 // Failure is ignored.
361 return result.value_or(false);
362}
363
364status_t AudioFlingerClientAdapter::setMode(audio_mode_t mode) {
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700365 AudioMode modeAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_mode_t_AudioMode(mode));
Andy Hung1131b6e2020-12-08 20:47:45 -0800366 return statusTFromBinderStatus(mDelegate->setMode(modeAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800367}
368
369status_t AudioFlingerClientAdapter::setMicMute(bool state) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800370 return statusTFromBinderStatus(mDelegate->setMicMute(state));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800371}
372
373bool AudioFlingerClientAdapter::getMicMute() const {
374 auto result = [&]() -> ConversionResult<bool> {
375 bool aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800376 RETURN_IF_ERROR(statusTFromBinderStatus(
377 mDelegate->getMicMute(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800378 return aidlRet;
379 }();
380 // Failure is ignored.
381 return result.value_or(false);
382}
383
384void AudioFlingerClientAdapter::setRecordSilenced(audio_port_handle_t portId, bool silenced) {
385 auto result = [&]() -> status_t {
386 int32_t portIdAidl = VALUE_OR_RETURN_STATUS(
387 legacy2aidl_audio_port_handle_t_int32_t(portId));
Andy Hung1131b6e2020-12-08 20:47:45 -0800388 return statusTFromBinderStatus(mDelegate->setRecordSilenced(portIdAidl, silenced));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800389 }();
390 // Failure is ignored.
391 (void) result;
392}
393
394status_t AudioFlingerClientAdapter::setParameters(audio_io_handle_t ioHandle,
395 const String8& keyValuePairs) {
396 int32_t ioHandleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
397 std::string keyValuePairsAidl = VALUE_OR_RETURN_STATUS(
398 legacy2aidl_String8_string(keyValuePairs));
Andy Hung1131b6e2020-12-08 20:47:45 -0800399 return statusTFromBinderStatus(mDelegate->setParameters(ioHandleAidl, keyValuePairsAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800400}
401
402String8 AudioFlingerClientAdapter::getParameters(audio_io_handle_t ioHandle, const String8& keys)
403const {
404 auto result = [&]() -> ConversionResult<String8> {
405 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
406 std::string keysAidl = VALUE_OR_RETURN(legacy2aidl_String8_string(keys));
407 std::string aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800408 RETURN_IF_ERROR(statusTFromBinderStatus(
409 mDelegate->getParameters(ioHandleAidl, keysAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800410 return aidl2legacy_string_view_String8(aidlRet);
411 }();
412 // Failure is ignored.
413 return result.value_or(String8());
414}
415
416void AudioFlingerClientAdapter::registerClient(const sp<media::IAudioFlingerClient>& client) {
417 mDelegate->registerClient(client);
418 // Failure is ignored.
419}
420
421size_t AudioFlingerClientAdapter::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
422 audio_channel_mask_t channelMask) const {
423 auto result = [&]() -> ConversionResult<size_t> {
424 int32_t sampleRateAidl = VALUE_OR_RETURN(convertIntegral<int32_t>(sampleRate));
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700425 AudioFormatDescription formatAidl = VALUE_OR_RETURN(
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -0700426 legacy2aidl_audio_format_t_AudioFormatDescription(format));
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700427 AudioChannelLayout channelMaskAidl = VALUE_OR_RETURN(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700428 legacy2aidl_audio_channel_mask_t_AudioChannelLayout(channelMask, true /*isInput*/));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800429 int64_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800430 RETURN_IF_ERROR(statusTFromBinderStatus(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800431 mDelegate->getInputBufferSize(sampleRateAidl, formatAidl, channelMaskAidl,
Andy Hung1131b6e2020-12-08 20:47:45 -0800432 &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800433 return convertIntegral<size_t>(aidlRet);
434 }();
435 // Failure is ignored.
436 return result.value_or(0);
437}
438
439status_t AudioFlingerClientAdapter::openOutput(const media::OpenOutputRequest& request,
440 media::OpenOutputResponse* response) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800441 return statusTFromBinderStatus(mDelegate->openOutput(request, response));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800442}
443
444audio_io_handle_t AudioFlingerClientAdapter::openDuplicateOutput(audio_io_handle_t output1,
445 audio_io_handle_t output2) {
446 auto result = [&]() -> ConversionResult<audio_io_handle_t> {
447 int32_t output1Aidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output1));
448 int32_t output2Aidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(output2));
449 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800450 RETURN_IF_ERROR(statusTFromBinderStatus(
451 mDelegate->openDuplicateOutput(output1Aidl, output2Aidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800452 return aidl2legacy_int32_t_audio_io_handle_t(aidlRet);
453 }();
454 // Failure is ignored.
455 return result.value_or(0);
456}
457
458status_t AudioFlingerClientAdapter::closeOutput(audio_io_handle_t output) {
459 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Andy Hung1131b6e2020-12-08 20:47:45 -0800460 return statusTFromBinderStatus(mDelegate->closeOutput(outputAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800461}
462
463status_t AudioFlingerClientAdapter::suspendOutput(audio_io_handle_t output) {
464 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Andy Hung1131b6e2020-12-08 20:47:45 -0800465 return statusTFromBinderStatus(mDelegate->suspendOutput(outputAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800466}
467
468status_t AudioFlingerClientAdapter::restoreOutput(audio_io_handle_t output) {
469 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
Andy Hung1131b6e2020-12-08 20:47:45 -0800470 return statusTFromBinderStatus(mDelegate->restoreOutput(outputAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800471}
472
473status_t AudioFlingerClientAdapter::openInput(const media::OpenInputRequest& request,
474 media::OpenInputResponse* response) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800475 return statusTFromBinderStatus(mDelegate->openInput(request, response));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800476}
477
478status_t AudioFlingerClientAdapter::closeInput(audio_io_handle_t input) {
479 int32_t inputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(input));
Andy Hung1131b6e2020-12-08 20:47:45 -0800480 return statusTFromBinderStatus(mDelegate->closeInput(inputAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800481}
482
483status_t AudioFlingerClientAdapter::invalidateStream(audio_stream_type_t stream) {
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700484 AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800485 legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
Andy Hung1131b6e2020-12-08 20:47:45 -0800486 return statusTFromBinderStatus(mDelegate->invalidateStream(streamAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800487}
488
489status_t AudioFlingerClientAdapter::setVoiceVolume(float volume) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800490 return statusTFromBinderStatus(mDelegate->setVoiceVolume(volume));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800491}
492
493status_t AudioFlingerClientAdapter::getRenderPosition(uint32_t* halFrames, uint32_t* dspFrames,
494 audio_io_handle_t output) const {
495 int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
496 media::RenderPosition aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800497 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
498 mDelegate->getRenderPosition(outputAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800499 if (halFrames != nullptr) {
500 *halFrames = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(aidlRet.halFrames));
501 }
502 if (dspFrames != nullptr) {
503 *dspFrames = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(aidlRet.dspFrames));
504 }
505 return OK;
506}
507
508uint32_t AudioFlingerClientAdapter::getInputFramesLost(audio_io_handle_t ioHandle) const {
509 auto result = [&]() -> ConversionResult<uint32_t> {
510 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
511 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800512 RETURN_IF_ERROR(statusTFromBinderStatus(
513 mDelegate->getInputFramesLost(ioHandleAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800514 return convertIntegral<uint32_t>(aidlRet);
515 }();
516 // Failure is ignored.
517 return result.value_or(0);
518}
519
520audio_unique_id_t AudioFlingerClientAdapter::newAudioUniqueId(audio_unique_id_use_t use) {
521 auto result = [&]() -> ConversionResult<audio_unique_id_t> {
522 media::AudioUniqueIdUse useAidl = VALUE_OR_RETURN(
523 legacy2aidl_audio_unique_id_use_t_AudioUniqueIdUse(use));
524 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800525 RETURN_IF_ERROR(statusTFromBinderStatus(
526 mDelegate->newAudioUniqueId(useAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800527 return aidl2legacy_int32_t_audio_unique_id_t(aidlRet);
528 }();
529 return result.value_or(AUDIO_UNIQUE_ID_ALLOCATE);
530}
531
532void AudioFlingerClientAdapter::acquireAudioSessionId(audio_session_t audioSession, pid_t pid,
533 uid_t uid) {
534 [&]() -> status_t {
535 int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(
536 legacy2aidl_audio_session_t_int32_t(audioSession));
537 int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
538 int32_t uidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(uid));
Andy Hung1131b6e2020-12-08 20:47:45 -0800539 return statusTFromBinderStatus(
540 mDelegate->acquireAudioSessionId(audioSessionAidl, pidAidl, uidAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800541 }();
542 // Failure is ignored.
543}
544
545void AudioFlingerClientAdapter::releaseAudioSessionId(audio_session_t audioSession, pid_t pid) {
546 [&]() -> status_t {
547 int32_t audioSessionAidl = VALUE_OR_RETURN_STATUS(
548 legacy2aidl_audio_session_t_int32_t(audioSession));
549 int32_t pidAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_pid_t_int32_t(pid));
Andy Hung1131b6e2020-12-08 20:47:45 -0800550 return statusTFromBinderStatus(
551 mDelegate->releaseAudioSessionId(audioSessionAidl, pidAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800552 }();
553 // Failure is ignored.
554}
555
556status_t AudioFlingerClientAdapter::queryNumberEffects(uint32_t* numEffects) const {
557 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800558 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
559 mDelegate->queryNumberEffects(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800560 if (numEffects != nullptr) {
561 *numEffects = VALUE_OR_RETURN_STATUS(convertIntegral<uint32_t>(aidlRet));
562 }
563 return OK;
564}
565
566status_t
567AudioFlingerClientAdapter::queryEffect(uint32_t index, effect_descriptor_t* pDescriptor) const {
568 int32_t indexAidl = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(index));
569 media::EffectDescriptor aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800570 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
571 mDelegate->queryEffect(indexAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800572 if (pDescriptor != nullptr) {
573 *pDescriptor = VALUE_OR_RETURN_STATUS(
574 aidl2legacy_EffectDescriptor_effect_descriptor_t(aidlRet));
575 }
576 return OK;
577}
578
579status_t AudioFlingerClientAdapter::getEffectDescriptor(const effect_uuid_t* pEffectUUID,
580 const effect_uuid_t* pTypeUUID,
581 uint32_t preferredTypeFlag,
582 effect_descriptor_t* pDescriptor) const {
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700583 AudioUuid effectUuidAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800584 legacy2aidl_audio_uuid_t_AudioUuid(*pEffectUUID));
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700585 AudioUuid typeUuidAidl = VALUE_OR_RETURN_STATUS(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800586 legacy2aidl_audio_uuid_t_AudioUuid(*pTypeUUID));
587 int32_t preferredTypeFlagAidl = VALUE_OR_RETURN_STATUS(
588 convertReinterpret<int32_t>(preferredTypeFlag));
589 media::EffectDescriptor aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800590 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800591 mDelegate->getEffectDescriptor(effectUuidAidl, typeUuidAidl, preferredTypeFlagAidl,
Andy Hung1131b6e2020-12-08 20:47:45 -0800592 &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800593 if (pDescriptor != nullptr) {
594 *pDescriptor = VALUE_OR_RETURN_STATUS(
595 aidl2legacy_EffectDescriptor_effect_descriptor_t(aidlRet));
596 }
597 return OK;
598}
599
600status_t AudioFlingerClientAdapter::createEffect(const media::CreateEffectRequest& request,
601 media::CreateEffectResponse* response) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800602 return statusTFromBinderStatus(mDelegate->createEffect(request, response));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800603}
604
605status_t
606AudioFlingerClientAdapter::moveEffects(audio_session_t session, audio_io_handle_t srcOutput,
607 audio_io_handle_t dstOutput) {
608 int32_t sessionAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_session_t_int32_t(session));
609 int32_t srcOutputAidl = VALUE_OR_RETURN_STATUS(
610 legacy2aidl_audio_io_handle_t_int32_t(srcOutput));
611 int32_t dstOutputAidl = VALUE_OR_RETURN_STATUS(
612 legacy2aidl_audio_io_handle_t_int32_t(dstOutput));
Andy Hung1131b6e2020-12-08 20:47:45 -0800613 return statusTFromBinderStatus(
614 mDelegate->moveEffects(sessionAidl, srcOutputAidl, dstOutputAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800615}
616
617void AudioFlingerClientAdapter::setEffectSuspended(int effectId,
618 audio_session_t sessionId,
619 bool suspended) {
620 [&]() -> status_t {
621 int32_t effectIdAidl = VALUE_OR_RETURN_STATUS(convertReinterpret<int32_t>(effectId));
622 int32_t sessionIdAidl = VALUE_OR_RETURN_STATUS(
623 legacy2aidl_audio_session_t_int32_t(sessionId));
Andy Hung1131b6e2020-12-08 20:47:45 -0800624 return statusTFromBinderStatus(
625 mDelegate->setEffectSuspended(effectIdAidl, sessionIdAidl, suspended));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800626 }();
627 // Failure is ignored.
628}
629
630audio_module_handle_t AudioFlingerClientAdapter::loadHwModule(const char* name) {
631 auto result = [&]() -> ConversionResult<audio_module_handle_t> {
632 std::string nameAidl(name);
633 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800634 RETURN_IF_ERROR(statusTFromBinderStatus(
635 mDelegate->loadHwModule(nameAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800636 return aidl2legacy_int32_t_audio_module_handle_t(aidlRet);
637 }();
638 // Failure is ignored.
639 return result.value_or(0);
640}
641
642uint32_t AudioFlingerClientAdapter::getPrimaryOutputSamplingRate() {
643 auto result = [&]() -> ConversionResult<uint32_t> {
644 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800645 RETURN_IF_ERROR(statusTFromBinderStatus(
646 mDelegate->getPrimaryOutputSamplingRate(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800647 return convertIntegral<uint32_t>(aidlRet);
648 }();
649 // Failure is ignored.
650 return result.value_or(0);
651}
652
653size_t AudioFlingerClientAdapter::getPrimaryOutputFrameCount() {
654 auto result = [&]() -> ConversionResult<size_t> {
655 int64_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800656 RETURN_IF_ERROR(statusTFromBinderStatus(
657 mDelegate->getPrimaryOutputFrameCount(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800658 return convertIntegral<size_t>(aidlRet);
659 }();
660 // Failure is ignored.
661 return result.value_or(0);
662}
663
664status_t AudioFlingerClientAdapter::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
Andy Hung1131b6e2020-12-08 20:47:45 -0800665 return statusTFromBinderStatus(mDelegate->setLowRamDevice(isLowRamDevice, totalMemory));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800666}
667
668status_t AudioFlingerClientAdapter::getAudioPort(struct audio_port_v7* port) {
669 media::AudioPort portAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_port_v7_AudioPort(*port));
670 media::AudioPort aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800671 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
672 mDelegate->getAudioPort(portAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800673 *port = VALUE_OR_RETURN_STATUS(aidl2legacy_AudioPort_audio_port_v7(aidlRet));
674 return OK;
675}
676
677status_t AudioFlingerClientAdapter::createAudioPatch(const struct audio_patch* patch,
678 audio_patch_handle_t* handle) {
679 media::AudioPatch patchAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_AudioPatch(*patch));
Kuowei Li247a3672021-07-21 21:46:07 +0800680 int32_t aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(
681 AUDIO_PATCH_HANDLE_NONE));
682 if (handle != nullptr) {
683 aidlRet = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(*handle));
684 }
Andy Hung1131b6e2020-12-08 20:47:45 -0800685 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
686 mDelegate->createAudioPatch(patchAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800687 if (handle != nullptr) {
688 *handle = VALUE_OR_RETURN_STATUS(aidl2legacy_int32_t_audio_patch_handle_t(aidlRet));
689 }
690 return OK;
691}
692
693status_t AudioFlingerClientAdapter::releaseAudioPatch(audio_patch_handle_t handle) {
694 int32_t handleAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_patch_handle_t_int32_t(handle));
Andy Hung1131b6e2020-12-08 20:47:45 -0800695 return statusTFromBinderStatus(mDelegate->releaseAudioPatch(handleAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800696}
697
698status_t AudioFlingerClientAdapter::listAudioPatches(unsigned int* num_patches,
699 struct audio_patch* patches) {
700 std::vector<media::AudioPatch> aidlRet;
701 int32_t maxPatches = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(*num_patches));
Andy Hung1131b6e2020-12-08 20:47:45 -0800702 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
703 mDelegate->listAudioPatches(maxPatches, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800704 *num_patches = VALUE_OR_RETURN_STATUS(convertIntegral<unsigned int>(aidlRet.size()));
705 return convertRange(aidlRet.begin(), aidlRet.end(), patches,
706 aidl2legacy_AudioPatch_audio_patch);
707}
708
709status_t AudioFlingerClientAdapter::setAudioPortConfig(const struct audio_port_config* config) {
710 media::AudioPortConfig configAidl = VALUE_OR_RETURN_STATUS(
711 legacy2aidl_audio_port_config_AudioPortConfig(*config));
Andy Hung1131b6e2020-12-08 20:47:45 -0800712 return statusTFromBinderStatus(mDelegate->setAudioPortConfig(configAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800713}
714
715audio_hw_sync_t AudioFlingerClientAdapter::getAudioHwSyncForSession(audio_session_t sessionId) {
716 auto result = [&]() -> ConversionResult<audio_hw_sync_t> {
717 int32_t sessionIdAidl = VALUE_OR_RETURN(legacy2aidl_audio_session_t_int32_t(sessionId));
718 int32_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800719 RETURN_IF_ERROR(statusTFromBinderStatus(
720 mDelegate->getAudioHwSyncForSession(sessionIdAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800721 return aidl2legacy_int32_t_audio_hw_sync_t(aidlRet);
722 }();
723 return result.value_or(AUDIO_HW_SYNC_INVALID);
724}
725
726status_t AudioFlingerClientAdapter::systemReady() {
Andy Hung1131b6e2020-12-08 20:47:45 -0800727 return statusTFromBinderStatus(mDelegate->systemReady());
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800728}
729
Eric Laurentd66d7a12021-07-13 13:35:32 +0200730status_t AudioFlingerClientAdapter::audioPolicyReady() {
731 return statusTFromBinderStatus(mDelegate->audioPolicyReady());
732}
733
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800734size_t AudioFlingerClientAdapter::frameCountHAL(audio_io_handle_t ioHandle) const {
735 auto result = [&]() -> ConversionResult<size_t> {
736 int32_t ioHandleAidl = VALUE_OR_RETURN(legacy2aidl_audio_io_handle_t_int32_t(ioHandle));
737 int64_t aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800738 RETURN_IF_ERROR(statusTFromBinderStatus(
739 mDelegate->frameCountHAL(ioHandleAidl, &aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800740 return convertIntegral<size_t>(aidlRet);
741 }();
742 // Failure is ignored.
743 return result.value_or(0);
744}
745
746status_t
747AudioFlingerClientAdapter::getMicrophones(std::vector<media::MicrophoneInfo>* microphones) {
748 std::vector<media::MicrophoneInfoData> aidlRet;
Andy Hung1131b6e2020-12-08 20:47:45 -0800749 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(
750 mDelegate->getMicrophones(&aidlRet)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800751 if (microphones != nullptr) {
752 *microphones = VALUE_OR_RETURN_STATUS(
753 convertContainer<std::vector<media::MicrophoneInfo>>(aidlRet,
754 media::aidl2legacy_MicrophoneInfo));
755 }
756 return OK;
757}
758
759status_t AudioFlingerClientAdapter::setAudioHalPids(const std::vector<pid_t>& pids) {
760 std::vector<int32_t> pidsAidl = VALUE_OR_RETURN_STATUS(
761 convertContainer<std::vector<int32_t>>(pids, legacy2aidl_pid_t_int32_t));
Andy Hung1131b6e2020-12-08 20:47:45 -0800762 return statusTFromBinderStatus(mDelegate->setAudioHalPids(pidsAidl));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800763}
764
jiabin1319f5a2021-03-30 22:21:24 +0000765status_t AudioFlingerClientAdapter::setVibratorInfos(
766 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
767 return statusTFromBinderStatus(mDelegate->setVibratorInfos(vibratorInfos));
768}
769
jiabin10a03f12021-05-07 23:46:28 +0000770status_t AudioFlingerClientAdapter::updateSecondaryOutputs(
771 const TrackSecondaryOutputsMap& trackSecondaryOutputs) {
772 std::vector<media::TrackSecondaryOutputInfo> trackSecondaryOutputInfos =
773 VALUE_OR_RETURN_STATUS(
774 convertContainer<std::vector<media::TrackSecondaryOutputInfo>>(
775 trackSecondaryOutputs,
776 legacy2aidl_TrackSecondaryOutputInfoPair_TrackSecondaryOutputInfo));
777 return statusTFromBinderStatus(mDelegate->updateSecondaryOutputs(trackSecondaryOutputInfos));
778}
779
Jiabin Huangebe64102021-09-07 20:01:07 +0000780status_t AudioFlingerClientAdapter::getMmapPolicyInfos(
jiabine99d0882021-09-17 05:21:25 +0000781 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *policyInfos) {
Jiabin Huangebe64102021-09-07 20:01:07 +0000782 return statusTFromBinderStatus(mDelegate->getMmapPolicyInfos(policyType, policyInfos));
783}
784
jiabine504e7b2021-09-18 00:27:08 +0000785int32_t AudioFlingerClientAdapter::getAAudioMixerBurstCount() {
786 auto result = [&]() -> ConversionResult<int32_t> {
787 int32_t aidlRet;
788 RETURN_IF_ERROR(statusTFromBinderStatus(mDelegate->getAAudioMixerBurstCount(&aidlRet)));
789 return convertIntegral<int32_t>(aidlRet);
790 }();
791 // Failure is ignored.
792 return result.value_or(0);
793}
794
795int32_t AudioFlingerClientAdapter::getAAudioHardwareBurstMinUsec() {
796 auto result = [&]() -> ConversionResult<int32_t> {
797 int32_t aidlRet;
798 RETURN_IF_ERROR(statusTFromBinderStatus(
799 mDelegate->getAAudioHardwareBurstMinUsec(&aidlRet)));
800 return convertIntegral<int32_t>(aidlRet);
801 }();
802 // Failure is ignored.
803 return result.value_or(0);
804}
805
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800806
807////////////////////////////////////////////////////////////////////////////////////////////////////
808// AudioFlingerServerAdapter
809AudioFlingerServerAdapter::AudioFlingerServerAdapter(
810 const sp<AudioFlingerServerAdapter::Delegate>& delegate) : mDelegate(delegate) {}
811
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -0700812status_t AudioFlingerServerAdapter::onTransact(uint32_t code,
813 const Parcel& data,
814 Parcel* reply,
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800815 uint32_t flags) {
Ytai Ben-Tsvi24b33fc2021-05-10 13:08:11 -0700816 return mDelegate->onTransactWrapper(static_cast<Delegate::TransactionCode>(code),
817 data,
818 flags,
819 [&] {
820 return BnAudioFlingerService::onTransact(
821 code,
822 data,
823 reply,
824 flags);
825 });
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800826}
827
828status_t AudioFlingerServerAdapter::dump(int fd, const Vector<String16>& args) {
829 return mDelegate->dump(fd, args);
830}
831
832Status AudioFlingerServerAdapter::createTrack(const media::CreateTrackRequest& request,
833 media::CreateTrackResponse* _aidl_return) {
834 return Status::fromStatusT(mDelegate->createTrack(request, *_aidl_return));
835}
836
837Status AudioFlingerServerAdapter::createRecord(const media::CreateRecordRequest& request,
838 media::CreateRecordResponse* _aidl_return) {
839 return Status::fromStatusT(mDelegate->createRecord(request, *_aidl_return));
840}
841
842Status AudioFlingerServerAdapter::sampleRate(int32_t ioHandle, int32_t* _aidl_return) {
843 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
844 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
845 *_aidl_return = VALUE_OR_RETURN_BINDER(
846 convertIntegral<int32_t>(mDelegate->sampleRate(ioHandleLegacy)));
847 return Status::ok();
848}
849
850Status AudioFlingerServerAdapter::format(int32_t output,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700851 AudioFormatDescription* _aidl_return) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800852 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
853 aidl2legacy_int32_t_audio_io_handle_t(output));
854 *_aidl_return = VALUE_OR_RETURN_BINDER(
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -0700855 legacy2aidl_audio_format_t_AudioFormatDescription(mDelegate->format(outputLegacy)));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800856 return Status::ok();
857}
858
859Status AudioFlingerServerAdapter::frameCount(int32_t ioHandle, int64_t* _aidl_return) {
860 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
861 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
862 *_aidl_return = VALUE_OR_RETURN_BINDER(
863 convertIntegral<int64_t>(mDelegate->frameCount(ioHandleLegacy)));
864 return Status::ok();
865}
866
867Status AudioFlingerServerAdapter::latency(int32_t output, int32_t* _aidl_return) {
868 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
869 aidl2legacy_int32_t_audio_io_handle_t(output));
870 *_aidl_return = VALUE_OR_RETURN_BINDER(
871 convertIntegral<int32_t>(mDelegate->latency(outputLegacy)));
872 return Status::ok();
873}
874
875Status AudioFlingerServerAdapter::setMasterVolume(float value) {
876 return Status::fromStatusT(mDelegate->setMasterVolume(value));
877}
878
879Status AudioFlingerServerAdapter::setMasterMute(bool muted) {
880 return Status::fromStatusT(mDelegate->setMasterMute(muted));
881}
882
883Status AudioFlingerServerAdapter::masterVolume(float* _aidl_return) {
884 *_aidl_return = mDelegate->masterVolume();
885 return Status::ok();
886}
887
888Status AudioFlingerServerAdapter::masterMute(bool* _aidl_return) {
889 *_aidl_return = mDelegate->masterMute();
890 return Status::ok();
891}
892
893Status AudioFlingerServerAdapter::setMasterBalance(float balance) {
894 return Status::fromStatusT(mDelegate->setMasterBalance(balance));
895}
896
897Status AudioFlingerServerAdapter::getMasterBalance(float* _aidl_return) {
898 return Status::fromStatusT(mDelegate->getMasterBalance(_aidl_return));
899}
900
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700901Status AudioFlingerServerAdapter::setStreamVolume(AudioStreamType stream, float value,
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800902 int32_t output) {
903 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
904 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
905 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
906 aidl2legacy_int32_t_audio_io_handle_t(output));
907 return Status::fromStatusT(mDelegate->setStreamVolume(streamLegacy, value, outputLegacy));
908}
909
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700910Status AudioFlingerServerAdapter::setStreamMute(AudioStreamType stream, bool muted) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800911 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
912 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
913 return Status::fromStatusT(mDelegate->setStreamMute(streamLegacy, muted));
914}
915
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700916Status AudioFlingerServerAdapter::streamVolume(AudioStreamType stream, int32_t output,
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800917 float* _aidl_return) {
918 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
919 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
920 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
921 aidl2legacy_int32_t_audio_io_handle_t(output));
922 *_aidl_return = mDelegate->streamVolume(streamLegacy, outputLegacy);
923 return Status::ok();
924}
925
Mikhail Naganovdbf03642021-08-25 18:15:32 -0700926Status AudioFlingerServerAdapter::streamMute(AudioStreamType stream, bool* _aidl_return) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800927 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
928 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
929 *_aidl_return = mDelegate->streamMute(streamLegacy);
930 return Status::ok();
931}
932
Mikhail Naganovddceecc2021-09-03 13:58:56 -0700933Status AudioFlingerServerAdapter::setMode(AudioMode mode) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800934 audio_mode_t modeLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioMode_audio_mode_t(mode));
935 return Status::fromStatusT(mDelegate->setMode(modeLegacy));
936}
937
938Status AudioFlingerServerAdapter::setMicMute(bool state) {
939 return Status::fromStatusT(mDelegate->setMicMute(state));
940}
941
942Status AudioFlingerServerAdapter::getMicMute(bool* _aidl_return) {
943 *_aidl_return = mDelegate->getMicMute();
944 return Status::ok();
945}
946
947Status AudioFlingerServerAdapter::setRecordSilenced(int32_t portId, bool silenced) {
948 audio_port_handle_t portIdLegacy = VALUE_OR_RETURN_BINDER(
949 aidl2legacy_int32_t_audio_port_handle_t(portId));
950 mDelegate->setRecordSilenced(portIdLegacy, silenced);
951 return Status::ok();
952}
953
954Status
955AudioFlingerServerAdapter::setParameters(int32_t ioHandle, const std::string& keyValuePairs) {
956 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
957 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
958 String8 keyValuePairsLegacy = VALUE_OR_RETURN_BINDER(
959 aidl2legacy_string_view_String8(keyValuePairs));
960 return Status::fromStatusT(mDelegate->setParameters(ioHandleLegacy, keyValuePairsLegacy));
961}
962
963Status AudioFlingerServerAdapter::getParameters(int32_t ioHandle, const std::string& keys,
964 std::string* _aidl_return) {
965 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
966 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
967 String8 keysLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_string_view_String8(keys));
968 *_aidl_return = VALUE_OR_RETURN_BINDER(
969 legacy2aidl_String8_string(mDelegate->getParameters(ioHandleLegacy, keysLegacy)));
970 return Status::ok();
971}
972
973Status AudioFlingerServerAdapter::registerClient(const sp<media::IAudioFlingerClient>& client) {
974 mDelegate->registerClient(client);
975 return Status::ok();
976}
977
978Status AudioFlingerServerAdapter::getInputBufferSize(int32_t sampleRate,
Mikhail Naganov57bd06f2021-08-10 16:41:54 -0700979 const AudioFormatDescription& format,
980 const AudioChannelLayout& channelMask,
Mikhail Naganov2d8df4e2021-06-03 13:59:13 -0700981 int64_t* _aidl_return) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800982 uint32_t sampleRateLegacy = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(sampleRate));
983 audio_format_t formatLegacy = VALUE_OR_RETURN_BINDER(
Mikhail Naganovb60bd1b2021-07-15 17:31:43 -0700984 aidl2legacy_AudioFormatDescription_audio_format_t(format));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800985 audio_channel_mask_t channelMaskLegacy = VALUE_OR_RETURN_BINDER(
Mikhail Naganovde3fa182021-07-30 15:06:42 -0700986 aidl2legacy_AudioChannelLayout_audio_channel_mask_t(channelMask, true /*isInput*/));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -0800987 size_t size = mDelegate->getInputBufferSize(sampleRateLegacy, formatLegacy, channelMaskLegacy);
988 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int64_t>(size));
989 return Status::ok();
990}
991
992Status AudioFlingerServerAdapter::openOutput(const media::OpenOutputRequest& request,
993 media::OpenOutputResponse* _aidl_return) {
994 return Status::fromStatusT(mDelegate->openOutput(request, _aidl_return));
995}
996
997Status AudioFlingerServerAdapter::openDuplicateOutput(int32_t output1, int32_t output2,
998 int32_t* _aidl_return) {
999 audio_io_handle_t output1Legacy = VALUE_OR_RETURN_BINDER(
1000 aidl2legacy_int32_t_audio_io_handle_t(output1));
1001 audio_io_handle_t output2Legacy = VALUE_OR_RETURN_BINDER(
1002 aidl2legacy_int32_t_audio_io_handle_t(output2));
1003 audio_io_handle_t result = mDelegate->openDuplicateOutput(output1Legacy, output2Legacy);
1004 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_io_handle_t_int32_t(result));
1005 return Status::ok();
1006}
1007
1008Status AudioFlingerServerAdapter::closeOutput(int32_t output) {
1009 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1010 aidl2legacy_int32_t_audio_io_handle_t(output));
1011 return Status::fromStatusT(mDelegate->closeOutput(outputLegacy));
1012}
1013
1014Status AudioFlingerServerAdapter::suspendOutput(int32_t output) {
1015 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1016 aidl2legacy_int32_t_audio_io_handle_t(output));
1017 return Status::fromStatusT(mDelegate->suspendOutput(outputLegacy));
1018}
1019
1020Status AudioFlingerServerAdapter::restoreOutput(int32_t output) {
1021 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1022 aidl2legacy_int32_t_audio_io_handle_t(output));
1023 return Status::fromStatusT(mDelegate->restoreOutput(outputLegacy));
1024}
1025
1026Status AudioFlingerServerAdapter::openInput(const media::OpenInputRequest& request,
1027 media::OpenInputResponse* _aidl_return) {
1028 return Status::fromStatusT(mDelegate->openInput(request, _aidl_return));
1029}
1030
1031Status AudioFlingerServerAdapter::closeInput(int32_t input) {
1032 audio_io_handle_t inputLegacy = VALUE_OR_RETURN_BINDER(
1033 aidl2legacy_int32_t_audio_io_handle_t(input));
1034 return Status::fromStatusT(mDelegate->closeInput(inputLegacy));
1035}
1036
Mikhail Naganovdbf03642021-08-25 18:15:32 -07001037Status AudioFlingerServerAdapter::invalidateStream(AudioStreamType stream) {
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08001038 audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
1039 aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
1040 return Status::fromStatusT(mDelegate->invalidateStream(streamLegacy));
1041}
1042
1043Status AudioFlingerServerAdapter::setVoiceVolume(float volume) {
1044 return Status::fromStatusT(mDelegate->setVoiceVolume(volume));
1045}
1046
1047Status
1048AudioFlingerServerAdapter::getRenderPosition(int32_t output, media::RenderPosition* _aidl_return) {
1049 audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
1050 aidl2legacy_int32_t_audio_io_handle_t(output));
1051 uint32_t halFramesLegacy;
1052 uint32_t dspFramesLegacy;
1053 RETURN_BINDER_IF_ERROR(
1054 mDelegate->getRenderPosition(&halFramesLegacy, &dspFramesLegacy, outputLegacy));
1055 _aidl_return->halFrames = VALUE_OR_RETURN_BINDER(convertIntegral<int32_t>(halFramesLegacy));
1056 _aidl_return->dspFrames = VALUE_OR_RETURN_BINDER(convertIntegral<int32_t>(dspFramesLegacy));
1057 return Status::ok();
1058}
1059
1060Status AudioFlingerServerAdapter::getInputFramesLost(int32_t ioHandle, int32_t* _aidl_return) {
1061 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
1062 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
1063 uint32_t result = mDelegate->getInputFramesLost(ioHandleLegacy);
1064 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int32_t>(result));
1065 return Status::ok();
1066}
1067
1068Status
1069AudioFlingerServerAdapter::newAudioUniqueId(media::AudioUniqueIdUse use, int32_t* _aidl_return) {
1070 audio_unique_id_use_t useLegacy = VALUE_OR_RETURN_BINDER(
1071 aidl2legacy_AudioUniqueIdUse_audio_unique_id_use_t(use));
1072 audio_unique_id_t result = mDelegate->newAudioUniqueId(useLegacy);
1073 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_unique_id_t_int32_t(result));
1074 return Status::ok();
1075}
1076
1077Status
1078AudioFlingerServerAdapter::acquireAudioSessionId(int32_t audioSession, int32_t pid, int32_t uid) {
1079 audio_session_t audioSessionLegacy = VALUE_OR_RETURN_BINDER(
1080 aidl2legacy_int32_t_audio_session_t(audioSession));
1081 pid_t pidLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_int32_t_pid_t(pid));
1082 uid_t uidLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_int32_t_uid_t(uid));
1083 mDelegate->acquireAudioSessionId(audioSessionLegacy, pidLegacy, uidLegacy);
1084 return Status::ok();
1085}
1086
1087Status AudioFlingerServerAdapter::releaseAudioSessionId(int32_t audioSession, int32_t pid) {
1088 audio_session_t audioSessionLegacy = VALUE_OR_RETURN_BINDER(
1089 aidl2legacy_int32_t_audio_session_t(audioSession));
1090 pid_t pidLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_int32_t_pid_t(pid));
1091 mDelegate->releaseAudioSessionId(audioSessionLegacy, pidLegacy);
1092 return Status::ok();
1093}
1094
1095Status AudioFlingerServerAdapter::queryNumberEffects(int32_t* _aidl_return) {
1096 uint32_t result;
1097 RETURN_BINDER_IF_ERROR(mDelegate->queryNumberEffects(&result));
1098 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(result));
1099 return Status::ok();
1100}
1101
1102Status
1103AudioFlingerServerAdapter::queryEffect(int32_t index, media::EffectDescriptor* _aidl_return) {
1104 uint32_t indexLegacy = VALUE_OR_RETURN_BINDER(convertIntegral<uint32_t>(index));
1105 effect_descriptor_t result;
1106 RETURN_BINDER_IF_ERROR(mDelegate->queryEffect(indexLegacy, &result));
1107 *_aidl_return = VALUE_OR_RETURN_BINDER(
1108 legacy2aidl_effect_descriptor_t_EffectDescriptor(result));
1109 return Status::ok();
1110}
1111
Mikhail Naganovddceecc2021-09-03 13:58:56 -07001112Status AudioFlingerServerAdapter::getEffectDescriptor(const AudioUuid& effectUUID,
1113 const AudioUuid& typeUUID,
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08001114 int32_t preferredTypeFlag,
1115 media::EffectDescriptor* _aidl_return) {
1116 effect_uuid_t effectUuidLegacy = VALUE_OR_RETURN_BINDER(
1117 aidl2legacy_AudioUuid_audio_uuid_t(effectUUID));
1118 effect_uuid_t typeUuidLegacy = VALUE_OR_RETURN_BINDER(
1119 aidl2legacy_AudioUuid_audio_uuid_t(typeUUID));
1120 uint32_t preferredTypeFlagLegacy = VALUE_OR_RETURN_BINDER(
1121 convertReinterpret<uint32_t>(preferredTypeFlag));
1122 effect_descriptor_t result;
1123 RETURN_BINDER_IF_ERROR(mDelegate->getEffectDescriptor(&effectUuidLegacy, &typeUuidLegacy,
1124 preferredTypeFlagLegacy, &result));
1125 *_aidl_return = VALUE_OR_RETURN_BINDER(
1126 legacy2aidl_effect_descriptor_t_EffectDescriptor(result));
1127 return Status::ok();
1128}
1129
1130Status AudioFlingerServerAdapter::createEffect(const media::CreateEffectRequest& request,
1131 media::CreateEffectResponse* _aidl_return) {
1132 return Status::fromStatusT(mDelegate->createEffect(request, _aidl_return));
1133}
1134
1135Status
1136AudioFlingerServerAdapter::moveEffects(int32_t session, int32_t srcOutput, int32_t dstOutput) {
1137 audio_session_t sessionLegacy = VALUE_OR_RETURN_BINDER(
1138 aidl2legacy_int32_t_audio_session_t(session));
1139 audio_io_handle_t srcOutputLegacy = VALUE_OR_RETURN_BINDER(
1140 aidl2legacy_int32_t_audio_io_handle_t(srcOutput));
1141 audio_io_handle_t dstOutputLegacy = VALUE_OR_RETURN_BINDER(
1142 aidl2legacy_int32_t_audio_io_handle_t(dstOutput));
1143 return Status::fromStatusT(
1144 mDelegate->moveEffects(sessionLegacy, srcOutputLegacy, dstOutputLegacy));
1145}
1146
1147Status AudioFlingerServerAdapter::setEffectSuspended(int32_t effectId, int32_t sessionId,
1148 bool suspended) {
1149 int effectIdLegacy = VALUE_OR_RETURN_BINDER(convertReinterpret<int>(effectId));
1150 audio_session_t sessionIdLegacy = VALUE_OR_RETURN_BINDER(
1151 aidl2legacy_int32_t_audio_session_t(sessionId));
1152 mDelegate->setEffectSuspended(effectIdLegacy, sessionIdLegacy, suspended);
1153 return Status::ok();
1154}
1155
1156Status AudioFlingerServerAdapter::loadHwModule(const std::string& name, int32_t* _aidl_return) {
1157 audio_module_handle_t result = mDelegate->loadHwModule(name.c_str());
1158 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_module_handle_t_int32_t(result));
1159 return Status::ok();
1160}
1161
1162Status AudioFlingerServerAdapter::getPrimaryOutputSamplingRate(int32_t* _aidl_return) {
1163 *_aidl_return = VALUE_OR_RETURN_BINDER(
1164 convertIntegral<int32_t>(mDelegate->getPrimaryOutputSamplingRate()));
1165 return Status::ok();
1166}
1167
1168Status AudioFlingerServerAdapter::getPrimaryOutputFrameCount(int64_t* _aidl_return) {
1169 *_aidl_return = VALUE_OR_RETURN_BINDER(
1170 convertIntegral<int64_t>(mDelegate->getPrimaryOutputFrameCount()));
1171 return Status::ok();
1172
1173}
1174
1175Status AudioFlingerServerAdapter::setLowRamDevice(bool isLowRamDevice, int64_t totalMemory) {
1176 return Status::fromStatusT(mDelegate->setLowRamDevice(isLowRamDevice, totalMemory));
1177}
1178
1179Status AudioFlingerServerAdapter::getAudioPort(const media::AudioPort& port,
1180 media::AudioPort* _aidl_return) {
1181 audio_port_v7 portLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPort_audio_port_v7(port));
1182 RETURN_BINDER_IF_ERROR(mDelegate->getAudioPort(&portLegacy));
1183 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_port_v7_AudioPort(portLegacy));
1184 return Status::ok();
1185}
1186
1187Status AudioFlingerServerAdapter::createAudioPatch(const media::AudioPatch& patch,
1188 int32_t* _aidl_return) {
1189 audio_patch patchLegacy = VALUE_OR_RETURN_BINDER(aidl2legacy_AudioPatch_audio_patch(patch));
Kuowei Li247a3672021-07-21 21:46:07 +08001190 audio_patch_handle_t handleLegacy = VALUE_OR_RETURN_BINDER(
1191 aidl2legacy_int32_t_audio_patch_handle_t(*_aidl_return));
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08001192 RETURN_BINDER_IF_ERROR(mDelegate->createAudioPatch(&patchLegacy, &handleLegacy));
1193 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_patch_handle_t_int32_t(handleLegacy));
1194 return Status::ok();
1195}
1196
1197Status AudioFlingerServerAdapter::releaseAudioPatch(int32_t handle) {
1198 audio_patch_handle_t handleLegacy = VALUE_OR_RETURN_BINDER(
1199 aidl2legacy_int32_t_audio_patch_handle_t(handle));
1200 return Status::fromStatusT(mDelegate->releaseAudioPatch(handleLegacy));
1201}
1202
1203Status AudioFlingerServerAdapter::listAudioPatches(int32_t maxCount,
1204 std::vector<media::AudioPatch>* _aidl_return) {
1205 unsigned int count = VALUE_OR_RETURN_BINDER(convertIntegral<unsigned int>(maxCount));
1206 count = std::min(count, static_cast<unsigned int>(MAX_ITEMS_PER_LIST));
1207 std::unique_ptr<audio_patch[]> patchesLegacy(new audio_patch[count]);
1208 RETURN_BINDER_IF_ERROR(mDelegate->listAudioPatches(&count, patchesLegacy.get()));
1209 RETURN_BINDER_IF_ERROR(convertRange(&patchesLegacy[0],
1210 &patchesLegacy[count],
1211 std::back_inserter(*_aidl_return),
1212 legacy2aidl_audio_patch_AudioPatch));
1213 return Status::ok();
1214}
1215
1216Status AudioFlingerServerAdapter::setAudioPortConfig(const media::AudioPortConfig& config) {
1217 audio_port_config configLegacy = VALUE_OR_RETURN_BINDER(
1218 aidl2legacy_AudioPortConfig_audio_port_config(config));
1219 return Status::fromStatusT(mDelegate->setAudioPortConfig(&configLegacy));
1220}
1221
1222Status AudioFlingerServerAdapter::getAudioHwSyncForSession(int32_t sessionId,
1223 int32_t* _aidl_return) {
1224 audio_session_t sessionIdLegacy = VALUE_OR_RETURN_BINDER(
1225 aidl2legacy_int32_t_audio_session_t(sessionId));
1226 audio_hw_sync_t result = mDelegate->getAudioHwSyncForSession(sessionIdLegacy);
1227 *_aidl_return = VALUE_OR_RETURN_BINDER(legacy2aidl_audio_hw_sync_t_int32_t(result));
1228 return Status::ok();
1229}
1230
1231Status AudioFlingerServerAdapter::systemReady() {
1232 return Status::fromStatusT(mDelegate->systemReady());
1233}
1234
Eric Laurentd66d7a12021-07-13 13:35:32 +02001235Status AudioFlingerServerAdapter::audioPolicyReady() {
1236 mDelegate->audioPolicyReady();
1237 return Status::ok();
1238}
1239
Ytai Ben-Tsvi50b8ccb2020-11-24 13:47:54 -08001240Status AudioFlingerServerAdapter::frameCountHAL(int32_t ioHandle, int64_t* _aidl_return) {
1241 audio_io_handle_t ioHandleLegacy = VALUE_OR_RETURN_BINDER(
1242 aidl2legacy_int32_t_audio_io_handle_t(ioHandle));
1243 size_t result = mDelegate->frameCountHAL(ioHandleLegacy);
1244 *_aidl_return = VALUE_OR_RETURN_BINDER(convertIntegral<int64_t>(result));
1245 return Status::ok();
1246}
1247
1248Status AudioFlingerServerAdapter::getMicrophones(
1249 std::vector<media::MicrophoneInfoData>* _aidl_return) {
1250 std::vector<media::MicrophoneInfo> resultLegacy;
1251 RETURN_BINDER_IF_ERROR(mDelegate->getMicrophones(&resultLegacy));
1252 *_aidl_return = VALUE_OR_RETURN_BINDER(convertContainer<std::vector<media::MicrophoneInfoData>>(
1253 resultLegacy, media::legacy2aidl_MicrophoneInfo));
1254 return Status::ok();
1255}
1256
1257Status AudioFlingerServerAdapter::setAudioHalPids(const std::vector<int32_t>& pids) {
1258 std::vector<pid_t> pidsLegacy = VALUE_OR_RETURN_BINDER(
1259 convertContainer<std::vector<pid_t>>(pids, aidl2legacy_int32_t_pid_t));
1260 RETURN_BINDER_IF_ERROR(mDelegate->setAudioHalPids(pidsLegacy));
1261 return Status::ok();
1262}
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001263
jiabin1319f5a2021-03-30 22:21:24 +00001264Status AudioFlingerServerAdapter::setVibratorInfos(
1265 const std::vector<media::AudioVibratorInfo>& vibratorInfos) {
1266 return Status::fromStatusT(mDelegate->setVibratorInfos(vibratorInfos));
1267}
1268
jiabin10a03f12021-05-07 23:46:28 +00001269Status AudioFlingerServerAdapter::updateSecondaryOutputs(
1270 const std::vector<media::TrackSecondaryOutputInfo>& trackSecondaryOutputInfos) {
1271 TrackSecondaryOutputsMap trackSecondaryOutputs =
1272 VALUE_OR_RETURN_BINDER(convertContainer<TrackSecondaryOutputsMap>(
1273 trackSecondaryOutputInfos,
1274 aidl2legacy_TrackSecondaryOutputInfo_TrackSecondaryOutputInfoPair));
1275 return Status::fromStatusT(mDelegate->updateSecondaryOutputs(trackSecondaryOutputs));
1276}
1277
Jiabin Huangebe64102021-09-07 20:01:07 +00001278Status AudioFlingerServerAdapter::getMmapPolicyInfos(
jiabine99d0882021-09-17 05:21:25 +00001279 AudioMMapPolicyType policyType, std::vector<AudioMMapPolicyInfo> *_aidl_return) {
Jiabin Huangebe64102021-09-07 20:01:07 +00001280 return Status::fromStatusT(mDelegate->getMmapPolicyInfos(policyType, _aidl_return));
1281}
1282
jiabine504e7b2021-09-18 00:27:08 +00001283Status AudioFlingerServerAdapter::getAAudioMixerBurstCount(int32_t* _aidl_return) {
1284 *_aidl_return = VALUE_OR_RETURN_BINDER(
1285 convertIntegral<int32_t>(mDelegate->getAAudioMixerBurstCount()));
1286 return Status::ok();
1287}
1288
1289Status AudioFlingerServerAdapter::getAAudioHardwareBurstMinUsec(int32_t* _aidl_return) {
1290 *_aidl_return = VALUE_OR_RETURN_BINDER(
1291 convertIntegral<int32_t>(mDelegate->getAAudioHardwareBurstMinUsec()));
1292 return Status::ok();
1293}
1294
Glenn Kasten40bc9062015-03-20 09:09:33 -07001295} // namespace android